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