* Author: Carl Worth <carl@theworths.org>
*/
-#include <Xr.h>
-#include <xsvg.h>
-
#include <math.h>
#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <cairo.h>
+#include <svg-cairo.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);
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);
-static gint grr_board_view_timer (grr_board_view_t *view);
+ 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->policy = GTK_UPDATE_CONTINUOUS;
+
+ view->time = 60.0;
+ view->drift_correct = 0.0;
view->timer = 0;
- view->radius = 0;
- view->pointer_width = 0;
- view->angle = 0.0;
- view->old_value = 0.0;
- view->old_lower = 0.0;
- view->old_upper = 0.0;
+ view->zap_time = 0.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 (view != NULL);
- g_return_if_fail (object != NULL);
- g_return_if_fail (GRR_IS_BOARD_VIEW (object));
+ view->client = client;
+}
- view = GRR_BOARD_VIEW (object);
+void
+grr_board_view_set_active_robot (grr_board_view_t *view, rr_robot_t robot)
+{
+ g_return_if_fail (view != NULL);
- rr_board_destroy (view->board);
+ view->active_robot = robot;
+}
- if (view->board && view->owns_board) {
- rr_board_destroy (view->board);
- view->board = NULL;
+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));
}
-
- 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)
+grr_board_view_undo (grr_board_view_t *view)
{
- g_return_if_fail (view != NULL);
- g_return_if_fail (GRR_IS_BOARD_VIEW (view));
-
- view->board = board;
-
- grr_board_view_update (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_realize (GtkWidget *widget)
+grr_board_view_destroy (GtkObject *object)
{
- grr_board_view_t *view;
- GdkWindowAttr attributes;
- gint attributes_mask;
+ grr_board_view_t *view;
- g_return_if_fail (widget != NULL);
- g_return_if_fail (GRR_IS_BOARD_VIEW (widget));
+ g_return_if_fail (object != NULL);
+ g_return_if_fail (GRR_IS_BOARD_VIEW (object));
- GTK_WIDGET_SET_FLAGS (widget, GTK_REALIZED);
- view = GRR_BOARD_VIEW (widget);
+ view = GRR_BOARD_VIEW (object);
- attributes.x = widget->allocation.x;
- attributes.y = widget->allocation.y;
- attributes.width = widget->allocation.width;
- attributes.height = widget->allocation.height;
- attributes.wclass = GDK_INPUT_OUTPUT;
- attributes.window_type = GDK_WINDOW_CHILD;
- attributes.event_mask = gtk_widget_get_events (widget) |
- GDK_EXPOSURE_MASK | GDK_BUTTON_PRESS_MASK |
- GDK_BUTTON_RELEASE_MASK | GDK_POINTER_MOTION_MASK |
- GDK_POINTER_MOTION_HINT_MASK;
- attributes.visual = gtk_widget_get_visual (widget);
- attributes.colormap = gtk_widget_get_colormap (widget);
+ view->board = NULL;
+ view->client = NULL;
+
+ if (GTK_OBJECT_CLASS (parent_class)->destroy)
+ (* GTK_OBJECT_CLASS (parent_class)->destroy) (object);
+}
- attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP;
- widget->window = gdk_window_new (widget->parent->window, &attributes, attributes_mask);
+static void
+grr_board_view_realize (GtkWidget *widget)
+{
+ grr_board_view_t *view;
+ GdkWindowAttr attributes;
+ gint attributes_mask;
- widget->style = gtk_style_attach (widget->style, widget->window);
+ g_return_if_fail (widget != NULL);
+ g_return_if_fail (GRR_IS_BOARD_VIEW (widget));
+
+ GTK_WIDGET_SET_FLAGS (widget, GTK_REALIZED);
+ view = GRR_BOARD_VIEW (widget);
- gdk_window_set_user_data (widget->window, widget);
+ attributes.x = widget->allocation.x;
+ attributes.y = widget->allocation.y;
+ attributes.width = widget->allocation.width;
+ attributes.height = widget->allocation.height;
+ attributes.wclass = GDK_INPUT_OUTPUT;
+ attributes.window_type = GDK_WINDOW_CHILD;
+ attributes.event_mask = gtk_widget_get_events (widget) |
+ GDK_EXPOSURE_MASK | GDK_BUTTON_PRESS_MASK |
+ GDK_BUTTON_RELEASE_MASK | GDK_POINTER_MOTION_MASK |
+ GDK_POINTER_MOTION_HINT_MASK;
+ attributes.visual = gtk_widget_get_visual (widget);
+ attributes.colormap = gtk_widget_get_colormap (widget);
+
+ attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP;
+ widget->window = gdk_window_new (widget->parent->window, &attributes, attributes_mask);
+
+ widget->style = gtk_style_attach (widget->style, widget->window);
+
+ gdk_window_set_user_data (widget->window, widget);
- gtk_style_set_background (widget->style, widget->window, GTK_STATE_ACTIVE);
+ gtk_style_set_background (widget->style, widget->window, GTK_STATE_ACTIVE);
}
static void
grr_board_view_size_request (GtkWidget *widget,
GtkRequisition *requisition)
{
- requisition->width = GRR_BOARD_VIEW_DEFAULT_SIZE;
- requisition->height = GRR_BOARD_VIEW_DEFAULT_SIZE;
+ requisition->width = GRR_BOARD_VIEW_DEFAULT_SIZE;
+ requisition->height = GRR_BOARD_VIEW_DEFAULT_SIZE;
}
static void
grr_board_view_size_allocate (GtkWidget *widget,
GtkAllocation *allocation)
{
- grr_board_view_t *view;
-
- g_return_if_fail (widget != NULL);
- g_return_if_fail (GRR_IS_BOARD_VIEW (widget));
- g_return_if_fail (allocation != NULL);
-
- widget->allocation = *allocation;
- view = GRR_BOARD_VIEW (widget);
-
- if (GTK_WIDGET_REALIZED (widget))
- {
-
- gdk_window_move_resize (widget->window,
- allocation->x, allocation->y,
- allocation->width, allocation->height);
+ grr_board_view_t *view;
- }
- view->radius = MIN (allocation->width, allocation->height) * 0.45;
- view->pointer_width = view->radius / 5;
-}
+ g_return_if_fail (widget != NULL);
+ g_return_if_fail (GRR_IS_BOARD_VIEW (widget));
+ g_return_if_fail (allocation != NULL);
-static void
-grr_svg_draw (XrState *xrs, char *svg)
-{
- xsvg_status_t status;
- xsvg_t *xsvg;
+ widget->allocation = *allocation;
+ view = GRR_BOARD_VIEW (widget);
- status = xsvg_create (&xsvg);
- if (status) {
- fprintf (stderr, "xsvg_create error\n");
- return;
+ if (GTK_WIDGET_REALIZED (widget)) {
+ gdk_window_move_resize (widget->window,
+ allocation->x, allocation->y,
+ allocation->width, allocation->height);
}
- 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,
+ cairo_t *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);
+ cairo_save (xrs);
+ cairo_translate (xrs, 0, GRR_SVG_ASSUMED_HEIGHT);
+ grr_icon_draw (view->wall_icon, xrs);
+ cairo_restore (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)
-{
- 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
grr_board_view_expose (GtkWidget *widget,
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);
+ }
+ }
- /* 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);
+ if (robot)
+ grr_icon_draw_predrawn (view->robot_icon[rr_robot_idx (robot)], xrs);
+
+ cairo_restore (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);
- 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 clock */
+ if (view->time < 60.0) {
+ cairo_save (xrs);
+ cairo_new_path (xrs);
+ cairo_move_to (xrs,
+ (double) view->board_width / 2 * view->cell_width,
+ (double) view->board_height / 2 * view->cell_height);
+ cairo_arc (xrs,
+ (double) view->board_width / 2 * view->cell_width,
+ (double) view->board_height / 2 * view->cell_height,
+ .9 * view->cell_width,
+ - M_PI_2,
+ 2 * M_PI * (60.0 - view->time) / 60.0 - M_PI_2);
+ cairo_close_path (xrs);
+
+ cairo_set_rgb_color (xrs, 0.0, 0.0, 0.0);
+ cairo_set_alpha (xrs, 0.5);
+ cairo_fill (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, af
-*/
+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)
+{
+ 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;
-
- 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_transform_pixel_to_cell (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)) {
+
+ gtk_grab_add (widget);
- view->button = event->button;
+ view->button = event->button;
+ grr_board_view_set_active_robot (view, RR_CELL_GET_ROBOT (cell));
- grr_board_view_update_mouse (view, event->x, event->y);
+ 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;
+ rr_direction_t dir;
+ 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_transform_pixel_to_cell (view, event->x, event->y, &x, &y);
-/*
- grr_board_view_pointer_coords_to_grid (view, event->x, event->y, &i, &j);
-*/
+ 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;
- /* XXX: Need to compute direction based on (i, j) and old (i, j) */
-/*
- rr_client_move (view->client, view->robot, direction);
-*/
+ 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;
+ return FALSE;
}
static gint
grr_board_view_motion_notify (GtkWidget *widget,
GdkEventMotion *event)
{
- grr_board_view_t *view;
- GdkModifierType mods;
- gint x, y, mask;
-
- 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);
-
- if (view->button != 0)
- {
- x = event->x;
- y = event->y;
-
- if (event->is_hint || (event->window != widget->window))
- gdk_window_get_pointer (widget->window, &x, &y, &mods);
-
- switch (view->button)
- {
+ grr_board_view_t *view;
+ GdkModifierType mods;
+ gint x, y, mask;
+
+ 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);
+
+ if (view->button != 0) {
+ x = event->x;
+ y = event->y;
+
+ if (event->is_hint || (event->window != widget->window))
+ gdk_window_get_pointer (widget->window, &x, &y, &mods);
+
+ switch (view->button) {
case 1:
- mask = GDK_BUTTON1_MASK;
- break;
+ mask = GDK_BUTTON1_MASK;
+ break;
case 2:
- mask = GDK_BUTTON2_MASK;
- break;
+ mask = GDK_BUTTON2_MASK;
+ break;
case 3:
- mask = GDK_BUTTON3_MASK;
- break;
+ mask = GDK_BUTTON3_MASK;
+ break;
default:
- mask = 0;
- break;
+ mask = 0;
+ break;
}
- if (mods & mask)
- grr_board_view_update_mouse (view, x,y);
+ if (mods & mask)
+ grr_board_view_update_mouse (view, x,y);
}
- return FALSE;
+ return FALSE;
}
-static gint
-grr_board_view_timer (grr_board_view_t *view)
+static void
+grr_board_view_update_mouse (grr_board_view_t *view, gint x, gint y)
{
- g_return_val_if_fail (view != NULL, FALSE);
- g_return_val_if_fail (GRR_IS_BOARD_VIEW (view), FALSE);
+ g_return_if_fail (view != NULL);
+ g_return_if_fail (GRR_IS_BOARD_VIEW (view));
- return FALSE;
+ /* XXX: Perhaps should draw a robot here */
}
+void
+grr_board_view_mark_damage (grr_board_view_t *view, int i, int j)
+{
+ int x, y;
+
+ 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);
+}
+
+#define TIMER_INTERVAL_MS 100.0
+
static void
-grr_board_view_update_mouse (grr_board_view_t *view, gint x, gint y)
+grr_board_view_refresh_timer (grr_board_view_t *view)
{
- gint xc, yc;
- gfloat old_value;
+ int x, y;
+
+ grr_board_view_transform_cell_to_pixel (view,
+ view->board_width / 2 - 1,
+ view->board_height / 2 -1,
+ &x, &y);
+ gtk_widget_queue_draw_area (GTK_WIDGET (view),
+ x, y,
+ 2 * view->cell_width,
+ 2 * view->cell_height);
+}
- g_return_if_fail (view != NULL);
- g_return_if_fail (GRR_IS_BOARD_VIEW (view));
+static gboolean
+grr_board_view_decrement_timer (void *widget)
+{
+ grr_board_view_t *view = widget;
- xc = GTK_WIDGET(view)->allocation.width / 2;
- yc = GTK_WIDGET(view)->allocation.height / 2;
+ view->time -= TIMER_INTERVAL_MS / 1000.0;
+ view->time += view->drift_correct;
- old_value = view->adjustment->value;
- view->angle = atan2(yc-y, x-xc);
+ if (view->zap_time) {
+ view->time -= view->zap_time;
+ view->zap_time += 1.0;
+ }
- if (view->angle < -G_PI/2.)
- view->angle += 2*G_PI;
-
- if (view->angle < -G_PI/6)
- view->angle = -G_PI/6;
+ grr_board_view_refresh_timer (view);
- if (view->angle > 7.*G_PI/6.)
- view->angle = 7.*G_PI/6.;
-
- view->adjustment->value = view->adjustment->lower + (7.*G_PI/6 - view->angle) *
- (view->adjustment->upper - view->adjustment->lower) / (4.*G_PI/3.);
-
- if (view->adjustment->value != old_value)
- {
- if (view->policy == GTK_UPDATE_CONTINUOUS)
- {
- g_signal_emit_by_name (GTK_OBJECT (view->adjustment), "value_changed");
- }
- else
- {
- gtk_widget_queue_draw (GTK_WIDGET (view));
-
- if (view->policy == GTK_UPDATE_DELAYED)
- {
- if (view->timer)
- gtk_timeout_remove (view->timer);
-
- view->timer = gtk_timeout_add (SCROLL_DELAY_LENGTH,
- (GtkFunction) grr_board_view_timer,
- (gpointer) view);
- }
- }
- }
+ if (view->time < 0) {
+ grr_board_view_stop_timer (view);
+ return FALSE;
+ }
+
+ return TRUE;
}
-static void
-grr_board_view_update (grr_board_view_t *view)
+void
+grr_board_view_set_timer (grr_board_view_t *view, double time)
+{
+ /* XXX: It would be good to adjust the clock for latency somewhere... */
+ if (view->timer) {
+ double correction_time;
+ /* Correct any drift within the next 10 seconds, or half the
+ remaining time --- whichever is less. */
+ if (time >= 20.0)
+ correction_time = 10.0;
+ else
+ correction_time = time / 2.0;
+ view->drift_correct = (time - view->time) / (correction_time * TIMER_INTERVAL_MS);
+ } else {
+ view->time = time;
+ view->drift_correct = 0.0;
+ view->zap_time = 0.0;
+ }
+}
+
+void
+grr_board_view_start_timer (grr_board_view_t *view)
+{
+ if (view->timer)
+ return;
+
+ view->timer = gtk_timeout_add (TIMER_INTERVAL_MS, grr_board_view_decrement_timer, view);
+}
+
+void
+grr_board_view_stop_timer (grr_board_view_t *view)
+{
+ if (view->timer == 0)
+ return;
+
+ gtk_timeout_remove (view->timer);
+ view->timer = 0;
+ view->time = 0.0;
+ view->drift_correct = 0.0;
+ view->zap_time = 0.0;
+
+ grr_board_view_refresh_timer (view);
+}
+
+void
+grr_board_view_zap_timer (grr_board_view_t *view)
{
- g_return_if_fail (view != NULL);
- g_return_if_fail (GRR_IS_BOARD_VIEW (view));
+ view->zap_time = 4;
- gtk_widget_queue_draw (GTK_WIDGET (view));
+ grr_board_view_refresh_timer (view);
}
+
projects / grrobot / blobdiff