#include <stdio.h>
#include <stdlib.h>
#include <string.h>
-#include <stdarg.h>
-#include <Xr.h>
+#include <cairo.h>
#include <xsvg.h>
#include <gtk/gtkmain.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 int
-grr_sprintf_alloc (char **str, const char *fmt, ...);
-
-static int
-grr_sprintf_alloc_va (char **str, const char *fmt, va_list ap);
-
-
static void grr_board_view_class_init (grr_board_view_class_t *klass);
static void grr_board_view_init (grr_board_view_t *view);
static void grr_board_view_destroy (GtkObject *object);
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);
/* Local data */
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->cell1_icon = grr_icon_create ("cell1");
+ view->cell2_icon = grr_icon_create ("cell2");
+ 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*
+grr_board_view_t *
grr_board_view_new (rr_board_t *board)
{
grr_board_view_t *view;
+ int x, y;
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;
+ rr_board_get_size (board, &view->board_width, &view->board_height);
+
+ view->damaged = malloc (view->board_height * sizeof (int *));
+ for (y = 0; y < view->board_height; y++) {
+ view->damaged[y] = malloc (view->board_width * sizeof (int));
+ for (x = 0; x< view->board_width; x++) {
+ view->damaged[y][x] = 1;
+ }
}
- grr_board_view_set_board (view, board);
+ gtk_widget_queue_draw (GTK_WIDGET (view));
- return GTK_WIDGET (view);
+ return view;
}
-static void
-grr_board_view_destroy (GtkObject *object)
+void
+grr_board_view_set_client (grr_board_view_t *view, rr_client_t *client)
{
- grr_board_view_t *view;
-
- g_return_if_fail (object != NULL);
- g_return_if_fail (GRR_IS_BOARD_VIEW (object));
-
- view = GRR_BOARD_VIEW (object);
-
- rr_board_destroy (view->board);
+ g_return_if_fail (view != NULL);
- if (view->board && view->owns_board) {
- rr_board_destroy (view->board);
- view->board = NULL;
- }
-
- if (GTK_OBJECT_CLASS (parent_class)->destroy)
- (* GTK_OBJECT_CLASS (parent_class)->destroy) (object);
+ view->client = client;
}
void
-grr_board_view_set_board (grr_board_view_t *view,
- rr_board_t *board)
+grr_board_view_set_active_robot (grr_board_view_t *view, rr_robot_t robot)
{
g_return_if_fail (view != NULL);
- view->board = board;
+ view->active_robot = robot;
+}
- grr_board_view_update (view);
+void
+grr_board_view_move_active (grr_board_view_t *view, rr_direction_t dir)
+{
+ if (view->client) {
+ rr_client_move (view->client, view->active_robot, dir);
+ } else {
+ rr_board_move (view->board, view->active_robot, dir);
+ gtk_widget_queue_draw (GTK_WIDGET (view));
+ }
}
void
-grr_board_view_set_client (grr_board_view_t *view,
- rr_client_t *client)
+grr_board_view_undo (grr_board_view_t *view)
{
- g_return_if_fail (view != NULL);
+ if (view->client) {
+ rr_client_undo (view->client);
+ } else {
+ rr_board_undo (view->board);
+ gtk_widget_queue_draw (GTK_WIDGET (view));
+ }
+}
- view->client = client;
+static void
+grr_board_view_destroy (GtkObject *object)
+{
+ grr_board_view_t *view;
+
+ g_return_if_fail (object != NULL);
+ g_return_if_fail (GRR_IS_BOARD_VIEW (object));
+
+ view = GRR_BOARD_VIEW (object);
+
+ view->board = NULL;
+ view->client = NULL;
+
+ if (GTK_OBJECT_CLASS (parent_class)->destroy)
+ (* GTK_OBJECT_CLASS (parent_class)->destroy) (object);
}
static void
}
static void
-grr_svg_draw (XrState *xrs, char *svg)
+grr_board_view_draw_walls (grr_board_view_t *view,
+ cairo_t *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);
- XrRestore (xrs);
+ cairo_save (xrs);
+ cairo_rotate (xrs, M_PI_2);
+ grr_icon_draw (view->wall_icon, xrs);
+ cairo_restore (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);
- XrRestore (xrs);
+ cairo_save (xrs);
+ cairo_translate (xrs, GRR_SVG_ASSUMED_WIDTH, 0);
+ cairo_rotate (xrs, M_PI_2);
+ grr_icon_draw (view->wall_icon, xrs);
+ cairo_restore (xrs);
}
if (wall & RR_WALL_BELOW) {
- XrSave (xrs);
- XrTranslate (xrs, 0, GRR_SVG_ASSUMED_HEIGHT);
- grr_svg_draw (xrs, wall_svg);
- 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;
+ cairo_save (xrs);
+ cairo_translate (xrs, 0, GRR_SVG_ASSUMED_HEIGHT);
+ grr_icon_draw (view->wall_icon, xrs);
+ cairo_restore (xrs);
}
-
- 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)
-{
- int xpad, ypad;
- 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));
- XrRestore (xrs);
-
- xpad = width / 5;
- ypad = width / 5;
-
- XrSave (xrs);
- XrTranslate (xrs, xpad, ypad);
- XrScale (xrs,
- (width - 2*xpad) / GRR_SVG_ASSUMED_WIDTH,
- (height - 2*ypad) / GRR_SVG_ASSUMED_HEIGHT);
-
- target = RR_CELL_GET_TARGET (cell);
- grr_target_draw (xrs, target);
- 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. */
- if (target && target != goal) {
- XrSave (xrs);
- XrScale (xrs,
- width / GRR_SVG_ASSUMED_WIDTH,
- height / GRR_SVG_ASSUMED_HEIGHT);
- XrRectangle (xrs, 0, 0,
- GRR_SVG_ASSUMED_WIDTH,
- GRR_SVG_ASSUMED_HEIGHT);
- XrSetRGBColor (xrs, 1, 1, 1);
- XrSetAlpha (xrs, 0.75);
- XrFill (xrs);
- XrRestore (xrs);
- }
-
- XrSave (xrs);
- XrTranslate (xrs, xpad, ypad);
- XrScale (xrs,
- (width - 2*xpad) / GRR_SVG_ASSUMED_WIDTH,
- (height - 2*ypad) / GRR_SVG_ASSUMED_HEIGHT);
-
- grr_robot_draw (xrs, RR_CELL_GET_ROBOT (cell));
-
- XrRestore (xrs);
-
}
static gint
GdkEventExpose *event)
{
grr_board_view_t *view;
+ rr_board_t *board;
Display *dpy;
Drawable drawable;
- XrState *xrs;
+ cairo_t *xrs;
GdkDrawable *real_drawable;
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);
g_return_val_if_fail (event != NULL, FALSE);
- if (event->count > 0)
- 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);
dpy = gdk_x11_drawable_get_xdisplay (real_drawable);
drawable = gdk_x11_drawable_get_xid (real_drawable);
- /* Ignore GTK+ and use Xr for drawing. */
- xrs = XrCreate ();
- XrSetTargetDrawable (xrs, dpy, drawable);
- XrTranslate (xrs, -x_off, -y_off);
+ /* Ignore GTK+ and use Cairo for drawing. */
+ xrs = cairo_create ();
+ cairo_set_target_drawable (xrs, dpy, drawable);
+
+ 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;
+
+ 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;
+
+ cairo_save (xrs);
+ cairo_scale (xrs,
+ view->cell_width / GRR_SVG_ASSUMED_WIDTH,
+ view->cell_height / GRR_SVG_ASSUMED_HEIGHT);
+
+ grr_icon_predraw (view->cell1_icon, xrs,
+ view->cell_width, view->cell_height);
+ grr_icon_predraw (view->cell2_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);
+ }
- rr_board_get_size (view->board, &view->board_width, &view->board_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);
+ }
- 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;
+ cairo_restore (xrs);
+ }
+
+ view->cell_width = new_cell_width;
+ view->cell_height = new_cell_height;
+
+ if (event->area.width) {
+ int x_start, y_start;
+ int x, y;
+ int x_stop, y_stop;
+ grr_board_view_transform_pixel_to_cell (view,
+ event->area.x, event->area.y,
+ &x_start, &y_start);
+ grr_board_view_transform_pixel_to_cell (view,
+ event->area.x + event->area.width - 1,
+ event->area.y + event->area.height - 1,
+ &x_stop, &y_stop);
+ for (y = y_start; y <= y_stop; y++)
+ for (x = x_start; x <= x_stop; x++)
+ view->damaged[y][x] = 1;
+ }
+
+ if (event->count > 0)
+ return FALSE;
+
+ cairo_translate (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);
+ cairo_translate (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 */
+ /* Draw cell contents */
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);
- XrRestore (xrs);
+ if (! view->damaged[j][i])
+ continue;
+ rr_cell_t cell = rr_board_get_cell (board, i, j);
+ rr_target_t target = RR_CELL_GET_TARGET (cell);
+ rr_robot_t robot = RR_CELL_GET_ROBOT (cell);
+
+ cairo_save (xrs);
+ cairo_translate (xrs, i * view->cell_width, j * view->cell_height);
+
+ if ((i+j) % 2 == 0)
+ grr_icon_draw_predrawn (view->cell1_icon, xrs);
+ else
+ grr_icon_draw_predrawn (view->cell2_icon, xrs);
+
+ if (target) {
+ if (target && target != goal_target) {
+ cairo_save (xrs);
+ cairo_set_alpha (xrs, 0.25);
+ grr_icon_draw_predrawn (view->target_icon[rr_target_idx (target)], xrs);
+ cairo_restore (xrs);
+ } else {
+ grr_icon_draw_predrawn (view->target_icon[rr_target_idx (target)], xrs);
+ }
+ }
+
+ if (robot)
+ grr_icon_draw_predrawn (view->robot_icon[rr_robot_idx (robot)], xrs);
+
+ cairo_restore (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);
- }
- 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);
- XrRestore (xrs);
+ /* XXX: Not a perfect heuristic. Should check for the vacant box too. */
+ if (view->board_width == 16 && view->board_height == 16) {
+ cairo_save (xrs);
+ cairo_translate (xrs,
+ (view->board_width / 2 - 1) * view->cell_width,
+ (view->board_height / 2 - 1) * view->cell_height);
+ cairo_scale (xrs,
+ 2 * view->cell_width / GRR_SVG_ASSUMED_WIDTH,
+ 2 * view->cell_height / GRR_SVG_ASSUMED_HEIGHT);
+ cairo_rectangle (xrs, 0, 0, GRR_SVG_ASSUMED_WIDTH, GRR_SVG_ASSUMED_HEIGHT);
+ cairo_set_rgb_color (xrs, 1, 1, 1);
+ cairo_fill (xrs);
+ grr_icon_draw (view->target_icon[rr_target_idx (goal_target)], xrs);
+ cairo_restore (xrs);
+ }
/* Draw walls */
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);
- XrScale (xrs,
+ if (! view->damaged[j][i])
+ continue;
+ view->damaged[j][i] = 0;
+ cairo_save (xrs);
+ cairo_translate (xrs, i * view->cell_width, j * view->cell_height);
+ cairo_scale (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)));
- XrRestore (xrs);
+ grr_board_view_draw_walls (view, xrs, RR_CELL_GET_WALLS (rr_board_get_cell(board, i, j)));
+ cairo_restore (xrs);
}
}
- XrDestroy (xrs);
+ cairo_destroy (xrs);
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, int *grid_y)
+void
+grr_board_view_transform_pixel_to_cell (grr_board_view_t *view,
+ int pixel_x, int pixel_y,
+ int *cell_x, int *cell_y)
{
- *grid_x = (pointer_x - view->board_pad_x) / view->cell_width;
- *grid_y = (pointer_y - view->board_pad_y) / view->cell_height;
+ int x, y;
+ x = (pixel_x - view->board_pad_x) / view->cell_width;
+ y = (pixel_y - view->board_pad_y) / view->cell_height;
+ if (x < 0)
+ x = 0;
+ if (x >= view->board_width)
+ x = view->board_width - 1;
+ if (y < 0)
+ y = 0;
+ if (y >= view->board_height)
+ y = view->board_height - 1;
+ *cell_x = x;
+ *cell_y = y;
}
+void
+grr_board_view_transform_cell_to_pixel (grr_board_view_t *view,
+ int cell_x, int cell_y,
+ int *pixel_x, int *pixel_y)
+{
+ *pixel_x = view->cell_width * cell_x + view->board_pad_x;
+ *pixel_y = view->cell_height * cell_y + view->board_pad_y;
+}
static gint
grr_board_view_button_press (GtkWidget *widget,
- GdkEventButton *event)
+ GdkEventButton *event)
{
grr_board_view_t *view;
rr_cell_t cell;
view = GRR_BOARD_VIEW (widget);
- grr_board_view_pointer_coords_to_grid (view,
- event->x, event->y,
- &x, &y);
+ grr_board_view_transform_pixel_to_cell (view,
+ event->x, event->y,
+ &x, &y);
cell = rr_board_get_cell (view->board, x, y);
if (!view->button && RR_CELL_GET_ROBOT (cell)) {
gtk_grab_add (widget);
view->button = event->button;
- view->drag_x = x;
- view->drag_y = y;
- view->drag_robot = RR_CELL_GET_ROBOT (cell);
+ grr_board_view_set_active_robot (view, RR_CELL_GET_ROBOT (cell));
grr_board_view_update_mouse (view, event->x, event->y);
}
static gint
grr_board_view_button_release (GtkWidget *widget,
- GdkEventButton *event)
+ GdkEventButton *event)
{
grr_board_view_t *view;
- const char *dir;
- const char *robot;
+ rr_direction_t dir;
int x, y;
+ int robot_x, robot_y;
int dx, dy;
g_return_val_if_fail (widget != NULL, FALSE);
if (view->button == event->button) {
gtk_grab_remove (widget);
-
view->button = 0;
-
- grr_board_view_pointer_coords_to_grid (view, event->x, event->y, &x, &y);
-
- dx = x - view->drag_x;
- dy = y - view->drag_y;
- if (dx == 0 && dy == 0)
- return FALSE;
-
- if (abs(dx) > abs(dy))
- if (x > view->drag_x)
- dir = "east";
- else
- dir = "west";
- else
- if (y > view->drag_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;
+ grr_board_view_transform_pixel_to_cell (view, event->x, event->y, &x, &y);
+
+ rr_board_find_robot (view->board, view->active_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 = RR_DIRECTION_EAST;
+ else
+ dir = RR_DIRECTION_WEST;
+ else
+ if (y > robot_y)
+ dir = RR_DIRECTION_SOUTH;
+ else
+ dir = RR_DIRECTION_NORTH;
+
+ grr_board_view_move_active (view, dir);
+
+ return FALSE;
}
static gint
g_return_if_fail (view != NULL);
g_return_if_fail (GRR_IS_BOARD_VIEW (view));
- /* XXX: Should draw a robot here */
+ /* XXX: Perhaps should draw a robot here */
}
-static void
-grr_board_view_update (grr_board_view_t *view)
-{
- g_return_if_fail (view != NULL);
- g_return_if_fail (GRR_IS_BOARD_VIEW (view));
-
- gtk_widget_queue_draw (GTK_WIDGET (view));
-}
-
-static int
-grr_sprintf_alloc (char **str, const char *fmt, ...)
+void
+grr_board_view_mark_damage (grr_board_view_t *view, int i, int j)
{
- int ret;
- va_list ap;
-
- va_start(ap, fmt);
- ret = grr_sprintf_alloc_va (str, fmt, ap);
- va_end(ap);
-
- return ret;
-}
+ int x, y;
-/* ripped more or less straight out of PRINTF(3) */
-static int
-grr_sprintf_alloc_va (char **str, const char *fmt, va_list ap)
-{
- char *new_str;
- /* Guess we need no more than 100 bytes. */
- int n, size = 100;
-
- if ((*str = malloc (size)) == NULL)
- return -1;
- while (1) {
- /* Try to print in the allocated space. */
- n = vsnprintf (*str, size, fmt, ap);
- /* If that worked, return the size. */
- if (n > -1 && n < size)
- return n;
- /* Else try again with more space. */
- if (n > -1) /* glibc 2.1 */
- size = n+1; /* precisely what is needed */
- else /* glibc 2.0 */
- size *= 2; /* twice the old size */
- new_str = realloc(*str, size);
- if (new_str == NULL) {
- free(*str);
- *str = NULL;
- return -1;
- }
- *str = new_str;
- }
+ grr_board_view_transform_cell_to_pixel (view, i, j, &x, &y);
+ gtk_widget_queue_draw_area (GTK_WIDGET (view), x, y, view->cell_width, view->cell_height);
}