]> git.cworth.org Git - grrobot/blobdiff - src/grr_board_view.c
grrobot will now load SVG icons from /share/grrobot/*.svg
[grrobot] / src / grr_board_view.c
index 3092f4a044dcbfdf1d30a35da9849b2d23b7cb96..f29ec9b76b4c10b445c9fcc4f13bcd085e2bfc10 100644 (file)
  * Author: Carl Worth <carl@theworths.org>
  */
 
+#include <math.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
 #include <Xr.h>
 #include <xsvg.h>
 
-#include <math.h>
-#include <stdio.h>
 #include <gtk/gtkmain.h>
 #include <gtk/gtksignal.h>
 #include <gdk/gdkx.h>
 
 #include "grr_board_view.h"
+#include "grr_icon.h"
+#include "grr_util.h"
 
 #define SCROLL_DELAY_LENGTH  300
 #define GRR_BOARD_VIEW_DEFAULT_SIZE 100
 #define GRR_SVG_ASSUMED_WIDTH 32.0
 #define GRR_SVG_ASSUMED_HEIGHT 32.0
 
-#define GRR_CELL_SVG "svg/cell.svg"
-#define GRR_WALL_SVG "svg/wall.svg"
-
-#define GRR_ROBOT_BLUE_SVG "svg/robot_blue.svg"
-#define GRR_ROBOT_GREEN_SVG "svg/robot_green.svg"
-#define GRR_ROBOT_RED_SVG "svg/robot_red.svg"
-#define GRR_ROBOT_YELLOW_SVG "svg/robot_yellow.svg"
-
-#define GRR_TARGET_BLUE_CIRCLE_SVG "svg/target_blue_circle.svg"
-#define GRR_TARGET_BLUE_OCTAGON_SVG "svg/target_blue_octagon.svg"
-#define GRR_TARGET_BLUE_SQUARE_SVG "svg/target_blue_square.svg"
-#define GRR_TARGET_BLUE_TRIANGLE_SVG "svg/target_blue_triangle.svg"
-
-#define GRR_TARGET_GREEN_CIRCLE_SVG "svg/target_green_circle.svg"
-#define GRR_TARGET_GREEN_OCTAGON_SVG "svg/target_green_octagon.svg"
-#define GRR_TARGET_GREEN_SQUARE_SVG "svg/target_green_square.svg"
-#define GRR_TARGET_GREEN_TRIANGLE_SVG "svg/target_green_triangle.svg"
-
-#define GRR_TARGET_RED_CIRCLE_SVG "svg/target_red_circle.svg"
-#define GRR_TARGET_RED_OCTAGON_SVG "svg/target_red_octagon.svg"
-#define GRR_TARGET_RED_SQUARE_SVG "svg/target_red_square.svg"
-#define GRR_TARGET_RED_TRIANGLE_SVG "svg/target_red_triangle.svg"
-
-#define GRR_TARGET_YELLOW_CIRCLE_SVG "svg/target_yellow_circle.svg"
-#define GRR_TARGET_YELLOW_OCTAGON_SVG "svg/target_yellow_octagon.svg"
-#define GRR_TARGET_YELLOW_SQUARE_SVG "svg/target_yellow_square.svg"
-#define GRR_TARGET_YELLOW_TRIANGLE_SVG "svg/target_yellow_triangle.svg"
-
-#define GRR_TARGET_WHIRL_SVG "svg/target_whirl.svg"
-
-
 /* Forward declarations */
 
 static void grr_board_view_class_init               (grr_board_view_class_t    *klass);
@@ -79,17 +53,17 @@ static void grr_board_view_init                     (grr_board_view_t         *v
 static void grr_board_view_destroy                  (GtkObject        *object);
 static void grr_board_view_realize                  (GtkWidget        *widget);
 static void grr_board_view_size_request             (GtkWidget      *widget,
-                                              GtkRequisition *requisition);
+                                                    GtkRequisition *requisition);
 static void grr_board_view_size_allocate            (GtkWidget     *widget,
-                                              GtkAllocation *allocation);
+                                                    GtkAllocation *allocation);
 static gint grr_board_view_expose                   (GtkWidget        *widget,
-                                               GdkEventExpose   *event);
+                                                    GdkEventExpose   *event);
 static gint grr_board_view_button_press             (GtkWidget        *widget,
-                                               GdkEventButton   *event);
+                                                    GdkEventButton   *event);
 static gint grr_board_view_button_release           (GtkWidget        *widget,
-                                               GdkEventButton   *event);
+                                                    GdkEventButton   *event);
 static gint grr_board_view_motion_notify            (GtkWidget        *widget,
-                                               GdkEventMotion   *event);
+                                                    GdkEventMotion   *event);
 
 static void grr_board_view_update_mouse             (grr_board_view_t *view, gint x, gint y);
 static void grr_board_view_update                   (grr_board_view_t *view);
@@ -127,33 +101,53 @@ grr_board_view_get_type ()
 static void
 grr_board_view_class_init (grr_board_view_class_t *class)
 {
-  GtkObjectClass *object_class;
-  GtkWidgetClass *widget_class;
+    GtkObjectClass *object_class;
+    GtkWidgetClass *widget_class;
 
-  object_class = (GtkObjectClass*) class;
-  widget_class = (GtkWidgetClass*) class;
+    object_class = (GtkObjectClass*) class;
+    widget_class = (GtkWidgetClass*) class;
 
-  parent_class = gtk_type_class (gtk_widget_get_type ());
+    parent_class = gtk_type_class (gtk_widget_get_type ());
 
-  object_class->destroy = grr_board_view_destroy;
+    object_class->destroy = grr_board_view_destroy;
 
-  widget_class->realize = grr_board_view_realize;
-  widget_class->expose_event = grr_board_view_expose;
-  widget_class->size_request = grr_board_view_size_request;
-  widget_class->size_allocate = grr_board_view_size_allocate;
-  widget_class->button_press_event = grr_board_view_button_press;
-  widget_class->button_release_event = grr_board_view_button_release;
-  widget_class->motion_notify_event = grr_board_view_motion_notify;
+    widget_class->realize = grr_board_view_realize;
+    widget_class->expose_event = grr_board_view_expose;
+    widget_class->size_request = grr_board_view_size_request;
+    widget_class->size_allocate = grr_board_view_size_allocate;
+    widget_class->button_press_event = grr_board_view_button_press;
+    widget_class->button_release_event = grr_board_view_button_release;
+    widget_class->motion_notify_event = grr_board_view_motion_notify;
 }
 
 static void
 grr_board_view_init (grr_board_view_t *view)
 {
+    int i;
+    rr_robot_t robot;
+    rr_target_t target;
+
     view->board = NULL;
-    view->owns_board = 0;
+    view->client = NULL;
     
     view->button = 0;
     view->timer = 0;
+
+    view->cell_width = 0;
+    view->cell_height = 0;
+
+    view->cell_icon = grr_icon_create ("cell");
+    view->wall_icon = grr_icon_create ("wall");
+
+    for (i=0; i < RR_NUM_ROBOTS; i++) {
+       robot = rr_robot_from_idx (i);
+       view->robot_icon[i] = grr_icon_create (grr_icon_robot_name (robot));
+    }
+
+    for (i=0; i < RR_NUM_TARGETS; i++) {
+       target = rr_target_from_idx (i);
+       view->target_icon[i] = grr_icon_create (grr_icon_target_name (target));
+    }
 }
 
 GtkWidget*
@@ -163,16 +157,21 @@ grr_board_view_new (rr_board_t *board)
     
     view = g_object_new (grr_board_view_get_type (), NULL);
 
-    if (board == NULL) {
-       board = rr_board_create (16, 16);
-       view->owns_board = 1;
-    }
+    view->board = board;
 
-    grr_board_view_set_board (view, board);
+    grr_board_view_update (view);
 
     return GTK_WIDGET (view);
 }
 
+void
+grr_board_view_set_client (grr_board_view_t *view, rr_client_t *client)
+{
+    g_return_if_fail (view != NULL);
+
+    view->client = client;
+}
+
 static void
 grr_board_view_destroy (GtkObject *object)
 {
@@ -183,29 +182,13 @@ grr_board_view_destroy (GtkObject *object)
 
     view = GRR_BOARD_VIEW (object);
 
-    rr_board_destroy (view->board);
-
-    if (view->board && view->owns_board) {
-       rr_board_destroy (view->board);
-       view->board = NULL;
-    }
+    view->board = NULL;
+    view->client = NULL;
     
     if (GTK_OBJECT_CLASS (parent_class)->destroy)
        (* GTK_OBJECT_CLASS (parent_class)->destroy) (object);
 }
 
-void
-grr_board_view_set_board (grr_board_view_t      *view,
-                         rr_board_t *board)
-{
-    g_return_if_fail (view != NULL);
-    g_return_if_fail (GRR_IS_BOARD_VIEW (view));
-
-    view->board = board;
-
-    grr_board_view_update (view);
-}
-
 static void
 grr_board_view_realize (GtkWidget *widget)
 {
@@ -271,169 +254,55 @@ grr_board_view_size_allocate (GtkWidget     *widget,
 }
 
 static void
-grr_svg_draw (XrState *xrs, char *svg)
+grr_board_view_draw_walls (grr_board_view_t    *view,
+                          XrState              *xrs,
+                          rr_wall_t            wall)
 {
-    xsvg_status_t status;
-    xsvg_t *xsvg;
-
-    status = xsvg_create (&xsvg);
-    if (status) {
-       fprintf (stderr, "xsvg_create error\n");
-       return;
-    }
-    status = xsvg_parse_file (xsvg, svg);
-    if (status) {
-       fprintf (stderr, "xsvg_parse_file error parsing %s\n", svg);
-       return;
-    }
-    xsvg_render (xsvg, xrs);
-    if (status) {
-       fprintf (stderr, "xsvg_render error\n");
-       return;
-    }
-    xsvg_destroy (xsvg);
-}
-
-static void
-grr_wall_draw (XrState *xrs, rr_wall_t wall)
-{
-    char *wall_svg = GRR_WALL_SVG;
-
     if (wall == RR_WALL_NONE)
        return;
 
     if (wall & RR_WALL_ABOVE) {
-       grr_svg_draw (xrs, wall_svg);
+       grr_icon_draw (view->wall_icon, xrs);
     }
     if (wall & RR_WALL_LEFT) {
        XrSave (xrs);
        XrRotate (xrs, M_PI_2);
-       grr_svg_draw (xrs, wall_svg);
+       grr_icon_draw (view->wall_icon, xrs);
        XrRestore (xrs);
     }
     if (wall & RR_WALL_RIGHT) {
        XrSave (xrs);
        XrTranslate (xrs, GRR_SVG_ASSUMED_WIDTH, 0);
        XrRotate (xrs, M_PI_2);
-       grr_svg_draw (xrs, wall_svg);
+       grr_icon_draw (view->wall_icon, xrs);
        XrRestore (xrs);
     }
     if (wall & RR_WALL_BELOW) {
        XrSave (xrs);
        XrTranslate (xrs, 0, GRR_SVG_ASSUMED_HEIGHT);
-       grr_svg_draw (xrs, wall_svg);
+       grr_icon_draw (view->wall_icon, xrs);
        XrRestore (xrs);
     }
 }
 
 static void
-grr_target_draw (XrState *xrs, rr_target_t target)
-{
-    char *target_svg;
-
-    if (target == RR_TARGET_NONE)
-       return;
-
-    switch (target) {
-    case RR_TARGET_BLUE_CIRCLE:
-       target_svg = GRR_TARGET_BLUE_CIRCLE_SVG;
-       break;
-    case RR_TARGET_BLUE_OCTAGON:
-       target_svg = GRR_TARGET_BLUE_OCTAGON_SVG;
-       break;
-    case RR_TARGET_BLUE_SQUARE:
-       target_svg = GRR_TARGET_BLUE_SQUARE_SVG;
-       break;
-    case RR_TARGET_BLUE_TRIANGLE:
-       target_svg = GRR_TARGET_BLUE_TRIANGLE_SVG;
-       break;
-    case RR_TARGET_GREEN_CIRCLE:
-       target_svg = GRR_TARGET_GREEN_CIRCLE_SVG;
-       break;
-    case RR_TARGET_GREEN_OCTAGON:
-       target_svg = GRR_TARGET_GREEN_OCTAGON_SVG;
-       break;
-    case RR_TARGET_GREEN_SQUARE:
-       target_svg = GRR_TARGET_GREEN_SQUARE_SVG;
-       break;
-    case RR_TARGET_GREEN_TRIANGLE:
-       target_svg = GRR_TARGET_GREEN_TRIANGLE_SVG;
-       break;
-    case RR_TARGET_RED_CIRCLE:
-       target_svg = GRR_TARGET_RED_CIRCLE_SVG;
-       break;
-    case RR_TARGET_RED_OCTAGON:
-       target_svg = GRR_TARGET_RED_OCTAGON_SVG;
-       break;
-    case RR_TARGET_RED_SQUARE:
-       target_svg = GRR_TARGET_RED_SQUARE_SVG;
-       break;
-    case RR_TARGET_RED_TRIANGLE:
-       target_svg = GRR_TARGET_RED_TRIANGLE_SVG;
-       break;
-    case RR_TARGET_YELLOW_CIRCLE:
-       target_svg = GRR_TARGET_YELLOW_CIRCLE_SVG;
-       break;
-    case RR_TARGET_YELLOW_OCTAGON:
-       target_svg = GRR_TARGET_YELLOW_OCTAGON_SVG;
-       break;
-    case RR_TARGET_YELLOW_SQUARE:
-       target_svg = GRR_TARGET_YELLOW_SQUARE_SVG;
-       break;
-    case RR_TARGET_YELLOW_TRIANGLE:
-       target_svg = GRR_TARGET_YELLOW_TRIANGLE_SVG;
-       break;
-    case RR_TARGET_WHIRL:
-       target_svg = GRR_TARGET_WHIRL_SVG;
-       break;
-    default:
-       return;
-    }
-
-    grr_svg_draw (xrs, target_svg);
-}
-
-static void
-grr_robot_draw (XrState *xrs, rr_robot_t robot)
-{
-    char *robot_svg;
-
-    if (robot == RR_ROBOT_NONE)
-       return;
-
-    switch (robot) {
-    case RR_ROBOT_BLUE:
-       robot_svg = GRR_ROBOT_BLUE_SVG;
-       break;
-    case RR_ROBOT_GREEN:
-       robot_svg = GRR_ROBOT_GREEN_SVG;
-       break;
-    case RR_ROBOT_RED:
-       robot_svg = GRR_ROBOT_RED_SVG;
-       break;
-    case RR_ROBOT_YELLOW:
-       robot_svg = GRR_ROBOT_YELLOW_SVG;
-       break;
-    default:
-       return;
-    }
-
-    grr_svg_draw (xrs, robot_svg);
-}
-
-static void
-grr_cell_draw (XrState *xrs, rr_cell_t cell, rr_target_t goal,
-              int width, int height)
+grr_board_view_draw_cell (grr_board_view_t     *view,
+                         XrState               *xrs,
+                         rr_cell_t             cell,
+                         rr_target_t           goal,
+                         int                   width,
+                         int                   height)
 {
     int xpad, ypad;
+    rr_robot_t robot;
     rr_target_t target;
 
     XrSave (xrs);
     XrScale (xrs,
             width / GRR_SVG_ASSUMED_WIDTH,
             height / GRR_SVG_ASSUMED_HEIGHT);
-    grr_svg_draw (xrs, GRR_CELL_SVG);
-    grr_wall_draw (xrs, RR_CELL_GET_WALLS (cell));
+    grr_icon_draw (view->cell_icon, xrs);
+    grr_board_view_draw_walls (view, xrs, RR_CELL_GET_WALLS (cell));
     XrRestore (xrs);
 
     xpad = width / 5;
@@ -446,12 +315,14 @@ grr_cell_draw (XrState *xrs, rr_cell_t cell, rr_target_t goal,
             (height - 2*ypad) / GRR_SVG_ASSUMED_HEIGHT);
 
     target = RR_CELL_GET_TARGET (cell);
-    grr_target_draw (xrs, target);
+    if (target)
+       grr_icon_draw (view->target_icon[rr_target_idx (target)], xrs);
+
     XrRestore (xrs);
 
-    /* This is a hack, (it obscures the cell background in addition to
-       the target). The real way to do this is to draw the target
-       itself with less opacity. */
+    /* XXX: This is a kludge, (it obscures the cell background in
+       addition to the target). The real way to do this is to draw the
+       target itself with less opacity. */
     if (target && target != goal) {
        XrSave (xrs);
        XrScale (xrs,
@@ -472,7 +343,9 @@ grr_cell_draw (XrState *xrs, rr_cell_t cell, rr_target_t goal,
             (width - 2*xpad)  / GRR_SVG_ASSUMED_WIDTH,
             (height - 2*ypad) / GRR_SVG_ASSUMED_HEIGHT);
 
-    grr_robot_draw (xrs, RR_CELL_GET_ROBOT (cell));
+    robot = RR_CELL_GET_ROBOT (cell);
+    if (robot)
+       grr_icon_draw (view->robot_icon[rr_robot_idx (robot)], xrs);
 
     XrRestore (xrs);
 
@@ -483,6 +356,7 @@ grr_board_view_expose (GtkWidget      *widget,
                       GdkEventExpose *event)
 {
     grr_board_view_t *view;
+    rr_board_t *board;
     Display *dpy;
     Drawable drawable;
     XrState *xrs;
@@ -490,6 +364,7 @@ grr_board_view_expose (GtkWidget      *widget,
     gint x_off, y_off;
     int i, j;
     rr_target_t goal_target;
+    int new_cell_width, new_cell_height;
 
     g_return_val_if_fail (widget != NULL, FALSE);
     g_return_val_if_fail (GRR_IS_BOARD_VIEW (widget), FALSE);
@@ -499,6 +374,7 @@ grr_board_view_expose (GtkWidget      *widget,
        return FALSE;
 
     view = GRR_BOARD_VIEW (widget);
+    board = view->board;
 
     /* Unabstract X from GTK+ */
     gdk_window_get_internal_paint_info (widget->window, &real_drawable, &x_off, &y_off);
@@ -508,59 +384,105 @@ grr_board_view_expose (GtkWidget      *widget,
     /* Ignore GTK+ and use Xr for drawing. */
     xrs = XrCreate ();
     XrSetTargetDrawable (xrs, dpy, drawable);
-    XrTranslate (xrs, -x_off, -y_off);
 
-    rr_board_get_size (view->board, &view->board_width, &view->board_height);
+    rr_board_get_size (board, &view->board_width, &view->board_height);
+
+    new_cell_width = widget->allocation.width / view->board_width;
+    if (new_cell_width == 0)
+       new_cell_width = 1;
+    new_cell_height = widget->allocation.height / view->board_height;
+    if (new_cell_height == 0)
+       new_cell_height = 1;
+
+    view->cell_width = new_cell_width;
+    view->cell_height = new_cell_height;
 
-    view->cell_width = widget->allocation.width / view->board_width;
-    if (view->cell_width == 0)
-       view->cell_width = 1;
-    view->cell_height = widget->allocation.height / view->board_height;
-    if (view->cell_height == 0)
-       view->cell_height = 1;
+    /* Pre-render icons if the size has changed */
+    /* XXX: This code isn't fully baked yet
+    if (new_cell_width != view->cell_width
+       || new_cell_height != view->cell_height) {
+       int i;
+       rr_robot_t robot;
+       rr_target_t target;
+
+       view->cell_width = new_cell_width;
+       view->cell_height = new_cell_height;
+
+       XrSave (xrs);
+       XrScale (xrs,
+                view->cell_width / GRR_SVG_ASSUMED_WIDTH,
+                view->cell_height / GRR_SVG_ASSUMED_HEIGHT);
+
+       grr_icon_predraw (view->cell_icon, xrs,
+                         view->cell_width, view->cell_height);
+
+       grr_icon_predraw (view->wall_icon, xrs,
+                         view->cell_width, view->cell_height);
+
+       for (i=0; i < RR_NUM_ROBOTS; i++) {
+           robot = rr_robot_from_idx (i);
+           grr_icon_predraw (view->robot_icon[i], xrs,
+                             view->cell_width, view->cell_height);
+       }
+
+       for (i=0; i < RR_NUM_TARGETS; i++) {
+           target = rr_target_from_idx (i);
+           grr_icon_predraw (view->target_icon[i], xrs,
+                             view->cell_width, view->cell_height);
+       }
+
+       XrRestore (xrs);
+    }
+    */
+
+    XrTranslate (xrs, -x_off, -y_off);
 
     view->board_pad_x = (widget->allocation.width - view->board_width * view->cell_width) / 2;
     view->board_pad_y = (widget->allocation.height - view->board_height * view->cell_height) / 2;
 
     XrTranslate (xrs, view->board_pad_x, view->board_pad_y);
 
-    goal_target = rr_board_get_goal_target (view->board);
+    goal_target = rr_board_get_goal_target (board);
 
     /* Draw cell targets */
     for (j=0; j < view->board_height; j++) {
        for (i=0; i < view->board_width; i++) {
            XrSave (xrs);
            XrTranslate (xrs, i * view->cell_width, j * view->cell_height);
-           grr_cell_draw (xrs,
-                          rr_board_get_cell (view->board, i, j),
-                          goal_target,
-                          view->cell_width, view->cell_height);
+           grr_board_view_draw_cell (view, xrs,
+                                     rr_board_get_cell (board, i, j),
+                                     goal_target,
+                                     view->cell_width, view->cell_height);
            XrRestore (xrs);
        }
     }
 
     /* Draw grid. */
     XrSave (xrs);
-    XrSetRGBColor (xrs, .75, .75, 1);
-    XrSetLineWidth (xrs, 1);
-    for (j=0; j < view->board_height; j++) {
-       XrMoveTo (xrs, 0, j * view->cell_height + 0.5);
-       XrRelLineTo (xrs, view->board_width * view->cell_width, 0);
-    }
-    for (i=0; i < view->board_width; i++) {
-       XrMoveTo (xrs, i * view->cell_width + 0.5, 0);
-       XrRelLineTo (xrs, 0, view->board_height * view->cell_height);
+    {
+       XrSetRGBColor (xrs, .75, .75, 1);
+       XrSetLineWidth (xrs, 1);
+       for (j=0; j < view->board_height; j++) {
+           XrMoveTo (xrs, 0, j * view->cell_height + 0.5);
+           XrRelLineTo (xrs, view->board_width * view->cell_width, 0);
+       }
+       for (i=0; i < view->board_width; i++) {
+           XrMoveTo (xrs, i * view->cell_width + 0.5, 0);
+           XrRelLineTo (xrs, 0, view->board_height * view->cell_height);
+       }
+       XrStroke (xrs);
     }
-    XrStroke (xrs);
     XrRestore (xrs);
 
     /* Draw goal target in center of board */
     XrSave (xrs);
-    XrTranslate (xrs,
-                (view->board_width / 2 - 1) * view->cell_width,
-                (view->board_height / 2 - 1) * view->cell_height);
-    grr_cell_draw (xrs, goal_target, goal_target,
-                  view->cell_width * 2, view->cell_height * 2);
+    {
+       XrTranslate (xrs,
+                    (view->board_width / 2 - 1) * view->cell_width,
+                    (view->board_height / 2 - 1) * view->cell_height);
+       grr_board_view_draw_cell (view, xrs, goal_target, goal_target,
+                                 view->cell_width * 2, view->cell_height * 2);
+    }
     XrRestore (xrs);
 
     /* Draw walls */
@@ -571,7 +493,7 @@ grr_board_view_expose (GtkWidget      *widget,
            XrScale (xrs,
                     view->cell_width / GRR_SVG_ASSUMED_WIDTH,
                     view->cell_height / GRR_SVG_ASSUMED_HEIGHT);
-           grr_wall_draw (xrs, RR_CELL_GET_WALLS (rr_board_get_cell(view->board, i, j)));
+           grr_board_view_draw_walls (view, xrs, RR_CELL_GET_WALLS (rr_board_get_cell(board, i, j)));
            XrRestore (xrs);
        }
     }
@@ -581,72 +503,115 @@ grr_board_view_expose (GtkWidget      *widget,
     return FALSE;
 }
 
-/*
 static void
 grr_board_view_pointer_coords_to_grid (grr_board_view_t *view,
                                       int pointer_x, int pointer_y,
-                                      int *grid_x, af
-*/
+                                      int *grid_x, int *grid_y)
+{
+    *grid_x = (pointer_x - view->board_pad_x) / view->cell_width;
+    *grid_y = (pointer_y - view->board_pad_y) / view->cell_height;
+}
+
+
 static gint
 grr_board_view_button_press (GtkWidget      *widget,
                       GdkEventButton *event)
 {
-  grr_board_view_t *view;
-
-  g_return_val_if_fail (widget != NULL, FALSE);
-  g_return_val_if_fail (GRR_IS_BOARD_VIEW (widget), FALSE);
-  g_return_val_if_fail (event != NULL, FALSE);
+    grr_board_view_t *view;
+    rr_cell_t cell;
+    int x, y;
 
-  view = GRR_BOARD_VIEW (widget);
+    g_return_val_if_fail (widget != NULL, FALSE);
+    g_return_val_if_fail (GRR_IS_BOARD_VIEW (widget), FALSE);
+    g_return_val_if_fail (event != NULL, FALSE);
+    
+    view = GRR_BOARD_VIEW (widget);
 
-/*
-  grr_board_view_pointer_coords_to_grid (view, event->x, event->y, &i, &j);
-*/
+    grr_board_view_pointer_coords_to_grid (view,
+                                          event->x, event->y,
+                                          &x, &y);
   
-/*
-  if (!view->button &&
-      rr_board_has_robot (view->board, i, j))
-    {
-      gtk_grab_add (widget);
+    cell = rr_board_get_cell (view->board, x, y);
+    if (!view->button && RR_CELL_GET_ROBOT (cell)) {
 
-      view->button = event->button;
+       gtk_grab_add (widget);
 
-      grr_board_view_update_mouse (view, event->x, event->y);
+       view->button = event->button;
+       view->drag_robot = RR_CELL_GET_ROBOT (cell);
+
+       grr_board_view_update_mouse (view, event->x, event->y);
     }
-  */
 
-  return FALSE;
+    return FALSE;
 }
 
 static gint
 grr_board_view_button_release (GtkWidget      *widget,
-                         GdkEventButton *event)
+                              GdkEventButton *event)
 {
-  grr_board_view_t *view;
+    grr_board_view_t *view;
+    const char *dir;
+    const char *robot;
+    int x, y;
+    int robot_x, robot_y;
+    int dx, dy;
 
-  g_return_val_if_fail (widget != NULL, FALSE);
-  g_return_val_if_fail (GRR_IS_BOARD_VIEW (widget), FALSE);
-  g_return_val_if_fail (event != NULL, FALSE);
+    g_return_val_if_fail (widget != NULL, FALSE);
+    g_return_val_if_fail (GRR_IS_BOARD_VIEW (widget), FALSE);
+    g_return_val_if_fail (event != NULL, FALSE);
 
-  view = GRR_BOARD_VIEW (widget);
+    view = GRR_BOARD_VIEW (widget);
 
-  if (view->button == event->button) {
-/*
+    if (view->button == event->button) {
       gtk_grab_remove (widget);
-*/
-
       view->button = 0;
+    }
 
-/*
-      grr_board_view_pointer_coords_to_grid (view, event->x, event->y, &i, &j);
-*/
+    grr_board_view_pointer_coords_to_grid (view, event->x, event->y, &x, &y);
 
-      /* XXX: Need to compute direction based on (i, j) and old (i, j) */
-/*
-      rr_client_move (view->client, view->robot, direction);
-*/
+    rr_board_find_robot (view->board, view->drag_robot, &robot_x, &robot_y);
+    dx = x - robot_x;
+    dy = y - robot_y;
+    if (dx == 0 && dy == 0)
+       return FALSE;
 
-  }
+    if (abs(dx) > abs(dy))
+       if (x > robot_x)
+           dir = "east";
+       else
+           dir = "west";
+    else
+       if (y > robot_y)
+           dir = "south";
+       else
+           dir = "north";
+    
+    switch (view->drag_robot) {
+    case RR_ROBOT_BLUE:
+       robot = "blue";
+       break;
+    case RR_ROBOT_GREEN:
+       robot = "green";
+       break;
+    case RR_ROBOT_RED:
+       robot = "RED";
+       break;
+    case RR_ROBOT_YELLOW:
+       robot = "YELLOW";
+       break;
+    default:
+       return FALSE;
+    }
+    
+    if (view->client) {
+       char *move_str;
+       
+       grr_sprintf_alloc (&move_str, "%s %s", robot, dir);
+       if (move_str == NULL)
+           return FALSE;
+       rr_client_move (view->client, move_str);
+       free (move_str);
+    }
 
   return FALSE;
 }
@@ -697,13 +662,10 @@ grr_board_view_motion_notify (GtkWidget      *widget,
 static void
 grr_board_view_update_mouse (grr_board_view_t *view, gint x, gint y)
 {
-    gint xc, yc;
-
     g_return_if_fail (view != NULL);
     g_return_if_fail (GRR_IS_BOARD_VIEW (view));
 
-    xc = GTK_WIDGET(view)->allocation.width / 2;
-    yc = GTK_WIDGET(view)->allocation.height / 2;
+    /* XXX: Should draw a robot here */
 }
 
 static void
@@ -714,3 +676,4 @@ grr_board_view_update (grr_board_view_t *view)
 
     gtk_widget_queue_draw (GTK_WIDGET (view));
 }
+