summaryrefslogtreecommitdiff
path: root/util/show-events.c
diff options
context:
space:
mode:
Diffstat (limited to 'util/show-events.c')
-rwxr-xr-xutil/show-events.c845
1 files changed, 845 insertions, 0 deletions
diff --git a/util/show-events.c b/util/show-events.c
new file mode 100755
index 000000000..8bff3efc4
--- /dev/null
+++ b/util/show-events.c
@@ -0,0 +1,845 @@
+#define _GNU_SOURCE
+#include <gtk/gtk.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <gdk/gdkkeysyms.h>
+#include <math.h>
+
+typedef struct _point {
+ gdouble x, y;
+} point_t;
+typedef struct _box {
+ point_t p1, p2;
+} box_t;
+typedef struct _line {
+ point_t p1, p2;
+} line_t;
+
+typedef struct _edge {
+ gulong id;
+ line_t line;
+ gdouble top, bottom;
+ point_t p1, p2;
+ int dir;
+} edge_t;
+typedef struct _trapezoid {
+ gdouble top, bottom;
+ const edge_t *left, *right;
+} trapezoid_t;
+typedef struct _traps {
+ int num_traps;
+ int size;
+ trapezoid_t traps[0];
+} traps_t;
+
+typedef struct _edges {
+ GHashTable *ht;
+
+ int num_edges;
+ int size;
+ edge_t edges[0];
+} edges_t;
+
+typedef struct _event {
+ enum {
+ START_EDGE,
+ END_EDGE,
+ INTERSECTION,
+ START_TRAP,
+ END_TRAP,
+ } type;
+
+ int x, y; /* (top, bottom) for trap */
+ long e1, e2;
+} event_t;
+
+typedef struct _events {
+ struct _events *prev, *next;
+
+ box_t extents;
+ edges_t *edges;
+ traps_t *prototraps;
+ traps_t *traps;
+
+ int current_event;
+ int num_events;
+ int size_events;
+ event_t *events;
+} events_t;
+
+typedef struct _EventView {
+ GtkWidget widget;
+
+ events_t *events_list;
+ events_t *current_events;
+
+ double px, py;
+
+ gint mag_x, mag_y;
+ gint mag_size;
+ gdouble mag_zoom;
+ gboolean in_mag_drag;
+ gint mag_drag_x, mag_drag_y;
+} EventView;
+
+typedef struct _EventViewClass {
+ GtkWidgetClass parent_class;
+} EventViewClass;
+
+G_DEFINE_TYPE (EventView, event_view, GTK_TYPE_WIDGET)
+
+static edge_t *
+edges_lookup (edges_t *edges, gulong id)
+{
+ return &edges->edges[GPOINTER_TO_UINT(g_hash_table_lookup (edges->ht,
+ GUINT_TO_POINTER
+ (id)))];
+}
+
+static gdouble
+_compute_intersection_x_for_y (const line_t *line,
+ gdouble y)
+{
+ gdouble dx = line->p2.x - line->p1.x;
+ gdouble dy = line->p2.y - line->p1.y;
+ gdouble x;
+
+ if (y == line->p1.y)
+ return line->p1.x;
+ if (y == line->p2.y)
+ return line->p2.x;
+
+ x = line->p1.x;
+ if (dy != 0)
+ x += (y - line->p1.y)*dx/dy;
+ return x;
+}
+
+static void
+_compute_intersection_point (const line_t *line,
+ gdouble y,
+ point_t *p)
+{
+ p->x = _compute_intersection_x_for_y (line, p->y = y);
+}
+
+static void
+_edge_path (cairo_t *cr, const cairo_matrix_t *m, const edge_t *e)
+{
+ double x, y;
+
+ x = e->p1.x; y = e->p1.y;
+ cairo_matrix_transform_point (m, &x, &y);
+ cairo_move_to (cr, x, y);
+
+ x = e->p2.x; y = e->p2.y;
+ cairo_matrix_transform_point (m, &x, &y);
+ cairo_line_to (cr, x, y);
+
+ if (e->dir < 0) {
+ cairo_set_source_rgb (cr, 0, 0, 1);
+ } else {
+ cairo_set_source_rgb (cr, 1, 0, 0);
+ }
+}
+
+static void
+_events_draw (events_t *events, cairo_t *cr, cairo_matrix_t *m)
+{
+ double dash[2] = {8, 8};
+ point_t p;
+ int n;
+
+ /* first the existing and proto-traps */
+ cairo_save (cr); {
+ cairo_set_matrix (cr, m);
+
+ cairo_set_source_rgba (cr, 1, 0, 0, .15);
+ for (n = 0; n < events->prototraps->num_traps; n++) {
+ const trapezoid_t *t = &events->prototraps->traps[n];
+
+ _compute_intersection_point (&t->left->line, t->top, &p);
+ cairo_move_to (cr, p.x, p.y);
+ _compute_intersection_point (&t->right->line, t->top, &p);
+ cairo_line_to (cr, p.x, p.y);
+ _compute_intersection_point (&t->right->line, t->bottom, &p);
+ cairo_line_to (cr, p.x, p.y);
+ _compute_intersection_point (&t->left->line, t->bottom, &p);
+ cairo_line_to (cr, p.x, p.y);
+ cairo_close_path (cr);
+ cairo_fill (cr);
+ }
+
+ cairo_set_source_rgba (cr, 0, 1, 0, .2);
+ for (n = 0; n < events->traps->num_traps; n++) {
+ const trapezoid_t *t = &events->traps->traps[n];
+
+ _compute_intersection_point (&t->left->line, t->top, &p);
+ cairo_move_to (cr, p.x, p.y);
+ _compute_intersection_point (&t->right->line, t->top, &p);
+ cairo_line_to (cr, p.x, p.y);
+ _compute_intersection_point (&t->right->line, t->bottom, &p);
+ cairo_line_to (cr, p.x, p.y);
+ _compute_intersection_point (&t->left->line, t->bottom, &p);
+ cairo_line_to (cr, p.x, p.y);
+ cairo_close_path (cr);
+ cairo_fill (cr);
+ }
+ } cairo_restore (cr);
+
+ /* known edges */
+ cairo_save (cr);
+ cairo_set_line_width (cr, 1.);
+ for (n = 0; n < events->edges->num_edges; n++) {
+ const edge_t *e = &events->edges->edges[n];
+ double x, y;
+
+ x = e->p1.x; y = e->p1.y;
+ cairo_matrix_transform_point (m, &x, &y);
+ cairo_move_to (cr, x, y);
+
+ x = e->p2.x; y = e->p2.y;
+ cairo_matrix_transform_point (m, &x, &y);
+ cairo_line_to (cr, x, y);
+
+ if (e->dir < 0) {
+ cairo_set_source_rgba (cr, 0, 0, 1., .4);
+ cairo_set_dash (cr, dash, 2, fmod (e->p1.x, dash[0]+dash[1]) + dash[0]);
+ } else {
+ cairo_set_source_rgba (cr, 1, 0, 0., 4);
+ cairo_set_dash (cr, dash, 2, fmod (e->p1.x, dash[0]+dash[1]));
+ }
+
+ cairo_stroke (cr);
+
+ x = e->p1.x; y = e->p1.y;
+ cairo_matrix_transform_point (m, &x, &y);
+ cairo_arc (cr, x, y, 2., 0, 2 * G_PI);
+
+ x = e->p2.x; y = e->p2.y;
+ cairo_matrix_transform_point (m, &x, &y);
+ cairo_arc (cr, x, y, 2., 0, 2 * G_PI);
+
+ cairo_fill (cr);
+ }
+ cairo_restore (cr);
+
+ /* event time */
+ cairo_save (cr); {
+ event_t *e;
+ double x, y;
+
+ e = &events->events[events->current_event];
+
+ cairo_set_line_width (cr, 2.);
+ cairo_set_matrix (cr, m);
+ cairo_move_to (cr,
+ events->extents.p1.x,
+ e->y);
+ cairo_line_to (cr,
+ events->extents.p2.x,
+ e->y);
+ cairo_identity_matrix (cr);
+ cairo_stroke (cr);
+
+ x = e->x; y = e->y;
+ cairo_matrix_transform_point (m, &x, &y);
+ switch (e->type) {
+ case START_EDGE:
+ case END_EDGE:
+ case INTERSECTION:
+ cairo_arc (cr, x, y, 4., 0, 2 * G_PI);
+ break;
+ case START_TRAP:
+ case END_TRAP:
+ break;
+ }
+ switch (e->type) {
+ case START_EDGE:
+ cairo_set_source_rgb (cr, 1, 0, 0);
+ break;
+ case END_EDGE:
+ cairo_set_source_rgb (cr, 0, 0, 1);
+ break;
+ case INTERSECTION:
+ cairo_set_source_rgb (cr, 1, 0, 1);
+ break;
+ case START_TRAP:
+ case END_TRAP:
+ break;
+ }
+ cairo_fill (cr);
+
+ cairo_set_line_width (cr, 1.);
+ switch (e->type) {
+ case START_EDGE:
+ _edge_path (cr, m, edges_lookup (events->edges, e->e1));
+ cairo_stroke (cr);
+ break;
+ case END_EDGE:
+ _edge_path (cr, m, edges_lookup (events->edges, e->e1));
+ cairo_stroke (cr);
+ break;
+ case INTERSECTION:
+ _edge_path (cr, m, edges_lookup (events->edges, e->e1));
+ cairo_stroke (cr);
+ _edge_path (cr, m, edges_lookup (events->edges, e->e2));
+ cairo_stroke (cr);
+ break;
+ }
+ } cairo_restore (cr);
+}
+
+static void
+event_view_draw (EventView *self, cairo_t *cr)
+{
+ events_t *events;
+ gdouble sf_x, sf_y, sf;
+ gdouble mid, dim;
+ gdouble x0, x1, y0, y1;
+ cairo_matrix_t m;
+
+ cairo_save (cr);
+ cairo_set_source_rgb (cr, 1, 1, 1);
+ cairo_paint (cr);
+ cairo_restore (cr);
+
+ events = self->current_events;
+ if (events == NULL)
+ return;
+
+ mid = (events->extents.p2.x + events->extents.p1.x) / 2.;
+ dim = (events->extents.p2.x - events->extents.p1.x) / 2. * 1.2;
+ sf_x = self->widget.allocation.width / dim / 2;
+
+ mid = (events->extents.p2.y + events->extents.p1.y) / 2.;
+ dim = (events->extents.p2.y - events->extents.p1.y) / 2. * 1.2;
+ sf_y = self->widget.allocation.height / dim / 2;
+
+ sf = MIN (sf_x, sf_y);
+
+ mid = (events->extents.p2.x + events->extents.p1.x) / 2.;
+ dim = sf_x / sf * (events->extents.p2.x - events->extents.p1.x) / 2. * 1.2;
+ x0 = mid - dim;
+ x1 = mid + dim;
+ mid = (events->extents.p2.y + events->extents.p1.y) / 2.;
+ dim = sf_y / sf * (events->extents.p2.y - events->extents.p1.y) / 2. * 1.2;
+ y0 = mid - dim;
+ y1 = mid + dim;
+
+ cairo_matrix_init_scale (&m, sf, sf);
+ cairo_matrix_translate (&m, -x0, -y0);
+ _events_draw (events, cr, &m);
+
+ /* draw a zoom view of the area around the mouse */
+ cairo_save (cr); {
+ double zoom = self->mag_zoom;
+ int size = self->mag_size;
+
+ /* bottom right */
+ cairo_rectangle (cr, self->mag_x, self->mag_y, size, size);
+ cairo_stroke_preserve (cr);
+ cairo_set_source_rgb (cr, 1, 1, 1);
+ cairo_fill_preserve (cr);
+ cairo_clip (cr);
+
+ /* compute roi in extents */
+ cairo_translate (cr, self->mag_x + size/2, self->mag_y + size/2);
+
+ cairo_matrix_init_scale (&m, zoom, zoom);
+ cairo_matrix_translate (&m, -(self->px / sf + x0), -(self->py /sf + y0));
+ _events_draw (events, cr, &m);
+
+ /* grid */
+ cairo_save (cr); {
+ int i;
+
+ cairo_translate (cr,
+ -zoom*fmod (self->px/sf + x0, 1.),
+ -zoom*fmod (self->py/sf + y0, 1.));
+ for (i = -size/2/zoom - 1; i <= size/2/zoom + 1; i++) {
+ cairo_move_to (cr, zoom*i, -size/2);
+ cairo_line_to (cr, zoom*i, size/2 + zoom);
+ cairo_move_to (cr, -size/2, zoom*i);
+ cairo_line_to (cr, size/2 + zoom, zoom*i);
+ }
+ cairo_set_source_rgba (cr, .7, .7, .7, .5);
+ cairo_set_line_width (cr, 1.);
+ cairo_stroke (cr);
+ } cairo_restore (cr);
+ } cairo_restore (cr);
+}
+
+static void
+event_view_draw_labels (EventView *self, cairo_t *cr)
+{
+ events_t *events;
+
+ events = self->current_events;
+ if (events == NULL)
+ return;
+
+}
+
+static gboolean
+event_view_expose (GtkWidget *w, GdkEventExpose *ev)
+{
+ EventView *self = (EventView *) w;
+ cairo_t *cr;
+
+ cr = gdk_cairo_create (w->window);
+ gdk_cairo_region (cr, ev->region);
+ cairo_clip (cr);
+
+ event_view_draw (self, cr);
+ event_view_draw_labels (self, cr);
+
+ cairo_destroy (cr);
+ return FALSE;
+}
+
+static void
+traps_clear (traps_t *traps)
+{
+ traps->num_traps = 0;
+}
+
+static traps_t *
+traps_add (traps_t *traps, int top, int bot, const edge_t *e1, const edge_t *e2)
+{
+ trapezoid_t *t;
+
+ if (traps->num_traps == traps->size) {
+ traps->size *= 2;
+ traps = g_realloc (traps,
+ sizeof (traps_t) + traps->size*sizeof (trapezoid_t));
+ }
+
+ t = &traps->traps[traps->num_traps++];
+ t->top = top;
+ if (bot > e1->bottom)
+ bot = e1->bottom;
+ if (bot > e2->bottom)
+ bot = e2->bottom;
+ t->bottom = bot;
+
+ t->left = e1;
+ t->right = e2;
+
+ return traps;
+}
+
+static void
+traps_remove (traps_t *traps, int top, const edge_t *e1, const edge_t *e2)
+{
+ int n;
+
+ for (n = 0; n < traps->num_traps; n++) {
+ trapezoid_t *t = &traps->traps[n];
+ if (t->top == top && t->left == e1 && t->right == e2)
+ break;
+ }
+ if (n < traps->num_traps) {
+ g_memmove (&traps->traps[n],
+ &traps->traps[n+1],
+ (traps->num_traps-n+1) * sizeof (trapezoid_t));
+ traps->num_traps--;
+ }
+}
+
+static void
+event_next (EventView *self)
+{
+ events_t *events;
+ event_t *e;
+
+ events = self->current_events;
+ if (++events->current_event == events->num_events) {
+ return;
+ } else if (events->current_event >= events->num_events) {
+ traps_clear (events->prototraps);
+ traps_clear (events->traps);
+ events->current_event = 0;
+
+ self->current_events = events->next;
+ if (self->current_events == NULL)
+ self->current_events = self->events_list;
+ events = self->current_events;
+ }
+
+ e = &events->events[events->current_event];
+ switch (e->type) {
+ case START_TRAP:
+ events->prototraps = traps_add (events->prototraps,
+ e->x, G_MAXINT,
+ edges_lookup (events->edges, e->e1),
+ edges_lookup (events->edges, e->e2));
+ break;
+ case END_TRAP:
+ traps_remove (events->prototraps,
+ e->x,
+ edges_lookup (events->edges, e->e1),
+ edges_lookup (events->edges, e->e2));
+ events->traps = traps_add (events->traps,
+ e->x, e->y,
+ edges_lookup (events->edges, e->e1),
+ edges_lookup (events->edges, e->e2));
+ break;
+ }
+}
+
+static gboolean
+event_view_button_press (GtkWidget *w, GdkEventButton *ev)
+{
+ EventView *self = (EventView *) w;
+
+ if (ev->x < self->mag_x ||
+ ev->y < self->mag_y ||
+ ev->x > self->mag_x + self->mag_size ||
+ ev->y > self->mag_y + self->mag_size)
+ {
+ if (ev->type == GDK_BUTTON_PRESS) {
+ event_next (self);
+ gtk_widget_queue_draw (w);
+ }
+ }
+ else
+ {
+ self->in_mag_drag = TRUE;
+ self->mag_drag_x = ev->x;
+ self->mag_drag_y = ev->y;
+ }
+
+ return FALSE;
+}
+
+static gboolean
+event_view_button_release (GtkWidget *w, GdkEventButton *ev)
+{
+ EventView *self = (EventView *) w;
+
+ self->in_mag_drag = FALSE;
+
+ return FALSE;
+}
+
+static gboolean
+event_view_motion (GtkWidget *w, GdkEventMotion *ev)
+{
+ EventView *self = (EventView *) w;
+
+ if (self->in_mag_drag) {
+ self->mag_x += ev->x - self->mag_drag_x;
+ self->mag_y += ev->y - self->mag_drag_y;
+
+ gtk_widget_queue_draw (&self->widget);
+
+ self->mag_drag_x = ev->x;
+ self->mag_drag_y = ev->y;
+ } else if (ev->x < self->mag_x ||
+ ev->y < self->mag_y ||
+ ev->x > self->mag_x + self->mag_size ||
+ ev->y > self->mag_y + self->mag_size)
+ {
+ self->px = ev->x;
+ self->py = ev->y;
+
+ gtk_widget_queue_draw (&self->widget);
+ }
+
+ return FALSE;
+}
+
+static void
+event_view_realize (GtkWidget *widget)
+{
+ GdkWindowAttr attributes;
+
+ GTK_WIDGET_SET_FLAGS (widget, GTK_REALIZED);
+
+ attributes.window_type = GDK_WINDOW_CHILD;
+ attributes.x = widget->allocation.x;
+ attributes.y = widget->allocation.y;
+ attributes.width = widget->allocation.width;
+ attributes.height = widget->allocation.height;
+ attributes.wclass = GDK_INPUT_OUTPUT;
+ attributes.visual = gtk_widget_get_visual (widget);
+ attributes.colormap = gtk_widget_get_colormap (widget);
+ attributes.event_mask = gtk_widget_get_events (widget) |
+ GDK_BUTTON_PRESS_MASK |
+ GDK_BUTTON_RELEASE_MASK |
+ GDK_KEY_PRESS_MASK |
+ GDK_KEY_RELEASE_MASK |
+ GDK_POINTER_MOTION_MASK |
+ GDK_BUTTON_MOTION_MASK |
+ GDK_EXPOSURE_MASK;
+
+ widget->window = gdk_window_new (gtk_widget_get_parent_window (widget),
+ &attributes,
+ GDK_WA_X | GDK_WA_Y |
+ GDK_WA_VISUAL | GDK_WA_COLORMAP);
+ gdk_window_set_user_data (widget->window, widget);
+
+ widget->style = gtk_style_attach (widget->style, widget->window);
+ gtk_style_set_background (widget->style, widget->window, GTK_STATE_NORMAL);
+}
+
+static void
+event_view_size_allocate (GtkWidget *w, GdkRectangle *r)
+{
+ EventView *self = (EventView *) w;
+
+ GTK_WIDGET_CLASS (event_view_parent_class)->size_allocate (w, r);
+
+ self->mag_x = w->allocation.width - self->mag_size - 10;
+ self->mag_y = w->allocation.height - self->mag_size - 10;
+}
+
+static void
+event_view_finalize (GObject *obj)
+{
+ G_OBJECT_CLASS (event_view_parent_class)->finalize (obj);
+}
+
+static void
+event_view_class_init (EventViewClass *klass)
+{
+ GObjectClass *object_class = (GObjectClass *) klass;
+ GtkWidgetClass *widget_class = (GtkWidgetClass *) klass;
+
+ object_class->finalize = event_view_finalize;
+
+ widget_class->realize = event_view_realize;
+ widget_class->size_allocate = event_view_size_allocate;
+ widget_class->expose_event = event_view_expose;
+ widget_class->button_press_event = event_view_button_press;
+ widget_class->button_release_event = event_view_button_release;
+ widget_class->motion_notify_event = event_view_motion;
+}
+
+static void
+event_view_init (EventView *self)
+{
+ self->mag_zoom = 10;
+ self->mag_size = 200;
+}
+
+static traps_t *
+traps_new (void)
+{
+ traps_t *t;
+
+ t = g_malloc (sizeof (traps_t) + 16 * sizeof (trapezoid_t));
+
+ t->size = 16;
+ t->num_traps = 0;
+
+ return t;
+}
+
+static edges_t *
+_edges_add_edge (edges_t *edges, edge_t *e, box_t *extents)
+{
+ if (e->top < extents->p1.y)
+ extents->p1.y = e->top;
+ if (e->bottom > extents->p2.y)
+ extents->p2.y = e->bottom;
+
+ _compute_intersection_point (&e->line, e->top, &e->p1);
+ _compute_intersection_point (&e->line, e->bottom, &e->p2);
+
+ if (e->p1.x < extents->p1.x)
+ extents->p1.x = e->p1.x;
+ if (e->p2.x < extents->p1.x)
+ extents->p1.x = e->p2.x;
+
+ if (e->p1.x > extents->p2.x)
+ extents->p2.x = e->p1.x;
+ if (e->p2.x > extents->p2.x)
+ extents->p2.x = e->p2.x;
+
+ if (edges->num_edges == edges->size) {
+ edges->size *= 2;
+ edges = g_realloc (edges,
+ sizeof (edges_t) + edges->size * sizeof (edge_t));
+ }
+
+ g_hash_table_insert (edges->ht,
+ GUINT_TO_POINTER (e->id),
+ GUINT_TO_POINTER (edges->num_edges));
+ edges->edges[edges->num_edges++] = *e;
+
+ return edges;
+}
+
+static void
+_events_add_event (events_t *events,
+ int type,
+ int x, int y,
+ gulong e1, gulong e2)
+{
+ event_t *e;
+
+ if (events->num_events == events->size_events) {
+ int newsize = 2 * events->size_events;
+ void *newevents;
+
+ newevents = g_renew (event_t, events->events, newsize);
+ events->events = newevents;
+ events->size_events = newsize;
+ }
+
+ e = &events->events[events->num_events++];
+ e->type = type;
+ e->x = x;
+ e->y = y;
+ e->e1 = e1;
+ e->e2 = e2;
+}
+
+static edges_t *
+edges_new (void)
+{
+ edges_t *t;
+
+ t = g_malloc (sizeof (edges_t) + 16 * sizeof (edge_t));
+ t->ht = g_hash_table_new (NULL, NULL);
+ t->size = 16;
+ t->num_edges = 0;
+
+ return t;
+}
+
+static events_t *
+events_new (void)
+{
+ events_t *events;
+
+ events = g_malloc (sizeof (events_t));
+
+ events->next = NULL;
+ events->prev = NULL;
+
+ events->events = g_new (event_t, 16);
+ events->size_events = 16;
+ events->num_events = 0;
+ events->current_event = 0;
+
+ events->edges = edges_new ();
+ events->prototraps = traps_new ();
+ events->traps = traps_new ();
+
+ events->extents.p1.x = G_MAXDOUBLE;
+ events->extents.p1.y = G_MAXDOUBLE;
+ events->extents.p2.x = -G_MAXDOUBLE;
+ events->extents.p2.y = -G_MAXDOUBLE;
+
+ return events;
+}
+
+static void
+events_read (EventView *ev, const char *filename)
+{
+ FILE *file;
+
+ file = fopen (filename, "r");
+ if (file != NULL) {
+ char *line = NULL;
+ size_t len = 0;
+ events_t *events;
+
+ events = ev->events_list = events_new ();
+ while (getline (&line, &len, file) != -1) {
+ line = g_strstrip (line);
+ if (*line == '\0') {
+ events->next = events_new ();
+ events->next->prev = events;
+ events = events->next;
+ } else if (g_str_has_prefix (line, "edge:")) {
+ edge_t edge;
+
+ sscanf (line, "edge: %lu (%lf, %lf) (%lf, %lf) (%lf, %lf) %d",
+ &edge.id,
+ &edge.line.p1.x,
+ &edge.line.p1.y,
+ &edge.line.p2.x,
+ &edge.line.p2.y,
+ &edge.top,
+ &edge.bottom,
+ &edge.dir);
+
+ events->edges = _edges_add_edge (events->edges,
+ &edge,
+ &events->extents);
+ } else if (g_str_has_prefix (line, "event:")) {
+ int type;
+ int x,y;
+ gulong e1, e2;
+
+ sscanf (line, "event: %d (%d, %d) %lu %lu",
+ &type, &x, &y,
+ &e1, &e2);
+
+ _events_add_event (events, type, x, y, e1, e2);
+ } else if (g_str_has_prefix (line, "begin trap:")) {
+ int top;
+ gulong e1, e2;
+
+ sscanf (line, "begin trap: %lu %lu %u", &e1, &e2, &top);
+
+ _events_add_event (events, START_TRAP, top, 0, e1, e2);
+ } else if (g_str_has_prefix (line, "end trap:")) {
+ int top, bottom;
+ gulong e1, e2;
+
+ sscanf (line, "end trap: %lu %lu %d %d",
+ &e1, &e2, &top, &bottom);
+
+ _events_add_event (events, END_TRAP, top, bottom, e1, e2);
+ }
+ }
+
+ ev->current_events = ev->events_list;
+
+ free (line);
+ fclose (file);
+ }
+}
+
+static gboolean
+timeout_advance (EventView *self)
+{
+ event_next (self);
+ gtk_widget_queue_draw (&self->widget);
+ return TRUE;
+}
+
+int
+main (int argc, char **argv)
+{
+ EventView *ev;
+ GtkWidget *window, *hbox;
+
+ gtk_init (&argc, &argv);
+
+ hbox = gtk_hbox_new (TRUE, 0);
+
+ ev = g_object_new (event_view_get_type (), NULL);
+ gtk_box_pack_start (GTK_BOX (hbox), &ev->widget, TRUE, TRUE, 0);
+ gtk_widget_show (&ev->widget);
+
+ events_read (ev, argv[1]);
+ g_timeout_add (750, (GSourceFunc) timeout_advance, ev);
+
+ window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+ gtk_widget_set_size_request (window, 800, 800);
+ g_signal_connect (window, "delete-event",
+ G_CALLBACK (gtk_main_quit), NULL);
+ gtk_container_add (GTK_CONTAINER (window), hbox);
+ gtk_widget_show (hbox);
+ gtk_widget_show (window);
+
+ gtk_main ();
+ return 0;
+}
generated by cgit v1.2.3 (git 2.25.1) at 2024-05-19 16:28:33 +0000