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         /*
 446          * Start bars at 0 unless we have negative values, otherwise we
 447          * present a skewed picture comparing label X and X+1.
 448          */
 449         mindata = find_min_data(bg->labels);
 450         if (mindata > 0)
 451                 mindata = 0;
 452
 453         maxdata = find_max_data(bg->labels);
 454
 455         if (fabs(maxdata - mindata) < 1e-20) {
 456                 draw_centered_text(bg, cr,
 457                         x1 + (x2 - x1) / 2.0,
 458                         y1 + (y2 - y1) / 2.0, 20.0, "No good data");
 459                 return;
 460         }
 461
 462         maxdata = graph_draw_y_ticks(bg, cr, x1, y1, x2, y2, mindata, maxdata, 10, 1);
 463         i = 0;
 464         for (lb = bg->labels; lb; lb = lb->next) {
 465                 int nvalues;
 466                 nvalues = count_values(lb->values);
 467                 bar_width = (space_per_label - space_per_label * 0.2) / (double) nvalues;
 468                 label_offset = bg->xdim * 0.1 + space_per_label * (double) i + space_per_label * 0.1;
 469                 draw_bars(bg, cr, lb, label_offset, bar_width, mindata, maxdata);
 470                 // draw_centered_text(cr, label_offset + (bar_width / 2.0 + bar_width * 0.1), bg->ydim * 0.93,
 471                 draw_centered_text(bg, cr, x1 + space_per_label * (i + 0.5), bg->ydim * 0.93,
 472                         12.0, lb->label);
 473                 i++;
 474         }
 475         cairo_stroke(cr);
 476         cairo_restore(cr);
 477 }
 478
 479 typedef double (*xy_value_extractor)(struct graph_value *v);
 480
 481 static double getx(struct graph_value *v)
 482 {
 483         struct xyvalue *xy = v->value;
 484         return xy->x;
 485 }
 486
 487 static double gety(struct graph_value *v)
 488 {
 489         struct xyvalue *xy = v->value;
 490         return xy->y;
 491 }
 492
 493 static double find_xy_value(struct graph *g, xy_value_extractor getvalue, double_comparator cmp)
 494 {
 495         double tmp, answer = 0.0;
 496         struct graph_label *i;
 497         struct graph_value *j;
 498         int first = 1;
 499
 500         for (i = g->labels; i; i = i->next)
 501                 for (j = i->values; j; j = j->next) {
 502                         tmp = getvalue(j);
 503                         if (first) {
 504                                 first = 0;
 505                                 answer = tmp;
 506                         }
 507                         answer = cmp(tmp, answer);
 508                 }
 509         return answer;
 510 }
 511
 512 void line_graph_draw(struct graph *g, cairo_t *cr)
 513 {
 514         double x1, y1, x2, y2;
 515         double minx, miny, maxx, maxy, gminx, gminy, gmaxx, gmaxy;
 516         double tx, ty, top_extra, bottom_extra, left_extra, right_extra;
 517         struct graph_label *i;
 518         struct graph_value *j;
 519         int good_data = 1, first = 1;
 520
 521         cairo_save(cr);
 522         cairo_translate(cr, g->xoffset, g->yoffset);
 523         graph_draw_common(g, cr, &x1, &y1, &x2, &y2);
 524
 525         minx = find_xy_value(g, getx, mindouble);
 526         maxx = find_xy_value(g, getx, maxdouble);
 527         miny = find_xy_value(g, gety, mindouble);
 528         maxy = find_xy_value(g, gety, maxdouble);
 529
 530         if (fabs(maxx - minx) < 1e-20 || fabs(maxy - miny) < 1e-20) {
 531                 good_data = 0;
 532                 minx = 0.0;
 533                 miny = 0.0;
 534                 maxx = 10.0;
 535                 maxy = 100.0;
 536         }
 537
 538         top_extra = 0.0;
 539         bottom_extra = 0.0;
 540         left_extra = 0.0;
 541         right_extra = 0.0;
 542
 543         if (g->top_extra > 0.001)
 544                 top_extra = fabs(maxy - miny) * g->top_extra;
 545         if (g->bottom_extra > 0.001)
 546                 bottom_extra = fabs(maxy - miny) * g->bottom_extra;
 547         if (g->left_extra > 0.001)
 548                 left_extra = fabs(maxx - minx) * g->left_extra;
 549         if (g->right_extra > 0.001)
 550                 right_extra = fabs(maxx - minx) * g->right_extra;
 551
 552         gminx = minx - left_extra;
 553         gmaxx = maxx + right_extra;
 554         gminy = miny - bottom_extra;
 555         gmaxy = maxy + top_extra;
 556
 557         graph_draw_x_ticks(g, cr, x1, y1, x2, y2, gminx, gmaxx, 10, good_data);
 558         gmaxy = graph_draw_y_ticks(g, cr, x1, y1, x2, y2, gminy, gmaxy, 10, good_data);
 559
 560         if (!good_data)
 561                 goto skip_data;
 562
 563         cairo_set_line_width(cr, 1.5);
 564         for (i = g->labels; i; i = i->next) {
 565                 first = 1;
 566                 if (i->r < 0) /* invisible data */
 567                         continue;
 568                 cairo_set_source_rgb(cr, i->r, i->g, i->b);
 569                 for (j = i->values; j; j = j->next) {
 570                         struct xyvalue *xy = j->value;
 571
 572                         tx = ((getx(j) - gminx) / (gmaxx - gminx)) * (x2 - x1) + x1;
 573                         ty = y2 - ((gety(j) - gminy) / (gmaxy - gminy)) * (y2 - y1);
 574                         if (first) {
 575                                 cairo_move_to(cr, tx, ty);
 576                                 first = 0;
 577                         } else {
 578                                 cairo_line_to(cr, tx, ty);
 579                         }
 580                         xy->gx = tx;
 581                         xy->gy = ty;
 582                 }
 583                 cairo_stroke(cr);
 584         }
 585
 586 skip_data:
 587         cairo_restore(cr);
 588
 589 }
 590
 591 static void gfree(void *f)
 592 {
 593         if (f)
 594                 free(f);
 595 }
 596
 597 static void setstring(char **str, const char *value)
 598 {
 599         gfree(*str);
 600         *str = strdup(value);
 601 }
 602
 603 void graph_title(struct graph *bg, const char *title)
 604 {
 605         setstring(&bg->title, title);
 606 }
 607
 608 void graph_x_title(struct graph *bg, const char *title)
 609 {
 610         setstring(&bg->xtitle, title);
 611 }
 612
 613 void graph_y_title(struct graph *bg, const char *title)
 614 {
 615         setstring(&bg->ytitle, title);
 616 }
 617
 618 static struct graph_label *graph_find_label(struct graph *bg,
 619                                 const char *label)
 620 {
 621         struct graph_label *i;
 622
 623         for (i = bg->labels; i; i = i->next)
 624                 if (strcmp(label, i->label) == 0)
 625                         return i;
 626         return NULL;
 627 }
 628
 629 void graph_add_label(struct graph *bg, const char *label)
 630 {
 631         struct graph_label *i;
 632
 633         i = graph_find_label(bg, label);
 634         if (i)
 635                 return; /* already present. */
 636         i = calloc(1, sizeof(*i));
 637         i->parent = bg;
 638         setstring(&i->label, label);
 639         i->next = NULL;
 640         if (!bg->tail)
 641                 bg->labels = i;
 642         else
 643                 bg->tail->next = i;
 644         bg->tail = i;
 645 }
 646
 647 static void graph_label_add_value(struct graph_label *i, void *value,
 648                                   const char *tooltip)
 649 {
 650         struct graph_value *x;
 651
 652         x = malloc(sizeof(*x));
 653         x->value = value;
 654         if (tooltip)
 655                 x->tooltip = strdup(tooltip);
 656         else
 657                 x->tooltip = NULL;
 658         x->next = NULL;
 659         if (!i->tail) {
 660                 i->values = x;
 661         } else {
 662                 i->tail->next = x;
 663         }
 664         i->tail = x;
 665         i->value_count++;
 666         if (x->tooltip)
 667                 i->tooltip_count++;
 668
 669         if (i->parent->per_label_limit != -1 &&
 670                 i->value_count > i->parent->per_label_limit) {
 671                 int to_drop = 1;
 672
 673                 /*
 674                  * If the limit was dynamically reduced, making us more
 675                  * than 1 entry ahead after adding this one, drop two
 676                  * entries. This will make us (eventually) reach the
 677                  * specified limit.
 678                  */
 679                 if (i->value_count - i->parent->per_label_limit >= 2)
 680                         to_drop = 2;
 681
 682                 while (to_drop--) {
 683                         x = i->values;
 684                         i->values = i->values->next;
 685                         if (x->tooltip) {
 686                                 free(x->tooltip);
 687                                 i->tooltip_count--;
 688                         }
 689                         free(x->value);
 690                         free(x);
 691                         i->value_count--;
 692                 }
 693         }
 694 }
 695
 696 int graph_add_data(struct graph *bg, const char *label, const double value)
 697 {
 698         struct graph_label *i;
 699         double *d;
 700
 701         d = malloc(sizeof(*d));
 702         *d = value;
 703
 704         i = graph_find_label(bg, label);
 705         if (!i)
 706                 return -1;
 707         graph_label_add_value(i, d, NULL);
 708         return 0;
 709 }
 710
 711 int graph_add_xy_data(struct graph *bg, const char *label,
 712                       const double x, const double y, const char *tooltip)
 713 {
 714         struct graph_label *i;
 715         struct xyvalue *xy;
 716
 717         xy = malloc(sizeof(*xy));
 718         xy->x = x;
 719         xy->y = y;
 720
 721         i = graph_find_label(bg, label);
 722         if (!i)
 723                 return -1;
 724
 725         graph_label_add_value(i, xy, tooltip);
 726         return 0;
 727 }
 728
 729 static void graph_free_values(struct graph_value *values)
 730 {
 731         struct graph_value *i, *next;
 732
 733         for (i = values; i; i = next) {
 734                 next = i->next;
 735                 gfree(i->value);
 736                 gfree(i);
 737         }
 738 }
 739
 740 static void graph_free_labels(struct graph_label *labels)
 741 {
 742         struct graph_label *i, *next;
 743
 744         for (i = labels; i; i = next) {
 745                 next = i->next;
 746                 graph_free_values(i->values);
 747                 gfree(i);
 748         }
 749 }
 750
 751 void graph_set_color(struct graph *gr, const char *label,
 752         double red, double green, double blue)
 753 {
 754         struct graph_label *i;
 755         double r, g, b;
 756
 757         if (red < 0.0) { /* invisible color */
 758                 r = -1.0;
 759                 g = -1.0;
 760                 b = -1.0;
 761         } else {
 762                 r = fabs(red);
 763                 g = fabs(green);
 764                 b = fabs(blue);
 765
 766                 if (r > 1.0)
 767                         r = 1.0;
 768                 if (g > 1.0)
 769                         g = 1.0;
 770                 if (b > 1.0)
 771                         b =1.0;
 772         }
 773
 774         for (i = gr->labels; i; i = i->next)
 775                 if (strcmp(i->label, label) == 0) {
 776                         i->r = r;
 777                         i->g = g;
 778                         i->b = b;
 779                         break;
 780                 }
 781 }
 782
 783 void graph_free(struct graph *bg)
 784 {
 785         gfree(bg->title);
 786         gfree(bg->xtitle);
 787         gfree(bg->ytitle);
 788         graph_free_labels(bg->labels);
 789 }
 790
 791 /* For each line in the line graph, up to per_label_limit segments may
 792  * be added.  After that, adding more data to the end of the line
 793  * causes data to drop off of the front of the line.
 794  */
 795 void line_graph_set_data_count_limit(struct graph *g, int per_label_limit)
 796 {
 797         g->per_label_limit = per_label_limit;
 798 }
 799
 800 void graph_add_extra_space(struct graph *g, double left_percent, double right_percent,
 801                                 double top_percent, double bottom_percent)
 802 {
 803         g->left_extra = left_percent;
 804         g->right_extra = right_percent;
 805         g->top_extra = top_percent;
 806         g->bottom_extra = bottom_percent;
 807 }
 808
 809 /*
 810  * Normally values are logged in a base unit of 0, but for other purposes
 811  * it makes more sense to log in higher unit. For instance for bandwidth
 812  * purposes, you may want to log in KB/sec (or MB/sec) rather than bytes/sec.
 813  */
 814 void graph_set_base_offset(struct graph *g, unsigned int base_offset)
 815 {
 816         g->base_offset = base_offset;
 817 }
 818
 819 int graph_has_tooltips(struct graph *g)
 820 {
 821         struct graph_label *i;
 822
 823         for (i = g->labels; i; i = i->next)
 824                 if (i->tooltip_count)
 825                         return 1;
 826
 827         return 0;
 828 }
 829
 830 int graph_contains_xy(struct graph *g, int x, int y)
 831 {
 832         int first_x = g->xoffset;
 833         int last_x = g->xoffset + g->xdim;
 834         int first_y = g->yoffset;
 835         int last_y = g->yoffset + g->ydim;
 836
 837         return (x >= first_x && x <= last_x) && (y >= first_y && y <= last_y);
 838 }
 839
 840 static int xy_match(struct xyvalue *xy, int x, int y)
 841 {
 842         int xdiff = abs(xy->gx - x);
 843         int ydiff = abs(xy->gy - y);
 844
 845         return xdiff <= 20 && ydiff <= 10;
 846 }
 847
 848 const char *graph_find_tooltip(struct graph *g, int x, int y)
 849 {
 850         struct graph_label *i;
 851         struct graph_value *j;
 852
 853         for (i = g->labels; i; i = i->next) {
 854                 for (j = i->values; j; j = j->next) {
 855                         struct xyvalue *xy = j->value;
 856
 857                         if (xy_match(xy, x - g->xoffset, y))
 858                                 return j->tooltip;
 859                 }
 860         }
 861
 862         return NULL;
 863 }