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