util/show-events.c

   1 #define _GNU_SOURCE
   2 #include <gtk/gtk.h>
   3 #include <stdlib.h>
   4 #include <stdio.h>
   5 #include <string.h>
   6 #include <gdk/gdkkeysyms.h>
   7 #include <math.h>
   8
   9 typedef struct _point {
  10     gdouble x, y;
  11 } point_t;
  12 typedef struct _box {
  13     point_t p1, p2;
  14 } box_t;
  15 typedef struct _line {
  16     point_t p1, p2;
  17 } line_t;
  18
  19 typedef struct _edge {
  20     gulong id;
  21     line_t line;
  22     gdouble top, bottom;
  23     point_t p1, p2;
  24     int dir;
  25 } edge_t;
  26 typedef struct _trapezoid {
  27     gdouble top, bottom;
  28     const edge_t *left, *right;
  29 } trapezoid_t;
  30 typedef struct _traps {
  31     int num_traps;
  32     int size;
  33     trapezoid_t traps[0];
  34 } traps_t;
  35
  36 typedef struct _edges {
  37     GHashTable *ht;
  38
  39     int num_edges;
  40     int size;
  41     edge_t edges[0];
  42 } edges_t;
  43
  44 typedef struct _event {
  45     enum {
  46         START_EDGE,
  47         END_EDGE,
  48         INTERSECTION,
  49         START_TRAP,
  50         END_TRAP,
  51     } type;
  52
  53     int x, y; /* (top, bottom) for trap */
  54     long e1, e2;
  55 } event_t;
  56
  57 typedef struct _events {
  58     struct _events *prev, *next;
  59
  60     box_t extents;
  61     edges_t *edges;
  62     traps_t *prototraps;
  63     traps_t *traps;
  64
  65     int current_event;
  66     int num_events;
  67     int size_events;
  68     event_t *events;
  69 } events_t;
  70
  71 typedef struct _EventView {
  72     GtkWidget widget;
  73
  74     events_t *events_list;
  75     events_t *current_events;
  76
  77     double px, py;
  78
  79     gint mag_x, mag_y;
  80     gint mag_size;
  81     gdouble mag_zoom;
  82     gboolean in_mag_drag;
  83     gint mag_drag_x, mag_drag_y;
  84 } EventView;
  85
  86 typedef struct _EventViewClass {
  87     GtkWidgetClass parent_class;
  88 } EventViewClass;
  89
  90 G_DEFINE_TYPE (EventView, event_view, GTK_TYPE_WIDGET)
  91
  92 static edge_t *
  93 edges_lookup (edges_t *edges, gulong id)
  94 {
  95     return &edges->edges[GPOINTER_TO_UINT(g_hash_table_lookup (edges->ht,
  96                                                                GUINT_TO_POINTER
  97                                                                (id)))];
  98 }
  99
 100 static gdouble
 101 _compute_intersection_x_for_y (const line_t *line,
 102                                gdouble y)
 103 {
 104     gdouble dx = line->p2.x - line->p1.x;
 105     gdouble dy = line->p2.y - line->p1.y;
 106     gdouble x;
 107
 108     if (y == line->p1.y)
 109         return line->p1.x;
 110     if (y == line->p2.y)
 111         return line->p2.x;
 112
 113     x = line->p1.x;
 114     if (dy != 0)
 115         x +=  (y - line->p1.y)*dx/dy;
 116     return x;
 117 }
 118
 119 static void
 120 _compute_intersection_point (const line_t *line,
 121                              gdouble y,
 122                              point_t *p)
 123 {
 124     p->x = _compute_intersection_x_for_y (line, p->y = y);
 125 }
 126
 127 static void
 128 _edge_path (cairo_t *cr, const cairo_matrix_t *m, const edge_t *e)
 129 {
 130     double x, y;
 131
 132     x = e->p1.x; y = e->p1.y;
 133     cairo_matrix_transform_point (m, &x, &y);
 134     cairo_move_to (cr, x, y);
 135
 136     x = e->p2.x; y = e->p2.y;
 137     cairo_matrix_transform_point (m, &x, &y);
 138     cairo_line_to (cr, x, y);
 139
 140     if (e->dir < 0) {
 141         cairo_set_source_rgb (cr, 0, 0, 1);
 142     } else {
 143         cairo_set_source_rgb (cr, 1, 0, 0);
 144     }
 145 }
 146
 147 static void
 148 _events_draw (events_t *events, cairo_t *cr, cairo_matrix_t *m)
 149 {
 150     double dash[2] = {8, 8};
 151     point_t p;
 152     int n;
 153
 154     /* first the existing and proto-traps */
 155     cairo_save (cr); {
 156         cairo_set_matrix (cr, m);
 157
 158         cairo_set_source_rgba (cr, 1, 0, 0, .15);
 159         for (n = 0; n < events->prototraps->num_traps; n++) {
 160             const trapezoid_t *t = &events->prototraps->traps[n];
 161
 162             _compute_intersection_point (&t->left->line, t->top, &p);
 163             cairo_move_to (cr, p.x, p.y);
 164             _compute_intersection_point (&t->right->line, t->top, &p);
 165             cairo_line_to (cr, p.x, p.y);
 166             _compute_intersection_point (&t->right->line, t->bottom, &p);
 167             cairo_line_to (cr, p.x, p.y);
 168             _compute_intersection_point (&t->left->line, t->bottom, &p);
 169             cairo_line_to (cr, p.x, p.y);
 170             cairo_close_path (cr);
 171             cairo_fill (cr);
 172         }
 173
 174         cairo_set_source_rgba (cr, 0, 1, 0, .2);
 175         for (n = 0; n < events->traps->num_traps; n++) {
 176             const trapezoid_t *t = &events->traps->traps[n];
 177
 178             _compute_intersection_point (&t->left->line, t->top, &p);
 179             cairo_move_to (cr, p.x, p.y);
 180             _compute_intersection_point (&t->right->line, t->top, &p);
 181             cairo_line_to (cr, p.x, p.y);
 182             _compute_intersection_point (&t->right->line, t->bottom, &p);
 183             cairo_line_to (cr, p.x, p.y);
 184             _compute_intersection_point (&t->left->line, t->bottom, &p);
 185             cairo_line_to (cr, p.x, p.y);
 186             cairo_close_path (cr);
 187             cairo_fill (cr);
 188         }
 189     } cairo_restore (cr);
 190
 191     /* known edges */
 192     cairo_save (cr);
 193     cairo_set_line_width (cr, 1.);
 194     for (n = 0; n < events->edges->num_edges; n++) {
 195         const edge_t *e = &events->edges->edges[n];
 196         double x, y;
 197
 198         x = e->p1.x; y = e->p1.y;
 199         cairo_matrix_transform_point (m, &x, &y);
 200         cairo_move_to (cr, x, y);
 201
 202         x = e->p2.x; y = e->p2.y;
 203         cairo_matrix_transform_point (m, &x, &y);
 204         cairo_line_to (cr, x, y);
 205
 206         if (e->dir < 0) {
 207             cairo_set_source_rgba (cr, 0, 0, 1., .4);
 208             cairo_set_dash (cr, dash, 2, fmod (e->p1.x, dash[0]+dash[1]) + dash[0]);
 209         } else {
 210             cairo_set_source_rgba (cr, 1, 0, 0., 4);
 211             cairo_set_dash (cr, dash, 2, fmod (e->p1.x, dash[0]+dash[1]));
 212         }
 213
 214         cairo_stroke (cr);
 215
 216         x = e->p1.x; y = e->p1.y;
 217         cairo_matrix_transform_point (m, &x, &y);
 218         cairo_arc (cr, x, y, 2., 0, 2 * G_PI);
 219
 220         x = e->p2.x; y = e->p2.y;
 221         cairo_matrix_transform_point (m, &x, &y);
 222         cairo_arc (cr, x, y, 2., 0, 2 * G_PI);
 223
 224         cairo_fill (cr);
 225     }
 226     cairo_restore (cr);
 227
 228     /* event time */
 229     cairo_save (cr); {
 230         event_t *e;
 231         double x, y;
 232
 233         e = &events->events[events->current_event];
 234
 235         cairo_set_line_width (cr, 2.);
 236         cairo_set_matrix (cr, m);
 237         cairo_move_to (cr,
 238                        events->extents.p1.x,
 239                        e->y);
 240         cairo_line_to (cr,
 241                        events->extents.p2.x,
 242                        e->y);
 243         cairo_identity_matrix (cr);
 244         cairo_stroke (cr);
 245
 246         x = e->x; y = e->y;
 247         cairo_matrix_transform_point (m, &x, &y);
 248         switch (e->type) {
 249         case START_EDGE:
 250         case END_EDGE:
 251         case INTERSECTION:
 252             cairo_arc (cr, x, y, 4., 0, 2 * G_PI);
 253             break;
 254         case START_TRAP:
 255         case END_TRAP:
 256             break;
 257         }
 258         switch (e->type) {
 259         case START_EDGE:
 260             cairo_set_source_rgb (cr, 1, 0, 0);
 261             break;
 262         case END_EDGE:
 263             cairo_set_source_rgb (cr, 0, 0, 1);
 264             break;
 265         case INTERSECTION:
 266             cairo_set_source_rgb (cr, 1, 0, 1);
 267             break;
 268         case START_TRAP:
 269         case END_TRAP:
 270             break;
 271         }
 272         cairo_fill (cr);
 273
 274         cairo_set_line_width (cr, 1.);
 275         switch (e->type) {
 276         case START_EDGE:
 277             _edge_path (cr, m, edges_lookup (events->edges, e->e1));
 278             cairo_stroke (cr);
 279             break;
 280         case END_EDGE:
 281             _edge_path (cr, m, edges_lookup (events->edges, e->e1));
 282             cairo_stroke (cr);
 283             break;
 284         case INTERSECTION:
 285             _edge_path (cr, m, edges_lookup (events->edges, e->e1));
 286             cairo_stroke (cr);
 287             _edge_path (cr, m, edges_lookup (events->edges, e->e2));
 288             cairo_stroke (cr);
 289             break;
 290         }
 291     } cairo_restore (cr);
 292 }
 293
 294 static void
 295 event_view_draw (EventView *self, cairo_t *cr)
 296 {
 297     events_t *events;
 298     gdouble sf_x, sf_y, sf;
 299     gdouble mid, dim;
 300     gdouble x0, x1,  y0, y1;
 301     cairo_matrix_t m;
 302
 303     cairo_save (cr);
 304     cairo_set_source_rgb (cr, 1, 1, 1);
 305     cairo_paint (cr);
 306     cairo_restore (cr);
 307
 308     events = self->current_events;
 309     if (events == NULL)
 310         return;
 311
 312     mid = (events->extents.p2.x + events->extents.p1.x) / 2.;
 313     dim = (events->extents.p2.x - events->extents.p1.x) / 2. * 1.2;
 314     sf_x = self->widget.allocation.width / dim / 2;
 315
 316     mid = (events->extents.p2.y + events->extents.p1.y) / 2.;
 317     dim = (events->extents.p2.y - events->extents.p1.y) / 2. * 1.2;
 318     sf_y = self->widget.allocation.height / dim / 2;
 319
 320     sf = MIN (sf_x, sf_y);
 321
 322     mid = (events->extents.p2.x + events->extents.p1.x) / 2.;
 323     dim = sf_x / sf * (events->extents.p2.x - events->extents.p1.x) / 2. * 1.2;
 324     x0 = mid - dim;
 325     x1 = mid + dim;
 326     mid = (events->extents.p2.y + events->extents.p1.y) / 2.;
 327     dim = sf_y / sf * (events->extents.p2.y - events->extents.p1.y) / 2. * 1.2;
 328     y0 = mid - dim;
 329     y1 = mid + dim;
 330
 331     cairo_matrix_init_scale (&m, sf, sf);
 332     cairo_matrix_translate (&m, -x0, -y0);
 333     _events_draw (events, cr, &m);
 334
 335     /* draw a zoom view of the area around the mouse */
 336     cairo_save (cr); {
 337         double zoom = self->mag_zoom;
 338         int size = self->mag_size;
 339
 340         /* bottom right */
 341         cairo_rectangle (cr, self->mag_x, self->mag_y, size, size);
 342         cairo_stroke_preserve (cr);
 343         cairo_set_source_rgb (cr, 1, 1, 1);
 344         cairo_fill_preserve (cr);
 345         cairo_clip (cr);
 346
 347         /* compute roi in extents */
 348         cairo_translate (cr, self->mag_x + size/2, self->mag_y + size/2);
 349
 350         cairo_matrix_init_scale (&m, zoom, zoom);
 351         cairo_matrix_translate (&m, -(self->px / sf + x0), -(self->py /sf + y0));
 352         _events_draw (events, cr, &m);
 353
 354         /* grid */
 355         cairo_save (cr); {
 356             int i;
 357
 358             cairo_translate (cr,
 359                              -zoom*fmod (self->px/sf + x0, 1.),
 360                              -zoom*fmod (self->py/sf + y0, 1.));
 361             for (i = -size/2/zoom - 1; i <= size/2/zoom + 1; i++) {
 362                 cairo_move_to (cr, zoom*i, -size/2);
 363                 cairo_line_to (cr, zoom*i, size/2 + zoom);
 364                 cairo_move_to (cr, -size/2, zoom*i);
 365                 cairo_line_to (cr, size/2 + zoom, zoom*i);
 366             }
 367             cairo_set_source_rgba (cr, .7, .7, .7, .5);
 368             cairo_set_line_width (cr, 1.);
 369             cairo_stroke (cr);
 370         } cairo_restore (cr);
 371     } cairo_restore (cr);
 372 }
 373
 374 static void
 375 event_view_draw_labels (EventView *self, cairo_t *cr)
 376 {
 377     events_t *events;
 378
 379     events = self->current_events;
 380     if (events == NULL)
 381         return;
 382
 383 }
 384
 385 static gboolean
 386 event_view_expose (GtkWidget *w, GdkEventExpose *ev)
 387 {
 388     EventView *self = (EventView *) w;
 389     cairo_t *cr;
 390
 391     cr = gdk_cairo_create (w->window);
 392     gdk_cairo_region (cr, ev->region);
 393     cairo_clip (cr);
 394
 395     event_view_draw (self, cr);
 396     event_view_draw_labels (self, cr);
 397
 398     cairo_destroy (cr);
 399     return FALSE;
 400 }
 401
 402 static void
 403 traps_clear (traps_t *traps)
 404 {
 405     traps->num_traps = 0;
 406 }
 407
 408 static traps_t *
 409 traps_add (traps_t *traps, int top, int bot, const edge_t *e1, const edge_t *e2)
 410 {
 411     trapezoid_t *t;
 412
 413     if (traps->num_traps == traps->size) {
 414         traps->size *= 2;
 415         traps = g_realloc (traps,
 416                            sizeof (traps_t) + traps->size*sizeof (trapezoid_t));
 417     }
 418
 419     t = &traps->traps[traps->num_traps++];
 420     t->top = top;
 421     if (bot > e1->bottom)
 422         bot = e1->bottom;
 423     if (bot > e2->bottom)
 424         bot = e2->bottom;
 425     t->bottom = bot;
 426
 427     t->left = e1;
 428     t->right = e2;
 429
 430     return traps;
 431 }
 432
 433 static void
 434 traps_remove (traps_t *traps, int top, const edge_t *e1, const edge_t *e2)
 435 {
 436     int n;
 437
 438     for (n = 0; n < traps->num_traps; n++) {
 439         trapezoid_t *t = &traps->traps[n];
 440         if (t->top == top && t->left == e1 && t->right == e2)
 441             break;
 442     }
 443     if (n < traps->num_traps) {
 444         g_memmove (&traps->traps[n],
 445                    &traps->traps[n+1],
 446                    (traps->num_traps-n+1) * sizeof (trapezoid_t));
 447         traps->num_traps--;
 448     }
 449 }
 450
 451 static void
 452 event_next (EventView *self)
 453 {
 454     events_t *events;
 455     event_t *e;
 456
 457     events = self->current_events;
 458     if (++events->current_event == events->num_events) {
 459         return;
 460     } else if (events->current_event >= events->num_events) {
 461         traps_clear (events->prototraps);
 462         traps_clear (events->traps);
 463         events->current_event = 0;
 464
 465         self->current_events = events->next;
 466         if (self->current_events == NULL)
 467             self->current_events = self->events_list;
 468         events = self->current_events;
 469     }
 470
 471     e = &events->events[events->current_event];
 472     switch (e->type) {
 473     case START_TRAP:
 474         events->prototraps = traps_add (events->prototraps,
 475                                         e->x, G_MAXINT,
 476                                         edges_lookup (events->edges, e->e1),
 477                                         edges_lookup (events->edges, e->e2));
 478         break;
 479     case END_TRAP:
 480         traps_remove (events->prototraps,
 481                       e->x,
 482                       edges_lookup (events->edges, e->e1),
 483                       edges_lookup (events->edges, e->e2));
 484         events->traps = traps_add (events->traps,
 485                                    e->x, e->y,
 486                                    edges_lookup (events->edges, e->e1),
 487                                    edges_lookup (events->edges, e->e2));
 488         break;
 489     }
 490 }
 491
 492 static gboolean
 493 event_view_button_press (GtkWidget *w, GdkEventButton *ev)
 494 {
 495     EventView *self = (EventView *) w;
 496
 497     if (ev->x < self->mag_x ||
 498         ev->y < self->mag_y ||
 499         ev->x > self->mag_x + self->mag_size ||
 500         ev->y > self->mag_y + self->mag_size)
 501     {
 502         if (ev->type == GDK_BUTTON_PRESS) {
 503             event_next (self);
 504             gtk_widget_queue_draw (w);
 505         }
 506     }
 507     else
 508     {
 509         self->in_mag_drag = TRUE;
 510         self->mag_drag_x = ev->x;
 511         self->mag_drag_y = ev->y;
 512     }
 513
 514     return FALSE;
 515 }
 516
 517 static gboolean
 518 event_view_button_release (GtkWidget *w, GdkEventButton *ev)
 519 {
 520     EventView *self = (EventView *) w;
 521
 522     self->in_mag_drag = FALSE;
 523
 524     return FALSE;
 525 }
 526
 527 static gboolean
 528 event_view_motion (GtkWidget *w, GdkEventMotion *ev)
 529 {
 530     EventView *self = (EventView *) w;
 531
 532     if (self->in_mag_drag) {
 533         self->mag_x += ev->x - self->mag_drag_x;
 534         self->mag_y += ev->y - self->mag_drag_y;
 535
 536         gtk_widget_queue_draw (&self->widget);
 537
 538         self->mag_drag_x = ev->x;
 539         self->mag_drag_y = ev->y;
 540     } else if (ev->x < self->mag_x ||
 541                ev->y < self->mag_y ||
 542                ev->x > self->mag_x + self->mag_size ||
 543                ev->y > self->mag_y + self->mag_size)
 544     {
 545         self->px = ev->x;
 546         self->py = ev->y;
 547
 548         gtk_widget_queue_draw (&self->widget);
 549     }
 550
 551     return FALSE;
 552 }
 553
 554 static void
 555 event_view_realize (GtkWidget *widget)
 556 {
 557     GdkWindowAttr attributes;
 558
 559     GTK_WIDGET_SET_FLAGS (widget, GTK_REALIZED);
 560
 561     attributes.window_type = GDK_WINDOW_CHILD;
 562     attributes.x = widget->allocation.x;
 563     attributes.y = widget->allocation.y;
 564     attributes.width  = widget->allocation.width;
 565     attributes.height = widget->allocation.height;
 566     attributes.wclass = GDK_INPUT_OUTPUT;
 567     attributes.visual = gtk_widget_get_visual (widget);
 568     attributes.colormap = gtk_widget_get_colormap (widget);
 569     attributes.event_mask = gtk_widget_get_events (widget) |
 570                             GDK_BUTTON_PRESS_MASK |
 571                             GDK_BUTTON_RELEASE_MASK |
 572                             GDK_KEY_PRESS_MASK |
 573                             GDK_KEY_RELEASE_MASK |
 574                             GDK_POINTER_MOTION_MASK |
 575                             GDK_BUTTON_MOTION_MASK |
 576                             GDK_EXPOSURE_MASK;
 577
 578     widget->window = gdk_window_new (gtk_widget_get_parent_window (widget),
 579                                      &attributes,
 580                                      GDK_WA_X | GDK_WA_Y |
 581                                      GDK_WA_VISUAL | GDK_WA_COLORMAP);
 582     gdk_window_set_user_data (widget->window, widget);
 583
 584     widget->style = gtk_style_attach (widget->style, widget->window);
 585     gtk_style_set_background (widget->style, widget->window, GTK_STATE_NORMAL);
 586 }
 587
 588 static void
 589 event_view_size_allocate (GtkWidget *w, GdkRectangle *r)
 590 {
 591     EventView *self = (EventView *) w;
 592
 593     GTK_WIDGET_CLASS (event_view_parent_class)->size_allocate (w, r);
 594
 595     self->mag_x = w->allocation.width - self->mag_size - 10;
 596     self->mag_y = w->allocation.height - self->mag_size - 10;
 597 }
 598
 599 static void
 600 event_view_finalize (GObject *obj)
 601 {
 602     G_OBJECT_CLASS (event_view_parent_class)->finalize (obj);
 603 }
 604
 605 static void
 606 event_view_class_init (EventViewClass *klass)
 607 {
 608     GObjectClass *object_class = (GObjectClass *) klass;
 609     GtkWidgetClass *widget_class = (GtkWidgetClass *) klass;
 610
 611     object_class->finalize = event_view_finalize;
 612
 613     widget_class->realize = event_view_realize;
 614     widget_class->size_allocate = event_view_size_allocate;
 615     widget_class->expose_event = event_view_expose;
 616     widget_class->button_press_event = event_view_button_press;
 617     widget_class->button_release_event = event_view_button_release;
 618     widget_class->motion_notify_event = event_view_motion;
 619 }
 620
 621 static void
 622 event_view_init (EventView *self)
 623 {
 624     self->mag_zoom = 10;
 625     self->mag_size = 200;
 626 }
 627
 628 static traps_t *
 629 traps_new (void)
 630 {
 631     traps_t *t;
 632
 633     t = g_malloc (sizeof (traps_t) + 16 * sizeof (trapezoid_t));
 634
 635     t->size = 16;
 636     t->num_traps = 0;
 637
 638     return t;
 639 }
 640
 641 static edges_t *
 642 _edges_add_edge (edges_t *edges, edge_t *e, box_t *extents)
 643 {
 644     if (e->top < extents->p1.y)
 645         extents->p1.y = e->top;
 646     if (e->bottom > extents->p2.y)
 647         extents->p2.y = e->bottom;
 648
 649     _compute_intersection_point (&e->line, e->top, &e->p1);
 650     _compute_intersection_point (&e->line, e->bottom, &e->p2);
 651
 652     if (e->p1.x < extents->p1.x)
 653         extents->p1.x = e->p1.x;
 654     if (e->p2.x < extents->p1.x)
 655         extents->p1.x = e->p2.x;
 656
 657     if (e->p1.x > extents->p2.x)
 658         extents->p2.x = e->p1.x;
 659     if (e->p2.x > extents->p2.x)
 660         extents->p2.x = e->p2.x;
 661
 662     if (edges->num_edges == edges->size) {
 663         edges->size *= 2;
 664         edges = g_realloc (edges,
 665                            sizeof (edges_t) + edges->size * sizeof (edge_t));
 666     }
 667
 668     g_hash_table_insert (edges->ht,
 669                          GUINT_TO_POINTER (e->id),
 670                          GUINT_TO_POINTER (edges->num_edges));
 671     edges->edges[edges->num_edges++] = *e;
 672
 673     return edges;
 674 }
 675
 676 static void
 677 _events_add_event (events_t *events,
 678                    int type,
 679                    int x, int y,
 680                    gulong e1, gulong e2)
 681 {
 682     event_t *e;
 683
 684     if (events->num_events == events->size_events) {
 685         int newsize = 2 * events->size_events;
 686         void *newevents;
 687
 688         newevents = g_renew (event_t, events->events, newsize);
 689         events->events = newevents;
 690         events->size_events = newsize;
 691     }
 692
 693     e = &events->events[events->num_events++];
 694     e->type = type;
 695     e->x = x;
 696     e->y = y;
 697     e->e1 = e1;
 698     e->e2 = e2;
 699 }
 700
 701 static edges_t *
 702 edges_new (void)
 703 {
 704     edges_t *t;
 705
 706     t = g_malloc (sizeof (edges_t) + 16 * sizeof (edge_t));
 707     t->ht = g_hash_table_new (NULL, NULL);
 708     t->size = 16;
 709     t->num_edges = 0;
 710
 711     return t;
 712 }
 713
 714 static events_t *
 715 events_new (void)
 716 {
 717     events_t *events;
 718
 719     events = g_malloc (sizeof (events_t));
 720
 721     events->next = NULL;
 722     events->prev = NULL;
 723
 724     events->events = g_new (event_t, 16);
 725     events->size_events = 16;
 726     events->num_events = 0;
 727     events->current_event = 0;
 728
 729     events->edges = edges_new ();
 730     events->prototraps = traps_new ();
 731     events->traps = traps_new ();
 732
 733     events->extents.p1.x = G_MAXDOUBLE;
 734     events->extents.p1.y = G_MAXDOUBLE;
 735     events->extents.p2.x = -G_MAXDOUBLE;
 736     events->extents.p2.y = -G_MAXDOUBLE;
 737
 738     return events;
 739 }
 740
 741 static void
 742 events_read (EventView *ev, const char *filename)
 743 {
 744     FILE *file;
 745
 746     file = fopen (filename, "r");
 747     if (file != NULL) {
 748         char *line = NULL;
 749         size_t len = 0;
 750         events_t *events;
 751
 752         events = ev->events_list = events_new ();
 753         while (getline (&line, &len, file) != -1) {
 754             line = g_strstrip (line);
 755             if (*line == '\0') {
 756                 events->next = events_new ();
 757                 events->next->prev = events;
 758                 events = events->next;
 759             } else if (g_str_has_prefix (line, "edge:")) {
 760                 edge_t edge;
 761
 762                 sscanf (line, "edge: %lu (%lf, %lf) (%lf, %lf) (%lf, %lf) %d",
 763                         &edge.id,
 764                         &edge.line.p1.x,
 765                         &edge.line.p1.y,
 766                         &edge.line.p2.x,
 767                         &edge.line.p2.y,
 768                         &edge.top,
 769                         &edge.bottom,
 770                         &edge.dir);
 771
 772                 events->edges = _edges_add_edge (events->edges,
 773                                                  &edge,
 774                                                  &events->extents);
 775             } else if (g_str_has_prefix (line, "event:")) {
 776                 int type;
 777                 int x,y;
 778                 gulong e1, e2;
 779
 780                 sscanf (line, "event: %d (%d, %d) %lu %lu",
 781                         &type, &x, &y,
 782                         &e1, &e2);
 783
 784                 _events_add_event (events, type, x, y, e1, e2);
 785             } else if (g_str_has_prefix (line, "begin trap:")) {
 786                 int top;
 787                 gulong e1, e2;
 788
 789                 sscanf (line, "begin trap: %lu %lu %u", &e1, &e2, &top);
 790
 791                 _events_add_event (events, START_TRAP, top, 0, e1, e2);
 792             } else if (g_str_has_prefix (line, "end trap:")) {
 793                 int top, bottom;
 794                 gulong e1, e2;
 795
 796                 sscanf (line, "end trap: %lu %lu %d %d",
 797                         &e1, &e2, &top, &bottom);
 798
 799                 _events_add_event (events, END_TRAP, top, bottom, e1, e2);
 800             }
 801         }
 802
 803         ev->current_events = ev->events_list;
 804
 805         free (line);
 806         fclose (file);
 807     }
 808 }
 809
 810 static gboolean
 811 timeout_advance (EventView *self)
 812 {
 813     event_next (self);
 814     gtk_widget_queue_draw (&self->widget);
 815     return TRUE;
 816 }
 817
 818 int
 819 main (int argc, char **argv)
 820 {
 821     EventView *ev;
 822     GtkWidget *window, *hbox;
 823
 824     gtk_init (&argc, &argv);
 825
 826     hbox = gtk_hbox_new (TRUE, 0);
 827
 828     ev = g_object_new (event_view_get_type (), NULL);
 829     gtk_box_pack_start (GTK_BOX (hbox), &ev->widget, TRUE, TRUE, 0);
 830     gtk_widget_show (&ev->widget);
 831
 832     events_read (ev, argv[1]);
 833     g_timeout_add (750, (GSourceFunc) timeout_advance, ev);
 834
 835     window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
 836     gtk_widget_set_size_request (window, 800, 800);
 837     g_signal_connect (window, "delete-event",
 838                       G_CALLBACK (gtk_main_quit), NULL);
 839     gtk_container_add (GTK_CONTAINER (window), hbox);
 840     gtk_widget_show (hbox);
 841     gtk_widget_show (window);
 842
 843     gtk_main ();
 844     return 0;
 845 }