]> git.cworth.org Git - akamaru/blobdiff - main.c
Indent to 8 columns rather than 2
[akamaru] / main.c
diff --git a/main.c b/main.c
index 15fbce446fbc41771d509ec9f29ad86a6141c7c4..a6d298f3023adaa0bd987f47dc1a75733412db2c 100644 (file)
--- a/main.c
+++ b/main.c
@@ -1,4 +1,4 @@
-/*                                           -*- mode: c; c-basic-offset: 2 -*-
+/*                                           -*- mode: c; c-basic-offset: 8 -*-
  * To compile:
  *
  *     gcc -Wall -g $(pkg-config --cflags --libs gtk+-2.0 cairo) \
 static void
 model_init_polygons (Model *model)
 {
-  const int num_polygons = 5;
-  const double ground_level = 500;
+       const int num_polygons = 5;
+       const double ground_level = 500;
 
-  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);
+       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);
+       polygon_init_rectangle (&model->polygons[4], 300, 320, 400, 350);
 
-  model->num_polygons = num_polygons;
+       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++) {
-    object_init (&model->objects[i],
-                random() % 200 + 20, random() % 200 + 20, 1);
-
-    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;
-    }
-  }
+       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++) {
+               object_init (&model->objects[i],
+                            random() % 200 + 20, random() % 200 + 20, 1);
+
+               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;
+               }
+       }
 }
 
 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++) {
-    object_init (&model->objects[i], 200, 40 + i * stick_length, 1);
-
-    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;
-    }
-  }
+       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++) {
+               object_init (&model->objects[i], 200, 40 + i * stick_length, 1);
+
+               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;
+               }
+       }
 }
 
 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, 1);
-  model->num_offsets = 1;
-  model_init_polygons (model);
-
-  model->offsets[0].num_objects = num_ropes;
-  model->offsets[0].objects = g_new (Object *, num_ropes);
-  model->offsets[0].dx = rope_offset;
-  model->offsets[0].dy = 0;
-
-  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;
-      object_init (&model->objects[index], x, y, 1);
-
-      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;
-      }
-    }
-
-    model->offsets[0].objects[i] = &model->objects[i * num_rope_objects];
-  }
+       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, 1);
+       model->num_offsets = 1;
+       model_init_polygons (model);
+
+       model->offsets[0].num_objects = num_ropes;
+       model->offsets[0].objects = g_new (Object *, num_ropes);
+       model->offsets[0].dx = rope_offset;
+       model->offsets[0].dy = 0;
+
+       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;
+                       object_init (&model->objects[index], x, y, 1);
+
+                       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;
+                       }
+               }
+
+               model->offsets[0].objects[i] = &model->objects[i * num_rope_objects];
+       }
 }
 
 static void
 model_init_grid (Model *model)
 {
-  const int num_ropes = 8;
-  const int num_rope_objects = 8;
-  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 = 20;
-  const int rope_offset = 20;
-  Object *object;
-  String *string;
-  int i, j;
-
-  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, 1);
-  model->num_offsets = 1;
-  model_init_polygons (model);
-
-  model->offsets[0].num_objects = num_ropes;
-  model->offsets[0].objects = g_new (Object *, num_ropes);
-  model->offsets[0].dx = rope_offset;
-  model->offsets[0].dy = 0;
-
-  object = model->objects;
-  string = model->strings;
-  for (i = 0; i < num_ropes; i++) {
-    for (j = 0; j < num_rope_objects; j++) {
-      object_init (object, 200 + i * rope_offset, 40 + j * string_length, 1);
-
-      if (i + 1 < num_ropes)
-       string_init (string++,
-                    object, object + num_rope_objects, string_length);
-      if (j + 1 < num_rope_objects)
-       string_init (string++, object, object + 1, string_length);
-      object++;
-    }
-
-    model->offsets[0].objects[i] = &model->objects[i * num_rope_objects];
-  }
+       const int num_ropes = 8;
+       const int num_rope_objects = 8;
+       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 = 20;
+       const int rope_offset = 20;
+       Object *object;
+       String *string;
+       int i, j;
+
+       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, 1);
+       model->num_offsets = 1;
+       model_init_polygons (model);
+
+       model->offsets[0].num_objects = num_ropes;
+       model->offsets[0].objects = g_new (Object *, num_ropes);
+       model->offsets[0].dx = rope_offset;
+       model->offsets[0].dy = 0;
+
+       object = model->objects;
+       string = model->strings;
+       for (i = 0; i < num_ropes; i++) {
+               for (j = 0; j < num_rope_objects; j++) {
+                       object_init (object, 200 + i * rope_offset, 40 + j * string_length, 1);
+
+                       if (i + 1 < num_ropes)
+                               string_init (string++,
+                                            object, object + num_rope_objects, string_length);
+                       if (j + 1 < num_rope_objects)
+                               string_init (string++, object, object + 1, string_length);
+                       object++;
+               }
+
+               model->offsets[0].objects[i] = &model->objects[i * num_rope_objects];
+       }
 }
 
 static void
 model_init_molecule (Model *model)
 {
-  const int num_objects = 8;
-  const int num_springs = num_objects * 2;
-  const int spring_length = 50;
-  int i;
-  Spring *spring;
-
-  memset (model, 0, sizeof *model);
-  model->objects = g_new (Object, num_objects);
-  model->num_objects = num_objects;
-  model->springs = g_new (Spring, num_springs);
-  model->num_springs = num_springs;
-  model->k = 2;
-
-  for (i = 0; i < num_objects; i++)
-    object_init (&model->objects[i], 200 + i * 20, 200, 0);
-
-  spring = model->springs;
-  for (i = 0; i < num_objects; i++) {
-    spring_init (spring++, &model->objects[i],
-                &model->objects[(i + 1) % num_objects],
-                spring_length);
-    spring_init (spring++, &model->objects[i],
-                &model->objects[(i + 2) % num_objects],
-                spring_length);
-  }
+       const int num_objects = 8;
+       const int num_springs = num_objects * 2;
+       const int spring_length = 50;
+       int i;
+       Spring *spring;
+
+       memset (model, 0, sizeof *model);
+       model->objects = g_new (Object, num_objects);
+       model->num_objects = num_objects;
+       model->springs = g_new (Spring, num_springs);
+       model->num_springs = num_springs;
+       model->k = 2;
+
+       for (i = 0; i < num_objects; i++)
+               object_init (&model->objects[i], 200 + i * 20, 200, 0);
+
+       spring = model->springs;
+       for (i = 0; i < num_objects; i++) {
+               spring_init (spring++, &model->objects[i],
+                            &model->objects[(i + 1) % num_objects],
+                            spring_length);
+               spring_init (spring++, &model->objects[i],
+                            &model->objects[(i + 2) % num_objects],
+                            spring_length);
+       }
 }
 
 
 static void
 model_init_wobbly (Model *model)
 {
-  const int width = 8, height = 8;
-  const int num_objects = width * height;
-  const int num_offset_springs = (width - 1) * height + width * (height - 1);
-  const int distance = 30;
-  double x, y;
-  int i, j;
-  Object *object;
-  OffsetSpring *spring;
-
-  memset (model, 0, sizeof *model);
-  model->objects = g_new (Object, num_objects);
-  model->num_objects = num_objects;
-  model->offset_springs = g_new (OffsetSpring, num_offset_springs);
-  model->num_offset_springs = num_offset_springs;
-  model->k = 4.5;
-
-  model_init_polygons (model);
-
-  object = model->objects;
-  spring = model->offset_springs;
-  for (i = 0; i < width; i++) {
-    for (j = 0; j < height; j++) {
-      x = 200 + i * distance;
-      y = 40 + j * distance;
-      object_init (object, x, y, 0);
-
-      if (i + 1 < width)
-       offset_spring_init (spring++, object, object + height, distance, 0);
+       const int width = 8, height = 8;
+       const int num_objects = width * height;
+       const int num_offset_springs = (width - 1) * height + width * (height - 1);
+       const int distance = 30;
+       double x, y;
+       int i, j;
+       Object *object;
+       OffsetSpring *spring;
+
+       memset (model, 0, sizeof *model);
+       model->objects = g_new (Object, num_objects);
+       model->num_objects = num_objects;
+       model->offset_springs = g_new (OffsetSpring, num_offset_springs);
+       model->num_offset_springs = num_offset_springs;
+       model->k = 4.5;
+
+       model_init_polygons (model);
+
+       object = model->objects;
+       spring = model->offset_springs;
+       for (i = 0; i < width; i++) {
+               for (j = 0; j < height; j++) {
+                       x = 200 + i * distance;
+                       y = 40 + j * distance;
+                       object_init (object, x, y, 0);
+
+                       if (i + 1 < width)
+                               offset_spring_init (spring++, object, object + height, distance, 0);
       
-      if (j + 1 < height)
-       offset_spring_init (spring++, object, object + 1, 0, distance);
+                       if (j + 1 < height)
+                               offset_spring_init (spring++, object, object + 1, 0, distance);
 
-      object++;
-    }
-  }
+                       object++;
+               }
+       }
 }
 
 static void
 model_init_dock (Model *model)
 {
-  const int num_objects = 8;
-  const int num_spacers = (num_objects - 1) * (num_objects - 2) / 2;
-  const int num_springs = num_objects - 1;
-  const int distance = 30;
-  double x, y;
-  int i, j;
-  Object *object;
-  Spring *spring;
-  Spacer *spacer;
-
-  memset (model, 0, sizeof *model);
-  model->objects = g_new (Object, num_objects);
-  model->num_objects = num_objects;
-  model->springs = g_new (Spring, num_springs);
-  model->num_springs = num_springs;
-  model->spacers = g_new (Spacer, num_spacers);
-  model->num_spacers = num_spacers;
-  model->anchors = g_new (Anchor, 1);
-  model->num_anchors = 1;
-  model->k = 0.1;
-
-  model->polygons = g_new (Polygon, 1);
-  model->num_polygons = 1;
-  polygon_init_enclosing_rectangle (&model->polygons[0], 10, 10, 700, 500);
-
-  model->anchors[0].x = 300;
-  model->anchors[0].y = 300;
-  model->anchors[0].object = &model->objects[0];
-
-  object = model->objects;
-  spring = model->springs;
-  spacer = model->spacers;
-  for (i = 0; i < num_objects; i++, object++) {
-    x = 200 + i * distance / 3;
-    y = 40;
-    object_init (object, x, y, 1);
-    if (i == 0)
-      continue;
-    spring_init (spring++,
-                &model->objects[0],
-                &model->objects[i],
-                distance);
-    for (j = 1; j < num_objects - i; j++) {
-      spacer_init (spacer++, object, object + j, distance);
-    }
-  }
+       const int num_objects = 8;
+       const int num_spacers = (num_objects - 1) * (num_objects - 2) / 2;
+       const int num_springs = num_objects - 1;
+       const int distance = 30;
+       double x, y;
+       int i, j;
+       Object *object;
+       Spring *spring;
+       Spacer *spacer;
+
+       memset (model, 0, sizeof *model);
+       model->objects = g_new (Object, num_objects);
+       model->num_objects = num_objects;
+       model->springs = g_new (Spring, num_springs);
+       model->num_springs = num_springs;
+       model->spacers = g_new (Spacer, num_spacers);
+       model->num_spacers = num_spacers;
+       model->anchors = g_new (Anchor, 1);
+       model->num_anchors = 1;
+       model->k = 0.1;
+
+       model->polygons = g_new (Polygon, 1);
+       model->num_polygons = 1;
+       polygon_init_enclosing_rectangle (&model->polygons[0], 10, 10, 700, 500);
+
+       model->anchors[0].x = 300;
+       model->anchors[0].y = 300;
+       model->anchors[0].object = &model->objects[0];
+
+       object = model->objects;
+       spring = model->springs;
+       spacer = model->spacers;
+       for (i = 0; i < num_objects; i++, object++) {
+               x = 200 + i * distance / 3;
+               y = 40;
+               object_init (object, x, y, 1);
+               if (i == 0)
+                       continue;
+               spring_init (spring++,
+                            &model->objects[0],
+                            &model->objects[i],
+                            distance);
+               for (j = 1; j < num_objects - i; j++) {
+                       spacer_init (spacer++, object, object + j, distance);
+               }
+       }
 }
 
 typedef struct _Color Color;
 struct _Color {
-  double red, green, blue;
+       double red, green, blue;
 };
 
 static void
@@ -314,24 +314,24 @@ 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);
+       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
@@ -339,24 +339,24 @@ 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);
+       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
@@ -364,22 +364,22 @@ draw_offsets (cairo_t *cr,
              Model   *model,
              Color   *color)
 {
-  int i, j;
-
-  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++) {
-    for (j = 0; j < model->offsets[i].num_objects; j++) {
-      cairo_line_to (cr,
-                    model->offsets[i].objects[j]->position.x,
-                    model->offsets[i].objects[j]->position.y);
-    }
-    cairo_stroke (cr);
-  }
+       int i, j;
+
+       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++) {
+               for (j = 0; j < model->offsets[i].num_objects; j++) {
+                       cairo_line_to (cr,
+                                      model->offsets[i].objects[j]->position.x,
+                                      model->offsets[i].objects[j]->position.y);
+               }
+               cairo_stroke (cr);
+       }
 
 }
 
@@ -388,24 +388,24 @@ draw_springs (cairo_t *cr,
              Model   *model,
              Color   *color)
 {
-  int i;
-
-  cairo_set_source_rgba (cr, color->red, color->green, color->blue, 0.4);
-  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_springs; i++) {
-    cairo_move_to (cr,
-                  model->springs[i].a->position.x,
-                  model->springs[i].a->position.y);
-    cairo_line_to (cr,
-                  model->springs[i].b->position.x,
-                  model->springs[i].b->position.y);
-  }
-
-  cairo_stroke (cr);
+       int i;
+
+       cairo_set_source_rgba (cr, color->red, color->green, color->blue, 0.4);
+       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_springs; i++) {
+               cairo_move_to (cr,
+                              model->springs[i].a->position.x,
+                              model->springs[i].a->position.y);
+               cairo_line_to (cr,
+                              model->springs[i].b->position.x,
+                              model->springs[i].b->position.y);
+       }
+
+       cairo_stroke (cr);
 }
 
 static void
@@ -413,65 +413,65 @@ draw_offset_springs (cairo_t *cr,
                     Model   *model,
                     Color   *color)
 {
-  int i;
-
-  cairo_set_source_rgba (cr, color->red, color->green, color->blue, 0.4);
-  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_offset_springs; i++) {
-    cairo_move_to (cr,
-                  model->offset_springs[i].a->position.x,
-                  model->offset_springs[i].a->position.y);
-    cairo_line_to (cr,
-                  model->offset_springs[i].b->position.x,
-                  model->offset_springs[i].b->position.y);
-  }
-
-  cairo_stroke (cr);
+       int i;
+
+       cairo_set_source_rgba (cr, color->red, color->green, color->blue, 0.4);
+       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_offset_springs; i++) {
+               cairo_move_to (cr,
+                              model->offset_springs[i].a->position.x,
+                              model->offset_springs[i].a->position.y);
+               cairo_line_to (cr,
+                              model->offset_springs[i].b->position.x,
+                              model->offset_springs[i].b->position.y);
+       }
+
+       cairo_stroke (cr);
 }
 
 static void
 draw_polygons (cairo_t *cr, Model *model, Color *color)
 {
-  Polygon *p;
-  int i, j;
+       Polygon *p;
+       int i, j;
 
-  for (i = 0; i < model->num_polygons; i++) {
-    p = &model->polygons[i];
+       for (i = 0; i < model->num_polygons; i++) {
+               p = &model->polygons[i];
     
-    for (j = 0; j < p->num_points; j++)
-      cairo_line_to (cr, p->points[j].x, p->points[j].y);
-    cairo_close_path (cr);
-
-    if (p->enclosing) {
-      cairo_set_source_rgba (cr, color->red, color->green, color->blue, 0.1);
-      cairo_fill_preserve (cr);
-    }
-
-    cairo_set_source_rgba (cr, color->red, color->green, color->blue, 0.4);
-    if (p->enclosing)
-      cairo_stroke (cr);
-    else
-      cairo_fill (cr);
-  }
+               for (j = 0; j < p->num_points; j++)
+                       cairo_line_to (cr, p->points[j].x, p->points[j].y);
+               cairo_close_path (cr);
+
+               if (p->enclosing) {
+                       cairo_set_source_rgba (cr, color->red, color->green, color->blue, 0.1);
+                       cairo_fill_preserve (cr);
+               }
+
+               cairo_set_source_rgba (cr, color->red, color->green, color->blue, 0.4);
+               if (p->enclosing)
+                       cairo_stroke (cr);
+               else
+                       cairo_fill (cr);
+       }
 
 }
 
 static void
 draw_objects (cairo_t *cr, Model *model, Color *color)
 {
-  int i;
-
-  cairo_set_source_rgba (cr, color->red, color->green, color->blue, 0.4);
-  for (i = 0; i < model->num_objects; i++) {
-    cairo_arc (cr, model->objects[i].position.x,
-              model->objects[i].position.y,
-              3, 0, 2*M_PI);
-    cairo_fill (cr);
-  }
+       int i;
+
+       cairo_set_source_rgba (cr, color->red, color->green, color->blue, 0.4);
+       for (i = 0; i < model->num_objects; i++) {
+               cairo_arc (cr, model->objects[i].position.x,
+                          model->objects[i].position.y,
+                          3, 0, 2*M_PI);
+               cairo_fill (cr);
+       }
 }
 
 static Color blue = { 0, 0, 1 };
@@ -481,33 +481,33 @@ static Color black = { 0, 0, 0 };
 
 typedef struct _Closure Closure;
 struct _Closure {
-  GtkWidget *drawing_area;
-  GtkWidget *fps_label;
-  Model *model;
-  int frame_count;
-  int i;
-  struct timeval start;
+       GtkWidget *drawing_area;
+       GtkWidget *fps_label;
+       Model *model;
+       int frame_count;
+       int i;
+       struct timeval start;
 };
 
 static void
 draw_model (GtkWidget *widget, Model *model)
 {
-  cairo_t *cr;
+       cairo_t *cr;
 
-  cr = gdk_cairo_create (widget->window);
+       cr = gdk_cairo_create (widget->window);
 
-  cairo_set_source_rgb (cr, 1, 1, 1);
-  cairo_paint (cr);
+       cairo_set_source_rgb (cr, 1, 1, 1);
+       cairo_paint (cr);
 
-  draw_polygons (cr, model, &blue);
-  draw_sticks (cr, model, &black);
-  draw_strings (cr, model, &green);
-  draw_springs (cr, model, &black);
-  draw_offsets (cr, model, &blue);
-  draw_offset_springs (cr, model, &blue);
-  draw_objects (cr, model, &red);
+       draw_polygons (cr, model, &blue);
+       draw_sticks (cr, model, &black);
+       draw_strings (cr, model, &green);
+       draw_springs (cr, model, &black);
+       draw_offsets (cr, model, &blue);
+       draw_offset_springs (cr, model, &blue);
+       draw_objects (cr, model, &red);
 
-  cairo_destroy (cr);
+       cairo_destroy (cr);
 }
 
 static gboolean
@@ -515,11 +515,11 @@ expose_event (GtkWidget      *widget,
              GdkEventExpose *event,
              gpointer        data)
 {
-  Closure *closure = data;
+       Closure *closure = data;
 
-  draw_model (widget, closure->model);
+       draw_model (widget, closure->model);
 
-  return TRUE;
+       return TRUE;
 }
 
 static gboolean
@@ -527,17 +527,17 @@ button_press_event (GtkWidget        *widget,
                    GdkEventButton *event,
                    gpointer        data)
 {
-  Closure *closure = data;
+       Closure *closure = data;
 
-  if (event->button != 1)
-    return TRUE;
+       if (event->button != 1)
+               return TRUE;
 
-  closure->model->mouse_anchor.x = event->x;
-  closure->model->mouse_anchor.y = event->y;
-  closure->model->mouse_anchor.object =
-    model_find_nearest (closure->model, event->x, event->y);
+       closure->model->mouse_anchor.x = event->x;
+       closure->model->mouse_anchor.y = event->y;
+       closure->model->mouse_anchor.object =
+               model_find_nearest (closure->model, event->x, event->y);
 
-  return TRUE;
+       return TRUE;
 }
 
 static gboolean
@@ -545,14 +545,14 @@ button_release_event (GtkWidget        *widget,
                      GdkEventButton *event,
                      gpointer        data)
 {
-  Closure *closure = data;
+       Closure *closure = data;
 
-  if ((event->state & GDK_BUTTON1_MASK) == 0)
-    return TRUE;
+       if ((event->state & GDK_BUTTON1_MASK) == 0)
+               return TRUE;
 
-  closure->model->mouse_anchor.object = NULL;
+       closure->model->mouse_anchor.object = NULL;
 
-  return TRUE;
+       return TRUE;
 }
 
 static gboolean
@@ -560,16 +560,16 @@ motion_notify_event (GtkWidget        *widget,
                     GdkEventMotion *event,
                     gpointer        data)
 {
-  Closure *closure = data;
-  int x, y;
-  GdkModifierType state;
+       Closure *closure = data;
+       int x, y;
+       GdkModifierType state;
 
-  gdk_window_get_pointer (event->window, &x, &y, &state);
+       gdk_window_get_pointer (event->window, &x, &y, &state);
   
-  closure->model->mouse_anchor.x = x + 0.5;
-  closure->model->mouse_anchor.y = y + 0.5;
+       closure->model->mouse_anchor.x = x + 0.5;
+       closure->model->mouse_anchor.y = y + 0.5;
 
-  return TRUE;
+       return TRUE;
 }
 
 typedef void (*ModelInitFunc) (Model *model);
@@ -577,213 +577,213 @@ 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;
+       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;
+       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);
+       gtk_tree_model_get (tree_model, &iter, 0, &name, 1, &init, -1);
 
-  model_fini (closure->model);
-  (*init) (closure->model);
+       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 },
-    { "Molecule", model_init_molecule },
-    { "Wobbly", model_init_wobbly },
-    { "Dock", model_init_dock }
-  };
-
-  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);
- }
+       static struct {
+               const char *name;
+               ModelInitFunc init;
+       } models[] = {
+               { "Rope", model_init_rope },
+               { "Snake", model_init_snake },
+               { "Curtain", model_init_curtain },
+               { "Grid", model_init_grid },
+               { "Molecule", model_init_molecule },
+               { "Wobbly", model_init_wobbly },
+               { "Dock", model_init_dock }
+       };
+
+       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);
+       return GTK_TREE_MODEL (store);
 
 }
 
 static GtkWidget *
 create_model_combo (Closure *closure)
 {
-  GtkWidget *hbox;
-  GtkWidget *combo, *label;
-  GtkTreeModel *store;
-  GtkCellRenderer *renderer;
+       GtkWidget *hbox;
+       GtkWidget *combo, *label;
+       GtkTreeModel *store;
+       GtkCellRenderer *renderer;
 
-  hbox = gtk_hbox_new (FALSE, 8);
+       hbox = gtk_hbox_new (FALSE, 8);
 
-  label = gtk_label_new_with_mnemonic ("_Model:");
-  gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
+       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);
+       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);
+       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);
+       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);
+       label = gtk_label_new ("Frames per second: 0");
+       gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
 
-  closure->fps_label = label;
+       closure->fps_label = label;
 
-  return hbox;
+       return hbox;
 }
 
 static void
 create_window (Closure *closure)
 {
-  GtkWidget *window;
-  GtkWidget *frame;
-  GtkWidget *vbox;
-  GtkWidget *da;
-  GtkWidget *model_combo;
+       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), "赤丸");
+       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+       gtk_window_set_title (GTK_WINDOW (window), "赤丸");
 
-  g_signal_connect (window, "destroy",
-                   G_CALLBACK (gtk_main_quit), &window);
+       g_signal_connect (window, "destroy",
+                         G_CALLBACK (gtk_main_quit), &window);
 
-  gtk_container_set_border_width (GTK_CONTAINER (window), 8);
+       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);
+       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
-   */
+       /*
+        * 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);
+       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, 200, 200);
+       da = gtk_drawing_area_new ();
+       /* set a minimum size */
+       gtk_widget_set_size_request (da, 200, 200);
 
-  gtk_container_add (GTK_CONTAINER (frame), da);
+       gtk_container_add (GTK_CONTAINER (frame), da);
 
-  /* Signals used to handle backing pixmap */
+       /* Signals used to handle backing pixmap */
       
-  g_signal_connect (da, "expose_event",
-                   G_CALLBACK (expose_event), closure);
+       g_signal_connect (da, "expose_event",
+                         G_CALLBACK (expose_event), closure);
       
-  /* Event signals */
+       /* 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;
+       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, 0.2);
-
-  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;
+       Closure *closure = data;
+
+       model_step (closure->model, 0.2);
+
+       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 (40, timeout_callback, &closure);
-  gtk_main ();
-
-  return 0;
+       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 (40, timeout_callback, &closure);
+       gtk_main ();
+
+       return 0;
 }