git.cworth.org Git - grrobot/blob - src/grr_board_view.c

   1 /* grr_board_view - GTK+ widget for displaying an rr_board
   2  *
   3  * Copyright © 2003 Carl Worth
   4  *
   5  * Permission to use, copy, modify, distribute, and sell this software
   6  * and its documentation for any purpose is hereby granted without
   7  * fee, provided that the above copyright notice appear in all copies
   8  * and that both that copyright notice and this permission notice
   9  * appear in supporting documentation, and that the name of Carl Worth
  10  * not be used in advertising or publicity pertaining to distribution
  11  * of the software without specific, written prior permission.
  12  * Carl Worth makes no representations about the suitability of this
  13  * software for any purpose.  It is provided "as is" without express
  14  * or implied warranty.
  15  *
  16  * CARL WORTH DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
  17  * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN
  18  * NO EVENT SHALL CARL WORTH BE LIABLE FOR ANY SPECIAL, INDIRECT OR
  19  * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
  20  * OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
  21  * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
  22  * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  23  *
  24  * Author: Carl Worth <carl@theworths.org>
  25  */
  26
  27 #include <math.h>
  28 #include <stdio.h>
  29 #include <stdlib.h>
  30 #include <string.h>
  31
  32 #include <cairo.h>
  33 #include <cairo-xlib.h>
  34 #include <svg-cairo.h>
  35
  36 #include <gtk/gtkmain.h>
  37 #include <gtk/gtksignal.h>
  38 #include <gdk/gdkx.h>
  39
  40 #include "grr_board_view.h"
  41 #include "grr_icon.h"
  42 #include "grr_util.h"
  43
  44 #define SCROLL_DELAY_LENGTH  300
  45 #define GRR_BOARD_VIEW_DEFAULT_SIZE 100
  46
  47 #define GRR_SVG_ASSUMED_WIDTH 32.0
  48 #define GRR_SVG_ASSUMED_HEIGHT 32.0
  49
  50 /* Forward declarations */
  51
  52 static void grr_board_view_class_init               (grr_board_view_class_t    *klass);
  53 static void grr_board_view_init                     (grr_board_view_t         *view);
  54 static void grr_board_view_destroy                  (GtkObject        *object);
  55 static void grr_board_view_realize                  (GtkWidget        *widget);
  56 static void grr_board_view_size_request             (GtkWidget      *widget,
  57                                                      GtkRequisition *requisition);
  58 static void grr_board_view_size_allocate            (GtkWidget     *widget,
  59                                                      GtkAllocation *allocation);
  60 static gint grr_board_view_expose                   (GtkWidget        *widget,
  61                                                      GdkEventExpose   *event);
  62 static gint grr_board_view_button_press             (GtkWidget        *widget,
  63                                                      GdkEventButton   *event);
  64 static gint grr_board_view_button_release           (GtkWidget        *widget,
  65                                                      GdkEventButton   *event);
  66 static gint grr_board_view_motion_notify            (GtkWidget        *widget,
  67                                                      GdkEventMotion   *event);
  68
  69 static void grr_board_view_update_mouse             (grr_board_view_t *view, gint x, gint y);
  70
  71 /* Local data */
  72
  73 static GtkWidgetClass *parent_class = NULL;
  74
  75 GType
  76 grr_board_view_get_type ()
  77 {
  78   static GType view_type = 0;
  79
  80   if (!view_type)
  81     {
  82       static const GTypeInfo view_info =
  83       {
  84         sizeof (grr_board_view_class_t),
  85         NULL,
  86         NULL,
  87         (GClassInitFunc) grr_board_view_class_init,
  88         NULL,
  89         NULL,
  90         sizeof (grr_board_view_t),
  91         0,
  92         (GInstanceInitFunc) grr_board_view_init,
  93       };
  94
  95       view_type = g_type_register_static (GTK_TYPE_WIDGET, "grr_board_view", &view_info, 0);
  96     }
  97
  98   return view_type;
  99 }
 100
 101 static void
 102 grr_board_view_class_init (grr_board_view_class_t *class)
 103 {
 104     GtkObjectClass *object_class;
 105     GtkWidgetClass *widget_class;
 106
 107     object_class = (GtkObjectClass*) class;
 108     widget_class = (GtkWidgetClass*) class;
 109
 110     parent_class = gtk_type_class (gtk_widget_get_type ());
 111
 112     object_class->destroy = grr_board_view_destroy;
 113
 114     widget_class->realize = grr_board_view_realize;
 115     widget_class->expose_event = grr_board_view_expose;
 116     widget_class->size_request = grr_board_view_size_request;
 117     widget_class->size_allocate = grr_board_view_size_allocate;
 118     widget_class->button_press_event = grr_board_view_button_press;
 119     widget_class->button_release_event = grr_board_view_button_release;
 120     widget_class->motion_notify_event = grr_board_view_motion_notify;
 121 }
 122
 123 static void
 124 grr_board_view_init (grr_board_view_t *view)
 125 {
 126     int i;
 127     rr_robot_t robot;
 128     rr_target_t target;
 129
 130     view->board = NULL;
 131     view->client = NULL;
 132
 133     view->button = 0;
 134
 135     view->time = 60.0;
 136     view->drift_correct = 0.0;
 137     view->timer = 0;
 138     view->zap_time = 0.0;
 139
 140     view->cell_width = 0;
 141     view->cell_height = 0;
 142
 143     view->cell1_icon = grr_icon_create ("cell1");
 144     view->cell2_icon = grr_icon_create ("cell2");
 145     view->wall_icon = grr_icon_create ("wall");
 146
 147     for (i=0; i < RR_NUM_ROBOTS; i++) {
 148         robot = rr_robot_from_idx (i);
 149         view->robot_icon[i] = grr_icon_create (grr_icon_robot_name (robot));
 150     }
 151
 152     for (i=0; i < RR_NUM_TARGETS; i++) {
 153         target = rr_target_from_idx (i);
 154         view->target_icon[i] = grr_icon_create (grr_icon_target_name (target));
 155     }
 156 }
 157
 158 grr_board_view_t *
 159 grr_board_view_new (rr_board_t *board)
 160 {
 161     grr_board_view_t *view;
 162     int x, y;
 163
 164     view = g_object_new (grr_board_view_get_type (), NULL);
 165
 166     view->board = board;
 167     rr_board_get_size (board, &view->board_width, &view->board_height);
 168
 169     view->damaged = malloc (view->board_height * sizeof (int *));
 170     for (y = 0; y < view->board_height; y++) {
 171         view->damaged[y] = malloc (view->board_width * sizeof (int));
 172         for (x = 0; x< view->board_width; x++) {
 173             view->damaged[y][x] = 1;
 174         }
 175     }
 176
 177     gtk_widget_queue_draw (GTK_WIDGET (view));
 178
 179     return view;
 180 }
 181
 182 void
 183 grr_board_view_set_client (grr_board_view_t *view, rr_client_t *client)
 184 {
 185     g_return_if_fail (view != NULL);
 186
 187     view->client = client;
 188 }
 189
 190 void
 191 grr_board_view_set_active_robot (grr_board_view_t *view, rr_robot_t robot)
 192 {
 193     g_return_if_fail (view != NULL);
 194
 195     view->active_robot = robot;
 196 }
 197
 198 void
 199 grr_board_view_move_active (grr_board_view_t *view, rr_direction_t dir)
 200 {
 201     if (view->client) {
 202         rr_client_move (view->client, view->active_robot, dir);
 203     } else {
 204         rr_board_move (view->board, view->active_robot, dir);
 205         gtk_widget_queue_draw (GTK_WIDGET (view));
 206     }
 207 }
 208
 209 void
 210 grr_board_view_undo (grr_board_view_t *view)
 211 {
 212     if (view->client) {
 213         rr_client_undo (view->client);
 214     } else {
 215         rr_board_undo (view->board);
 216         gtk_widget_queue_draw (GTK_WIDGET (view));
 217     }
 218 }
 219
 220 static void
 221 grr_board_view_destroy (GtkObject *object)
 222 {
 223     grr_board_view_t *view;
 224
 225     g_return_if_fail (object != NULL);
 226     g_return_if_fail (GRR_IS_BOARD_VIEW (object));
 227
 228     view = GRR_BOARD_VIEW (object);
 229
 230     view->board = NULL;
 231     view->client = NULL;
 232
 233     if (GTK_OBJECT_CLASS (parent_class)->destroy)
 234         (* GTK_OBJECT_CLASS (parent_class)->destroy) (object);
 235 }
 236
 237 static void
 238 grr_board_view_realize (GtkWidget *widget)
 239 {
 240     grr_board_view_t *view;
 241     GdkWindowAttr attributes;
 242     gint attributes_mask;
 243
 244     g_return_if_fail (widget != NULL);
 245     g_return_if_fail (GRR_IS_BOARD_VIEW (widget));
 246
 247     GTK_WIDGET_SET_FLAGS (widget, GTK_REALIZED);
 248     view = GRR_BOARD_VIEW (widget);
 249
 250     attributes.x = widget->allocation.x;
 251     attributes.y = widget->allocation.y;
 252     attributes.width = widget->allocation.width;
 253     attributes.height = widget->allocation.height;
 254     attributes.wclass = GDK_INPUT_OUTPUT;
 255     attributes.window_type = GDK_WINDOW_CHILD;
 256     attributes.event_mask = gtk_widget_get_events (widget) |
 257         GDK_EXPOSURE_MASK | GDK_BUTTON_PRESS_MASK |
 258         GDK_BUTTON_RELEASE_MASK | GDK_POINTER_MOTION_MASK |
 259         GDK_POINTER_MOTION_HINT_MASK;
 260     attributes.visual = gtk_widget_get_visual (widget);
 261     attributes.colormap = gtk_widget_get_colormap (widget);
 262
 263     attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP;
 264     widget->window = gdk_window_new (widget->parent->window, &attributes, attributes_mask);
 265
 266     widget->style = gtk_style_attach (widget->style, widget->window);
 267
 268     gdk_window_set_user_data (widget->window, widget);
 269
 270     gtk_style_set_background (widget->style, widget->window, GTK_STATE_ACTIVE);
 271 }
 272
 273 static void
 274 grr_board_view_size_request (GtkWidget      *widget,
 275                        GtkRequisition *requisition)
 276 {
 277     requisition->width = GRR_BOARD_VIEW_DEFAULT_SIZE;
 278     requisition->height = GRR_BOARD_VIEW_DEFAULT_SIZE;
 279 }
 280
 281 static void
 282 grr_board_view_size_allocate (GtkWidget     *widget,
 283                         GtkAllocation *allocation)
 284 {
 285     grr_board_view_t *view;
 286
 287     g_return_if_fail (widget != NULL);
 288     g_return_if_fail (GRR_IS_BOARD_VIEW (widget));
 289     g_return_if_fail (allocation != NULL);
 290
 291     widget->allocation = *allocation;
 292     view = GRR_BOARD_VIEW (widget);
 293
 294     if (GTK_WIDGET_REALIZED (widget)) {
 295         gdk_window_move_resize (widget->window,
 296                                 allocation->x, allocation->y,
 297                                 allocation->width, allocation->height);
 298     }
 299 }
 300
 301 static void
 302 grr_board_view_draw_walls (grr_board_view_t     *view,
 303                            cairo_t              *xrs,
 304                            rr_wall_t            wall)
 305 {
 306     if (wall == RR_WALL_NONE)
 307         return;
 308
 309     if (wall & RR_WALL_ABOVE) {
 310         grr_icon_draw (view->wall_icon, xrs);
 311     }
 312     if (wall & RR_WALL_LEFT) {
 313         cairo_save (xrs);
 314         cairo_rotate (xrs, M_PI_2);
 315         grr_icon_draw (view->wall_icon, xrs);
 316         cairo_restore (xrs);
 317     }
 318     if (wall & RR_WALL_RIGHT) {
 319         cairo_save (xrs);
 320         cairo_translate (xrs, GRR_SVG_ASSUMED_WIDTH, 0);
 321         cairo_rotate (xrs, M_PI_2);
 322         grr_icon_draw (view->wall_icon, xrs);
 323         cairo_restore (xrs);
 324     }
 325     if (wall & RR_WALL_BELOW) {
 326         cairo_save (xrs);
 327         cairo_translate (xrs, 0, GRR_SVG_ASSUMED_HEIGHT);
 328         grr_icon_draw (view->wall_icon, xrs);
 329         cairo_restore (xrs);
 330     }
 331 }
 332
 333 static gint
 334 grr_board_view_expose (GtkWidget      *widget,
 335                        GdkEventExpose *event)
 336 {
 337     grr_board_view_t *view;
 338     rr_board_t *board;
 339     Display *dpy;
 340     Drawable drawable;
 341     Visual *visual;
 342     cairo_surface_t *surface;
 343     cairo_t *xrs;
 344     GdkDrawable *real_drawable;
 345     gint x_off, y_off;
 346     int i, j;
 347     rr_target_t goal_target;
 348     int new_cell_width, new_cell_height;
 349
 350     g_return_val_if_fail (widget != NULL, FALSE);
 351     g_return_val_if_fail (GRR_IS_BOARD_VIEW (widget), FALSE);
 352     g_return_val_if_fail (event != NULL, FALSE);
 353
 354     view = GRR_BOARD_VIEW (widget);
 355     board = view->board;
 356
 357     /* Unabstract X from GTK+ */
 358     gdk_window_get_internal_paint_info (widget->window, &real_drawable, &x_off, &y_off);
 359     dpy = gdk_x11_drawable_get_xdisplay (real_drawable);
 360     drawable = gdk_x11_drawable_get_xid (real_drawable);
 361
 362     /* Ignore GTK+ and use Cairo for drawing. */
 363     visual = GDK_VISUAL_XVISUAL (gdk_drawable_get_visual (real_drawable));
 364     surface = cairo_xlib_surface_create (dpy, drawable, visual,
 365                                          widget->allocation.width,
 366                                          widget->allocation.height);
 367     xrs = cairo_create (surface);
 368
 369     new_cell_width = widget->allocation.width / view->board_width;
 370     if (new_cell_width == 0)
 371         new_cell_width = 1;
 372     new_cell_height = widget->allocation.height / view->board_height;
 373     if (new_cell_height == 0)
 374         new_cell_height = 1;
 375
 376     if (new_cell_width != view->cell_width
 377         || new_cell_height != view->cell_height) {
 378         int i;
 379         rr_robot_t robot;
 380         rr_target_t target;
 381
 382         view->cell_width = new_cell_width;
 383         view->cell_height = new_cell_height;
 384
 385         cairo_save (xrs);
 386         cairo_scale (xrs,
 387                  view->cell_width / GRR_SVG_ASSUMED_WIDTH,
 388                  view->cell_height / GRR_SVG_ASSUMED_HEIGHT);
 389
 390         grr_icon_predraw (view->cell1_icon, xrs,
 391                           view->cell_width, view->cell_height);
 392         grr_icon_predraw (view->cell2_icon, xrs,
 393                           view->cell_width, view->cell_height);
 394
 395         grr_icon_predraw (view->wall_icon, xrs,
 396                           view->cell_width, view->cell_height);
 397
 398         for (i=0; i < RR_NUM_ROBOTS; i++) {
 399             robot = rr_robot_from_idx (i);
 400             grr_icon_predraw (view->robot_icon[i], xrs,
 401                               view->cell_width, view->cell_height);
 402         }
 403
 404         for (i=0; i < RR_NUM_TARGETS; i++) {
 405             target = rr_target_from_idx (i);
 406             grr_icon_predraw (view->target_icon[i], xrs,
 407                               view->cell_width, view->cell_height);
 408         }
 409
 410         cairo_restore (xrs);
 411     }
 412
 413     view->cell_width = new_cell_width;
 414     view->cell_height = new_cell_height;
 415
 416     if (event->area.width) {
 417         int x_start, y_start;
 418         int x, y;
 419         int x_stop, y_stop;
 420         grr_board_view_transform_pixel_to_cell (view,
 421                                                 event->area.x, event->area.y,
 422                                                 &x_start, &y_start);
 423         grr_board_view_transform_pixel_to_cell (view,
 424                                                 event->area.x + event->area.width - 1,
 425                                                 event->area.y + event->area.height - 1,
 426                                                 &x_stop, &y_stop);
 427         for (y = y_start; y <= y_stop; y++)
 428             for (x = x_start; x <= x_stop; x++)
 429                 view->damaged[y][x] = 1;
 430     }
 431
 432     if (event->count > 0)
 433         return FALSE;
 434
 435     cairo_translate (xrs, -x_off, -y_off);
 436
 437     view->board_pad_x = (widget->allocation.width - view->board_width * view->cell_width) / 2;
 438     view->board_pad_y = (widget->allocation.height - view->board_height * view->cell_height) / 2;
 439
 440     cairo_translate (xrs, view->board_pad_x, view->board_pad_y);
 441
 442     goal_target = rr_board_get_goal_target (board);
 443
 444     /* Draw cell contents */
 445     for (j=0; j < view->board_height; j++) {
 446         for (i=0; i < view->board_width; i++) {
 447             if (! view->damaged[j][i])
 448                 continue;
 449             rr_cell_t cell = rr_board_get_cell (board, i, j);
 450             rr_target_t target = RR_CELL_GET_TARGET (cell);
 451             rr_robot_t robot = RR_CELL_GET_ROBOT (cell);
 452
 453             cairo_save (xrs);
 454             cairo_translate (xrs, i * view->cell_width, j * view->cell_height);
 455
 456             if ((i+j) % 2 == 0)
 457                 grr_icon_draw_predrawn (view->cell1_icon, xrs, 1.0);
 458             else
 459                 grr_icon_draw_predrawn (view->cell2_icon, xrs, 1.0);
 460
 461             if (target)
 462                 grr_icon_draw_predrawn (view->target_icon[rr_target_idx (target)],
 463                                         xrs,
 464                                         target == goal_target ? 1.0 : 0.25);
 465
 466             if (robot)
 467                 grr_icon_draw_predrawn (view->robot_icon[rr_robot_idx (robot)],
 468                                         xrs, 1.0);
 469
 470             cairo_restore (xrs);
 471         }
 472     }
 473
 474     /* Draw goal target in center of board */
 475     /* XXX: Not a perfect heuristic. Should check for the vacant box too. */
 476     if (view->board_width == 16 && view->board_height == 16) {
 477         cairo_save (xrs);
 478         cairo_translate (xrs,
 479                      (view->board_width / 2 - 1) * view->cell_width,
 480                      (view->board_height / 2 - 1) * view->cell_height);
 481         cairo_scale (xrs,
 482                      2 * view->cell_width / GRR_SVG_ASSUMED_WIDTH,
 483                      2 * view->cell_height / GRR_SVG_ASSUMED_HEIGHT);
 484         cairo_rectangle (xrs, 0, 0, GRR_SVG_ASSUMED_WIDTH, GRR_SVG_ASSUMED_HEIGHT);
 485         cairo_set_source_rgb (xrs, 1, 1, 1);
 486         cairo_fill (xrs);
 487         grr_icon_draw (view->target_icon[rr_target_idx (goal_target)], xrs);
 488         cairo_restore (xrs);
 489
 490         /* Draw clock */
 491         if (view->time < 60.0) {
 492             cairo_save (xrs);
 493             cairo_new_path (xrs);
 494             cairo_move_to (xrs,
 495                            (double) view->board_width / 2 * view->cell_width,
 496                            (double) view->board_height / 2 * view->cell_height);
 497             cairo_arc (xrs,
 498                        (double) view->board_width / 2 * view->cell_width,
 499                        (double) view->board_height / 2 * view->cell_height,
 500                        .9 * view->cell_width,
 501                        - M_PI_2,
 502                        2 * M_PI * (60.0 - view->time) / 60.0 - M_PI_2);
 503             cairo_close_path (xrs);
 504
 505             cairo_set_source_rgba (xrs, 0.0, 0.0, 0.0, 0.5);
 506             cairo_fill (xrs);
 507
 508             cairo_restore (xrs);
 509         }
 510     }
 511
 512     /* Draw walls */
 513     for (j=0; j < view->board_height; j++) {
 514         for (i=0; i < view->board_width; i++) {
 515             if (! view->damaged[j][i])
 516                 continue;
 517             view->damaged[j][i] = 0;
 518             cairo_save (xrs);
 519             cairo_translate (xrs, i * view->cell_width, j * view->cell_height);
 520             cairo_scale (xrs,
 521                      view->cell_width / GRR_SVG_ASSUMED_WIDTH,
 522                      view->cell_height / GRR_SVG_ASSUMED_HEIGHT);
 523             grr_board_view_draw_walls (view, xrs, RR_CELL_GET_WALLS (rr_board_get_cell(board, i, j)));
 524             cairo_restore (xrs);
 525         }
 526     }
 527
 528     cairo_destroy (xrs);
 529
 530     return FALSE;
 531 }
 532
 533 void
 534 grr_board_view_transform_pixel_to_cell (grr_board_view_t *view,
 535                                         int pixel_x, int pixel_y,
 536                                         int *cell_x, int *cell_y)
 537 {
 538     int x, y;
 539     x = (pixel_x - view->board_pad_x) / view->cell_width;
 540     y = (pixel_y - view->board_pad_y) / view->cell_height;
 541     if (x < 0)
 542         x = 0;
 543     if (x >= view->board_width)
 544         x = view->board_width - 1;
 545     if (y < 0)
 546         y = 0;
 547     if (y >= view->board_height)
 548         y = view->board_height - 1;
 549     *cell_x = x;
 550     *cell_y = y;
 551 }
 552
 553 void
 554 grr_board_view_transform_cell_to_pixel (grr_board_view_t *view,
 555                                         int cell_x, int cell_y,
 556                                         int *pixel_x, int *pixel_y)
 557 {
 558     *pixel_x = view->cell_width * cell_x + view->board_pad_x;
 559     *pixel_y = view->cell_height * cell_y + view->board_pad_y;
 560 }
 561
 562 static gint
 563 grr_board_view_button_press (GtkWidget      *widget,
 564                              GdkEventButton *event)
 565 {
 566     grr_board_view_t *view;
 567     rr_cell_t cell;
 568     int x, y;
 569
 570     g_return_val_if_fail (widget != NULL, FALSE);
 571     g_return_val_if_fail (GRR_IS_BOARD_VIEW (widget), FALSE);
 572     g_return_val_if_fail (event != NULL, FALSE);
 573
 574     view = GRR_BOARD_VIEW (widget);
 575
 576     grr_board_view_transform_pixel_to_cell (view,
 577                                             event->x, event->y,
 578                                             &x, &y);
 579
 580     cell = rr_board_get_cell (view->board, x, y);
 581     if (!view->button && RR_CELL_GET_ROBOT (cell)) {
 582
 583         gtk_grab_add (widget);
 584
 585         view->button = event->button;
 586         grr_board_view_set_active_robot (view, RR_CELL_GET_ROBOT (cell));
 587
 588         grr_board_view_update_mouse (view, event->x, event->y);
 589     }
 590
 591     return FALSE;
 592 }
 593
 594 static gint
 595 grr_board_view_button_release (GtkWidget      *widget,
 596                                GdkEventButton *event)
 597 {
 598     grr_board_view_t *view;
 599     rr_direction_t dir;
 600     int x, y;
 601     int robot_x, robot_y;
 602     int dx, dy;
 603
 604     g_return_val_if_fail (widget != NULL, FALSE);
 605     g_return_val_if_fail (GRR_IS_BOARD_VIEW (widget), FALSE);
 606     g_return_val_if_fail (event != NULL, FALSE);
 607
 608     view = GRR_BOARD_VIEW (widget);
 609
 610     if (view->button == event->button) {
 611       gtk_grab_remove (widget);
 612       view->button = 0;
 613     }
 614
 615     grr_board_view_transform_pixel_to_cell (view, event->x, event->y, &x, &y);
 616
 617     rr_board_find_robot (view->board, view->active_robot, &robot_x, &robot_y);
 618     dx = x - robot_x;
 619     dy = y - robot_y;
 620     if (dx == 0 && dy == 0)
 621         return FALSE;
 622
 623     if (abs(dx) > abs(dy))
 624         if (x > robot_x)
 625             dir = RR_DIRECTION_EAST;
 626         else
 627             dir = RR_DIRECTION_WEST;
 628     else
 629         if (y > robot_y)
 630             dir = RR_DIRECTION_SOUTH;
 631         else
 632             dir = RR_DIRECTION_NORTH;
 633
 634     grr_board_view_move_active (view, dir);
 635
 636     return FALSE;
 637 }
 638
 639 static gint
 640 grr_board_view_motion_notify (GtkWidget      *widget,
 641                          GdkEventMotion *event)
 642 {
 643     grr_board_view_t *view;
 644     GdkModifierType mods;
 645     gint x, y, mask;
 646
 647     g_return_val_if_fail (widget != NULL, FALSE);
 648     g_return_val_if_fail (GRR_IS_BOARD_VIEW (widget), FALSE);
 649     g_return_val_if_fail (event != NULL, FALSE);
 650
 651     view = GRR_BOARD_VIEW (widget);
 652
 653     if (view->button != 0) {
 654         x = event->x;
 655         y = event->y;
 656
 657         if (event->is_hint || (event->window != widget->window))
 658             gdk_window_get_pointer (widget->window, &x, &y, &mods);
 659
 660         switch (view->button) {
 661         case 1:
 662             mask = GDK_BUTTON1_MASK;
 663             break;
 664         case 2:
 665             mask = GDK_BUTTON2_MASK;
 666             break;
 667         case 3:
 668             mask = GDK_BUTTON3_MASK;
 669             break;
 670         default:
 671             mask = 0;
 672             break;
 673         }
 674
 675         if (mods & mask)
 676             grr_board_view_update_mouse (view, x,y);
 677     }
 678
 679     return FALSE;
 680 }
 681
 682 static void
 683 grr_board_view_update_mouse (grr_board_view_t *view, gint x, gint y)
 684 {
 685     g_return_if_fail (view != NULL);
 686     g_return_if_fail (GRR_IS_BOARD_VIEW (view));
 687
 688     /* XXX: Perhaps should draw a robot here */
 689 }
 690
 691 void
 692 grr_board_view_mark_damage (grr_board_view_t *view, int i, int j)
 693 {
 694     int x, y;
 695
 696     grr_board_view_transform_cell_to_pixel (view, i, j, &x, &y);
 697     gtk_widget_queue_draw_area (GTK_WIDGET (view), x, y, view->cell_width, view->cell_height);
 698 }
 699
 700 #define TIMER_INTERVAL_MS 100.0
 701
 702 static void
 703 grr_board_view_refresh_timer (grr_board_view_t *view)
 704 {
 705     int x, y;
 706
 707     grr_board_view_transform_cell_to_pixel (view,
 708                                             view->board_width / 2 - 1,
 709                                             view->board_height / 2 -1,
 710                                             &x, &y);
 711     gtk_widget_queue_draw_area (GTK_WIDGET (view),
 712                                 x, y,
 713                                 2 * view->cell_width,
 714                                 2 * view->cell_height);
 715 }
 716
 717 static gboolean
 718 grr_board_view_decrement_timer (void *widget)
 719 {
 720     grr_board_view_t *view = widget;
 721
 722     view->time -= TIMER_INTERVAL_MS / 1000.0;
 723     view->time += view->drift_correct;
 724
 725     if (view->zap_time) {
 726         view->time -= view->zap_time;
 727         view->zap_time += 1.0;
 728     }
 729
 730     grr_board_view_refresh_timer (view);
 731
 732     if (view->time < 0) {
 733         grr_board_view_stop_timer (view);
 734         return FALSE;
 735     }
 736
 737     return TRUE;
 738 }
 739
 740 void
 741 grr_board_view_set_timer (grr_board_view_t *view, double time)
 742 {
 743     /* XXX: It would be good to adjust the clock for latency somewhere... */
 744     if (view->timer) {
 745         double correction_time;
 746         /* Correct any drift within the next 10 seconds, or half the
 747            remaining time --- whichever is less. */
 748         if (time >= 20.0)
 749             correction_time = 10.0;
 750         else
 751             correction_time = time / 2.0;
 752         view->drift_correct = (time - view->time) / (correction_time * TIMER_INTERVAL_MS);
 753     } else {
 754         view->time = time;
 755         view->drift_correct = 0.0;
 756         view->zap_time = 0.0;
 757     }
 758 }
 759
 760 void
 761 grr_board_view_start_timer (grr_board_view_t *view)
 762 {
 763     if (view->timer)
 764         return;
 765
 766     view->timer = gtk_timeout_add (TIMER_INTERVAL_MS, grr_board_view_decrement_timer, view);
 767 }
 768
 769 void
 770 grr_board_view_stop_timer (grr_board_view_t *view)
 771 {
 772     if (view->timer == 0)
 773         return;
 774
 775     gtk_timeout_remove (view->timer);
 776     view->timer = 0;
 777     view->time = 0.0;
 778     view->drift_correct = 0.0;
 779     view->zap_time = 0.0;
 780
 781     grr_board_view_refresh_timer (view);
 782 }
 783
 784 void
 785 grr_board_view_zap_timer (grr_board_view_t *view)
 786 {
 787     view->zap_time = 4;
 788
 789     grr_board_view_refresh_timer (view);
 790 }
 791