#include <stdio.h>
#include <stdlib.h>
#include <string.h>
-#include <stdarg.h>
#include <Xr.h>
#include <xsvg.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);
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->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*
+grr_board_view_t *
grr_board_view_new (rr_board_t *board)
{
grr_board_view_t *view;
grr_board_view_update (view);
- return GTK_WIDGET (view);
+ return view;
}
void
view->client = client;
}
+void
+grr_board_view_set_active_robot (grr_board_view_t *view, rr_robot_t robot)
+{
+ g_return_if_fail (view != NULL);
+
+ view->active_robot = robot;
+}
+
+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_undo (grr_board_view_t *view)
+{
+ if (view->client) {
+ rr_client_undo (view->client);
+ } else {
+ rr_board_undo (view->board);
+ gtk_widget_queue_draw (GTK_WIDGET (view));
+ }
+}
+
static void
grr_board_view_destroy (GtkObject *object)
{
}
static void
-grr_svg_draw (XrState *xrs, char *svg)
-{
- 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)
+grr_board_view_draw_walls (grr_board_view_t *view,
+ 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;
- ypad = width / 5;
+ xpad = width / 10;
+ ypad = width / 10;
XrSave (xrs);
XrTranslate (xrs, xpad, ypad);
(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,
width / GRR_SVG_ASSUMED_WIDTH,
height / GRR_SVG_ASSUMED_HEIGHT);
- XrRectangle (xrs, 0, 0,
- GRR_SVG_ASSUMED_WIDTH,
- GRR_SVG_ASSUMED_HEIGHT);
+ XrRectangle (xrs, 1, 1,
+ GRR_SVG_ASSUMED_WIDTH - 1,
+ GRR_SVG_ASSUMED_HEIGHT - 1);
XrSetRGBColor (xrs, 1, 1, 1);
XrSetAlpha (xrs, 0.75);
XrFill (xrs);
(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);
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);
/* Ignore GTK+ and use Xr for drawing. */
xrs = XrCreate ();
XrSetTargetDrawable (xrs, dpy, drawable);
- XrTranslate (xrs, -x_off, -y_off);
rr_board_get_size (board, &view->board_width, &view->board_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;
+ 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;
+
+ /* 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;
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 (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);
- }
- XrStroke (xrs);
- }
- XrRestore (xrs);
-
/* Draw goal target in center of board */
- XrSave (xrs);
- {
+ /* XXX: Not a perfect heuristic. Should check for the vacant box too. */
+ if (view->board_width == 16 && view->board_height == 16) {
+ 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);
+ grr_board_view_draw_cell (view, xrs, goal_target, goal_target,
+ view->cell_width * 2, view->cell_height * 2);
+ XrRestore (xrs);
}
- XrRestore (xrs);
/* Draw walls */
for (j=0; j < view->board_height; j++) {
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(board, i, j)));
+ grr_board_view_draw_walls (view, xrs, RR_CELL_GET_WALLS (rr_board_get_cell(board, i, j)));
XrRestore (xrs);
}
}
*grid_y = (pointer_y - view->board_pad_y) / view->cell_height;
}
-
static gint
grr_board_view_button_press (GtkWidget *widget,
- GdkEventButton *event)
+ GdkEventButton *event)
{
grr_board_view_t *view;
rr_cell_t cell;
gtk_grab_add (widget);
view->button = event->button;
- 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);
}
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;
grr_board_view_pointer_coords_to_grid (view, event->x, event->y, &x, &y);
- rr_board_find_robot (view->board, view->drag_robot, &robot_x, &robot_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)
if (abs(dx) > abs(dy))
if (x > robot_x)
- dir = "east";
+ dir = RR_DIRECTION_EAST;
else
- dir = "west";
+ dir = RR_DIRECTION_WEST;
else
if (y > robot_y)
- dir = "south";
+ dir = RR_DIRECTION_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);
- }
+ dir = RR_DIRECTION_NORTH;
- return FALSE;
+ 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
gtk_widget_queue_draw (GTK_WIDGET (view));
}
-static int
-grr_sprintf_alloc (char **str, const char *fmt, ...)
-{
- int ret;
- va_list ap;
-
- va_start(ap, fmt);
- ret = grr_sprintf_alloc_va (str, fmt, ap);
- va_end(ap);
-
- return ret;
-}
-
-/* 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;
- }
-}
projects / grrobot / blobdiff