graph.c

   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 #include <stdlib.h>
  28
  29 #include <cairo.h>
  30 #include <gtk/gtk.h>
  31
  32 #include "tickmarks.h"
  33 #include "graph.h"
  34
  35 struct xyvalue {
  36         double x, y;
  37         int gx, gy;
  38 };
  39
  40 struct graph_value {
  41         struct graph_value *next;
  42         char *tooltip;
  43         void *value;
  44 };
  45
  46 struct graph_label {
  47         char *label;
  48         struct graph_value *tail;
  49         struct graph_value *values;
  50         struct graph_label *next;
  51         double r, g, b;
  52         int value_count;
  53         unsigned int tooltip_count;
  54         struct graph *parent;
  55 };
  56
  57 struct graph {
  58         char *title;
  59         char *xtitle;
  60         char *ytitle;
  61         unsigned int xdim, ydim;
  62         double xoffset, yoffset;
  63         struct graph_label *labels;
  64         struct graph_label *tail;
  65         int per_label_limit;
  66         const char *font;
  67         graph_axis_unit_change_callback x_axis_unit_change_callback;
  68         graph_axis_unit_change_callback y_axis_unit_change_callback;
  69         unsigned int base_offset;
  70         double left_extra;
  71         double right_extra;
  72         double top_extra;
  73         double bottom_extra;
  74 };
  75
  76 void graph_set_size(struct graph *g, unsigned int xdim, unsigned int ydim)
  77 {
  78         g->xdim = xdim;
  79         g->ydim = ydim;
  80 }
  81
  82 void graph_set_position(struct graph *g, double xoffset, double yoffset)
  83 {
  84         g->xoffset = xoffset;
  85         g->yoffset = yoffset;
  86 }
  87
  88 struct graph *graph_new(unsigned int xdim, unsigned int ydim, const char *font)
  89 {
  90         struct graph *g;
  91
  92         g = calloc(1, sizeof(*g));
  93         graph_set_size(g, xdim, ydim);
  94         g->per_label_limit = -1;
  95         g->font = font;
  96         if (!g->font)
  97                 g->font = "Sans";
  98         return g;
  99 }
 100
 101 void graph_x_axis_unit_change_notify(struct graph *g, graph_axis_unit_change_callback f)
 102 {
 103         g->x_axis_unit_change_callback = f;
 104 }
 105
 106 void graph_y_axis_unit_change_notify(struct graph *g, graph_axis_unit_change_callback f)
 107 {
 108         g->y_axis_unit_change_callback = f;
 109 }
 110
 111 static int count_labels(struct graph_label *labels)
 112 {
 113         int count = 0;
 114         struct graph_label *i;
 115
 116         for (i = labels; i; i = i->next)
 117                 count++;
 118         return count;
 119 }
 120
 121 static int count_values(struct graph_value *values)
 122 {
 123         int count = 0;
 124         struct graph_value *i;
 125
 126         for (i = values; i; i = i->next)
 127                 count++;
 128         return count;
 129 }
 130
 131 typedef double (*double_comparator)(double a, double b);
 132
 133 static double mindouble(double a, double b)
 134 {
 135         return a < b ? a : b;
 136 }
 137
 138 static double maxdouble(double a, double b)
 139 {
 140         return a < b ? b : a;
 141 }
 142
 143 static double find_double_values(struct graph_value *values, double_comparator cmp)
 144 {
 145         struct graph_value *i;
 146         int first = 1;
 147         double answer, tmp;
 148
 149         assert(values != NULL);
 150         answer = 0.0; /* shut the compiler up, might need to think harder though. */
 151         for (i = values; i; i = i->next) {
 152                 tmp = *(double *) i->value;
 153                 if (first) {
 154                         answer = tmp;
 155                         first = 0;
 156                 } else {
 157                         answer = cmp(answer, tmp);
 158                 }
 159         }
 160         return answer;
 161 }
 162
 163 static double find_double_data(struct graph_label *labels, double_comparator cmp)
 164 {
 165         struct graph_label *i;
 166         int first = 1;
 167         double answer, tmp;
 168
 169         assert(labels != NULL);
 170         answer = 0.0; /* shut the compiler up, might need to think harder though. */
 171         for (i = labels; i; i = i->next) {
 172                 tmp = find_double_values(i->values, cmp);
 173                 if (first) {
 174                         answer = tmp;
 175                         first = 0;
 176                 } else {
 177                         answer = cmp(tmp, answer);
 178                 }
 179         }
 180         return answer;
 181 }
 182
 183 static double find_min_data(struct graph_label *labels)
 184 {
 185         return find_double_data(labels, mindouble);
 186 }
 187
 188 static double find_max_data(struct graph_label *labels)
 189 {
 190         return find_double_data(labels, maxdouble);
 191 }
 192
 193 static void draw_bars(struct graph *bg, cairo_t *cr, struct graph_label *lb,
 194                         double label_offset, double bar_width,
 195                         double mindata, double maxdata)
 196 {
 197         struct graph_value *i;
 198         double x1, y1, x2, y2;
 199         int bar_num = 0;
 200         double domain, range, v;
 201
 202         domain = (maxdata - mindata);
 203         range = (double) bg->ydim * 0.80; /* FIXME */
 204         cairo_stroke(cr);
 205         for (i = lb->values; i; i = i->next) {
 206
 207                 x1 = label_offset + (double) bar_num * bar_width + (bar_width * 0.05);
 208                 x2 = x1 + bar_width * 0.90;
 209                 y2 = bg->ydim * 0.90;
 210                 v = *(double *) i->value;
 211                 y1 = y2 - (((v - mindata) / domain) * range);
 212                 cairo_move_to(cr, x1, y1);
 213                 cairo_line_to(cr, x1, y2);
 214                 cairo_line_to(cr, x2, y2);
 215                 cairo_line_to(cr, x2, y1);
 216                 cairo_close_path(cr);
 217                 cairo_fill(cr);
 218                 cairo_stroke(cr);
 219                 bar_num++;
 220         }
 221 }
 222
 223 static void draw_aligned_text(struct graph *g, cairo_t *cr, double x, double y,
 224                                double fontsize, const char *text, int alignment)
 225 {
 226 #define CENTERED 0
 227 #define LEFT_JUSTIFIED 1
 228 #define RIGHT_JUSTIFIED 2
 229
 230         double factor, direction;
 231         cairo_text_extents_t extents;
 232
 233         switch(alignment) {
 234                 case CENTERED:
 235                         direction = -1.0;
 236                         factor = 0.5;
 237                         break;
 238                 case RIGHT_JUSTIFIED:
 239                         direction = -1.0;
 240                         factor = 1.0;
 241                         break;
 242                 case LEFT_JUSTIFIED:
 243                 default:
 244                         direction = 1.0;
 245                         factor = 1.0;
 246                         break;
 247         }
 248         cairo_select_font_face (cr, g->font, CAIRO_FONT_SLANT_NORMAL, CAIRO_FONT_WEIGHT_NORMAL);
 249
 250         cairo_set_font_size(cr, fontsize);
 251         cairo_text_extents(cr, text, &extents);
 252         x = x + direction * (factor * extents.width  + extents.x_bearing);
 253         y = y - (extents.height / 2 + extents.y_bearing);
 254
 255         cairo_move_to(cr, x, y);
 256         cairo_show_text(cr, text);
 257 }
 258
 259 static inline void draw_centered_text(struct graph *g, cairo_t *cr, double x, double y,
 260                                double fontsize, const char *text)
 261 {
 262         draw_aligned_text(g, cr, x, y, fontsize, text, CENTERED);
 263 }
 264
 265 static inline void draw_right_justified_text(struct graph *g, cairo_t *cr,
 266                                 double x, double y,
 267                                 double fontsize, const char *text)
 268 {
 269         draw_aligned_text(g, cr, x, y, fontsize, text, RIGHT_JUSTIFIED);
 270 }
 271
 272 static inline void draw_left_justified_text(struct graph *g, cairo_t *cr,
 273                                 double x, double y,
 274                                 double fontsize, const char *text)
 275 {
 276         draw_aligned_text(g, cr, x, y, fontsize, text, LEFT_JUSTIFIED);
 277 }
 278
 279 static void draw_vertical_centered_text(struct graph *g, cairo_t *cr, double x,
 280                                         double y, double fontsize,
 281                                         const char *text)
 282 {
 283         double sx, sy;
 284         cairo_text_extents_t extents;
 285
 286         cairo_select_font_face(cr, g->font, CAIRO_FONT_SLANT_NORMAL, CAIRO_FONT_WEIGHT_NORMAL);
 287
 288         cairo_set_font_size(cr, fontsize);
 289         cairo_text_extents(cr, text, &extents);
 290         sx = x;
 291         sy = y;
 292         y = y + (extents.width / 2.0 + extents.x_bearing);
 293         x = x - (extents.height / 2.0 + extents.y_bearing);
 294
 295         cairo_move_to(cr, x, y);
 296         cairo_save(cr);
 297         cairo_translate(cr, -sx, -sy);
 298         cairo_rotate(cr, -90.0 * M_PI / 180.0);
 299         cairo_translate(cr, sx, sy);
 300         cairo_show_text(cr, text);
 301         cairo_restore(cr);
 302 }
 303
 304 static void graph_draw_common(struct graph *g, cairo_t *cr,
 305         double *x1, double *y1, double *x2, double *y2)
 306 {
 307         cairo_set_source_rgb(cr, 0, 0, 0);
 308         cairo_set_line_width (cr, 0.8);
 309
 310         *x1 = 0.10 * g->xdim;
 311         *x2 = 0.95 * g->xdim;
 312         *y1 = 0.10 * g->ydim;
 313         *y2 = 0.90 * g->ydim;
 314
 315         cairo_move_to(cr, *x1, *y1);
 316         cairo_line_to(cr, *x1, *y2);
 317         cairo_line_to(cr, *x2, *y2);
 318         cairo_line_to(cr, *x2, *y1);
 319         cairo_line_to(cr, *x1, *y1);
 320         cairo_stroke(cr);
 321
 322         draw_centered_text(g, cr, g->xdim / 2, g->ydim / 20, 20.0, g->title);
 323         draw_centered_text(g, cr, g->xdim / 2, g->ydim * 0.97, 14.0, g->xtitle);
 324         draw_vertical_centered_text(g, cr, g->xdim * 0.02, g->ydim / 2, 14.0, g->ytitle);
 325         cairo_stroke(cr);
 326 }
 327
 328 static void graph_draw_x_ticks(struct graph *g, cairo_t *cr,
 329         double x1, double y1, double x2, double y2,
 330         double minx, double maxx, int nticks, int add_tm_text)
 331 {
 332         struct tickmark *tm;
 333         double tx;
 334         int i, power_of_ten;
 335         static double dash[] = { 1.0, 2.0 };
 336
 337         nticks = calc_tickmarks(minx, maxx, nticks, &tm, &power_of_ten,
 338                 g->x_axis_unit_change_callback == NULL, g->base_offset);
 339         if (g->x_axis_unit_change_callback)
 340                 g->x_axis_unit_change_callback(g, power_of_ten);
 341
 342         for (i = 0; i < nticks; i++) {
 343                 tx = (((tm[i].value) - minx) / (maxx - minx)) * (x2 - x1) + x1;
 344
 345                 /* really tx < yx || tx > x2, but protect against rounding */
 346                 if (x1 - tx > 0.01 || tx - x2 > 0.01)
 347                         continue;
 348
 349                 /* Draw tick mark */
 350                 cairo_set_line_width(cr, 0.8);
 351                 cairo_move_to(cr, tx, y2);
 352                 cairo_line_to(cr, tx, y2 + (y2 - y1) * 0.03);
 353                 cairo_stroke(cr);
 354
 355                 /* draw grid lines */
 356                 cairo_save(cr);
 357                 cairo_set_dash(cr, dash, 2, 2.0);
 358                 cairo_set_line_width(cr, 0.5);
 359                 cairo_move_to(cr, tx, y1);
 360                 cairo_line_to(cr, tx, y2);
 361                 cairo_stroke(cr);
 362                 cairo_restore(cr);
 363
 364                 if (!add_tm_text)
 365                         continue;
 366
 367                 /* draw tickmark label */
 368                 draw_centered_text(g, cr, tx, y2 * 1.04, 12.0, tm[i].string);
 369                 cairo_stroke(cr);
 370
 371         }
 372 }
 373
 374 static double graph_draw_y_ticks(struct graph *g, cairo_t *cr,
 375         double x1, double y1, double x2, double y2,
 376         double miny, double maxy, int nticks, int add_tm_text)
 377 {
 378         struct tickmark *tm;
 379         double ty;
 380         int i, power_of_ten;
 381         static double dash[] = { 2.0, 2.0 };
 382
 383         nticks = calc_tickmarks(miny, maxy, nticks, &tm, &power_of_ten,
 384                 g->y_axis_unit_change_callback == NULL, g->base_offset);
 385         if (g->y_axis_unit_change_callback)
 386                 g->y_axis_unit_change_callback(g, power_of_ten);
 387
 388         /*
 389          * Use highest tickmark as top of graph, not highest value. Otherwise
 390          * it's impossible to see what the max value is, if the graph is
 391          * fairly flat.
 392          */
 393         maxy = tm[nticks - 1].value;
 394
 395         for (i = 0; i < nticks; i++) {
 396                 ty = y2 - (((tm[i].value) - miny) / (maxy - miny)) * (y2 - y1);
 397
 398                 /* really ty < y1 || ty > y2, but protect against rounding */
 399                 if (y1 - ty > 0.01 || ty - y2 > 0.01)
 400                         continue;
 401
 402                 /* draw tick mark */
 403                 cairo_move_to(cr, x1, ty);
 404                 cairo_line_to(cr, x1 - (x2 - x1) * 0.02, ty);
 405                 cairo_stroke(cr);
 406
 407                 /* draw grid lines */
 408                 cairo_save(cr);
 409                 cairo_set_dash(cr, dash, 2, 2.0);
 410                 cairo_set_line_width(cr, 0.5);
 411                 cairo_move_to(cr, x1, ty);
 412                 cairo_line_to(cr, x2, ty);
 413                 cairo_stroke(cr);
 414                 cairo_restore(cr);
 415
 416                 if (!add_tm_text)
 417                         continue;
 418
 419                 /* draw tickmark label */
 420                 draw_right_justified_text(g, cr, x1 - (x2 - x1) * 0.025, ty, 12.0, tm[i].string);
 421                 cairo_stroke(cr);
 422         }
 423
 424         /*
 425          * Return new max to use
 426          */
 427         return maxy;
 428 }
 429
 430 void bar_graph_draw(struct graph *bg, cairo_t *cr)
 431 {
 432         double x1, y1, x2, y2;
 433         double space_per_label, bar_width;
 434         double label_offset, mindata, maxdata;
 435         int i, nlabels;
 436         struct graph_label *lb;
 437
 438         cairo_save(cr);
 439         cairo_translate(cr, bg->xoffset, bg->yoffset);
 440         graph_draw_common(bg, cr, &x1, &y1, &x2, &y2);
 441
 442         nlabels = count_labels(bg->labels);
 443         space_per_label = (x2 - x1) / (double) nlabels;
 444
 445         mindata = find_min_data(bg->labels);
 446         maxdata = find_max_data(bg->labels);
 447
 448         if (fabs(maxdata - mindata) < 1e-20) {
 449                 draw_centered_text(bg, cr,
 450                         x1 + (x2 - x1) / 2.0,
 451                         y1 + (y2 - y1) / 2.0, 20.0, "No good data");
 452                 return;
 453         }
 454
 455         graph_draw_y_ticks(bg, cr, x1, y1, x2, y2, mindata, maxdata, 10, 1);
 456
 457         i = 0;
 458         for (lb = bg->labels; lb; lb = lb->next) {
 459                 int nvalues;
 460                 nvalues = count_values(lb->values);
 461                 bar_width = (space_per_label - space_per_label * 0.2) / (double) nvalues;
 462                 label_offset = bg->xdim * 0.1 + space_per_label * (double) i + space_per_label * 0.1;
 463                 draw_bars(bg, cr, lb, label_offset, bar_width, mindata, maxdata);
 464                 // draw_centered_text(cr, label_offset + (bar_width / 2.0 + bar_width * 0.1), bg->ydim * 0.93,
 465                 draw_centered_text(bg, cr, x1 + space_per_label * (i + 0.5), bg->ydim * 0.93,
 466                         12.0, lb->label);
 467                 i++;
 468         }
 469         cairo_stroke(cr);
 470         cairo_restore(cr);
 471 }
 472
 473 typedef double (*xy_value_extractor)(struct graph_value *v);
 474
 475 static double getx(struct graph_value *v)
 476 {
 477         struct xyvalue *xy = v->value;
 478         return xy->x;
 479 }
 480
 481 static double gety(struct graph_value *v)
 482 {
 483         struct xyvalue *xy = v->value;
 484         return xy->y;
 485 }
 486
 487 static double find_xy_value(struct graph *g, xy_value_extractor getvalue, double_comparator cmp)
 488 {
 489         double tmp, answer = 0.0;
 490         struct graph_label *i;
 491         struct graph_value *j;
 492         int first = 1;
 493
 494         for (i = g->labels; i; i = i->next)
 495                 for (j = i->values; j; j = j->next) {
 496                         tmp = getvalue(j);
 497                         if (first) {
 498                                 first = 0;
 499                                 answer = tmp;
 500                         }
 501                         answer = cmp(tmp, answer);
 502                 }
 503         return answer;
 504 }
 505
 506 void line_graph_draw(struct graph *g, cairo_t *cr)
 507 {
 508         double x1, y1, x2, y2;
 509         double minx, miny, maxx, maxy, gminx, gminy, gmaxx, gmaxy;
 510         double tx, ty, top_extra, bottom_extra, left_extra, right_extra;
 511         struct graph_label *i;
 512         struct graph_value *j;
 513         int good_data = 1, first = 1;
 514
 515         cairo_save(cr);
 516         cairo_translate(cr, g->xoffset, g->yoffset);
 517         graph_draw_common(g, cr, &x1, &y1, &x2, &y2);
 518
 519         minx = find_xy_value(g, getx, mindouble);
 520         maxx = find_xy_value(g, getx, maxdouble);
 521         miny = find_xy_value(g, gety, mindouble);
 522         maxy = find_xy_value(g, gety, maxdouble);
 523
 524         if (fabs(maxx - minx) < 1e-20 || fabs(maxy - miny) < 1e-20) {
 525                 good_data = 0;
 526                 minx = 0.0;
 527                 miny = 0.0;
 528                 maxx = 10.0;
 529                 maxy = 100.0;
 530         }
 531
 532         top_extra = 0.0;
 533         bottom_extra = 0.0;
 534         left_extra = 0.0;
 535         right_extra = 0.0;
 536
 537         if (g->top_extra > 0.001)
 538                 top_extra = fabs(maxy - miny) * g->top_extra;
 539         if (g->bottom_extra > 0.001)
 540                 bottom_extra = fabs(maxy - miny) * g->bottom_extra;
 541         if (g->left_extra > 0.001)
 542                 left_extra = fabs(maxx - minx) * g->left_extra;
 543         if (g->right_extra > 0.001)
 544                 right_extra = fabs(maxx - minx) * g->right_extra;
 545
 546         gminx = minx - left_extra;
 547         gmaxx = maxx + right_extra;
 548         gminy = miny - bottom_extra;
 549         gmaxy = maxy + top_extra;
 550
 551         graph_draw_x_ticks(g, cr, x1, y1, x2, y2, gminx, gmaxx, 10, good_data);
 552         gmaxy = graph_draw_y_ticks(g, cr, x1, y1, x2, y2, gminy, gmaxy, 10, good_data);
 553
 554         if (!good_data)
 555                 goto skip_data;
 556
 557         cairo_set_line_width(cr, 1.5);
 558         for (i = g->labels; i; i = i->next) {
 559                 first = 1;
 560                 if (i->r < 0) /* invisible data */
 561                         continue;
 562                 cairo_set_source_rgb(cr, i->r, i->g, i->b);
 563                 for (j = i->values; j; j = j->next) {
 564                         struct xyvalue *xy = j->value;
 565
 566                         tx = ((getx(j) - gminx) / (gmaxx - gminx)) * (x2 - x1) + x1;
 567                         ty = y2 - ((gety(j) - gminy) / (gmaxy - gminy)) * (y2 - y1);
 568                         if (first) {
 569                                 cairo_move_to(cr, tx, ty);
 570                                 first = 0;
 571                         } else {
 572                                 cairo_line_to(cr, tx, ty);
 573                         }
 574                         xy->gx = tx;
 575                         xy->gy = ty;
 576                 }
 577                 cairo_stroke(cr);
 578         }
 579
 580 skip_data:
 581         cairo_restore(cr);
 582
 583 }
 584
 585 static void gfree(void *f)
 586 {
 587         if (f)
 588                 free(f);
 589 }
 590
 591 static void setstring(char **str, const char *value)
 592 {
 593         gfree(*str);
 594         *str = strdup(value);
 595 }
 596
 597 void graph_title(struct graph *bg, const char *title)
 598 {
 599         setstring(&bg->title, title);
 600 }
 601
 602 void graph_x_title(struct graph *bg, const char *title)
 603 {
 604         setstring(&bg->xtitle, title);
 605 }
 606
 607 void graph_y_title(struct graph *bg, const char *title)
 608 {
 609         setstring(&bg->ytitle, title);
 610 }
 611
 612 static struct graph_label *graph_find_label(struct graph *bg,
 613                                 const char *label)
 614 {
 615         struct graph_label *i;
 616
 617         for (i = bg->labels; i; i = i->next)
 618                 if (strcmp(label, i->label) == 0)
 619                         return i;
 620         return NULL;
 621 }
 622
 623 void graph_add_label(struct graph *bg, const char *label)
 624 {
 625         struct graph_label *i;
 626
 627         i = graph_find_label(bg, label);
 628         if (i)
 629                 return; /* already present. */
 630         i = calloc(1, sizeof(*i));
 631         i->parent = bg;
 632         setstring(&i->label, label);
 633         i->next = NULL;
 634         if (!bg->tail)
 635                 bg->labels = i;
 636         else
 637                 bg->tail->next = i;
 638         bg->tail = i;
 639 }
 640
 641 static void graph_label_add_value(struct graph_label *i, void *value,
 642                                   const char *tooltip)
 643 {
 644         struct graph_value *x;
 645
 646         x = malloc(sizeof(*x));
 647         x->value = value;
 648         if (tooltip)
 649                 x->tooltip = strdup(tooltip);
 650         else
 651                 x->tooltip = NULL;
 652         x->next = NULL;
 653         if (!i->tail) {
 654                 i->values = x;
 655         } else {
 656                 i->tail->next = x;
 657         }
 658         i->tail = x;
 659         i->value_count++;
 660         if (x->tooltip)
 661                 i->tooltip_count++;
 662
 663         if (i->parent->per_label_limit != -1 &&
 664                 i->value_count > i->parent->per_label_limit) {
 665                 int to_drop = 1;
 666
 667                 /*
 668                  * If the limit was dynamically reduced, making us more
 669                  * than 1 entry ahead after adding this one, drop two
 670                  * entries. This will make us (eventually) reach the
 671                  * specified limit.
 672                  */
 673                 if (i->value_count - i->parent->per_label_limit >= 2)
 674                         to_drop = 2;
 675
 676                 while (to_drop--) {
 677                         x = i->values;
 678                         i->values = i->values->next;
 679                         if (x->tooltip) {
 680                                 free(x->tooltip);
 681                                 i->tooltip_count--;
 682                         }
 683                         free(x->value);
 684                         free(x);
 685                         i->value_count--;
 686                 }
 687         }
 688 }
 689
 690 int graph_add_data(struct graph *bg, const char *label, const double value)
 691 {
 692         struct graph_label *i;
 693         double *d;
 694
 695         d = malloc(sizeof(*d));
 696         *d = value;
 697
 698         i = graph_find_label(bg, label);
 699         if (!i)
 700                 return -1;
 701         graph_label_add_value(i, d, NULL);
 702         return 0;
 703 }
 704
 705 int graph_add_xy_data(struct graph *bg, const char *label,
 706                       const double x, const double y, const char *tooltip)
 707 {
 708         struct graph_label *i;
 709         struct xyvalue *xy;
 710
 711         xy = malloc(sizeof(*xy));
 712         xy->x = x;
 713         xy->y = y;
 714
 715         i = graph_find_label(bg, label);
 716         if (!i)
 717                 return -1;
 718
 719         graph_label_add_value(i, xy, tooltip);
 720         return 0;
 721 }
 722
 723 static void graph_free_values(struct graph_value *values)
 724 {
 725         struct graph_value *i, *next;
 726
 727         for (i = values; i; i = next) {
 728                 next = i->next;
 729                 gfree(i->value);
 730                 gfree(i);
 731         }
 732 }
 733
 734 static void graph_free_labels(struct graph_label *labels)
 735 {
 736         struct graph_label *i, *next;
 737
 738         for (i = labels; i; i = next) {
 739                 next = i->next;
 740                 graph_free_values(i->values);
 741                 gfree(i);
 742         }
 743 }
 744
 745 void graph_set_color(struct graph *gr, const char *label,
 746         double red, double green, double blue)
 747 {
 748         struct graph_label *i;
 749         double r, g, b;
 750
 751         if (red < 0.0) { /* invisible color */
 752                 r = -1.0;
 753                 g = -1.0;
 754                 b = -1.0;
 755         } else {
 756                 r = fabs(red);
 757                 g = fabs(green);
 758                 b = fabs(blue);
 759
 760                 if (r > 1.0)
 761                         r = 1.0;
 762                 if (g > 1.0)
 763                         g = 1.0;
 764                 if (b > 1.0)
 765                         b =1.0;
 766         }
 767
 768         for (i = gr->labels; i; i = i->next)
 769                 if (strcmp(i->label, label) == 0) {
 770                         i->r = r;
 771                         i->g = g;
 772                         i->b = b;
 773                         break;
 774                 }
 775 }
 776
 777 void graph_free(struct graph *bg)
 778 {
 779         gfree(bg->title);
 780         gfree(bg->xtitle);
 781         gfree(bg->ytitle);
 782         graph_free_labels(bg->labels);
 783 }
 784
 785 /* For each line in the line graph, up to per_label_limit segments may
 786  * be added.  After that, adding more data to the end of the line
 787  * causes data to drop off of the front of the line.
 788  */
 789 void line_graph_set_data_count_limit(struct graph *g, int per_label_limit)
 790 {
 791         g->per_label_limit = per_label_limit;
 792 }
 793
 794 void graph_add_extra_space(struct graph *g, double left_percent, double right_percent,
 795                                 double top_percent, double bottom_percent)
 796 {
 797         g->left_extra = left_percent;
 798         g->right_extra = right_percent;
 799         g->top_extra = top_percent;
 800         g->bottom_extra = bottom_percent;
 801 }
 802
 803 /*
 804  * Normally values are logged in a base unit of 0, but for other purposes
 805  * it makes more sense to log in higher unit. For instance for bandwidth
 806  * purposes, you may want to log in KB/sec (or MB/sec) rather than bytes/sec.
 807  */
 808 void graph_set_base_offset(struct graph *g, unsigned int base_offset)
 809 {
 810         g->base_offset = base_offset;
 811 }
 812
 813 int graph_has_tooltips(struct graph *g)
 814 {
 815         struct graph_label *i;
 816
 817         for (i = g->labels; i; i = i->next)
 818                 if (i->tooltip_count)
 819                         return 1;
 820
 821         return 0;
 822 }
 823
 824 int graph_contains_xy(struct graph *g, int x, int y)
 825 {
 826         int first_x = g->xoffset;
 827         int last_x = g->xoffset + g->xdim;
 828         int first_y = g->yoffset;
 829         int last_y = g->yoffset + g->ydim;
 830
 831         return (x >= first_x && x <= last_x) && (y >= first_y && y <= last_y);
 832 }
 833
 834 static int xy_match(struct xyvalue *xy, int x, int y)
 835 {
 836         int xdiff = abs(xy->gx - x);
 837         int ydiff = abs(xy->gy - y);
 838
 839         return xdiff <= 20 && ydiff <= 10;
 840 }
 841
 842 const char *graph_find_tooltip(struct graph *g, int x, int y)
 843 {
 844         struct graph_label *i;
 845         struct graph_value *j;
 846
 847         for (i = g->labels; i; i = i->next) {
 848                 for (j = i->values; j; j = j->next) {
 849                         struct xyvalue *xy = j->value;
 850
 851                         if (xy_match(xy, x - g->xoffset, y))
 852                                 return j->tooltip;
 853                 }
 854         }
 855
 856         return NULL;
 857 }