path: root/akamaru.c

/*                                           -*- mode: c; c-basic-offset: 2 -*-
 * To compile:
 *
 *     gcc -Wall -g $(pkg-config --cflags --libs gtk+-2.0 cairo) \
 *             akamaru.c -o akamaru
 *
 * See:
 *
 *     http://en.wikipedia.org/wiki/Verlet_integration
 *     http://www.teknikus.dk/tj/gdc2001.htm
 *
 * TODO:
 *
 * - Add code to add boxes
 * - Add circle object
 * - Try out this idea: make constraint solver take mean of all
 *   corrections at the end instead of meaning as it goes.
 */

#include <gtk/gtk.h>
#include <cairo.h>
#include <cairo-xlib.h>
#include <gdk/gdkx.h>
#include <stdlib.h>
#include <string.h>
#include <sys/time.h>
#include <math.h>

const double ground_friction = 0.1, ground_level = 400;
const double box_left = 200, box_top = 200, box_bottom = 210;
const double elasticity = 0.7;
const double edge_fuzz = 1;

typedef struct _xy_pair Point;
typedef struct _xy_pair Vector;
struct _xy_pair {
  double x, y;
};

typedef struct _Object Object;
typedef struct _Stick Stick;
typedef struct _String String;
typedef struct _Polygon Polygon;
typedef struct _Offset Offset;
typedef struct _Model Model;

struct _Object {
  Vector force;

  Point position;
  Point previous_position;
  Vector velocity;

  double mass;
  double theta;
};

struct _Stick {
  Object *a, *b;
  int length;
};

struct _String {
  Object *a, *b;
  int length;
};

struct _Offset {
  Object *a, *b;
  int dx, dy;
};

struct _Polygon {
  int num_points;
  Point *points;
  Vector *normals;
  int edge;
};

struct _Model {
  int num_objects;
  Object *objects;
  int num_sticks;
  Stick *sticks;
  int num_strings;
  String *strings;
  int num_offsets;
  Offset *offsets;
  int num_polygons;
  Polygon *polygons;
  double k;
  double friction;

  Object *anchor_object;
  Vector anchor_position;

  double theta;
};

static void
polygon_init (Polygon *p, int num_points, ...)
{
  double dx, dy, length;
  int i, j;
  va_list ap;

  /* Polygons are defined counter-clock-wise in a coordinate system
   * with the y-axis pointing down. */

  va_start (ap, num_points);
  p->num_points = num_points;
  p->points = g_new (Point, num_points);

  for (i = 0; i < num_points; i++) {
    p->points[i].x = va_arg (ap, double);
    p->points[i].y = va_arg (ap, double);
  }
  va_end (ap);
  
  p->normals = g_new (Vector, p->num_points);
  /* Compute outward pointing normals.  p->normals[i] is the normal
   * for the edged between p->points[i] and p->points[i + 1]. */
 for (i = 0; i < p->num_points; i++) {
    j = (i + 1) % p->num_points;
    dx = p->points[j].x - p->points[i].x;
    dy = p->points[j].y - p->points[i].y;
    length = sqrt (dx * dx + dy * dy);
    p->normals[i].x = -dy / length;
    p->normals[i].y = dx / length;
  }
}

static void
polygon_init_diamond (Polygon *polygon, double x, double y)
{
  return polygon_init (polygon, 5, 
		       x, y, 
		       x + 10, y + 40,
		       x + 90, y + 40,
		       x + 100, y,
		       x + 50, y - 20);
}

static void
polygon_init_rectangle (Polygon *polygon, double x0, double y0,
			double x1, double y1)
{
  return polygon_init (polygon, 4, x0, y0, x0, y1, x1, y1, x1, y0);
}

static void
model_init_polygons (Model *model)
{
  const int num_polygons = 5;

  model->polygons = g_new (Polygon, num_polygons);
  polygon_init_diamond (&model->polygons[0], 250, 300);
  polygon_init_diamond (&model->polygons[1], 400, 150);
  polygon_init_rectangle (&model->polygons[2], -100, 200, 200, 250);
  polygon_init_rectangle (&model->polygons[3], -200, ground_level,
			  1200, ground_level + 400);

  polygon_init_rectangle (&model->polygons[4], 300, 320, 400, 350);


  model->num_polygons = num_polygons;
}

static void
model_init_snake (Model *model)
{
  const int num_objects = 20;
  const int num_sticks = num_objects * 2 - 3;
  int i;

  memset (model, 0, sizeof *model);
  model->objects = g_new (Object, num_objects);
  model->num_objects = num_objects;
  model->sticks = g_new (Stick, num_sticks);
  model->num_sticks = num_sticks;
  model_init_polygons (model);

  for (i = 0; i < num_objects; i++) {
    model->objects[i].position.x = random() % 200 + 20;
    model->objects[i].position.y = random() % 200 + 20;
    model->objects[i].previous_position.x = random() % 200 + 20;
    model->objects[i].previous_position.y = random() % 200 + 20;

    if (i + 1 < num_objects) {
      model->sticks[i * 2].a = &model->objects[i];
      model->sticks[i * 2].b = &model->objects[i + 1];
      model->sticks[i * 2].length = random() % 20 + 20;
    }
    if (i + 2 < num_objects) {
      model->sticks[i * 2 + 1].a = &model->objects[i];
      model->sticks[i * 2 + 1].b = &model->objects[i + 2];
      model->sticks[i * 2 + 1].length = random() % 20 + 20;
    }
  }

  model->anchor_object = NULL;
}

static void
model_init_rope (Model *model)
{
  const int num_objects = 20;
  const int num_sticks = num_objects - 1;
  const int stick_length = 10;
  int i;

  memset (model, 0, sizeof *model);
  model->objects = g_new (Object, num_objects);
  model->num_objects = num_objects;
  model->sticks = g_new (Stick, num_sticks);
  model->num_sticks = num_sticks;
  model_init_polygons (model);

  for (i = 0; i < num_objects; i++) {
    model->objects[i].position.x = 200;
    model->objects[i].position.y = 40 + i * stick_length;
    model->objects[i].previous_position.x = 200;
    model->objects[i].previous_position.y = 40 + i * stick_length;

    if (i + 1 < num_objects) {
      model->sticks[i].a = &model->objects[i];
      model->sticks[i].b = &model->objects[i + 1];
      model->sticks[i].length = stick_length;
    }
  }

  model->anchor_object = NULL;
}

static void
model_init_curtain (Model *model)
{
  const int num_ropes = 5;
  const int num_rope_objects = 15;
  const int num_objects = num_ropes * num_rope_objects;
  const int num_sticks = num_ropes * (num_rope_objects - 1);
  const int stick_length = 10;
  const int rope_offset = 30;
  double x, y;
  int i, j, index, stick_index;

  memset (model, 0, sizeof *model);
  model->objects = g_new (Object, num_objects);
  model->num_objects = num_objects;
  model->sticks = g_new (Stick, num_sticks);
  model->num_sticks = num_sticks;
  model->offsets = g_new (Offset, num_ropes - 1);
  model->num_offsets = num_ropes - 1;
  model_init_polygons (model);

  for (i = 0; i < num_ropes; i++) {
    for (j = 0; j < num_rope_objects; j++) {
      x = 200 + i * rope_offset;
      y = 40 + j * stick_length;
      index = i * num_rope_objects + j;
      model->objects[index].position.x = x;
      model->objects[index].position.y = y;
      model->objects[index].previous_position.x = x;
      model->objects[index].previous_position.y = y;

      if (j + 1 < num_rope_objects) {
	stick_index = i * (num_rope_objects - 1) + j;
	model->sticks[stick_index].a = &model->objects[index];
	model->sticks[stick_index].b = &model->objects[index + 1];
	model->sticks[stick_index].length = stick_length;
      }
    }

    if (i + 1 < num_ropes) {
      model->offsets[i].a = &model->objects[i * num_rope_objects];
      model->offsets[i].b = &model->objects[(i + 1) * num_rope_objects];
      model->offsets[i].dx = rope_offset;
      model->offsets[i].dy = 0;
    }
  }

  model->anchor_object = NULL;
}

static void
model_init_grid (Model *model)
{
  const int num_ropes = 10;
  const int num_rope_objects = 10;
  const int num_objects = num_ropes * num_rope_objects;
  const int num_strings = num_ropes * (num_rope_objects - 1) +
    (num_ropes - 1) * num_rope_objects;
  const int string_length = 10;
  const int rope_offset = 10;
  double x, y;
  int i, j, index, string_index;

  memset (model, 0, sizeof *model);
  model->objects = g_new (Object, num_objects);
  model->num_objects = num_objects;
  model->strings = g_new (String, num_strings);
  model->num_strings = num_strings;
  model->offsets = g_new (Offset, num_ropes - 1);
  model->num_offsets = num_ropes - 1;
  model_init_polygons (model);

  for (i = 0; i < num_ropes; i++) {
    for (j = 0; j < num_rope_objects; j++) {
      x = 200 + i * rope_offset;
      y = 40 + j * string_length;
      index = i * num_rope_objects + j;
      model->objects[index].position.x = x;
      model->objects[index].position.y = y;
      model->objects[index].previous_position.x = x;
      model->objects[index].previous_position.y = y;

      if (i + 1 < num_ropes) {
	string_index = i * num_rope_objects + j;
	model->strings[string_index].a = &model->objects[index];
	model->strings[string_index].b = &model->objects[index + num_rope_objects];
	model->strings[string_index].length = string_length;
      }

      if (j + 1 < num_rope_objects) {
	string_index =
	  (num_ropes - 1) * num_rope_objects + i * (num_rope_objects - 1) + j;
	model->strings[string_index].a = &model->objects[index];
	model->strings[string_index].b = &model->objects[index + 1];
	model->strings[string_index].length = string_length;
      }
    }

    if (i + 1 < num_ropes) {
      model->offsets[i].a = &model->objects[i * num_rope_objects];
      model->offsets[i].b = &model->objects[(i + 1) * num_rope_objects];
      model->offsets[i].dx = rope_offset;
      model->offsets[i].dy = 0;
    }
  }

  model->anchor_object = NULL;
}

static void
model_fini (Model *model)
{
  g_free (model->objects);
  g_free (model->sticks);
  g_free (model->strings);
  g_free (model->offsets);
  memset (model, 0, sizeof *model);
}

static void
model_accumulate_forces (Model *model)
{
  int i;

  for (i = 0; i < model->num_objects; i++) {
    model->objects[i].force.x = 0;
    model->objects[i].force.y = 3;
  }
}

static void
model_integrate (Model *model, double step)
{
  double x, y;
  Object *o;
  int i;

  for (i = 0; i < model->num_objects; i++) {
    o = &model->objects[i];
    x = o->position.x;
    y = o->position.y;
    
    o->position.x =
      x + 0.9 * (x - o->previous_position.x) + o->force.x * step * step;
    o->position.y =
      y + 0.9 * (y - o->previous_position.y) + o->force.y * step * step;

    o->previous_position.x = x;
    o->previous_position.y = y;
  }
}

/* The square root in the distance computation for the string and
 * stick constraints can be aproximated using Newton:
 *
 *    distance = 
 *      (model->sticks[i].length +
 *       (dx * dx + dy * dy) / model->sticks[i].length) / 2;
 *
 * This works really well, since the constraints aren't typically
 * violated much.  Thus, the distance is really close to the stick
 * length, which then makes a good initial guess.  However, the
 * approximation seems to be slower that just calling sqrt()...
 */

static inline double
estimate_distance (double dx, double dy, double r)
{
#ifdef APPROXIMATE_SQUARE_ROOTS
  return (r + (dx * dx + dy * dy) / r) / 2;
#else
  return sqrt (dx * dx + dy * dy);
#endif
}

static int
polygon_contains_point (Polygon *polygon, Point *point)
{
  int i;
  double dx, dy;

  for (i = 0; i < polygon->num_points; i++) {
    dx = point->x - polygon->points[i].x;
    dy = point->y - polygon->points[i].y;

    if (polygon->normals[i].x * dx + polygon->normals[i].y * dy >= 0)
      return FALSE;
  }

  return TRUE;
}

static void
polygon_reflect_object (Polygon *polygon, Object *object)
{
  int i, edge;
  double d, distance;
  Vector *n;

  distance = -1000;
  for (i = 0; i < polygon->num_points; i++) {
    d = polygon->normals[i].x * (object->position.x - polygon->points[i].x) +
      polygon->normals[i].y * (object->position.y - polygon->points[i].y);

    if (d > distance) {
      distance = d;
      edge = i;
      polygon->edge = i;
      n = &polygon->normals[i];
    }
  }

  object->position.x -= (1 + elasticity) * distance * n->x;
  object->position.y -= (1 + elasticity) * distance * n->y;

  distance =
    n->x * (object->previous_position.x - polygon->points[edge].x) +
    n->y * (object->previous_position.y - polygon->points[edge].y);

  object->previous_position.x -= (1 + elasticity) * distance * n->x;
  object->previous_position.y -= (1 + elasticity) * distance * n->y;
}

static void
model_constrain_polygon (Model *model, Polygon *polygon)
{
  int i;

  for (i = 0; i < model->num_objects; i++) {
    if (polygon_contains_point (polygon, &model->objects[i].position))
      polygon_reflect_object (polygon, &model->objects[i]);
  }
}

static void
model_constrain (Model *model)
{
  double dx, dy, x, y, distance, fraction;
  int i;

  /* Anchor object constraint. */
  if (model->anchor_object != NULL) {
    model->anchor_object->position.x = model->anchor_position.x;
    model->anchor_object->position.y = model->anchor_position.y;
    model->anchor_object->previous_position.x = model->anchor_position.x;
    model->anchor_object->previous_position.y = model->anchor_position.y;
  }

  /* Offset constraints. */
  for (i = 0; i < model->num_offsets; i++) {
    x = (model->offsets[i].a->position.x + model->offsets[i].b->position.x) / 2;
    y = (model->offsets[i].a->position.y + model->offsets[i].b->position.y) / 2;
    model->offsets[i].a->position.x = x - model->offsets[i].dx / 2;
    model->offsets[i].a->position.y = y - model->offsets[i].dy / 2;
    model->offsets[i].b->position.x = x + model->offsets[i].dx / 2;
    model->offsets[i].b->position.y = y + model->offsets[i].dy / 2;
  }

  /* String constraints. */
  for (i = 0; i < model->num_strings; i++) {
    x = model->strings[i].a->position.x;
    y = model->strings[i].a->position.y;
    dx = model->strings[i].b->position.x - x;
    dy = model->strings[i].b->position.y - y;
    distance = estimate_distance (dx, dy, model->strings[i].length);
    if (distance < model->strings[i].length)
      continue;
    fraction = (distance - model->strings[i].length) / distance / 2;
    model->strings[i].a->position.x = x + dx * fraction;
    model->strings[i].a->position.y = y + dy * fraction;
    model->strings[i].b->position.x = x + dx * (1 - fraction);
    model->strings[i].b->position.y = y + dy * (1 - fraction);
  }

  /* Stick constraints. */
  for (i = 0; i < model->num_sticks; i++) {
    x = model->sticks[i].a->position.x;
    y = model->sticks[i].a->position.y;
    dx = model->sticks[i].b->position.x - x;
    dy = model->sticks[i].b->position.y - y;
    distance = estimate_distance (dx, dy, model->sticks[i].length);
    fraction = (distance - model->sticks[i].length) / distance / 2;
    model->sticks[i].a->position.x = x + dx * fraction;
    model->sticks[i].a->position.y = y + dy * fraction;
    model->sticks[i].b->position.x = x + dx * (1 - fraction);
    model->sticks[i].b->position.y = y + dy * (1 - fraction);
  }

  /* Polygon constraints. */
  for (i = 0; i < model->num_polygons; i++)
    model_constrain_polygon (model, &model->polygons[i]);
}

static void
model_step (Model *model, double delta_t)
{
  int i;

  model_accumulate_forces (model);
  model_integrate (model, delta_t);

  for (i = 0; i < 100; i++)
    model_constrain (model);

  model->theta += delta_t;
}

static double
object_distance (Object *object, double x, double y)
{
  double dx, dy;

  dx = object->position.x - x;
  dy = object->position.y - y;

  return sqrt (dx*dx + dy*dy);
}

static Object *
model_find_nearest (Model *model, double x, double y)
{
  Object *object;
  double distance, min_distance;
  int i;

  for (i = 0; i < model->num_objects; i++) {
    distance = object_distance (&model->objects[i], x, y);
    if (i == 0 || distance < min_distance) {
      min_distance = distance;
      object = &model->objects[i];
    }
  }

  return object;
}

typedef struct _Color Color;
struct _Color {
  double red, green, blue;
};

static void
draw_sticks (cairo_t *cr,
	     Model   *model,
	     Color   *color)
{
  int i;

  cairo_set_source_rgba (cr, color->red, color->green, color->blue, 1);
  cairo_new_path (cr);
  cairo_set_line_width (cr, 2);
  cairo_set_line_join (cr, CAIRO_LINE_JOIN_ROUND);
  cairo_set_line_cap (cr, CAIRO_LINE_CAP_ROUND);

  for (i = 0; i < model->num_sticks; i++) {
    cairo_move_to (cr,
		   model->sticks[i].a->position.x,
		   model->sticks[i].a->position.y);
    cairo_line_to (cr,
		   model->sticks[i].b->position.x,
		   model->sticks[i].b->position.y);
  }

  cairo_stroke (cr);
}

static void
draw_strings (cairo_t *cr,
	      Model   *model,
	      Color   *color)
{
  int i;

  cairo_set_source_rgba (cr, color->red, color->green, color->blue, 1);
  cairo_new_path (cr);
  cairo_set_line_width (cr, 1);
  cairo_set_line_join (cr, CAIRO_LINE_JOIN_ROUND);
  cairo_set_line_cap (cr, CAIRO_LINE_CAP_ROUND);

  for (i = 0; i < model->num_strings; i++) {
    cairo_move_to (cr,
		   model->strings[i].a->position.x,
		   model->strings[i].a->position.y);
    cairo_line_to (cr,
		   model->strings[i].b->position.x,
		   model->strings[i].b->position.y);
  }

  cairo_stroke (cr);
}

static void
draw_offsets (cairo_t *cr,
	      Model   *model,
	      Color   *color)
{
  int i;

  cairo_set_source_rgba (cr, color->red, color->green, color->blue, 0.5);
  cairo_new_path (cr);
  cairo_set_line_width (cr, 4);
  cairo_set_line_join (cr, CAIRO_LINE_JOIN_ROUND);
  cairo_set_line_cap (cr, CAIRO_LINE_CAP_ROUND);

  for (i = 0; i < model->num_offsets; i++) {
    cairo_move_to (cr,
		   model->offsets[i].a->position.x,
		   model->offsets[i].a->position.y);
    cairo_line_to (cr,
		   model->offsets[i].b->position.x,
		   model->offsets[i].b->position.y);
  }

  cairo_stroke (cr);
}

static void
draw_polygons (cairo_t *cr, Model *model, Color *color)
{
  Polygon *p;
  int i, j;

  for (i = 0; i < model->num_polygons; i++) {
    p = &model->polygons[i];
    cairo_set_source_rgba (cr, color->red, color->green, color->blue, 0.4);

    
    for (j = 0; j < p->num_points; j++)
      cairo_line_to (cr, p->points[j].x, p->points[j].y);
    cairo_close_path (cr);
  }
  cairo_fill (cr);

}

static void
draw_objects (cairo_t *cr, Model *model, Color *color)
{
  int i;

  for (i = 0; i < model->num_objects; i++) {
  }
}

static Color blue = { 0, 0, 1 };
static Color green = { 0, 1, 0 };
static Color red = { 1, 0, 0 };
static Color black = { 0, 0, 0 };
static Color white = { 1, 1, 1 };

typedef struct _Closure Closure;
struct _Closure {
  GtkWidget *drawing_area;
  GtkWidget *fps_label;
  Model *model;
  int frame_count;
  int i;
  struct timeval start;
};

static gboolean
expose_event (GtkWidget      *widget,
	      GdkEventExpose *event,
	      gpointer	      data)
{
  Closure *closure = data;
  cairo_t *cr;

  cr = gdk_cairo_create (widget->window);

  cairo_set_source_rgb (cr, 1, 1, 1);
  cairo_paint (cr);

  draw_polygons (cr, closure->model, &blue);
  draw_sticks (cr, closure->model, &black);
  draw_strings (cr, closure->model, &green);
  draw_offsets (cr, closure->model, &blue);
  draw_objects (cr, closure->model, &white);

  cairo_destroy (cr);

  return TRUE;
}

static gboolean
button_press_event (GtkWidget	   *widget,
		    GdkEventButton *event,
		    gpointer	    data)
{
  Closure *closure = data;

  if (event->button != 1)
    return TRUE;

  closure->model->anchor_position.x = event->x;
  closure->model->anchor_position.y = event->y;
  closure->model->anchor_object = model_find_nearest (closure->model,
						      event->x, event->y);

  return TRUE;
}

static gboolean
button_release_event (GtkWidget	     *widget,
		      GdkEventButton *event,
		      gpointer	      data)
{
  Closure *closure = data;

  if ((event->state & GDK_BUTTON1_MASK) == 0)
    return TRUE;

  closure->model->anchor_object = NULL;

  return TRUE;
}

static gboolean
motion_notify_event (GtkWidget	    *widget,
		     GdkEventMotion *event,
		     gpointer	     data)
{
  Closure *closure = data;
  int x, y;
  GdkModifierType state;

  gdk_window_get_pointer (event->window, &x, &y, &state);

  closure->model->anchor_position.x = x + 0.5;
  closure->model->anchor_position.y = y + 0.5;

  return TRUE;
}

typedef void (*ModelInitFunc) (Model *model);

static void
model_changed (GtkComboBox *combo, gpointer user_data)
{
  Closure *closure = user_data;
  GtkTreeIter iter;
  GtkTreeModel *tree_model;
  ModelInitFunc init;
  char *name;

  tree_model = gtk_combo_box_get_model (combo);
  if (!gtk_combo_box_get_active_iter (combo, &iter))
    return;

  gtk_tree_model_get (tree_model, &iter, 0, &name, 1, &init, -1);

  model_fini (closure->model);
  (*init) (closure->model);
}

static GtkTreeModel *
create_model_store (void)
{
  static struct {
    const char *name;
    ModelInitFunc init;
  } models[] = {
    { "Rope", model_init_rope },
    { "Snake", model_init_snake },
    { "Curtain", model_init_curtain },
    { "Grid", model_init_grid }
  };

  GtkTreeIter iter;
  GtkTreeStore *store;
  gint i;

  store = gtk_tree_store_new (2, G_TYPE_STRING, G_TYPE_POINTER);

  for (i = 0; i < G_N_ELEMENTS(models); i++) {
    gtk_tree_store_append (store, &iter, NULL);
    gtk_tree_store_set (store, &iter,
			0, models[i].name, 1, models[i].init, -1);
 }
  
  return GTK_TREE_MODEL (store);

}

static GtkWidget *
create_model_combo (Closure *closure)
{
  GtkWidget *hbox;
  GtkWidget *combo, *label;
  GtkTreeModel *store;
  GtkCellRenderer *renderer;

  hbox = gtk_hbox_new (FALSE, 8);

  label = gtk_label_new_with_mnemonic ("_Model:");
  gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);

  store = create_model_store ();
  combo = gtk_combo_box_new_with_model (store);
  gtk_combo_box_set_active (GTK_COMBO_BOX (combo), 0);
  g_object_unref (store);

  renderer = gtk_cell_renderer_text_new ();
  gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combo), renderer, TRUE);
  gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (combo), renderer,
				  "text", 0,
				  NULL);

  gtk_label_set_mnemonic_widget (GTK_LABEL (label), combo);
  gtk_box_pack_start (GTK_BOX (hbox), combo, FALSE, FALSE, 0);
  g_signal_connect (combo, "changed",
		    G_CALLBACK (model_changed), closure);

  label = gtk_label_new ("Frames per second: 0");
  gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);

  closure->fps_label = label;

  return hbox;
}

static void
create_window (Closure *closure)
{
  GtkWidget *window;
  GtkWidget *frame;
  GtkWidget *vbox;
  GtkWidget *da;
  GtkWidget *model_combo;

  window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
  gtk_window_set_title (GTK_WINDOW (window), "Akamaru");

  g_signal_connect (window, "destroy",
		    G_CALLBACK (gtk_main_quit), &window);

  gtk_container_set_border_width (GTK_CONTAINER (window), 8);

  vbox = gtk_vbox_new (FALSE, 8);
  gtk_container_set_border_width (GTK_CONTAINER (vbox), 8);
  gtk_container_add (GTK_CONTAINER (window), vbox);

  /*
   * Create the drawing area
   */
      
  frame = gtk_frame_new (NULL);
  gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
  gtk_box_pack_start (GTK_BOX (vbox), frame, TRUE, TRUE, 0);
      
  da = gtk_drawing_area_new ();
  /* set a minimum size */
  gtk_widget_set_size_request (da, 600, 500);

  gtk_container_add (GTK_CONTAINER (frame), da);

  /* Signals used to handle backing pixmap */
      
  g_signal_connect (da, "expose_event",
		    G_CALLBACK (expose_event), closure);
      
  /* Event signals */
      
  g_signal_connect (da, "motion_notify_event",
		    G_CALLBACK (motion_notify_event), closure);
  g_signal_connect (da, "button_press_event",
		    G_CALLBACK (button_press_event), closure);
  g_signal_connect (da, "button_release_event",
		    G_CALLBACK (button_release_event), closure);

  /* Ask to receive events the drawing area doesn't normally
   * subscribe to
   */
  gtk_widget_set_events (da, gtk_widget_get_events (da)
			 | GDK_LEAVE_NOTIFY_MASK
			 | GDK_BUTTON_PRESS_MASK
			 | GDK_BUTTON_RELEASE_MASK
			 | GDK_POINTER_MOTION_MASK
			 | GDK_POINTER_MOTION_HINT_MASK);

  model_combo = create_model_combo (closure);
  gtk_box_pack_start (GTK_BOX (vbox), model_combo, FALSE, FALSE, 0);

  closure->drawing_area = da;
}

static gint
timeout_callback (gpointer data)
{
  Closure *closure = data;

  model_step (closure->model, 1);

  closure->i++;
  if (closure->i == 1) {
    gtk_widget_queue_draw (closure->drawing_area);
    closure->i = 0;
    closure->frame_count++;
  }

  if (closure->frame_count == 200) {
    struct timeval end, elapsed;
    double total;
    char text[50];

    closure->frame_count = 0;
    gettimeofday (&end, NULL);
    if (closure->start.tv_usec > end.tv_usec) {
      end.tv_usec += 1000000;
      end.tv_sec--;
    }

    elapsed.tv_usec = end.tv_usec - closure->start.tv_usec;
    elapsed.tv_sec = end.tv_sec - closure->start.tv_sec;

    total = elapsed.tv_sec + ((double) elapsed.tv_usec / 1e6);
    if (total < 0) {
      total = 0;
    }
    closure->start = end;
    snprintf (text, sizeof text, "Frames per second: %.2f", 200 / total);
    gtk_label_set_text (GTK_LABEL (closure->fps_label), text);
  }

  return TRUE;
}

int
main (int argc, char *argv[])
{
  Closure closure;
  Model model;

  gtk_init (&argc, &argv);
  model_init_rope (&model);
  create_window (&closure);
  closure.i = 0;
  gtk_widget_show_all (gtk_widget_get_toplevel (closure.drawing_area));
  closure.model = &model;
  closure.frame_count = 0;
  gettimeofday (&closure.start, NULL);
  g_timeout_add (50, timeout_callback, &closure);
  gtk_main ();

  return 0;
}