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 <Xr.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 static void grr_board_view_update                   (grr_board_view_t *view);
  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     view->timer = 0;
 135
 136     view->cell_width = 0;
 137     view->cell_height = 0;
 138
 139     view->cell_icon = grr_icon_create ("cell");
 140     view->wall_icon = grr_icon_create ("wall");
 141
 142     for (i=0; i < RR_NUM_ROBOTS; i++) {
 143         robot = rr_robot_from_idx (i);
 144         view->robot_icon[i] = grr_icon_create (grr_icon_robot_name (robot));
 145     }
 146
 147     for (i=0; i < RR_NUM_TARGETS; i++) {
 148         target = rr_target_from_idx (i);
 149         view->target_icon[i] = grr_icon_create (grr_icon_target_name (target));
 150     }
 151 }
 152
 153 grr_board_view_t *
 154 grr_board_view_new (rr_board_t *board)
 155 {
 156     grr_board_view_t *view;
 157
 158     view = g_object_new (grr_board_view_get_type (), NULL);
 159
 160     view->board = board;
 161
 162     grr_board_view_update (view);
 163
 164     return view;
 165 }
 166
 167 void
 168 grr_board_view_set_client (grr_board_view_t *view, rr_client_t *client)
 169 {
 170     g_return_if_fail (view != NULL);
 171
 172     view->client = client;
 173 }
 174
 175 void
 176 grr_board_view_set_active_robot (grr_board_view_t *view, rr_robot_t robot)
 177 {
 178     g_return_if_fail (view != NULL);
 179
 180     view->active_robot = robot;
 181 }
 182
 183 void
 184 grr_board_view_move_active (grr_board_view_t *view, rr_direction_t dir)
 185 {
 186     if (view->client) {
 187         rr_client_move (view->client, view->active_robot, dir);
 188     } else {
 189         rr_board_move (view->board, view->active_robot, dir);
 190         gtk_widget_queue_draw (GTK_WIDGET (view));
 191     }
 192 }
 193
 194 void
 195 grr_board_view_undo (grr_board_view_t *view)
 196 {
 197     if (view->client) {
 198         rr_client_undo (view->client);
 199     } else {
 200         rr_board_undo (view->board);
 201         gtk_widget_queue_draw (GTK_WIDGET (view));
 202     }
 203 }
 204
 205 static void
 206 grr_board_view_destroy (GtkObject *object)
 207 {
 208     grr_board_view_t *view;
 209
 210     g_return_if_fail (object != NULL);
 211     g_return_if_fail (GRR_IS_BOARD_VIEW (object));
 212
 213     view = GRR_BOARD_VIEW (object);
 214
 215     view->board = NULL;
 216     view->client = NULL;
 217
 218     if (GTK_OBJECT_CLASS (parent_class)->destroy)
 219         (* GTK_OBJECT_CLASS (parent_class)->destroy) (object);
 220 }
 221
 222 static void
 223 grr_board_view_realize (GtkWidget *widget)
 224 {
 225     grr_board_view_t *view;
 226     GdkWindowAttr attributes;
 227     gint attributes_mask;
 228
 229     g_return_if_fail (widget != NULL);
 230     g_return_if_fail (GRR_IS_BOARD_VIEW (widget));
 231
 232     GTK_WIDGET_SET_FLAGS (widget, GTK_REALIZED);
 233     view = GRR_BOARD_VIEW (widget);
 234
 235     attributes.x = widget->allocation.x;
 236     attributes.y = widget->allocation.y;
 237     attributes.width = widget->allocation.width;
 238     attributes.height = widget->allocation.height;
 239     attributes.wclass = GDK_INPUT_OUTPUT;
 240     attributes.window_type = GDK_WINDOW_CHILD;
 241     attributes.event_mask = gtk_widget_get_events (widget) |
 242         GDK_EXPOSURE_MASK | GDK_BUTTON_PRESS_MASK |
 243         GDK_BUTTON_RELEASE_MASK | GDK_POINTER_MOTION_MASK |
 244         GDK_POINTER_MOTION_HINT_MASK;
 245     attributes.visual = gtk_widget_get_visual (widget);
 246     attributes.colormap = gtk_widget_get_colormap (widget);
 247
 248     attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP;
 249     widget->window = gdk_window_new (widget->parent->window, &attributes, attributes_mask);
 250
 251     widget->style = gtk_style_attach (widget->style, widget->window);
 252
 253     gdk_window_set_user_data (widget->window, widget);
 254
 255     gtk_style_set_background (widget->style, widget->window, GTK_STATE_ACTIVE);
 256 }
 257
 258 static void
 259 grr_board_view_size_request (GtkWidget      *widget,
 260                        GtkRequisition *requisition)
 261 {
 262     requisition->width = GRR_BOARD_VIEW_DEFAULT_SIZE;
 263     requisition->height = GRR_BOARD_VIEW_DEFAULT_SIZE;
 264 }
 265
 266 static void
 267 grr_board_view_size_allocate (GtkWidget     *widget,
 268                         GtkAllocation *allocation)
 269 {
 270     grr_board_view_t *view;
 271
 272     g_return_if_fail (widget != NULL);
 273     g_return_if_fail (GRR_IS_BOARD_VIEW (widget));
 274     g_return_if_fail (allocation != NULL);
 275
 276     widget->allocation = *allocation;
 277     view = GRR_BOARD_VIEW (widget);
 278
 279     if (GTK_WIDGET_REALIZED (widget)) {
 280         gdk_window_move_resize (widget->window,
 281                                 allocation->x, allocation->y,
 282                                 allocation->width, allocation->height);
 283     }
 284 }
 285
 286 static void
 287 grr_board_view_draw_walls (grr_board_view_t     *view,
 288                            XrState              *xrs,
 289                            rr_wall_t            wall)
 290 {
 291     if (wall == RR_WALL_NONE)
 292         return;
 293
 294     if (wall & RR_WALL_ABOVE) {
 295         grr_icon_draw (view->wall_icon, xrs);
 296     }
 297     if (wall & RR_WALL_LEFT) {
 298         XrSave (xrs);
 299         XrRotate (xrs, M_PI_2);
 300         grr_icon_draw (view->wall_icon, xrs);
 301         XrRestore (xrs);
 302     }
 303     if (wall & RR_WALL_RIGHT) {
 304         XrSave (xrs);
 305         XrTranslate (xrs, GRR_SVG_ASSUMED_WIDTH, 0);
 306         XrRotate (xrs, M_PI_2);
 307         grr_icon_draw (view->wall_icon, xrs);
 308         XrRestore (xrs);
 309     }
 310     if (wall & RR_WALL_BELOW) {
 311         XrSave (xrs);
 312         XrTranslate (xrs, 0, GRR_SVG_ASSUMED_HEIGHT);
 313         grr_icon_draw (view->wall_icon, xrs);
 314         XrRestore (xrs);
 315     }
 316 }
 317
 318 static void
 319 grr_board_view_draw_cell (grr_board_view_t      *view,
 320                           XrState               *xrs,
 321                           rr_cell_t             cell,
 322                           rr_target_t           goal,
 323                           int                   width,
 324                           int                   height)
 325 {
 326     int xpad, ypad;
 327     rr_robot_t robot;
 328     rr_target_t target;
 329
 330     XrSave (xrs);
 331     XrScale (xrs,
 332              width / GRR_SVG_ASSUMED_WIDTH,
 333              height / GRR_SVG_ASSUMED_HEIGHT);
 334     grr_icon_draw (view->cell_icon, xrs);
 335     grr_board_view_draw_walls (view, xrs, RR_CELL_GET_WALLS (cell));
 336     XrRestore (xrs);
 337
 338     xpad = width / 10;
 339     ypad = width / 10;
 340
 341     XrSave (xrs);
 342     XrTranslate (xrs, xpad, ypad);
 343     XrScale (xrs,
 344              (width - 2*xpad)  / GRR_SVG_ASSUMED_WIDTH,
 345              (height - 2*ypad) / GRR_SVG_ASSUMED_HEIGHT);
 346
 347     target = RR_CELL_GET_TARGET (cell);
 348     if (target)
 349         grr_icon_draw (view->target_icon[rr_target_idx (target)], xrs);
 350
 351     XrRestore (xrs);
 352
 353     /* XXX: This is a kludge, (it obscures the cell background in
 354        addition to the target). The real way to do this is to draw the
 355        target itself with less opacity. */
 356     if (target && target != goal) {
 357         XrSave (xrs);
 358         XrScale (xrs,
 359                  width / GRR_SVG_ASSUMED_WIDTH,
 360                  height / GRR_SVG_ASSUMED_HEIGHT);
 361         XrRectangle (xrs, 1, 1,
 362                      GRR_SVG_ASSUMED_WIDTH - 1,
 363                      GRR_SVG_ASSUMED_HEIGHT - 1);
 364         XrSetRGBColor (xrs, 1, 1, 1);
 365         XrSetAlpha (xrs, 0.75);
 366         XrFill (xrs);
 367         XrRestore (xrs);
 368     }
 369
 370     XrSave (xrs);
 371     XrTranslate (xrs, xpad, ypad);
 372     XrScale (xrs,
 373              (width - 2*xpad)  / GRR_SVG_ASSUMED_WIDTH,
 374              (height - 2*ypad) / GRR_SVG_ASSUMED_HEIGHT);
 375
 376     robot = RR_CELL_GET_ROBOT (cell);
 377     if (robot)
 378         grr_icon_draw (view->robot_icon[rr_robot_idx (robot)], xrs);
 379
 380     XrRestore (xrs);
 381
 382 }
 383
 384 static gint
 385 grr_board_view_expose (GtkWidget      *widget,
 386                        GdkEventExpose *event)
 387 {
 388     grr_board_view_t *view;
 389     rr_board_t *board;
 390     Display *dpy;
 391     Drawable drawable;
 392     XrState *xrs;
 393     GdkDrawable *real_drawable;
 394     gint x_off, y_off;
 395     int i, j;
 396     rr_target_t goal_target;
 397     int new_cell_width, new_cell_height;
 398
 399     g_return_val_if_fail (widget != NULL, FALSE);
 400     g_return_val_if_fail (GRR_IS_BOARD_VIEW (widget), FALSE);
 401     g_return_val_if_fail (event != NULL, FALSE);
 402
 403     if (event->count > 0)
 404         return FALSE;
 405
 406     view = GRR_BOARD_VIEW (widget);
 407     board = view->board;
 408
 409     /* Unabstract X from GTK+ */
 410     gdk_window_get_internal_paint_info (widget->window, &real_drawable, &x_off, &y_off);
 411     dpy = gdk_x11_drawable_get_xdisplay (real_drawable);
 412     drawable = gdk_x11_drawable_get_xid (real_drawable);
 413
 414     /* Ignore GTK+ and use Xr for drawing. */
 415     xrs = XrCreate ();
 416     XrSetTargetDrawable (xrs, dpy, drawable);
 417
 418     rr_board_get_size (board, &view->board_width, &view->board_height);
 419
 420     new_cell_width = widget->allocation.width / view->board_width;
 421     if (new_cell_width == 0)
 422         new_cell_width = 1;
 423     new_cell_height = widget->allocation.height / view->board_height;
 424     if (new_cell_height == 0)
 425         new_cell_height = 1;
 426
 427     view->cell_width = new_cell_width;
 428     view->cell_height = new_cell_height;
 429
 430     /* Pre-render icons if the size has changed */
 431     /* XXX: This code isn't fully baked yet
 432     if (new_cell_width != view->cell_width
 433         || new_cell_height != view->cell_height) {
 434         int i;
 435         rr_robot_t robot;
 436         rr_target_t target;
 437
 438         view->cell_width = new_cell_width;
 439         view->cell_height = new_cell_height;
 440
 441         XrSave (xrs);
 442         XrScale (xrs,
 443                  view->cell_width / GRR_SVG_ASSUMED_WIDTH,
 444                  view->cell_height / GRR_SVG_ASSUMED_HEIGHT);
 445
 446         grr_icon_predraw (view->cell_icon, xrs,
 447                           view->cell_width, view->cell_height);
 448
 449         grr_icon_predraw (view->wall_icon, xrs,
 450                           view->cell_width, view->cell_height);
 451
 452         for (i=0; i < RR_NUM_ROBOTS; i++) {
 453             robot = rr_robot_from_idx (i);
 454             grr_icon_predraw (view->robot_icon[i], xrs,
 455                               view->cell_width, view->cell_height);
 456         }
 457
 458         for (i=0; i < RR_NUM_TARGETS; i++) {
 459             target = rr_target_from_idx (i);
 460             grr_icon_predraw (view->target_icon[i], xrs,
 461                               view->cell_width, view->cell_height);
 462         }
 463
 464         XrRestore (xrs);
 465     }
 466     */
 467
 468     XrTranslate (xrs, -x_off, -y_off);
 469
 470     view->board_pad_x = (widget->allocation.width - view->board_width * view->cell_width) / 2;
 471     view->board_pad_y = (widget->allocation.height - view->board_height * view->cell_height) / 2;
 472
 473     XrTranslate (xrs, view->board_pad_x, view->board_pad_y);
 474
 475     goal_target = rr_board_get_goal_target (board);
 476
 477     /* Draw cell targets */
 478     for (j=0; j < view->board_height; j++) {
 479         for (i=0; i < view->board_width; i++) {
 480             XrSave (xrs);
 481             XrTranslate (xrs, i * view->cell_width, j * view->cell_height);
 482             grr_board_view_draw_cell (view, xrs,
 483                                       rr_board_get_cell (board, i, j),
 484                                       goal_target,
 485                                       view->cell_width, view->cell_height);
 486             XrRestore (xrs);
 487         }
 488     }
 489
 490     /* Draw goal target in center of board */
 491     /* XXX: Not a perfect heuristic. Should check for the vacant box too. */
 492     if (view->board_width == 16 && view->board_height == 16) {
 493         XrSave (xrs);
 494         XrTranslate (xrs,
 495                      (view->board_width / 2 - 1) * view->cell_width,
 496                      (view->board_height / 2 - 1) * view->cell_height);
 497         grr_board_view_draw_cell (view, xrs, goal_target, goal_target,
 498                                   view->cell_width * 2, view->cell_height * 2);
 499         XrRestore (xrs);
 500     }
 501
 502     /* Draw walls */
 503     for (j=0; j < view->board_height; j++) {
 504         for (i=0; i < view->board_width; i++) {
 505             XrSave (xrs);
 506             XrTranslate (xrs, i * view->cell_width, j * view->cell_height);
 507             XrScale (xrs,
 508                      view->cell_width / GRR_SVG_ASSUMED_WIDTH,
 509                      view->cell_height / GRR_SVG_ASSUMED_HEIGHT);
 510             grr_board_view_draw_walls (view, xrs, RR_CELL_GET_WALLS (rr_board_get_cell(board, i, j)));
 511             XrRestore (xrs);
 512         }
 513     }
 514
 515     XrDestroy (xrs);
 516
 517     return FALSE;
 518 }
 519
 520 static void
 521 grr_board_view_pointer_coords_to_grid (grr_board_view_t *view,
 522                                        int pointer_x, int pointer_y,
 523                                        int *grid_x, int *grid_y)
 524 {
 525     *grid_x = (pointer_x - view->board_pad_x) / view->cell_width;
 526     *grid_y = (pointer_y - view->board_pad_y) / view->cell_height;
 527 }
 528
 529 static gint
 530 grr_board_view_button_press (GtkWidget      *widget,
 531                              GdkEventButton *event)
 532 {
 533     grr_board_view_t *view;
 534     rr_cell_t cell;
 535     int x, y;
 536
 537     g_return_val_if_fail (widget != NULL, FALSE);
 538     g_return_val_if_fail (GRR_IS_BOARD_VIEW (widget), FALSE);
 539     g_return_val_if_fail (event != NULL, FALSE);
 540
 541     view = GRR_BOARD_VIEW (widget);
 542
 543     grr_board_view_pointer_coords_to_grid (view,
 544                                            event->x, event->y,
 545                                            &x, &y);
 546
 547     cell = rr_board_get_cell (view->board, x, y);
 548     if (!view->button && RR_CELL_GET_ROBOT (cell)) {
 549
 550         gtk_grab_add (widget);
 551
 552         view->button = event->button;
 553         grr_board_view_set_active_robot (view, RR_CELL_GET_ROBOT (cell));
 554
 555         grr_board_view_update_mouse (view, event->x, event->y);
 556     }
 557
 558     return FALSE;
 559 }
 560
 561 static gint
 562 grr_board_view_button_release (GtkWidget      *widget,
 563                                GdkEventButton *event)
 564 {
 565     grr_board_view_t *view;
 566     rr_direction_t dir;
 567     int x, y;
 568     int robot_x, robot_y;
 569     int dx, dy;
 570
 571     g_return_val_if_fail (widget != NULL, FALSE);
 572     g_return_val_if_fail (GRR_IS_BOARD_VIEW (widget), FALSE);
 573     g_return_val_if_fail (event != NULL, FALSE);
 574
 575     view = GRR_BOARD_VIEW (widget);
 576
 577     if (view->button == event->button) {
 578       gtk_grab_remove (widget);
 579       view->button = 0;
 580     }
 581
 582     grr_board_view_pointer_coords_to_grid (view, event->x, event->y, &x, &y);
 583
 584     rr_board_find_robot (view->board, view->active_robot, &robot_x, &robot_y);
 585     dx = x - robot_x;
 586     dy = y - robot_y;
 587     if (dx == 0 && dy == 0)
 588         return FALSE;
 589
 590     if (abs(dx) > abs(dy))
 591         if (x > robot_x)
 592             dir = RR_DIRECTION_EAST;
 593         else
 594             dir = RR_DIRECTION_WEST;
 595     else
 596         if (y > robot_y)
 597             dir = RR_DIRECTION_SOUTH;
 598         else
 599             dir = RR_DIRECTION_NORTH;
 600
 601     grr_board_view_move_active (view, dir);
 602
 603     return FALSE;
 604 }
 605
 606 static gint
 607 grr_board_view_motion_notify (GtkWidget      *widget,
 608                          GdkEventMotion *event)
 609 {
 610     grr_board_view_t *view;
 611     GdkModifierType mods;
 612     gint x, y, mask;
 613
 614     g_return_val_if_fail (widget != NULL, FALSE);
 615     g_return_val_if_fail (GRR_IS_BOARD_VIEW (widget), FALSE);
 616     g_return_val_if_fail (event != NULL, FALSE);
 617
 618     view = GRR_BOARD_VIEW (widget);
 619
 620     if (view->button != 0) {
 621         x = event->x;
 622         y = event->y;
 623
 624         if (event->is_hint || (event->window != widget->window))
 625             gdk_window_get_pointer (widget->window, &x, &y, &mods);
 626
 627         switch (view->button) {
 628         case 1:
 629             mask = GDK_BUTTON1_MASK;
 630             break;
 631         case 2:
 632             mask = GDK_BUTTON2_MASK;
 633             break;
 634         case 3:
 635             mask = GDK_BUTTON3_MASK;
 636             break;
 637         default:
 638             mask = 0;
 639             break;
 640         }
 641
 642         if (mods & mask)
 643             grr_board_view_update_mouse (view, x,y);
 644     }
 645
 646     return FALSE;
 647 }
 648
 649 static void
 650 grr_board_view_update_mouse (grr_board_view_t *view, gint x, gint y)
 651 {
 652     g_return_if_fail (view != NULL);
 653     g_return_if_fail (GRR_IS_BOARD_VIEW (view));
 654
 655     /* XXX: Perhaps should draw a robot here */
 656 }
 657
 658 static void
 659 grr_board_view_update (grr_board_view_t *view)
 660 {
 661     g_return_if_fail (view != NULL);
 662     g_return_if_fail (GRR_IS_BOARD_VIEW (view));
 663
 664     gtk_widget_queue_draw (GTK_WIDGET (view));
 665 }
 666