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