Description: Port to GTK+ 3
Bug-Debian: https://bugs.debian.org/885735
Author: Yavor Doganov, Bastian Germann
Forwarded: no
Last-Update: 2026-01-31
---
diff --git a/configure.in b/configure.in
index 25e785b..9c912f5 100644
--- a/configure.in
+++ b/configure.in
@@ -1,7 +1,7 @@
 dnl Process this file with autoconf to produce a configure script.
 
 AC_INIT(configure.in)
-AM_INIT_AUTOMAKE(gamazons, 0.1)
+AM_INIT_AUTOMAKE(gamazons, 0.83)
 AM_MAINTAINER_MODE
 AM_CONFIG_HEADER(config.h)
 
@@ -12,7 +12,7 @@ AC_HEADER_STDC
 
 GNOME_COMPILE_WARNINGS
 
-pkg_modules="libgnomeui-2.0"
+pkg_modules="gtk+-3.0"
 PKG_CHECK_MODULES(PACKAGE, [$pkg_modules])
 AC_SUBST(PACKAGE_CFLAGS)
 AC_SUBST(PACKAGE_LIBS)
diff --git a/src/board.c b/src/board.c
index ac3c00d..aa0c71d 100644
--- a/src/board.c
+++ b/src/board.c
@@ -2,7 +2,8 @@
 #include <stdio.h>
 #include <time.h>
 #include <assert.h>
-#include <gnome.h>
+#include <gtk/gtk.h>
+#include <glib/gi18n.h>
 
 #include "amazons.h"
 #include "board.h"
@@ -12,10 +13,8 @@
 
 /* local Prototypes */
 
-
-static void draw_a_line(GnomeCanvasGroup *group, 
-	int x1, int y1, int x2, int y2, char *color);
-static void draw_grid();
+static void draw_grid(cairo_t *cr);
+static gboolean on_draw(GtkWidget *widget, cairo_t *cr, gpointer data);
 
 
 /* Globals */
@@ -28,6 +27,65 @@ extern GtkWidget *main_window;
 Square legal_moves[100];
 int state_hash;
 
+/* Just a wrapper around GtkMessageDialog.  */
+void run_dialog(GtkMessageType type, const gchar *message)
+{
+  GtkWidget *dialog;
+
+  dialog = gtk_message_dialog_new(GTK_WINDOW (main_window),
+                                  GTK_DIALOG_DESTROY_WITH_PARENT,
+                                  type,
+                                  GTK_BUTTONS_CLOSE,
+                                  "%s", message);
+
+  gtk_dialog_run(GTK_DIALOG (dialog));
+  gtk_widget_destroy(dialog);
+}
+
+/* Load all pixbufs for drawing */
+static void load_pixbufs(void)
+{
+   if (board->white_piece_pb)
+      g_object_unref(board->white_piece_pb);
+   if (board->black_piece_pb)
+      g_object_unref(board->black_piece_pb);
+   if (board->white_sq_pb)
+      g_object_unref(board->white_sq_pb);
+   if (board->grey_sq_pb)
+      g_object_unref(board->grey_sq_pb);
+   if (board->arrow_sq_pb)
+      g_object_unref(board->arrow_sq_pb);
+
+   board->white_piece_pb = gdk_pixbuf_new_from_file(options.images.white_piece, NULL);
+   if (board->white_piece_pb == NULL) {
+      fprintf(stderr, "Cannot find white piece image: %s\n", options.images.white_piece);
+      exit(1);
+   }
+
+   board->black_piece_pb = gdk_pixbuf_new_from_file(options.images.black_piece, NULL);
+   if (board->black_piece_pb == NULL) {
+      fprintf(stderr, "Cannot find black piece image: %s\n", options.images.black_piece);
+      exit(1);
+   }
+
+   board->white_sq_pb = gdk_pixbuf_new_from_file(options.images.white_sq, NULL);
+   if (board->white_sq_pb == NULL) {
+      fprintf(stderr, "Cannot find white square image: %s\n", options.images.white_sq);
+      exit(1);
+   }
+
+   board->grey_sq_pb = gdk_pixbuf_new_from_file(options.images.grey_sq, NULL);
+   if (board->grey_sq_pb == NULL) {
+      fprintf(stderr, "Cannot find grey square image: %s\n", options.images.grey_sq);
+      exit(1);
+   }
+
+   board->arrow_sq_pb = gdk_pixbuf_new_from_file(options.images.arrow_sq, NULL);
+   if (board->arrow_sq_pb == NULL) {
+      fprintf(stderr, "Cannot find arrow square image: %s\n", options.images.arrow_sq);
+      exit(1);
+   }
+}
 
 void init_game_board(GtkWidget *GamazonsMain)
 {
@@ -43,15 +101,10 @@ void init_game_board(GtkWidget *GamazonsMain)
       printf("Couldn't find board!!!!!!!!\n");
 
    board = (Board *) malloc(sizeof(Board));
-   board->canvas = GNOME_CANVAS(w);
-   board->root = GNOME_CANVAS_GROUP(gnome_canvas_item_new(gnome_canvas_root(board->canvas),
-	       gnome_canvas_group_get_type(),
-	       NULL));
-   
-   gnome_canvas_set_scroll_region(board->canvas, 0.0, 0.0,
-	   400.0,
-	   400.0);
-
+   memset(board, 0, sizeof(Board));
+   board->drawing_area = w;
+   board->selected_queen = -1;
+   board->is_dragging = FALSE;
 
    /* initialize pieces */
    for (i=0; i<BOARD_SIZE; i++)
@@ -61,8 +114,16 @@ void init_game_board(GtkWidget *GamazonsMain)
 	 board->squares[i][j] = NOTHING;
 	}
      }
-   gtk_signal_connect(GTK_OBJECT(board->canvas), "event",
-	   GTK_SIGNAL_FUNC(arrow_fire_cb), NULL);
+
+   /* Connect draw signal */
+   g_signal_connect(G_OBJECT(w), "draw", G_CALLBACK(on_draw), NULL);
+
+   /* Connect event signals for mouse interaction */
+   gtk_widget_add_events(w, GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK | 
+                            GDK_POINTER_MOTION_MASK);
+   g_signal_connect(G_OBJECT(w), "button-press-event", G_CALLBACK(board_button_press_cb), NULL);
+   g_signal_connect(G_OBJECT(w), "button-release-event", G_CALLBACK(board_button_release_cb), NULL);
+   g_signal_connect(G_OBJECT(w), "motion-notify-event", G_CALLBACK(board_motion_notify_cb), NULL);
 
    //Place amazon queens on the board
    board->squares[9][3] = WHITE;
@@ -113,231 +174,140 @@ void init_game_board(GtkWidget *GamazonsMain)
 }
 
 
-static void draw_grid()
+static void draw_grid(cairo_t *cr)
 {
    int x,y;
 
+   cairo_set_source_rgb(cr, 0, 0, 0);
+   cairo_set_line_width(cr, THICKNESS);
+
    for (x=0; x<=10; x++)
      {
       for (y=0; y<=10; y++)
 	{
 	 //draw horiz
-	 draw_a_line(board->root, //gnome_canvas_root(board->canvas),
-		 0, y*CELL_SIZE, BOARD_SIZE*CELL_SIZE, y*CELL_SIZE, "black");
+	 cairo_move_to(cr, 0, y*CELL_SIZE);
+	 cairo_line_to(cr, BOARD_SIZE*CELL_SIZE, y*CELL_SIZE);
 
 	 //draw vert
-	 draw_a_line(board->root, //gnome_canvas_root(board->canvas),
-		 x*CELL_SIZE, 0, x*CELL_SIZE, BOARD_SIZE*CELL_SIZE, "black");
+	 cairo_move_to(cr, x*CELL_SIZE, 0);
+	 cairo_line_to(cr, x*CELL_SIZE, BOARD_SIZE*CELL_SIZE);
 	}
      }
-
-
+   cairo_stroke(cr);
 }
 
-static void draw_a_line(GnomeCanvasGroup *group,
-       	int x1, int y1, int x2, int y2, char *color)
+/* Draw callback for the drawing area */
+static gboolean on_draw(GtkWidget *widget, cairo_t *cr, gpointer data)
 {
-   GnomeCanvasPoints *points;
-
-   /* allocate a new points array */
-   points = gnome_canvas_points_new (2);
-
-   /* fill out the points */
-   points->coords[0] = x1;
-   points->coords[1] = y1;
-   points->coords[2] = x2;
-   points->coords[3] = y2;
-   /* draw the line */
-   gnome_canvas_item_new(group,
-	   gnome_canvas_line_get_type(),
-	   "points", points,
-	   "fill_color", color,
-	   "width_units", (double)THICKNESS,
-	   NULL);
-
-   /* free the points array */
-   gnome_canvas_points_free(points);
-}
-
-void draw_board()
-{
-   int i,j,k;
-   GdkPixbuf *white_pb, *black_pb;
-   GdkPixbuf *white_sq, *grey_sq, *arrow_sq;
-   GnomeCanvasItem *image;
-   GnomeCanvasGroup *root = NULL;
-   
-   root = GNOME_CANVAS_GROUP(gnome_canvas_root (GNOME_CANVAS (board->canvas)));
-
-
-   /* Find images */
-   white_pb = gdk_pixbuf_new_from_file(options.images.white_piece, NULL);
-   if (white_pb == NULL)
-     {
-      fprintf(stderr, "Cannot find white piece image: %s\n", options.images.white_piece);
-      exit(1);
-     }
-
-   black_pb = gdk_pixbuf_new_from_file(options.images.black_piece, NULL);
-   if (black_pb == NULL)
-     {
-      fprintf(stderr, "Cannot find black piece image: %s\n", options.images.black_piece);
-      exit(1);
-     }
-
-   white_sq = gdk_pixbuf_new_from_file(options.images.white_sq, NULL);
-   if (white_sq == NULL)
-     {
-      fprintf(stderr, "Cannot find white square image: %s\n", options.images.white_sq);
-      exit(1);
-     }
+   int i, j;
+   GdkPixbuf *scaled_pb;
+   int cell_size = (int)CELL_SIZE;
 
-   grey_sq = gdk_pixbuf_new_from_file(options.images.grey_sq, NULL);
-   if (grey_sq == NULL)
-     {
-      fprintf(stderr, "Cannot find grey square image: %s\n", options.images.grey_sq);
-      exit(1);
-     }
-   arrow_sq = gdk_pixbuf_new_from_file(options.images.arrow_sq, NULL);
-   if (arrow_sq == NULL)
+   /* Draw squares */
+   for(j=0; j<BOARD_SIZE; j++) 
      {
-      fprintf(stderr, "Cannot find arrow square image: %s\n", options.images.arrow_sq);
-      exit(1);
-     }
-
-
-
-   /* fill alternate squares */
-   for(j=0;j<BOARD_SIZE;j++) 
-     {
-      for(i=0;i<BOARD_SIZE;i++) 
+      for(i=0; i<BOARD_SIZE; i++) 
 	{
-	 board->square_items[j*10+i] = NULL;
+	 GdkPixbuf *sq_pb;
+	 
 	 if ((i + j) % 2)
-	   {
-	    board->square_items[j*10+i] = gnome_canvas_item_new (board->root,
-		    gnome_canvas_pixbuf_get_type (),
-		    "x", i*CELL_SIZE+QUEEN_OFFSET, "y", j*CELL_SIZE+QUEEN_OFFSET,
-		    "width", CELL_SIZE, "height", CELL_SIZE,
-		    "width_set", TRUE, "height_set", TRUE,
-		    "pixbuf", grey_sq,
-		    NULL);
-	   }
+	    sq_pb = board->grey_sq_pb;
 	 else
-	   {
-	    board->square_items[j*10+i] = gnome_canvas_item_new (board->root,
-		    gnome_canvas_pixbuf_get_type (),
-		    "x", i*CELL_SIZE+QUEEN_OFFSET, "y", j*CELL_SIZE+QUEEN_OFFSET,
-		    "width", CELL_SIZE, "height", CELL_SIZE,
-		    "width_set", TRUE, "height_set", TRUE,
-		    "pixbuf", white_sq,
-		    NULL);
-	   }
-
-
-
-	 //Place the queen images on the board in the right order
-	 if (board->squares[j][i] == WHITE)
-	   {
-#ifdef DEBUG
-	    printf("Square %c%c contains a white queen\n",i+'a',10-j+'0');
-#endif
-	    image = gnome_canvas_item_new (board->root,
-		    gnome_canvas_pixbuf_get_type (),
-		    "x", i*CELL_SIZE+QUEEN_OFFSET, "y", j*CELL_SIZE+QUEEN_OFFSET,
-		    "width", CELL_SIZE, "height", CELL_SIZE,
-		    "width_set", TRUE, "height_set", TRUE,
-		    "pixbuf", white_pb,
-		    NULL);
-	    //We need to do some funky checking to make sure board->white_queens[] matches
-	    //up exactly with state->white_q_x[], state->white_q_y[]
-	    for (k=0; k<4; k++)
-	      {
-	       if(j*10 +i == board->square_to_wh_queen_map[k])
-		 {
-		  board->white_queens[k] = image;
-#ifdef DEBUG
-		  printf("registering queen %d\n", k);
-#endif
-		  break;
-		 }
-	      }
-
-#ifdef DEBUG
-	    printf("connecting signal to queen\n");
-#endif
-	    gtk_signal_connect(GTK_OBJECT(image), "event",
-		    GTK_SIGNAL_FUNC(board_press_cb), NULL);
-	   }
-	 else if (board->squares[j][i] == BLACK)
-	   {
-#ifdef DEBUG
-	    printf("Square %c%c contains a black queen\n",i+'a',10-j+'0');
-#endif
-	    image = gnome_canvas_item_new (board->root,
-		    gnome_canvas_pixbuf_get_type (),
-		    "x", i*CELL_SIZE+QUEEN_OFFSET, "y", j*CELL_SIZE+QUEEN_OFFSET,
-		    "width", CELL_SIZE, "height", CELL_SIZE,
-		    "width_set", TRUE, "height_set", TRUE,
-		    "pixbuf", black_pb,
-		    NULL);
-	    for (k=0; k<4; k++)
-	      {
-	       if(j*10 +i == board->square_to_bl_queen_map[k])
-		 {
-		  board->black_queens[k] = image;
-#ifdef DEBUG
-		  printf("registering queen %d\n", k);
-#endif
-		  break;
-		 }
-	      }
-
-#ifdef DEBUG
-	    printf("connecting signal to queen\n");
-#endif
-	    gtk_signal_connect(GTK_OBJECT(image), "event",
-		    GTK_SIGNAL_FUNC(board_press_cb), NULL);
-	   }
-	 else if (board->squares[j][i] == ARROW)
-	   {
-	    image = gnome_canvas_item_new (board->root,
-		    gnome_canvas_pixbuf_get_type (),
-		    "x", i*CELL_SIZE+QUEEN_OFFSET, "y", j*CELL_SIZE+QUEEN_OFFSET,
-		    "width", CELL_SIZE, "height", CELL_SIZE,
-		    "width_set", TRUE, "height_set", TRUE,
-		    "pixbuf", arrow_sq,
-		    NULL);
-	   }
-	    
+	    sq_pb = board->white_sq_pb;
+	 
+	 if (sq_pb) {
+	    scaled_pb = gdk_pixbuf_scale_simple(sq_pb, cell_size, cell_size, GDK_INTERP_BILINEAR);
+	    gdk_cairo_set_source_pixbuf(cr, scaled_pb, i*CELL_SIZE, j*CELL_SIZE);
+	    cairo_paint(cr);
+	    g_object_unref(scaled_pb);
+	 }
+
+	 /* Draw arrows */
+	 if (board->squares[j][i] == ARROW && board->arrow_sq_pb) {
+	    scaled_pb = gdk_pixbuf_scale_simple(board->arrow_sq_pb, cell_size, cell_size, GDK_INTERP_BILINEAR);
+	    gdk_cairo_set_source_pixbuf(cr, scaled_pb, i*CELL_SIZE, j*CELL_SIZE);
+	    cairo_paint(cr);
+	    g_object_unref(scaled_pb);
+	 }
+	}
+     }
 
+   /* Draw queens (except the one being dragged) */
+   for(j=0; j<BOARD_SIZE; j++) 
+     {
+      for(i=0; i<BOARD_SIZE; i++) 
+	{
+	 int sq = j * 10 + i;
+	 gboolean is_being_dragged = FALSE;
+
+	 /* Check if this queen is being dragged */
+	 if (board->is_dragging && board->selected_queen >= 0) {
+	    int drag_sq;
+	    if (board->selected_queen_is_white)
+	       drag_sq = board->square_to_wh_queen_map[board->selected_queen];
+	    else
+	       drag_sq = board->square_to_bl_queen_map[board->selected_queen];
+	    if (sq == drag_sq)
+	       is_being_dragged = TRUE;
+	 }
+
+	 if (!is_being_dragged) {
+	    if (board->squares[j][i] == WHITE && board->white_piece_pb) {
+	       scaled_pb = gdk_pixbuf_scale_simple(board->white_piece_pb, cell_size, cell_size, GDK_INTERP_BILINEAR);
+	       gdk_cairo_set_source_pixbuf(cr, scaled_pb, i*CELL_SIZE, j*CELL_SIZE);
+	       cairo_paint(cr);
+	       g_object_unref(scaled_pb);
+	    }
+	    else if (board->squares[j][i] == BLACK && board->black_piece_pb) {
+	       scaled_pb = gdk_pixbuf_scale_simple(board->black_piece_pb, cell_size, cell_size, GDK_INTERP_BILINEAR);
+	       gdk_cairo_set_source_pixbuf(cr, scaled_pb, i*CELL_SIZE, j*CELL_SIZE);
+	       cairo_paint(cr);
+	       g_object_unref(scaled_pb);
+	    }
+	 }
 	}
      }
 
+   /* Draw the dragged queen at drag position */
+   if (board->is_dragging && board->selected_queen >= 0) {
+      GdkPixbuf *piece_pb = board->selected_queen_is_white ? 
+                            board->white_piece_pb : board->black_piece_pb;
+      if (piece_pb) {
+	 scaled_pb = gdk_pixbuf_scale_simple(piece_pb, cell_size, cell_size, GDK_INTERP_BILINEAR);
+	 gdk_cairo_set_source_pixbuf(cr, scaled_pb, 
+	    board->drag_x - cell_size/2, board->drag_y - cell_size/2);
+	 cairo_paint(cr);
+	 g_object_unref(scaled_pb);
+      }
+   }
+
    if (options.images.grid == TRUE)
-      draw_grid();
+      draw_grid(cr);
 
-   /*
-   image = gnome_canvas_item_new (root,
-	   gnome_canvas_pixbuf_get_type (),
-	   "x", 10.0, "y", 10.0,
-	   "width", 40.0, "height", 40.0,
-	   "width_set", TRUE, "height_set", TRUE,
-	   "pixbuf", white_pb,
-	   NULL);
-	   */
+   return FALSE;
+}
 
+void draw_board()
+{
+   /* Load/reload pixbufs */
+   load_pixbufs();
 
    gtk_widget_show_now(main_window);
-   gtk_widget_queue_draw ((GtkWidget *) board->canvas);
-   gtk_widget_show_now((GtkWidget *) board->canvas);
+   gtk_widget_queue_draw(board->drawing_area);
+   gtk_widget_show_now(board->drawing_area);
 }
 
+/* Request a redraw of the board */
+void redraw_board(void)
+{
+   if (board && board->drawing_area)
+      gtk_widget_queue_draw(board->drawing_area);
+}
 
-
-void mark_square (GnomeCanvasItem *square)
+void mark_square (int square)
 {
-   gnome_canvas_item_set (square, "outline_color", "red", NULL);
+  /* Not used in current implementation */
 }
 
 Square get_square (double x, double y)
@@ -346,11 +316,6 @@ Square get_square (double x, double y)
    int x_square;
    int y_square;
 
-   /*
-   x -= (BOARD_BORDER - CELL_PAD);
-   y -= (BOARD_BORDER - CELL_PAD);
-   */
-
    if (x < 0)
       x = 0.0;
    else if (x > ((BOARD_SIZE-1) * CELL_SIZE))
@@ -373,96 +338,95 @@ Square get_square (double x, double y)
    return from;
 }
 
-void clear_square (GnomeCanvasItem **square)
+void clear_selected_queen (void)
 {
-   gnome_canvas_item_set (*square, "outline_color", NULL, NULL);
-   *square = NULL;
+   board->selected_queen = -1;
+   board->is_dragging = FALSE;
 }
 
 /*==============================================================================
  * move_piece_to
  *
- * This moves the given piece to the given square.  This is a very tricky function
- * because the user can do many things to upset the state of the board while a 
- * piece is sliding, so various checks must take place throughout the movement 
- * process to make sure the board still exists as it thinks it does.
- *
- * The piece can also move at different speeds.  Originally, it moved one pixel at
- * a time, but it now gets its value from the MovementSpeedSpinner widget.  This
- * makes it so the pieces can move at acceptable speeds on slower computers, but 
- * adds more complexity in trying to calculate the distance a piece should move.
+ * This moves the given piece to the given square.  With Cairo-based drawing,
+ * we simply update the board state and request a redraw. For smooth animation,
+ * we still support the sliding effect.
  */
-void move_piece_to(Square to, GnomeCanvasItem *item)
+void move_piece_to(Square to, int queen_index, gboolean is_white)
 {
-   double Lx, Uy, Rx, By;
-   double to_Lx, to_Uy;
-   int x = 0, y = 0;
+   double to_x, to_y;
+   double curr_x, curr_y;
    int game_life;
-   GtkWidget *speed = (GtkWidget *)lookup_widget(main_window, "MovementSpeedSpinner");
-   int inc = gtk_spin_button_get_value_as_int((GtkSpinButton *)speed);
+   GtkWidget *speed_widget = (GtkWidget *)lookup_widget(main_window, "MovementSpeedSpinner");
+   int inc = gtk_spin_button_get_value_as_int((GtkSpinButton *)speed_widget);
+   int sq;
+
+   if (queen_index < 0 || queen_index >= 4)
+      return;
 
    game_life = bstate_get_game_life();
-   to_Lx = get_x_from_square(to);
-   to_Uy = get_y_from_square(to);
-      
-#ifdef DEBUG
-   printf("We want the queen at coords %f, %f\n", to_Lx, to_Uy);
-#endif
-   gnome_canvas_item_get_bounds(item, &Lx, &Uy, &Rx, &By);
+   
+   if (is_white)
+      sq = board->square_to_wh_queen_map[queen_index];
+   else
+      sq = board->square_to_bl_queen_map[queen_index];
+
+   to_x = get_x_from_square(to) + CELL_SIZE/2;
+   to_y = get_y_from_square(to) + CELL_SIZE/2;
+   curr_x = get_x_from_square(sq) + CELL_SIZE/2;
+   curr_y = get_y_from_square(sq) + CELL_SIZE/2;
+
 #ifdef DEBUG
-   printf("The queen is at coords %f, %f\n", Lx, Uy);
+   printf("We want the queen at coords %f, %f\n", to_x, to_y);
+   printf("The queen is at coords %f, %f\n", curr_x, curr_y);
 #endif
+
    if (bstate_get_dont_slide())
      {
-      gnome_canvas_item_get_bounds(item, &Lx, &Uy, &Rx, &By);
-      gnome_canvas_item_move (item, 
-	      get_x_from_square(to) - Lx,
-	      get_y_from_square(to) - Uy);
-      gnome_canvas_item_raise_to_top (item);
+      /* Just move instantly */
+      redraw_board();
      }
    else
      {
-      while (Lx != to_Lx || Uy != to_Uy)
+      board->is_dragging = TRUE;
+      board->selected_queen = queen_index;
+      board->selected_queen_is_white = is_white;
+
+      while ((int)curr_x != (int)to_x || (int)curr_y != (int)to_y)
        	{
-#ifdef DEBUG
-	 if (count++ < 20)
-	    printf("Lx = %g;  to_Lx = %g; Uy = %g; to_Uy = %g\n", Lx, to_Lx, Uy, to_Uy);
-#endif
 	 bstate_set_moving_piece(TRUE);
-	 if ((int)Lx == (int)to_Lx)
-	    x = 0;
-	 else if (Lx < to_Lx && (to_Lx - Lx) >= inc)
-	    x = inc;
-	 else if (Lx < to_Lx && (to_Lx - Lx) <= inc)
-	    x = to_Lx - Lx;
-	 else if (Lx > to_Lx && (Lx - to_Lx) >= inc)
-	    x = -inc;
-	 else if (Lx > to_Lx && (Lx - to_Lx) <= inc)
-	    x = to_Lx - Lx;
-
-	 if ((int)Uy == (int)to_Uy)
-	    y = 0;
-	 else if (Uy < to_Uy && (to_Uy - Uy) >= inc)
-	    y = inc;
-	 else if (Uy < to_Uy && (to_Uy - Uy) <= inc)
-	    y = to_Uy - Uy;
-	 else if (Uy > to_Uy && (Uy - to_Uy) >= inc)
-	    y = -inc;
-	 else if (Uy > to_Uy && (Uy - to_Uy) <= inc)
-	    y = to_Uy - Uy;
-
-#ifdef DEBUG
-	 if (count < 20)
-	    printf("x = %d, y = %d\n", x, y);
-#endif
+	 
+	 if ((int)curr_x == (int)to_x)
+	    ; /* no x movement */
+	 else if (curr_x < to_x && (to_x - curr_x) >= inc)
+	    curr_x += inc;
+	 else if (curr_x < to_x && (to_x - curr_x) < inc)
+	    curr_x = to_x;
+	 else if (curr_x > to_x && (curr_x - to_x) >= inc)
+	    curr_x -= inc;
+	 else if (curr_x > to_x && (curr_x - to_x) < inc)
+	    curr_x = to_x;
+
+	 if ((int)curr_y == (int)to_y)
+	    ; /* no y movement */
+	 else if (curr_y < to_y && (to_y - curr_y) >= inc)
+	    curr_y += inc;
+	 else if (curr_y < to_y && (to_y - curr_y) < inc)
+	    curr_y = to_y;
+	 else if (curr_y > to_y && (curr_y - to_y) >= inc)
+	    curr_y -= inc;
+	 else if (curr_y > to_y && (curr_y - to_y) < inc)
+	    curr_y = to_y;
 
 	 if (bstate_get_game_life() != game_life)
 	   {
 	    bstate_set_moving_piece(FALSE);
+	    board->is_dragging = FALSE;
 	    return;
 	   }
-	 gnome_canvas_item_move (item, (double)x, (double)y);
-	 gnome_canvas_item_raise_to_top (item);
+
+	 board->drag_x = curr_x;
+	 board->drag_y = curr_y;
+	 redraw_board();
 
 	 //update the board
          while (gtk_events_pending())
@@ -473,24 +437,25 @@ void move_piece_to(Square to, GnomeCanvasItem *item)
 	 if (bstate_get_game_life() != game_life)
 	   {
 	    bstate_set_moving_piece(FALSE);
+	    board->is_dragging = FALSE;
 	    return;
 	   }
-	 gnome_canvas_item_get_bounds(item, &Lx, &Uy, &Rx, &By);
        	}
      }
 
    if (bstate_get_game_life() != game_life)
      {
       bstate_set_moving_piece(FALSE);
+      board->is_dragging = FALSE;
       return;
      }
-   gnome_canvas_item_raise_to_top (item);
+
+   board->is_dragging = FALSE;
    bstate_set_moving_piece(FALSE);
-	   //see where it landed
-   gnome_canvas_item_get_bounds(item, &Lx, &Uy, &Rx, &By);
+   redraw_board();
+
 #ifdef DEBUG
-   printf("The queen landed at coords %f, %f\n", Lx, Uy);
-   printf("this time the queen is on square %d\n", to);
+   printf("The queen landed at square %d\n", to);
 #endif
 }
 
@@ -567,32 +532,12 @@ int get_square_from_engine(int x, int y)
 void fire_arrow(Square sq)
 {
    int x,y;
-   GdkPixbuf *arrow_sq;
-   GnomeCanvasItem *image;
-   GnomeCanvasGroup *root = NULL;
-
-   root = GNOME_CANVAS_GROUP(gnome_canvas_root (GNOME_CANVAS (board->canvas)));
 
    x = sq % 10;
    y = sq / 10;
 
    board->squares[y][x] = ARROW;
-
-   arrow_sq = gdk_pixbuf_new_from_file(options.images.arrow_sq, NULL);
-   if (arrow_sq == NULL)
-     {
-      fprintf(stderr, "Cannot find arrow image: %s\n", options.images.arrow_sq);
-      exit(1);
-     }
-
-   image = gnome_canvas_item_new (board->root,
-	   gnome_canvas_pixbuf_get_type (),
-	   "x", x*CELL_SIZE+QUEEN_OFFSET, "y", y*CELL_SIZE+QUEEN_OFFSET,
-	   "width", CELL_SIZE, "height", CELL_SIZE,
-	   "width_set", TRUE, "height_set", TRUE,
-	   "pixbuf", arrow_sq,
-	   NULL);
-
+   redraw_board();
 }
 
 void square_contains(Square sq)
@@ -635,42 +580,23 @@ int move_ai()
    int ai = FALSE;
    int current_hash;
    int game_life = bstate_get_game_life();
-   //GtkWidget *auto_button, *force_button;
 
    current_hash = state_hash = create_hash(s);
 
-   //quit this function if a 'New Game' option was selected since this
-   //function was started.
-   /*
-   if (bstate_get_new_game())
-     {
-      bstate_set_new_game(FALSE);
-      return FALSE;
-     }
-     */
    ok = 1;
    ai = TRUE;
    start = time(NULL);
    temp = isearch(s, NOTHINK);
-   if (s->winner) //XXX does this if statement do any good?  I thot winner was handled elsewhere
+   if (s->winner)
       return FALSE;
    makemove(s,temp);
 
    //update the board before drawing the new move
-   //the program would segfault if you closed it while it was thinking
    while (gtk_events_pending())
       gtk_main_iteration();
    if (current_hash != state_hash)
       return FALSE;
 
-   /*
-   if (bstate_get_new_game())
-     {
-      bstate_set_new_game(FALSE);
-      return FALSE;
-     }
-     */
-
    if (bstate_get_quit_game())
       exit(0);
 
@@ -697,7 +623,6 @@ int move_ai()
 
    if (game_over())
      {
-      //XXX should I set ai = FALSE?
       ai = FALSE;
       return (ai);
      }
@@ -713,14 +638,15 @@ int move_ai()
  */
 void move_piece(move m)
 {
-   GnomeCanvasItem *item;
    int from_row, from_col;
    int to_row, to_col;
    int game_life = bstate_get_game_life();
+   gboolean is_white;
 
    bstate_set_move_to(get_square_from_engine(m.tocol, m.torow));
    to_col = get_x_int_from_square(bstate_get_move_to());
    to_row = get_y_int_from_square(bstate_get_move_to());
+   
    //Note: by the time the state gets here, it's signaled the other player's turn
    //so if it says it's white's turn, black just moved and we need to move black's
    //piece.
@@ -733,8 +659,8 @@ void move_piece(move m)
 #ifdef DEBUG
       printf("Moving black queen\n");
 #endif
-      item = board->black_queens[m.queen];
       board->square_to_bl_queen_map[m.queen] = to_row*10 +to_col;
+      is_white = FALSE;
      }
    else
      {
@@ -744,8 +670,8 @@ void move_piece(move m)
 #ifdef DEBUG
       printf("Moving white queen\n");
 #endif
-      item = board->white_queens[m.queen];
       board->square_to_wh_queen_map[m.queen] = to_row*10 +to_col;
+      is_white = TRUE;
      }
 
 
@@ -753,7 +679,7 @@ void move_piece(move m)
    from_row = get_y_int_from_square(bstate_get_move_from());
    board->squares[from_row][from_col] = NOTHING;
 
-   move_piece_to(bstate_get_move_to(), item);
+   move_piece_to(bstate_get_move_to(), m.queen, is_white);
 #ifdef DEBUG
    printf("Engine coords for arrow: %d, %d\n", m.wallcol, m.wallrow);
 #endif
@@ -783,17 +709,10 @@ void register_move_with_engine(Square arrow_sq)
    char move_str[32];
    char err_msg[256];
 
-   //find out the index of the queen that was just moved.  
-   //weird things will happen if it's not found.
-   for (i=0; i<4; i++)
-     {
-      if (board->selected_queen == board->white_queens[i] || 
-	  board->selected_queen == board->black_queens[i])
-	{
-	 found = TRUE;
-	 break;
-	}
-     }
+   //find out the index of the queen that was just moved.
+   i = board->selected_queen;
+   if (i >= 0 && i < 4)
+      found = TRUE;
 
    if (!found)
       fprintf(stderr, "Error registering move w/ AI engine!  Game play will now be weird.\n");
@@ -809,7 +728,9 @@ void register_move_with_engine(Square arrow_sq)
    move_count = children(s, movelist);
    if (move_count == 0)
      {
-      gnome_error_dialog("The AI engine thinks the game is over.  Please use the menu item Game->New to start a new game");
+      run_dialog(GTK_MESSAGE_ERROR,
+                 _("The AI engine thinks the game is over.  Please use "
+                   "the menu item Game->New to start a new game"));
       return;
      }
    if (!move_lookup(&m, movelist, move_count))
@@ -817,7 +738,7 @@ void register_move_with_engine(Square arrow_sq)
       get_move_str(&m, move_str);
       strcpy(err_msg, "You've hit a bug.  The following illegal move was just attempted: ");
       strcat(err_msg, move_str);
-      gnome_error_dialog(err_msg);
+      run_dialog(GTK_MESSAGE_ERROR, err_msg);
       return;
      }
 
@@ -1031,20 +952,6 @@ void free_all_memory()
    for (i=0; i< states.max_state; i++)
       free (states.s[i]);
 
-   //Oh, this is ugly!  Do I really want to do this?
-   /*
-   if(tt)
-     {
-      for (i=0; i<TT; i++)
-       	{
-	 if (tt[i])
-	    free(tt[i]);
-       	}
-     }
-     */
-
-
-
 }
 
 
@@ -1076,26 +983,17 @@ int game_over()
 {
    state *s = states.s[states.current_state];
    move movelist[3000];
-//   GtkWidget *auto_button, *force_button;
 
    if (children(s, movelist) == 0)
      {
-      //printf("player %d wins!\n", s->turn^3);
       s->winner = s->turn^3;
       if (s->winner == BLACK)
-	 gnome_ok_dialog("White wins!");
+	 run_dialog(GTK_MESSAGE_INFO, "White wins!");
       else
-	 gnome_ok_dialog("Black wins!");
+	 run_dialog(GTK_MESSAGE_INFO, "Black wins!");
 
       bstate_set_just_finished(GAME_OVER);
 
-      /*
-      auto_button = (GtkWidget *) lookup_widget(main_window, "BT_AUTOFINISH");
-      force_button = (GtkWidget *) lookup_widget(main_window, "BT_FORCEMOVE");
-      gtk_widget_set_sensitive (auto_button, FALSE);
-      gtk_widget_set_sensitive (force_button, FALSE);
-      */
-
       return TRUE;
      }
    else
@@ -1115,7 +1013,6 @@ int update_status_bar()
 
    gtk_statusbar_pop(status, context_id);
 
-   //printf("Updating status bar for state %d\n", bstate_get_what_next());
    switch (bstate_get_what_next()) 
      {
        case FIRE_ARROW:
@@ -1175,25 +1072,17 @@ void print_board()
 /*==============================================================================
  * destroy_board
  *
- * Destroys the main board canvas group which contains all the square and piece
- * images, and takes them with it.  Once done, it creates a new group that 
- * draw_board() can take advantage of.
+ * Clears the board state for a new game.
  */
 void destroy_board()
 {
-
-
 #ifdef DEBUG
    printf("Destroying board now\n");
 #endif
-
-
-   gtk_object_destroy(GTK_OBJECT(board->root));
-   board->root = GNOME_CANVAS_GROUP(gnome_canvas_item_new(gnome_canvas_root(board->canvas),
-	       gnome_canvas_group_get_type(),
-	       NULL));
+   /* Nothing special needed - the drawing area persists */
 }
 
+
 /*==============================================================================
  * print_move_in_text_window
  *
@@ -1222,7 +1111,7 @@ void print_move_in_text_window(move *m)
 
    w = (GtkScrolledWindow *) lookup_widget(main_window, "scrolledwindow6");
    adj = gtk_scrolled_window_get_vadjustment(w);
-   gtk_adjustment_set_value(adj, adj->upper);
+   gtk_adjustment_set_value(adj, gtk_adjustment_get_upper (adj));
    gtk_scrolled_window_set_vadjustment(w, adj);
    
 
@@ -1343,12 +1232,10 @@ int get_move_from_str(move *m, char move_str[])
       if (queen_sq == board->square_to_wh_queen_map[j])
 	{
 	 queen_i = j;
-	 //printf("found move for white queen\n");
 	}
       if (queen_sq == board->square_to_bl_queen_map[j])
 	{
 	 queen_i = j;
-	 //printf("found move for black queen\n");
 	}
      }
    if (queen_i == -1)
@@ -1388,16 +1275,11 @@ int read_in_moves(FILE *history_fd)
      {
       bstate_set_dont_slide(TRUE);
      }
-   //printf("History contents:\n");
    while (getline(&buffer, &buf_size, history_fd) != -1)
      {
       if (replay_mode && !bstate_get_replay_mode()) //If not in replay mode anymore, drop out
 	 return FALSE;
       s = states.s[states.current_state];
-      /*
-      if (buffer != NULL)
-	 printf("%s", buffer);
-      */
       if (get_move_from_str(&m, buffer))
 	{
 	 makemove(s,m);  //register w/ engine
@@ -1446,3 +1328,19 @@ void rest(int duration)
 }
 
 
+/* Helper function to find which queen is at a given square */
+int find_queen_at_square(Square sq, gboolean *is_white)
+{
+   int k;
+   for (k = 0; k < 4; k++) {
+      if (board->square_to_wh_queen_map[k] == sq) {
+	 *is_white = TRUE;
+	 return k;
+      }
+      if (board->square_to_bl_queen_map[k] == sq) {
+	 *is_white = FALSE;
+	 return k;
+      }
+   }
+   return -1;
+}
diff --git a/src/board.h b/src/board.h
index 4299595..eefb258 100644
--- a/src/board.h
+++ b/src/board.h
@@ -27,7 +27,7 @@ typedef gchar   Piece;
 
 struct amazon_board {
 
-   // Gnome canvas counts coordinates w/ origin starting in top/left corner
+   // Board squares array with origin starting in top/left corner
    Square squares[BOARD_SIZE][BOARD_SIZE];
    //These are really meant for temporary processing, and might not contain
    //safe values.  They are currently candidates for downsizing.
@@ -41,20 +41,30 @@ struct amazon_board {
    Square square_to_wh_queen_map[4];
    Square square_to_bl_queen_map[4];
 
-   GnomeCanvasItem *selected_queen;
-   GnomeCanvasItem *white_queens[4];
-   GnomeCanvasItem *black_queens[4];
+   /* Index of the selected queen (0-3), or -1 if none selected */
+   int selected_queen;
+   /* Whether the selected queen is white (TRUE) or black (FALSE) */
+   gboolean selected_queen_is_white;
 
    double orig_x;
    double orig_y;
    double curr_x;
    double curr_y;
 
+   /* Dragging state */
+   double drag_x;
+   double drag_y;
+   gboolean is_dragging;
+
    char db[120];
-   GnomeCanvasItem *square_items[100];
-   GnomeCanvasGroup *root;
-   GnomeCanvas *canvas;
+   GtkWidget *drawing_area;
 
+   /* Cached pixbufs for drawing */
+   GdkPixbuf *white_piece_pb;
+   GdkPixbuf *black_piece_pb;
+   GdkPixbuf *white_sq_pb;
+   GdkPixbuf *grey_sq_pb;
+   GdkPixbuf *arrow_sq_pb;
 
 };
 typedef struct amazon_board Board;
@@ -89,15 +99,17 @@ enum {
 
 /* Prototypes */
 
+void run_dialog(GtkMessageType type, const gchar *message);
 void init_game_board(GtkWidget *GamazonsMain);
 void draw_board();
-void mark_square (GnomeCanvasItem *square);
+void redraw_board(void);
+void mark_square (int square);
 
 
 Square get_square (double x, double y);
-void clear_square (GnomeCanvasItem **square);
+void clear_selected_queen (void);
 //void try_move (Board *board, GnomeCanvasItem *item);
-void move_piece_to (Square to, GnomeCanvasItem *item);
+void move_piece_to (Square to, int queen_index, gboolean is_white);
 
 void move_piece(move m);
 int move_ai();
@@ -127,6 +139,9 @@ int board_x_to_engine_x(int brd_x);
 int board_y_to_engine_y(int brd_y);
 int get_square_from_engine(int x, int y);
 
+// Helper functions
+int find_queen_at_square(Square sq, gboolean *is_white);
+
 
 void fire_arrow(Square sq);
 void square_contains(Square sq);
diff --git a/src/bstate.c b/src/bstate.c
index a1eede8..4c1c473 100644
--- a/src/bstate.c
+++ b/src/bstate.c
@@ -1,4 +1,4 @@
-#include <gnome.h>
+#include <gtk/gtk.h>
 #include "amazons.h"
 #include "board.h"
 #include "bstate.h"
diff --git a/src/callbacks.c b/src/callbacks.c
index b2bae83..fc52b1b 100644
--- a/src/callbacks.c
+++ b/src/callbacks.c
@@ -2,7 +2,8 @@
 #  include <config.h>
 #endif
 
-#include <gnome.h>
+#include <gtk/gtk.h>
+#include <glib/gi18n.h>
 #include <libgen.h>
 
 #include "callbacks.h"
@@ -19,33 +20,27 @@ extern Square legal_moves[100];
 extern int ok;
 extern GtkWidget *main_window;
 extern int state_hash;
-int grabbed_queen;
 GtkWidget *PlayerSettingsWindow;
-extern int moving_ai;
 
 GtkWidget *file_selector;
 gchar *selected_filename;
 
 /* Local Prototypes */
-void load_new_theme (GtkFileSelection *selector, gpointer user_data);
-void save_game_history(GtkFileSelection *selector, gpointer user_data);
-void on_ThemeCancelButton_clicked(GtkButton *button, gpointer user_data);
-void on_save_as1CancelButton_clicked(GtkButton *button, gpointer user_data);
-void on_OpenCancelButton_clicked(GtkButton *button, gpointer user_data);
-void load_saved_game(GtkFileSelection *selector, gpointer user_data);
+void load_new_theme (gchar *filename);
+void save_game_history(gchar *filename);
+void on_save_as1CancelButton_clicked(void);
+void on_OpenCancelButton_clicked(void);
+void load_saved_game(gchar *filename);
 
+/* Static variables for drag-and-drop */
+static Square drag_from_square;
+static Square drag_to_square;
+static gboolean grabbed_queen = FALSE;
 
 void
 on_new1_activate                       (GtkMenuItem     *menuitem,
                                         gpointer         user_data)
 {
-   /*
-   if (bstate_get_moving_piece())
-     {
-      gnome_warning_dialog("Unable to start a new game while a piece is being moved.  Please try again.");
-      return;
-     }
-     */
    free_all_memory();
    init_engine();
    destroy_board();
@@ -93,21 +88,9 @@ void
 on_about1_activate                     (GtkMenuItem     *menuitem,
                                         gpointer         user_data)
 {
-   static GtkWidget *about;
    GdkPixbuf *pixbuf = NULL;
 
    const gchar *authors[] = {"Ron Yorgason", "Sean McMillen", NULL};
-   gchar *documenters[] = {
-      NULL
-   };
-   /* Translator credits */
-   gchar *translator_credits = _("translator_credits");
-
-   if (about != NULL) {
-      gdk_window_raise (about->window);
-      gdk_window_show (about->window);
-      return;
-   }
 
      {
       char filename[1024];
@@ -116,17 +99,17 @@ on_about1_activate                     (GtkMenuItem     *menuitem,
       pixbuf = gdk_pixbuf_new_from_file(filename, NULL);
      }
 
-   about = gnome_about_new (_("Gamazons"), VERSION,
-	   "(C) 2002 Ronald Yorgason and Sean McMillen",
-	   _("Send comments and bug reports to: "
-	       "yorgasor@cs.pdx.edu"),
-	   (const char **)authors,
-	   (const char **)documenters,
-	   strcmp (translator_credits, "translator_credits") != 0 ? translator_credits : NULL,
-	   pixbuf);
-   g_signal_connect (G_OBJECT (about), "destroy", G_CALLBACK
-	   (gtk_widget_destroyed), &about);
-   gtk_widget_show (about);
+   gtk_show_about_dialog (GTK_WINDOW (main_window),
+                          "program-name", _("Gamazons"),
+                          "version", VERSION,
+                          "copyright",
+                          "(C) 2002 Ronald Yorgason and Sean McMillen",
+                          "comments", _("Send comments and bug reports to: "
+                                        "yorgasor@cs.pdx.edu"),
+                          "authors", authors,
+                          "translator-credits", _("translator_credits"),
+                          "logo", pixbuf,
+                          NULL);
 }
 
 
@@ -191,7 +174,7 @@ on_how_to_play1_activate               (GtkMenuItem     *menuitem,
                                         gpointer         user_data)
 {
     GError *error = NULL;
-    if (gnome_help_display("gamazons",NULL,&error))
+    if (gtk_show_uri_on_window(NULL,"ghelp:gamazons",GDK_CURRENT_TIME,&error))
       {
 #ifdef DEBUG
        printf("I should pop up the help display now\n");
@@ -236,7 +219,10 @@ on_BT_UNDO_clicked                     (GtkButton       *button,
       bstate_set_move_to(to);
       bstate_set_move_from(from);
 
-      move_piece_to (to, board->selected_queen);
+      /* Move the queen back */
+      if (board->selected_queen >= 0) {
+         move_piece_to(to, board->selected_queen, board->selected_queen_is_white);
+      }
 
       //roll back the state of the board
       from_col = get_x_int_from_square(bstate_get_move_from());
@@ -274,9 +260,8 @@ on_BT_UNDO_clicked                     (GtkButton       *button,
 	   }
 	}
 
+      redraw_board();
      }
-
-
 }
 
 
@@ -326,7 +311,7 @@ on_BT_AUTOFINISH_clicked               (GtkButton       *button,
 
 
 void
-on_GamazonsMain_destroy                (GtkObject       *object,
+on_GamazonsMain_destroy                (GObject         *object,
                                         gpointer         user_data)
 {
 
@@ -336,299 +321,254 @@ on_GamazonsMain_destroy                (GtkObject       *object,
 
 }
 
-
 /*==============================================================================
- * board_press_cb
+ * board_button_press_cb
  *
- * This is the main board handling routine.  Determines what the user is clicking
- * on and what a click means.  
+ * Handle button press on the game board. This initiates queen movement
+ * or fires an arrow depending on the game state.
  */
-int board_press_cb (GnomeCanvasItem *item, GdkEvent *event, gpointer data)
+gboolean board_button_press_cb (GtkWidget *widget, GdkEventButton *event, gpointer data)
 {
-   double drop_x, drop_y;
-   double new_x, new_y;
-   int from_row, from_col, to_row, to_col;
-//   int from;
-   int k;
-   static Square to;
-   static Square from;
+   int from_row, from_col;
+   Square from;
+   gboolean is_white;
+   int queen_index;
 
    if (bstate_get_moving_piece())
-     {
-      //printf("Can't do that while a piece is moving\n");
-      return 0;
-     }
+      return FALSE;
    if (bstate_get_open_dialog())
-     {
-      //printf("Can't do that while another window is open\n");
-      return 0;
-     }
+      return FALSE;
    if (bstate_get_what_next() == NEW_GAME)
-     {
-      //printf("Can't do that while I'm expecting a new game to start\n");
-      return 0;
-     }
+      return FALSE;
    if (bstate_get_replay_mode())
-      return 0;
+      return FALSE;
 
-   switch (event->type) {
-       case GDK_BUTTON_PRESS:
-	   if (event->button.button != 1)
-	      break;	
+   /* Handle arrow firing */
+   if (event->button == 1 && bstate_get_what_next() == FIRE_ARROW) {
+      int sq, row, col;
+      double x_coord, y_coord;
+      state *s;
 
-#ifdef DEBUG
-	   printf("what_next = %d\n", bstate_get_what_next());
-#endif
-	   //Set where a piece is coming from
-	   board->orig_x = board->curr_x = event->button.x;
-	   board->orig_y = board->curr_y = event->button.y;
-	   from = get_square (board->curr_x, board->curr_y);
-	   from_col = get_x_int_from_square(from);
-	   from_row = get_y_int_from_square(from);
+      x_coord = event->x;
+      y_coord = event->y;
 
-#ifdef DEBUG
-	   print_board();
-#endif
+      sq = get_square(x_coord, y_coord);
+      if (!is_move_legal(sq))
+         return TRUE;
+
+      col = get_x_int_from_square(sq);
+      row = get_y_int_from_square(sq);
 
-	   //Make sure it's time to move a queen before letting the user do it,
-	   //as well as make sure he's moving his own queen.  Also make sure it's
-   	   //a human's turn!
-#ifdef DEBUG
-	   printf("checking row %d, col %d\n", from_row, from_col);
-	   square_contains(from);
-	   printf("board->squares = %d\n",board->squares[from_row][from_col]);
-#endif
-	   if ((board->squares[from_row][from_col] == WHITE && 
-		       bstate_get_what_next() == MOVE_WHITE_QUEEN && 
-		       options.white_player == HUMAN) ||
-	       (board->squares[from_row][from_col] == BLACK && 
-			bstate_get_what_next() == MOVE_BLACK_QUEEN && 
-			options.black_player == HUMAN))
-	     {
-	      //Human is moving a queen
-#ifdef DEBUG
-	      printf("board->squares = %d, what_next = %d\n", board->squares[from_row][from_col], bstate_get_what_next());
-#endif
-	      grabbed_queen = TRUE;
-	      gen_legal_moves(from);
-#ifdef DEBUG
-	      printf("grabbing queen\n");
-#endif
-	      gnome_canvas_item_raise_to_top (item);
-	      gnome_canvas_item_grab (item,
-		      GDK_POINTER_MOTION_MASK | 
-		      GDK_BUTTON_RELEASE_MASK,
-		      NULL,
-		      event->button.time);
-
-	      board->selected_queen = item;
-	     }
-	   from = get_square (board->curr_x, board->curr_y);
-	   to = from;
-#ifdef DEBUG
-	   printf("GDK_BUTTON_PRESS: to = %d  from = %d\n", to, from);
-#endif
-	   break;
-
-       case GDK_MOTION_NOTIFY:
-	   if (event && (event->motion.state & GDK_BUTTON1_MASK)) 
-	     {
-	      if (!grabbed_queen)
-		 break;
-	      new_x = event->motion.x;
-	      new_y = event->motion.y;
-	      gnome_canvas_item_raise_to_top (item);
-	      gnome_canvas_item_move (item, 
-		      new_x - board->curr_x,
-		      new_y - board->curr_y);
-
-
-	      board->curr_x = new_x;
-	      board->curr_y = new_y;
-	     }
-	   break;
-
-       case GDK_BUTTON_RELEASE:
-	   if (event->button.button != 1)
-	      break;
 #ifdef DEBUG
-	   printf("what_next = %d\n", bstate_get_what_next());
+      printf("arrow fire: square %d\n", sq);
 #endif
-	   if (grabbed_queen == FALSE)
-	      break;
-	   else
-	      grabbed_queen = FALSE;
+      if (board->squares[row][col] != NOTHING)
+         return TRUE;
 
-	   if (item != NULL)
-	      gnome_canvas_item_ungrab (item, event->button.time);
+      fire_arrow(sq);
+      s = states.s[states.current_state];
+      register_move_with_engine(sq);
 
+      bstate_set_just_finished(FIRE_ARROW);
 
-#ifdef DEBUG
-	   printf("GDK_BUTTON_RELEASE: to = %d  from = %d\n", to, from);
-#endif
-	   drop_x = event->button.x;
-	   drop_y = event->button.y;
+      if (game_over())
+         return TRUE;
 
-	   //something funny here?
-	   if (is_queen_square(get_square (drop_x, drop_y)))
-	     {
-	      move_piece_to (to, item);
-	      break;
-	     }
+      dup_state(s, states.s[++(states.current_state)]);
+      if (bstate_get_what_next() == WAIT_FOR_AI)
+         move_ai();
+      
+      return TRUE;
+   }
 
+   /* Handle queen movement */
+   if (event->button == 1 && !grabbed_queen)
+     {
 #ifdef DEBUG
-	   printf("Queen is dropped at coords %f, %f\n", drop_x, drop_y);
+      printf("what_next = %d\n", bstate_get_what_next());
 #endif
-	   to = get_square (drop_x, drop_y);
+      //Set where a piece is coming from
+      board->orig_x = board->curr_x = event->x;
+      board->orig_y = board->curr_y = event->y;
+      from = get_square (board->curr_x, board->curr_y);
+      from_col = get_x_int_from_square(from);
+      from_row = get_y_int_from_square(from);
+
 #ifdef DEBUG
-	   printf("new square is %d\n", to);
+      print_board();
 #endif
-	
-	   /* Register the queen move with the board */
-	   from_col = get_x_int_from_square(from);
-	   from_row = get_y_int_from_square(from);
 
-	   to_col = get_x_int_from_square(to);
-	   to_row = get_y_int_from_square(to);
+      //Make sure it's time to move a queen before letting the user do it,
+      //as well as make sure he's moving his own queen.  Also make sure it's
+      //a human's turn!
 #ifdef DEBUG
-	   printf("setting square %d%d to hold %d\n", to_row, to_col, board->squares[from_row][from_col]);
+      printf("checking row %d, col %d\n", from_row, from_col);
+      square_contains(from);
+      printf("board->squares = %d\n",board->squares[from_row][from_col]);
 #endif
-
-	   //Queen is being moved to a different square
-	   if (to != from) 
-	     {
-	      //put the piece back if it's not a legal move
-	      if (!is_move_legal(to))
-		{
-		 //bstate_set_move_to(from);
-		 move_piece_to(from, item);
-		 break;
-		}
-	      else
-		{
-		 bstate_set_move_to(to);
-		 bstate_set_move_from(from);
-		 bstate_set_just_finished(MOVE_WHITE_QUEEN);
-
-		 board->squares[to_row][to_col] = board->squares[from_row][from_col];
-		 for (k=0; k<4; k++) //update square to queen mapping
-		   {
-		    if (board->square_to_wh_queen_map[k] == from_row*10 + from_col)
-		      {
-		       board->square_to_wh_queen_map[k] = to_row*10 + to_col;
-		       break;
-		      }
-		    if (board->square_to_bl_queen_map[k] == from_row*10 + from_col)
-		      {
-		       board->square_to_bl_queen_map[k] = to_row*10 + to_col;
-		       break;
-		      }
-		   }
-		 board->squares[from_row][from_col] = NOTHING;
-		 gen_legal_moves(to); //prepare moves for arrow
-		}
-	     }
-
+      if ((board->squares[from_row][from_col] == WHITE && 
+              bstate_get_what_next() == MOVE_WHITE_QUEEN && 
+              options.white_player == HUMAN) ||
+          (board->squares[from_row][from_col] == BLACK && 
+             bstate_get_what_next() == MOVE_BLACK_QUEEN && 
+             options.black_player == HUMAN))
+        {
+         //Human is moving a queen
 #ifdef DEBUG
-	   square_contains(to);
-	   square_contains(from);
+         printf("board->squares = %d, what_next = %d\n", board->squares[from_row][from_col], bstate_get_what_next());
 #endif
-
-
-	   move_piece_to(to, item);
+         grabbed_queen = TRUE;
+         gen_legal_moves(from);
+#ifdef DEBUG
+         printf("grabbing queen\n");
+#endif
+         /* Find which queen is being grabbed */
+         queen_index = find_queen_at_square(from, &is_white);
+         if (queen_index >= 0) {
+            board->selected_queen = queen_index;
+            board->selected_queen_is_white = is_white;
+            board->is_dragging = TRUE;
+            board->drag_x = event->x;
+            board->drag_y = event->y;
+         }
+        }
+      drag_from_square = from;
+      drag_to_square = from;
 #ifdef DEBUG
-	   printf("what_next = %d\n", bstate_get_what_next());
+      printf("GDK_BUTTON_PRESS: to = %d  from = %d\n", drag_to_square, drag_from_square);
 #endif
-	   break;
-       default:
-	   break;
+      redraw_board();
+      return TRUE;
    }
 
-   return 1;
+   return FALSE;
 }
 
 /*==============================================================================
- * arrow_fire_cb
+ * board_motion_notify_cb
  *
- * Determines the square the arrow is fired at and marks it as such.
- * Also checks that this is the appropriate time to fire an arrow and that the
- * given square is in the list of legal moves.
+ * Handle mouse motion on the game board during queen dragging.
  */
-int arrow_fire_cb(GnomeCanvasItem *item, GdkEvent *event, gpointer data)
+gboolean board_motion_notify_cb (GtkWidget *widget, GdkEventMotion *event, gpointer data)
 {
-   double x_coord, y_coord;
-   int sq;
-   int row, col;
-   state *s;
-   //GtkWidget *auto_button, *undo_button;
+  if (grabbed_queen && (event->state & GDK_BUTTON1_MASK))
+    {
+      board->drag_x = event->x;
+      board->drag_y = event->y;
+      redraw_board();
+      return TRUE;
+    }
+
+  return FALSE;
+}
 
-   if (bstate_get_moving_piece())
-      return 0;
-   if (bstate_get_open_dialog())
-      return 0;
-   if (bstate_get_what_next() == NEW_GAME)
-      return 0;
-   if (bstate_get_replay_mode())
-      return 0;
+/*==============================================================================
+ * board_button_release_cb
+ *
+ * Handle button release on the game board to complete queen movement.
+ */
+gboolean board_button_release_cb (GtkWidget *widget, GdkEventButton *event, gpointer data)
+{
+  double drop_x, drop_y;
+  int from_row, from_col, to_row, to_col;
+  int k;
+  Square to, from;
 
-   count_queens();
-   switch (event->type) 
+#ifdef DEBUG
+  printf("what_next = %d\n", bstate_get_what_next());
+#endif
+
+  if (grabbed_queen)
      {
-       case GDK_BUTTON_PRESS:
-	   if (event->button.button != 1)
-	      break;	
-	   if (bstate_get_what_next() != FIRE_ARROW)
-	      break;
+       grabbed_queen = FALSE;
+       board->is_dragging = FALSE;
 
-	   x_coord = event->button.x-4;
-	   y_coord = event->button.y-4;
+#ifdef DEBUG
+       printf("GDK_BUTTON_RELEASE: to = %d  from = %d\n", drag_to_square, drag_from_square);
+#endif
+       drop_x = event->x;
+       drop_y = event->y;
 
-	   sq = get_square(x_coord, y_coord);
-	   if (!is_move_legal(sq))
-	      break;
+       from = drag_from_square;
+       to = get_square(drop_x, drop_y);
 
-	   /* Make sure the square is empty first */
-	   col = get_x_int_from_square(sq);
-	   row = get_y_int_from_square(sq);
+       //something funny here?
+       if (is_queen_square(to) && to == from)
+	 {
+          /* Dropped on same square */
+          redraw_board();
+          return TRUE;
+	 }
 
 #ifdef DEBUG
-	   printf("what_next = %d\n", bstate_get_what_next());
-	   printf("arrow fire:  ");
-	   square_contains(sq);
+       printf("Queen is dropped at coords %f, %f\n", drop_x, drop_y);
+       printf("new square is %d\n", to);
 #endif
-	   if (board->squares[row][col] != NOTHING)
-	      break;
+	
+       from_col = get_x_int_from_square(from);
+       from_row = get_y_int_from_square(from);
 
-	   fire_arrow(sq);
-	   s = states.s[states.current_state];
-	   register_move_with_engine(sq);
+       to_col = get_x_int_from_square(to);
+       to_row = get_y_int_from_square(to);
+#ifdef DEBUG
+       printf("setting square %d%d to hold %d\n", to_row, to_col, board->squares[from_row][from_col]);
+#endif
 
-	   bstate_set_just_finished(FIRE_ARROW);
+       //Queen is being moved to a different square
+       if (to != from) 
+	 {
+	  //put the piece back if it's not a legal move
+	  if (!is_move_legal(to))
+	    {
+             redraw_board();
+             return TRUE;
+	    }
+	  else
+	    {
+	     bstate_set_move_to(to);
+	     bstate_set_move_from(from);
+	     bstate_set_just_finished(MOVE_WHITE_QUEEN);
+
+	     board->squares[to_row][to_col] = board->squares[from_row][from_col];
+	     for (k=0; k<4; k++) //update square to queen mapping
+	       {
+	        if (board->square_to_wh_queen_map[k] == from_row*10 + from_col)
+		  {
+		   board->square_to_wh_queen_map[k] = to_row*10 + to_col;
+		   break;
+		  }
+	        if (board->square_to_bl_queen_map[k] == from_row*10 + from_col)
+		  {
+		   board->square_to_bl_queen_map[k] = to_row*10 + to_col;
+		   break;
+		  }
+	       }
+	     board->squares[from_row][from_col] = NOTHING;
+	     gen_legal_moves(to); //prepare moves for arrow
+	    }
+	 }
 
-	   
-	   //check for gameover
-	   if (game_over())
-	      break;
+#ifdef DEBUG
+       square_contains(to);
+       square_contains(from);
+#endif
 
-	   dup_state(s, states.s[++(states.current_state)]);
-	   if (bstate_get_what_next() == WAIT_FOR_AI)
-	      move_ai();
-       default:
-	   break;
+       redraw_board();
+#ifdef DEBUG
+       printf("what_next = %d\n", bstate_get_what_next());
+#endif
+       return TRUE;
      }
 
-   return 0;
-
+   return FALSE;
 }
 
+
 /*==============================================================================
  * on_PlayerOKButton_clicked
  *
  * This processes the information from the Player settings window.  If a change
- * is made, sometimes the state of the game must reflect this change.  For 
- * instance, if it was a humans turn, and this player was set to AI, the game
- * state must stop waiting for the human to move and must instead instruct the
- * AI to start thinking.
+ * is made, sometimes the state of the game must reflect this change.
  */
 void
 on_PlayerOKButton_clicked              (GtkButton       *button,
@@ -695,56 +635,61 @@ void
 on_theme1_activate                     (GtkMenuItem     *menuitem,
                                         gpointer         user_data)
 {
+  GtkFileChooser *chooser;
+  GtkFileFilter *filter;
+  gint response;
 
    if (bstate_get_open_dialog())
       return;
    bstate_set_open_dialog(TRUE);
-   file_selector = gtk_file_selection_new ("Pick your theme file.");
-   
-   gtk_file_selection_set_filename (GTK_FILE_SELECTION (file_selector), PACKAGE_DATA_DIR "/gamazons/");
-   gtk_file_selection_complete (GTK_FILE_SELECTION (file_selector), "*.theme");
-   g_signal_connect (GTK_OBJECT (GTK_FILE_SELECTION (file_selector)->ok_button),
-                     "clicked",
-                     G_CALLBACK (load_new_theme),
-                     NULL);
-   g_signal_connect (GTK_OBJECT (GTK_FILE_SELECTION (file_selector)->cancel_button),
-                     "clicked",
-                     G_CALLBACK (on_ThemeCancelButton_clicked),
-                     NULL);
-   			   
-   /* Ensure that the dialog box is destroyed when the user clicks a button. */
-   
-   g_signal_connect_swapped (GTK_OBJECT (GTK_FILE_SELECTION (file_selector)->ok_button),
-                             "clicked",
-                             G_CALLBACK (gtk_widget_destroy), 
-                             (gpointer) file_selector); 
-
-   g_signal_connect_swapped (GTK_OBJECT (GTK_FILE_SELECTION (file_selector)->cancel_button),
-                             "clicked",
-                             G_CALLBACK (gtk_widget_destroy),
-                             (gpointer) file_selector); 
-   
-   /* Display that dialog */
-   
-   gtk_widget_show (file_selector);
 
+   file_selector = gtk_file_chooser_dialog_new (_("Pick your theme file"),
+                                                GTK_WINDOW (main_window),
+                                                GTK_FILE_CHOOSER_ACTION_OPEN,
+                                                _("_Cancel"),
+                                                GTK_RESPONSE_CANCEL,
+                                                _("_OK"),
+                                                GTK_RESPONSE_ACCEPT,
+                                                NULL);
+
+   chooser = GTK_FILE_CHOOSER (file_selector);
+   gtk_file_chooser_set_current_folder (chooser, PACKAGE_DATA_DIR "/gamazons");
+
+   filter = gtk_file_filter_new ();
+   gtk_file_filter_set_name (filter, _("Gamazons themes"));
+   gtk_file_filter_add_pattern (filter, "*.theme");
+   gtk_file_chooser_add_filter (chooser, filter);
+
+   response = gtk_dialog_run (GTK_DIALOG (file_selector));
+   if (response == GTK_RESPONSE_ACCEPT)
+     {
+       gchar *filename;
 
+       filename = gtk_file_chooser_get_filename (chooser);
+       load_new_theme (filename);
+       g_free (filename);
+     }
+   else
+     on_ThemeCancelButton_clicked ();
+
+   gtk_widget_destroy (file_selector);
 }
 
-void load_new_theme (GtkFileSelection *selector, gpointer user_data)
+void load_new_theme (gchar *filename)
 {
    if (bstate_get_moving_piece())
      {
-      gnome_warning_dialog("Warning: Theme can't be updated while a game piece is moving.  Please try again.");
+      run_dialog(GTK_MESSAGE_WARNING,
+                 _("Warning: Theme can't be updated while a game piece is "
+                   "moving.  Please try again."));
       bstate_set_open_dialog(FALSE);
       return;
      }
 
-   selected_filename = (gchar *) gtk_file_selection_get_filename (GTK_FILE_SELECTION (file_selector));
    load_values_from_file(); //Get current settings
-   if (!load_images_from_theme (selected_filename)) //load new theme settings
+   if (!load_images_from_theme (filename)) //load new theme settings
      {
-      gnome_error_dialog("Theme file doesn't exist!\n");
+      run_dialog(GTK_MESSAGE_ERROR, _("Theme file doesn't exist!"));
       bstate_set_open_dialog(FALSE);
       return;
      }
@@ -755,7 +700,7 @@ void load_new_theme (GtkFileSelection *selector, gpointer user_data)
    
 }
 
-void on_ThemeCancelButton_clicked(GtkButton *button, gpointer user_data)
+void on_ThemeCancelButton_clicked(void)
 {
    bstate_set_open_dialog(FALSE);
 
@@ -765,44 +710,41 @@ void
 on_save_as1_activate                   (GtkMenuItem     *menuitem,
                                         gpointer         user_data)
 {
-   //char home[256];
+  GtkFileChooser *chooser;
+  gint response;
 
    if (bstate_get_open_dialog())
       return;
    bstate_set_open_dialog(TRUE);
 
-   file_selector = gtk_file_selection_new ("Save your move history to a file");
-
-   gtk_file_selection_set_filename (GTK_FILE_SELECTION (file_selector), options.hist_dir);
-   g_signal_connect (GTK_OBJECT (GTK_FILE_SELECTION (file_selector)->ok_button),
-                     "clicked",
-                     G_CALLBACK (save_game_history),
-                     NULL);
-   g_signal_connect (GTK_OBJECT (GTK_FILE_SELECTION (file_selector)->cancel_button),
-                     "clicked",
-                     G_CALLBACK (on_save_as1CancelButton_clicked),
-                     NULL);
-   			   
-   /* Ensure that the dialog box is destroyed when the user clicks a button. */
-   
-   g_signal_connect_swapped (GTK_OBJECT (GTK_FILE_SELECTION (file_selector)->ok_button),
-                             "clicked",
-                             G_CALLBACK (gtk_widget_destroy), 
-                             (gpointer) file_selector); 
-
-   g_signal_connect_swapped (GTK_OBJECT (GTK_FILE_SELECTION (file_selector)->cancel_button),
-                             "clicked",
-                             G_CALLBACK (gtk_widget_destroy),
-                             (gpointer) file_selector); 
-   
-   /* Display that dialog */
-   
-   gtk_widget_show (file_selector);
+   file_selector = gtk_file_chooser_dialog_new (_("Save your move history to a file"),
+                                                GTK_WINDOW (main_window),
+                                                GTK_FILE_CHOOSER_ACTION_SAVE,
+                                                _("_Cancel"),
+                                                GTK_RESPONSE_CANCEL,
+                                                _("_OK"),
+                                                GTK_RESPONSE_ACCEPT,
+                                                NULL);
 
+   chooser = GTK_FILE_CHOOSER (file_selector);
+   gtk_file_chooser_set_do_overwrite_confirmation (chooser, TRUE);
 
+   response = gtk_dialog_run (GTK_DIALOG (file_selector));
+   if (response == GTK_RESPONSE_ACCEPT)
+     {
+       gchar *filename;
+
+       filename = gtk_file_chooser_get_filename (chooser);
+       save_game_history (filename);
+       g_free (filename);
+     }
+   else
+     on_save_as1CancelButton_clicked ();
+
+   gtk_widget_destroy (file_selector);
 }
 
-void save_game_history(GtkFileSelection *selector, gpointer user_data)
+void save_game_history(gchar *filename)
 {
    FILE *history_fd;
    GtkTextView *view; 
@@ -812,7 +754,7 @@ void save_game_history(GtkFileSelection *selector, gpointer user_data)
    gchar *text;
    char *temp_dir;
 
-   selected_filename = (gchar *)gtk_file_selection_get_filename (GTK_FILE_SELECTION (file_selector));
+   selected_filename = filename;
    if (strcmp(options.hist_dir, selected_filename) == 0)
      {
       bstate_set_open_dialog(FALSE);
@@ -837,7 +779,7 @@ void save_game_history(GtkFileSelection *selector, gpointer user_data)
 
    if (history_fd == NULL)
      {
-      gnome_error_dialog("Unable to save move history");
+      run_dialog(GTK_MESSAGE_ERROR, "Unable to save move history");
       bstate_set_open_dialog(FALSE);
       return;
      }
@@ -847,7 +789,7 @@ void save_game_history(GtkFileSelection *selector, gpointer user_data)
    bstate_set_open_dialog(FALSE);
 }
 
-void on_save_as1CancelButton_clicked(GtkButton *button, gpointer user_data)
+void on_save_as1CancelButton_clicked(void)
 {
    bstate_set_open_dialog(FALSE);
 }
@@ -857,50 +799,48 @@ void
 on_open_activate                       (GtkMenuItem     *menuitem,
                                         gpointer         user_data)
 {
-   //char home[256];
+  GtkFileChooser *chooser;
+  gint response;
 
    if (bstate_get_open_dialog())
       return;
    bstate_set_open_dialog(TRUE);
 
-   file_selector = gtk_file_selection_new ("Load saved Gamazons history file you wish to continue");
-
-   gtk_file_selection_set_filename (GTK_FILE_SELECTION (file_selector), options.hist_dir);
-   g_signal_connect (GTK_OBJECT (GTK_FILE_SELECTION (file_selector)->ok_button),
-                     "clicked",
-                     G_CALLBACK (load_saved_game),
-                     NULL);
-   g_signal_connect (GTK_OBJECT (GTK_FILE_SELECTION (file_selector)->cancel_button),
-                     "clicked",
-                     G_CALLBACK (on_OpenCancelButton_clicked),
-                     NULL);
-   			   
-   /* Ensure that the dialog box is destroyed when the user clicks a button. */
-   
-   g_signal_connect_swapped (GTK_OBJECT (GTK_FILE_SELECTION (file_selector)->ok_button),
-                             "clicked",
-                             G_CALLBACK (gtk_widget_destroy), 
-                             (gpointer) file_selector); 
-
-   g_signal_connect_swapped (GTK_OBJECT (GTK_FILE_SELECTION (file_selector)->cancel_button),
-                             "clicked",
-                             G_CALLBACK (gtk_widget_destroy),
-                             (gpointer) file_selector); 
-   
-   /* Display that dialog */
-   
-   gtk_widget_show (file_selector);
+   file_selector = gtk_file_chooser_dialog_new (_("Load saved Gamazons history file you wish to continue"),
+                                                GTK_WINDOW (main_window),
+                                                GTK_FILE_CHOOSER_ACTION_OPEN,
+                                                _("_Cancel"),
+                                                GTK_RESPONSE_CANCEL,
+                                                _("_OK"),
+                                                GTK_RESPONSE_ACCEPT,
+                                                NULL);
 
+   chooser = GTK_FILE_CHOOSER (file_selector);
+   gtk_file_chooser_set_current_folder (chooser, options.hist_dir);
 
+   response = gtk_dialog_run (GTK_DIALOG (file_selector));
+   if (response == GTK_RESPONSE_ACCEPT)
+     {
+       gchar *filename;
+
+       filename = gtk_file_chooser_get_filename (chooser);
+       load_saved_game (filename);
+       g_free (filename);
+     }
+   else
+     {
+      on_OpenCancelButton_clicked ();
+      gtk_widget_destroy (file_selector);
+     }
 }
 
-void load_saved_game(GtkFileSelection *selector, gpointer user_data)
+void load_saved_game(gchar *filename)
 {
 
    FILE *history_fd;
    char *temp_dir;
 
-   selected_filename = (gchar *)gtk_file_selection_get_filename (GTK_FILE_SELECTION (file_selector));
+   selected_filename = filename;
    if (strcmp(options.hist_dir, selected_filename) == 0)
      {
       bstate_set_open_dialog(FALSE);
@@ -918,7 +858,7 @@ void load_saved_game(GtkFileSelection *selector, gpointer user_data)
    history_fd = fopen(selected_filename, "ro");
    if (history_fd == NULL)
      {
-      gnome_error_dialog("Error opening history file\n");
+      run_dialog(GTK_MESSAGE_ERROR, "Error opening history file\n");
       bstate_set_open_dialog(FALSE);
       return;
      }
@@ -934,10 +874,9 @@ void load_saved_game(GtkFileSelection *selector, gpointer user_data)
    if (read_in_moves(history_fd))
       bstate_set_just_finished(LOAD_GAME);
    else
-      gnome_error_dialog("Error: Corrupted history file\n");
+      run_dialog(GTK_MESSAGE_ERROR, "Error: Corrupted history file");
       
 
-   //printf("finished loading history file\n");
    fclose(history_fd);
 
    if (bstate_get_what_next() == NEW_GAME) //game over
@@ -947,7 +886,7 @@ void load_saved_game(GtkFileSelection *selector, gpointer user_data)
 
 }
 
-void on_OpenCancelButton_clicked(GtkButton *button, gpointer user_data)
+void on_OpenCancelButton_clicked(void)
 {
    bstate_set_open_dialog(FALSE);
 }
@@ -956,51 +895,48 @@ void
 on_BT_REPLAY_clicked                   (GtkButton       *button,
                                         gpointer         user_data)
 {
-   //char home[256];
+  GtkFileChooser *chooser;
+  gint response;
 
    if (bstate_get_open_dialog())
       return;
    bstate_set_open_dialog(TRUE);
 
-   file_selector = gtk_file_selection_new ("Load saved Gamazons history file you wish to replay");
-
-   gtk_file_selection_set_filename (GTK_FILE_SELECTION (file_selector), options.hist_dir);
-   g_signal_connect (GTK_OBJECT (GTK_FILE_SELECTION (file_selector)->ok_button),
-                     "clicked",
-                     G_CALLBACK (replay_saved_game),
-                     NULL);
-   g_signal_connect (GTK_OBJECT (GTK_FILE_SELECTION (file_selector)->cancel_button),
-                     "clicked",
-                     G_CALLBACK (on_OpenCancelButton_clicked),
-                     NULL);
-   			   
-   /* Ensure that the dialog box is destroyed when the user clicks a button. */
-   
-   g_signal_connect_swapped (GTK_OBJECT (GTK_FILE_SELECTION (file_selector)->ok_button),
-                             "clicked",
-                             G_CALLBACK (gtk_widget_destroy), 
-                             (gpointer) file_selector); 
-
-   g_signal_connect_swapped (GTK_OBJECT (GTK_FILE_SELECTION (file_selector)->cancel_button),
-                             "clicked",
-                             G_CALLBACK (gtk_widget_destroy),
-                             (gpointer) file_selector); 
-   
-   /* Display that dialog */
-   
-   gtk_widget_show (file_selector);
+   file_selector = gtk_file_chooser_dialog_new (_("Load saved Gamazons history file you wish to replay"),
+                                                GTK_WINDOW (main_window),
+                                                GTK_FILE_CHOOSER_ACTION_OPEN,
+                                                _("_Cancel"),
+                                                GTK_RESPONSE_CANCEL,
+                                                _("_OK"),
+                                                GTK_RESPONSE_ACCEPT,
+                                                NULL);
 
+   chooser = GTK_FILE_CHOOSER (file_selector);
+   gtk_file_chooser_set_current_folder (chooser, options.hist_dir);
 
+   response = gtk_dialog_run (GTK_DIALOG (file_selector));
+   if (response == GTK_RESPONSE_ACCEPT)
+     {
+       gchar *filename;
+       filename = gtk_file_chooser_get_filename (chooser);
+       replay_saved_game (filename);
+       g_free (filename);
+     }
+   else
+     {
+      on_OpenCancelButton_clicked ();
+      gtk_widget_destroy (file_selector);
+     }
 }
 
-void replay_saved_game(GtkFileSelection *selector, gpointer user_data)
+void replay_saved_game(gchar *filename)
 {
 
    FILE *history_fd;
    char *temp_dir;
    int game_life = bstate_get_game_life();
 
-   selected_filename = (gchar *)gtk_file_selection_get_filename (GTK_FILE_SELECTION (file_selector));
+   selected_filename = filename;
    if (strcmp(options.hist_dir, selected_filename) == 0)
      {
       bstate_set_open_dialog(FALSE);
@@ -1018,7 +954,7 @@ void replay_saved_game(GtkFileSelection *selector, gpointer user_data)
    history_fd = fopen(selected_filename, "ro");
    if (history_fd == NULL)
      {
-      gnome_error_dialog("Error opening history file\n");
+      run_dialog(GTK_MESSAGE_ERROR, "Error opening history file");
       bstate_set_open_dialog(FALSE);
       return;
      }
@@ -1031,24 +967,20 @@ void replay_saved_game(GtkFileSelection *selector, gpointer user_data)
    destroy_board();
    init_game_board(main_window);
 
-   //bstate_set_replay_mode(TRUE);
    if (read_in_moves(history_fd))
      {
      }
-   else if (bstate_get_replay_mode()) //if still in replay mode, there must have been an error.  Otherwise
-     {				      //the stop button was pressed and all is well.
-      gnome_error_dialog("Error: Corrupted history file\n");
+   else if (bstate_get_replay_mode())
+     {
+      run_dialog(GTK_MESSAGE_ERROR, "Error: Corrupted history file");
      }
    else if (game_life != bstate_get_game_life())
      {
       return;
      }
 
-   bstate_set_just_finished(STOP_REPLAY); //cleans up replay mode if successfully finished
-   //bstate_set_replay_mode(FALSE);
-      
+   bstate_set_just_finished(STOP_REPLAY);
 
-   //printf("finished loading history file\n");
    fclose(history_fd);
 
    if (bstate_get_what_next() == NEW_GAME) //game over
@@ -1063,8 +995,6 @@ void
 on_BT_REPLAY_STOP_clicked              (GtkButton       *button,
                                         gpointer         user_data)
 {
-   //bstate_set_replay_mode(FALSE);
    bstate_set_just_finished(STOP_REPLAY);
 
 }
-
diff --git a/src/callbacks.h b/src/callbacks.h
index e9d5844..69fa6c4 100644
--- a/src/callbacks.h
+++ b/src/callbacks.h
@@ -1,4 +1,4 @@
-#include <gnome.h>
+#include <gtk/gtk.h>
 
 
 void
@@ -50,13 +50,17 @@ on_BT_AUTOFINISH_clicked               (GtkButton       *button,
                                         gpointer         user_data);
 
 void
-on_GamazonsMain_destroy                (GtkObject       *object,
+on_GamazonsMain_destroy                (GObject         *object,
                                         gpointer         user_data);
 
-int
-board_press_cb (GnomeCanvasItem *item, GdkEvent *event, gpointer data);
+gboolean
+board_button_press_cb (GtkWidget *widget, GdkEventButton *event, gpointer data);
 
-int arrow_fire_cb(GnomeCanvasItem *item, GdkEvent *event, gpointer data);
+gboolean
+board_motion_notify_cb (GtkWidget *widget, GdkEventMotion *event, gpointer data);
+
+gboolean
+board_button_release_cb (GtkWidget *widget, GdkEventButton *event, gpointer data);
 
 void
 on_PlayerOKButton_clicked              (GtkButton       *button,
@@ -70,19 +74,7 @@ void
 on_theme1_activate                     (GtkMenuItem     *menuitem,
                                         gpointer         user_data);
 
-void
-on_BT_UNDO_clicked                     (GtkButton       *button,
-                                        gpointer         user_data);
-
-void
-on_BT_FORCEMOVE_clicked                (GtkButton       *button,
-                                        gpointer         user_data);
-
-void
-on_BT_AUTOFINISH_clicked               (GtkButton       *button,
-                                        gpointer         user_data);
-
-void on_ThemeCancelButton_clicked(GtkButton *button, gpointer user_data);
+void on_ThemeCancelButton_clicked(void);
 
 void
 on_save_as1_activate                   (GtkMenuItem     *menuitem,
@@ -100,5 +92,5 @@ void
 on_BT_REPLAY_STOP_clicked              (GtkButton       *button,
                                         gpointer         user_data);
 
-void replay_saved_game(GtkFileSelection *selector, gpointer user_data);
+void replay_saved_game(gchar *filename);
 
diff --git a/src/interface.c b/src/interface.c
index c3200a5..a7d4005 100644
--- a/src/interface.c
+++ b/src/interface.c
@@ -12,68 +12,19 @@
 #include <string.h>
 #include <stdio.h>
 
-#include <gnome.h>
+#include <gtk/gtk.h>
+#include <glib/gi18n.h>
 
 #include "callbacks.h"
 #include "interface.h"
 #include "support.h"
 
 #define GLADE_HOOKUP_OBJECT(component,widget,name) \
-  gtk_object_set_data_full (GTK_OBJECT (component), name, \
-    gtk_widget_ref (widget), (GtkDestroyNotify) gtk_widget_unref)
+  g_object_set_data_full (G_OBJECT (component), name, \
+    g_object_ref (widget), (GDestroyNotify) g_object_unref)
 
 #define GLADE_HOOKUP_OBJECT_NO_REF(component,widget,name) \
-  gtk_object_set_data (GTK_OBJECT (component), name, widget)
-
-static GnomeUIInfo file1_menu_uiinfo[] =
-{
-  GNOMEUIINFO_MENU_NEW_ITEM (N_("_New"), NULL, on_new1_activate, NULL),
-  GNOMEUIINFO_MENU_OPEN_ITEM (on_open_activate, NULL),
-  GNOMEUIINFO_MENU_SAVE_AS_ITEM (on_save_as1_activate, NULL),
-  GNOMEUIINFO_SEPARATOR,
-  GNOMEUIINFO_MENU_EXIT_ITEM (on_quit1_activate, NULL),
-  GNOMEUIINFO_END
-};
-
-static GnomeUIInfo Settings_menu_uiinfo[] =
-{
-  {
-    GNOME_APP_UI_ITEM, N_("_Player"),
-    NULL,
-    (gpointer) on_player1_activate, NULL, NULL,
-    GNOME_APP_PIXMAP_NONE, NULL,
-    0, (GdkModifierType) 0, NULL
-  },
-  {
-    GNOME_APP_UI_ITEM, N_("_Theme"),
-    NULL,
-    (gpointer) on_theme1_activate, NULL, NULL,
-    GNOME_APP_PIXMAP_NONE, NULL,
-    0, (GdkModifierType) 0, NULL
-  },
-  GNOMEUIINFO_END
-};
-
-static GnomeUIInfo help1_menu_uiinfo[] =
-{
-  {
-    GNOME_APP_UI_ITEM, N_("_How To Play"),
-    NULL,
-    (gpointer) on_how_to_play1_activate, NULL, NULL,
-    GNOME_APP_PIXMAP_STOCK, "gtk-help",
-    0, (GdkModifierType) 0, NULL
-  },
-  GNOMEUIINFO_MENU_ABOUT_ITEM (on_about1_activate, NULL),
-  GNOMEUIINFO_END
-};
-
-static GnomeUIInfo menubar1_uiinfo[] =
-{
-  GNOMEUIINFO_MENU_GAME_TREE (file1_menu_uiinfo),
-  GNOMEUIINFO_MENU_SETTINGS_TREE (Settings_menu_uiinfo),
-  GNOMEUIINFO_MENU_HELP_TREE (help1_menu_uiinfo),
-  GNOMEUIINFO_END
-};
+  g_object_set_data (G_OBJECT (component), name, widget)
 
 GtkWidget*
 create_GamazonsMain (void)
@@ -81,6 +32,21 @@ create_GamazonsMain (void)
   GtkWidget *GamazonsMain;
   GtkWidget *vbox1;
   GtkWidget *menubar1;
+  GtkWidget *filemenu;
+  GtkWidget *file1_menu;
+  GtkWidget *new_menu;
+  GtkWidget *open_menu;
+  GtkWidget *save_menu;
+  GtkWidget *separator1;
+  GtkWidget *quit_menu;
+  GtkWidget *settingsmenu;
+  GtkWidget *settings1_menu;
+  GtkWidget *player_menu;
+  GtkWidget *theme_menu;
+  GtkWidget *helpmenu;
+  GtkWidget *help1_menu;
+  GtkWidget *howtoplay_menu;
+  GtkWidget *about_menu;
   GtkWidget *scrolledwindow1;
   GtkWidget *viewport1;
   GtkWidget *hbox1;
@@ -155,32 +121,90 @@ create_GamazonsMain (void)
   GtkWidget *BT_REPLAY;
   GtkWidget *BT_REPLAY_STOP;
   GtkWidget *label50;
-  GtkObject *ReplayDelaySpinner_adj;
+  GtkAdjustment *ReplayDelaySpinner_adj;
   GtkWidget *ReplayDelaySpinner;
   GtkWidget *hseparator3;
   GtkWidget *vbox13;
   GtkWidget *label51;
-  GtkObject *MovementSpeedSpinner_adj;
+  GtkAdjustment *MovementSpeedSpinner_adj;
   GtkWidget *MovementSpeedSpinner;
   GtkWidget *scrolledwindow6;
   GtkWidget *textview1;
   GtkWidget *statusbar1;
 
   GamazonsMain = gtk_window_new (GTK_WINDOW_TOPLEVEL);
-  gtk_widget_set_usize (GamazonsMain, 770, 510);
+  gtk_widget_set_size_request (GamazonsMain, 770, 510);
   gtk_window_set_title (GTK_WINDOW (GamazonsMain), _("Gamazons"));
   gtk_window_set_resizable (GTK_WINDOW (GamazonsMain), FALSE);
   gtk_window_set_destroy_with_parent (GTK_WINDOW (GamazonsMain), TRUE);
 
-  vbox1 = gtk_vbox_new (FALSE, 0);
+  vbox1 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
   gtk_widget_show (vbox1);
   gtk_container_add (GTK_CONTAINER (GamazonsMain), vbox1);
 
   menubar1 = gtk_menu_bar_new ();
   gtk_widget_show (menubar1);
   gtk_box_pack_start (GTK_BOX (vbox1), menubar1, FALSE, FALSE, 0);
-  gnome_app_fill_menu (GTK_MENU_SHELL (menubar1), menubar1_uiinfo,
-                       NULL, FALSE, 0);
+
+  filemenu = gtk_menu_new ();
+  file1_menu = gtk_menu_item_new_with_mnemonic (_("_Game"));
+  gtk_menu_item_set_submenu (GTK_MENU_ITEM (file1_menu), filemenu);
+  gtk_menu_shell_append (GTK_MENU_SHELL (menubar1), file1_menu);
+
+  new_menu = gtk_menu_item_new_with_mnemonic (_("_New"));
+  gtk_menu_shell_append (GTK_MENU_SHELL (filemenu), new_menu);
+  g_signal_connect (new_menu, "activate",
+                    G_CALLBACK (on_new1_activate), NULL);
+
+  open_menu = gtk_menu_item_new_with_mnemonic (_("_Open..."));
+  gtk_menu_shell_append (GTK_MENU_SHELL (filemenu), open_menu);
+  g_signal_connect (open_menu, "activate",
+                    G_CALLBACK (on_open_activate), NULL);
+
+  save_menu = gtk_menu_item_new_with_mnemonic (_("_Save as..."));
+  gtk_menu_shell_append (GTK_MENU_SHELL (filemenu), save_menu);
+  g_signal_connect (save_menu, "activate",
+                    G_CALLBACK (on_save_as1_activate), NULL);
+
+  separator1 = gtk_separator_menu_item_new ();
+  gtk_menu_shell_append (GTK_MENU_SHELL (filemenu), separator1);
+
+  quit_menu = gtk_menu_item_new_with_mnemonic (_("_Quit"));
+  gtk_menu_shell_append (GTK_MENU_SHELL (filemenu), quit_menu);
+  g_signal_connect (quit_menu, "activate",
+                    G_CALLBACK (on_quit1_activate), NULL);
+
+  settingsmenu = gtk_menu_new ();
+  settings1_menu = gtk_menu_item_new_with_mnemonic (_("_Settings"));
+  gtk_menu_item_set_submenu (GTK_MENU_ITEM (settings1_menu), settingsmenu);
+  gtk_menu_shell_append (GTK_MENU_SHELL (menubar1), settings1_menu);
+
+  player_menu = gtk_menu_item_new_with_mnemonic (_("_Player"));
+  gtk_menu_shell_append (GTK_MENU_SHELL (settingsmenu), player_menu);
+  g_signal_connect (player_menu, "activate",
+                    G_CALLBACK (on_player1_activate), NULL);
+
+  theme_menu = gtk_menu_item_new_with_mnemonic (_("_Theme"));
+  gtk_menu_shell_append (GTK_MENU_SHELL (settingsmenu), theme_menu);
+  g_signal_connect (theme_menu, "activate",
+                    G_CALLBACK (on_theme1_activate), NULL);
+
+  helpmenu = gtk_menu_new ();
+  help1_menu = gtk_menu_item_new_with_mnemonic (_("_Help"));
+  gtk_menu_item_set_submenu (GTK_MENU_ITEM (help1_menu), helpmenu);
+  gtk_menu_shell_append (GTK_MENU_SHELL (menubar1), help1_menu);
+
+  howtoplay_menu = gtk_menu_item_new_with_mnemonic (_("_How To Play"));
+  gtk_menu_shell_append (GTK_MENU_SHELL (helpmenu), howtoplay_menu);
+  g_signal_connect (howtoplay_menu, "activate",
+                    G_CALLBACK (on_how_to_play1_activate), NULL);
+
+  about_menu = gtk_menu_item_new_with_mnemonic (_("_About"));
+  gtk_menu_shell_append (GTK_MENU_SHELL (helpmenu), about_menu);
+  g_signal_connect (about_menu, "activate",
+                    G_CALLBACK (on_about1_activate), NULL);
+
+  gtk_widget_show_all (menubar1);
 
   scrolledwindow1 = gtk_scrolled_window_new (NULL, NULL);
   gtk_widget_show (scrolledwindow1);
@@ -191,320 +215,312 @@ create_GamazonsMain (void)
   gtk_widget_show (viewport1);
   gtk_container_add (GTK_CONTAINER (scrolledwindow1), viewport1);
 
-  hbox1 = gtk_hbox_new (FALSE, 0);
+  hbox1 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
   gtk_widget_show (hbox1);
   gtk_container_add (GTK_CONTAINER (viewport1), hbox1);
 
   scrolledwindow2 = gtk_scrolled_window_new (NULL, NULL);
   gtk_widget_show (scrolledwindow2);
   gtk_box_pack_start (GTK_BOX (hbox1), scrolledwindow2, TRUE, TRUE, 0);
-  gtk_widget_set_usize (scrolledwindow2, 210, -2);
-  GTK_WIDGET_SET_FLAGS (scrolledwindow2, GTK_CAN_DEFAULT);
+  gtk_widget_set_size_request (scrolledwindow2, 210, -1);
+  gtk_widget_set_can_default (scrolledwindow2, TRUE);
   gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwindow2), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
 
   viewport2 = gtk_viewport_new (NULL, NULL);
   gtk_widget_show (viewport2);
   gtk_container_add (GTK_CONTAINER (scrolledwindow2), viewport2);
 
-  table1 = gtk_table_new (3, 3, FALSE);
+  table1 = gtk_grid_new ();
   gtk_widget_show (table1);
   gtk_container_add (GTK_CONTAINER (viewport2), table1);
 
-  hbox9 = gtk_hbox_new (FALSE, 0);
+  hbox9 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
   gtk_widget_show (hbox9);
-  gtk_table_attach (GTK_TABLE (table1), hbox9, 1, 2, 0, 1,
-                    (GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
-                    (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0);
+  gtk_grid_attach (GTK_GRID (table1), hbox9, 1, 0, 1, 1);
 
   label30 = gtk_label_new (_("a"));
   gtk_widget_show (label30);
   gtk_box_pack_start (GTK_BOX (hbox9), label30, FALSE, FALSE, 0);
-  gtk_widget_set_usize (label30, 40, 15);
+  gtk_widget_set_size_request (label30, 40, 15);
   gtk_label_set_justify (GTK_LABEL (label30), GTK_JUSTIFY_LEFT);
 
   label31 = gtk_label_new (_("b"));
   gtk_widget_show (label31);
   gtk_box_pack_start (GTK_BOX (hbox9), label31, FALSE, FALSE, 0);
-  gtk_widget_set_usize (label31, 40, 15);
+  gtk_widget_set_size_request (label31, 40, 15);
   gtk_label_set_justify (GTK_LABEL (label31), GTK_JUSTIFY_LEFT);
 
   label32 = gtk_label_new (_("c"));
   gtk_widget_show (label32);
   gtk_box_pack_start (GTK_BOX (hbox9), label32, FALSE, FALSE, 0);
-  gtk_widget_set_usize (label32, 40, 15);
+  gtk_widget_set_size_request (label32, 40, 15);
   gtk_label_set_justify (GTK_LABEL (label32), GTK_JUSTIFY_LEFT);
 
   label33 = gtk_label_new (_("d"));
   gtk_widget_show (label33);
   gtk_box_pack_start (GTK_BOX (hbox9), label33, FALSE, FALSE, 0);
-  gtk_widget_set_usize (label33, 40, 15);
+  gtk_widget_set_size_request (label33, 40, 15);
   gtk_label_set_justify (GTK_LABEL (label33), GTK_JUSTIFY_LEFT);
 
   label34 = gtk_label_new (_("e"));
   gtk_widget_show (label34);
   gtk_box_pack_start (GTK_BOX (hbox9), label34, FALSE, FALSE, 0);
-  gtk_widget_set_usize (label34, 40, 15);
+  gtk_widget_set_size_request (label34, 40, 15);
   gtk_label_set_justify (GTK_LABEL (label34), GTK_JUSTIFY_LEFT);
 
   label35 = gtk_label_new (_("f"));
   gtk_widget_show (label35);
   gtk_box_pack_start (GTK_BOX (hbox9), label35, FALSE, FALSE, 0);
-  gtk_widget_set_usize (label35, 40, 15);
+  gtk_widget_set_size_request (label35, 40, 15);
   gtk_label_set_justify (GTK_LABEL (label35), GTK_JUSTIFY_LEFT);
 
   label36 = gtk_label_new (_("g"));
   gtk_widget_show (label36);
   gtk_box_pack_start (GTK_BOX (hbox9), label36, FALSE, FALSE, 0);
-  gtk_widget_set_usize (label36, 40, 15);
+  gtk_widget_set_size_request (label36, 40, 15);
   gtk_label_set_justify (GTK_LABEL (label36), GTK_JUSTIFY_LEFT);
 
   label37 = gtk_label_new (_("h"));
   gtk_widget_show (label37);
   gtk_box_pack_start (GTK_BOX (hbox9), label37, FALSE, FALSE, 0);
-  gtk_widget_set_usize (label37, 40, 15);
+  gtk_widget_set_size_request (label37, 40, 15);
   gtk_label_set_justify (GTK_LABEL (label37), GTK_JUSTIFY_LEFT);
 
   label38 = gtk_label_new (_("i"));
   gtk_widget_show (label38);
   gtk_box_pack_start (GTK_BOX (hbox9), label38, FALSE, FALSE, 0);
-  gtk_widget_set_usize (label38, 40, 15);
+  gtk_widget_set_size_request (label38, 40, 15);
   gtk_label_set_justify (GTK_LABEL (label38), GTK_JUSTIFY_LEFT);
 
   label39 = gtk_label_new (_("j"));
   gtk_widget_show (label39);
   gtk_box_pack_start (GTK_BOX (hbox9), label39, FALSE, FALSE, 0);
-  gtk_widget_set_usize (label39, 40, 15);
+  gtk_widget_set_size_request (label39, 40, 15);
   gtk_label_set_justify (GTK_LABEL (label39), GTK_JUSTIFY_LEFT);
 
-  vbox7 = gtk_vbox_new (FALSE, 0);
+  vbox7 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
   gtk_widget_show (vbox7);
-  gtk_table_attach (GTK_TABLE (table1), vbox7, 0, 1, 1, 2,
-                    (GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
-                    (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0);
+  gtk_grid_attach (GTK_GRID (table1), vbox7, 0, 1, 1, 1);
 
   label29 = gtk_label_new (_("10"));
   gtk_widget_show (label29);
   gtk_box_pack_start (GTK_BOX (vbox7), label29, FALSE, FALSE, 0);
-  gtk_widget_set_usize (label29, 15, 40);
+  gtk_widget_set_size_request (label29, 15, 40);
   gtk_label_set_justify (GTK_LABEL (label29), GTK_JUSTIFY_LEFT);
 
   label28 = gtk_label_new (_("9"));
   gtk_widget_show (label28);
   gtk_box_pack_start (GTK_BOX (vbox7), label28, FALSE, FALSE, 0);
-  gtk_widget_set_usize (label28, 15, 40);
+  gtk_widget_set_size_request (label28, 15, 40);
   gtk_label_set_justify (GTK_LABEL (label28), GTK_JUSTIFY_LEFT);
 
   label27 = gtk_label_new (_("8"));
   gtk_widget_show (label27);
   gtk_box_pack_start (GTK_BOX (vbox7), label27, FALSE, FALSE, 0);
-  gtk_widget_set_usize (label27, 15, 40);
+  gtk_widget_set_size_request (label27, 15, 40);
   gtk_label_set_justify (GTK_LABEL (label27), GTK_JUSTIFY_LEFT);
 
   label26 = gtk_label_new (_("7"));
   gtk_widget_show (label26);
   gtk_box_pack_start (GTK_BOX (vbox7), label26, FALSE, FALSE, 0);
-  gtk_widget_set_usize (label26, 15, 40);
+  gtk_widget_set_size_request (label26, 15, 40);
   gtk_label_set_justify (GTK_LABEL (label26), GTK_JUSTIFY_LEFT);
 
   label25 = gtk_label_new (_("6"));
   gtk_widget_show (label25);
   gtk_box_pack_start (GTK_BOX (vbox7), label25, FALSE, FALSE, 0);
-  gtk_widget_set_usize (label25, 15, 40);
+  gtk_widget_set_size_request (label25, 15, 40);
   gtk_label_set_justify (GTK_LABEL (label25), GTK_JUSTIFY_LEFT);
 
   label24 = gtk_label_new (_("5"));
   gtk_widget_show (label24);
   gtk_box_pack_start (GTK_BOX (vbox7), label24, FALSE, FALSE, 0);
-  gtk_widget_set_usize (label24, 15, 40);
+  gtk_widget_set_size_request (label24, 15, 40);
   gtk_label_set_justify (GTK_LABEL (label24), GTK_JUSTIFY_LEFT);
 
   label23 = gtk_label_new (_("4"));
   gtk_widget_show (label23);
   gtk_box_pack_start (GTK_BOX (vbox7), label23, FALSE, FALSE, 0);
-  gtk_widget_set_usize (label23, 15, 40);
+  gtk_widget_set_size_request (label23, 15, 40);
   gtk_label_set_justify (GTK_LABEL (label23), GTK_JUSTIFY_LEFT);
 
   label22 = gtk_label_new (_("3"));
   gtk_widget_show (label22);
   gtk_box_pack_start (GTK_BOX (vbox7), label22, FALSE, FALSE, 0);
-  gtk_widget_set_usize (label22, 15, 40);
+  gtk_widget_set_size_request (label22, 15, 40);
   gtk_label_set_justify (GTK_LABEL (label22), GTK_JUSTIFY_LEFT);
 
   label21 = gtk_label_new (_("2"));
   gtk_widget_show (label21);
   gtk_box_pack_start (GTK_BOX (vbox7), label21, FALSE, FALSE, 0);
-  gtk_widget_set_usize (label21, 15, 40);
+  gtk_widget_set_size_request (label21, 15, 40);
   gtk_label_set_justify (GTK_LABEL (label21), GTK_JUSTIFY_LEFT);
 
   label20 = gtk_label_new (_("1"));
   gtk_widget_show (label20);
   gtk_box_pack_start (GTK_BOX (vbox7), label20, FALSE, FALSE, 0);
-  gtk_widget_set_usize (label20, 15, 40);
+  gtk_widget_set_size_request (label20, 15, 40);
   gtk_label_set_justify (GTK_LABEL (label20), GTK_JUSTIFY_LEFT);
 
-  vbox8 = gtk_vbox_new (FALSE, 0);
+  vbox8 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
   gtk_widget_show (vbox8);
-  gtk_table_attach (GTK_TABLE (table1), vbox8, 2, 3, 1, 2,
-                    (GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
-                    (GtkAttachOptions) (GTK_FILL), 0, 0);
+  gtk_grid_attach (GTK_GRID (table1), vbox8, 2, 1, 1, 1);
 
   label40 = gtk_label_new (_("10"));
   gtk_widget_show (label40);
   gtk_box_pack_start (GTK_BOX (vbox8), label40, FALSE, FALSE, 0);
-  gtk_widget_set_usize (label40, 15, 40);
+  gtk_widget_set_size_request (label40, 15, 40);
   gtk_label_set_justify (GTK_LABEL (label40), GTK_JUSTIFY_LEFT);
 
   label41 = gtk_label_new (_("9"));
   gtk_widget_show (label41);
   gtk_box_pack_start (GTK_BOX (vbox8), label41, FALSE, FALSE, 0);
-  gtk_widget_set_usize (label41, 15, 40);
+  gtk_widget_set_size_request (label41, 15, 40);
   gtk_label_set_justify (GTK_LABEL (label41), GTK_JUSTIFY_LEFT);
 
   label42 = gtk_label_new (_("8"));
   gtk_widget_show (label42);
   gtk_box_pack_start (GTK_BOX (vbox8), label42, FALSE, FALSE, 0);
-  gtk_widget_set_usize (label42, 15, 40);
+  gtk_widget_set_size_request (label42, 15, 40);
   gtk_label_set_justify (GTK_LABEL (label42), GTK_JUSTIFY_LEFT);
 
   label43 = gtk_label_new (_("7"));
   gtk_widget_show (label43);
   gtk_box_pack_start (GTK_BOX (vbox8), label43, FALSE, FALSE, 0);
-  gtk_widget_set_usize (label43, 15, 40);
+  gtk_widget_set_size_request (label43, 15, 40);
   gtk_label_set_justify (GTK_LABEL (label43), GTK_JUSTIFY_LEFT);
 
   label44 = gtk_label_new (_("6"));
   gtk_widget_show (label44);
   gtk_box_pack_start (GTK_BOX (vbox8), label44, FALSE, FALSE, 0);
-  gtk_widget_set_usize (label44, 15, 40);
+  gtk_widget_set_size_request (label44, 15, 40);
   gtk_label_set_justify (GTK_LABEL (label44), GTK_JUSTIFY_LEFT);
 
   label45 = gtk_label_new (_("5"));
   gtk_widget_show (label45);
   gtk_box_pack_start (GTK_BOX (vbox8), label45, FALSE, FALSE, 0);
-  gtk_widget_set_usize (label45, 15, 40);
+  gtk_widget_set_size_request (label45, 15, 40);
   gtk_label_set_justify (GTK_LABEL (label45), GTK_JUSTIFY_LEFT);
 
   label46 = gtk_label_new (_("4"));
   gtk_widget_show (label46);
   gtk_box_pack_start (GTK_BOX (vbox8), label46, FALSE, FALSE, 0);
-  gtk_widget_set_usize (label46, 15, 40);
+  gtk_widget_set_size_request (label46, 15, 40);
   gtk_label_set_justify (GTK_LABEL (label46), GTK_JUSTIFY_LEFT);
 
   label47 = gtk_label_new (_("3"));
   gtk_widget_show (label47);
   gtk_box_pack_start (GTK_BOX (vbox8), label47, FALSE, FALSE, 0);
-  gtk_widget_set_usize (label47, 15, 40);
+  gtk_widget_set_size_request (label47, 15, 40);
   gtk_label_set_justify (GTK_LABEL (label47), GTK_JUSTIFY_LEFT);
 
   label48 = gtk_label_new (_("2"));
   gtk_widget_show (label48);
   gtk_box_pack_start (GTK_BOX (vbox8), label48, FALSE, FALSE, 0);
-  gtk_widget_set_usize (label48, 15, 40);
+  gtk_widget_set_size_request (label48, 15, 40);
   gtk_label_set_justify (GTK_LABEL (label48), GTK_JUSTIFY_LEFT);
 
   label49 = gtk_label_new (_("1"));
   gtk_widget_show (label49);
   gtk_box_pack_start (GTK_BOX (vbox8), label49, FALSE, FALSE, 0);
-  gtk_widget_set_usize (label49, 15, 40);
+  gtk_widget_set_size_request (label49, 15, 40);
   gtk_label_set_justify (GTK_LABEL (label49), GTK_JUSTIFY_LEFT);
 
-  hbox10 = gtk_hbox_new (FALSE, 0);
+  hbox10 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
   gtk_widget_show (hbox10);
-  gtk_table_attach (GTK_TABLE (table1), hbox10, 1, 2, 2, 3,
-                    (GtkAttachOptions) (GTK_FILL),
-                    (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0);
+  gtk_grid_attach (GTK_GRID (table1), hbox10, 1, 2, 1, 1);
 
   label10 = gtk_label_new (_("a"));
   gtk_widget_show (label10);
   gtk_box_pack_start (GTK_BOX (hbox10), label10, FALSE, FALSE, 0);
-  gtk_widget_set_usize (label10, 40, 15);
+  gtk_widget_set_size_request (label10, 40, 15);
   gtk_label_set_justify (GTK_LABEL (label10), GTK_JUSTIFY_LEFT);
 
   label11 = gtk_label_new (_("b"));
   gtk_widget_show (label11);
   gtk_box_pack_start (GTK_BOX (hbox10), label11, FALSE, FALSE, 0);
-  gtk_widget_set_usize (label11, 40, 15);
+  gtk_widget_set_size_request (label11, 40, 15);
   gtk_label_set_justify (GTK_LABEL (label11), GTK_JUSTIFY_LEFT);
 
   label12 = gtk_label_new (_("c"));
   gtk_widget_show (label12);
   gtk_box_pack_start (GTK_BOX (hbox10), label12, FALSE, FALSE, 0);
-  gtk_widget_set_usize (label12, 40, 15);
+  gtk_widget_set_size_request (label12, 40, 15);
   gtk_label_set_justify (GTK_LABEL (label12), GTK_JUSTIFY_LEFT);
 
   label13 = gtk_label_new (_("d"));
   gtk_widget_show (label13);
   gtk_box_pack_start (GTK_BOX (hbox10), label13, FALSE, FALSE, 0);
-  gtk_widget_set_usize (label13, 40, 15);
+  gtk_widget_set_size_request (label13, 40, 15);
   gtk_label_set_justify (GTK_LABEL (label13), GTK_JUSTIFY_LEFT);
 
   label14 = gtk_label_new (_("e"));
   gtk_widget_show (label14);
   gtk_box_pack_start (GTK_BOX (hbox10), label14, FALSE, FALSE, 0);
-  gtk_widget_set_usize (label14, 40, 15);
+  gtk_widget_set_size_request (label14, 40, 15);
   gtk_label_set_justify (GTK_LABEL (label14), GTK_JUSTIFY_LEFT);
 
   label15 = gtk_label_new (_("f"));
   gtk_widget_show (label15);
   gtk_box_pack_start (GTK_BOX (hbox10), label15, FALSE, FALSE, 0);
-  gtk_widget_set_usize (label15, 40, 15);
+  gtk_widget_set_size_request (label15, 40, 15);
   gtk_label_set_justify (GTK_LABEL (label15), GTK_JUSTIFY_LEFT);
 
   label16 = gtk_label_new (_("g"));
   gtk_widget_show (label16);
   gtk_box_pack_start (GTK_BOX (hbox10), label16, FALSE, FALSE, 0);
-  gtk_widget_set_usize (label16, 40, 15);
+  gtk_widget_set_size_request (label16, 40, 15);
   gtk_label_set_justify (GTK_LABEL (label16), GTK_JUSTIFY_LEFT);
 
   label17 = gtk_label_new (_("h"));
   gtk_widget_show (label17);
   gtk_box_pack_start (GTK_BOX (hbox10), label17, FALSE, FALSE, 0);
-  gtk_widget_set_usize (label17, 40, 15);
+  gtk_widget_set_size_request (label17, 40, 15);
   gtk_label_set_justify (GTK_LABEL (label17), GTK_JUSTIFY_LEFT);
 
   label18 = gtk_label_new (_("i"));
   gtk_widget_show (label18);
   gtk_box_pack_start (GTK_BOX (hbox10), label18, FALSE, FALSE, 0);
-  gtk_widget_set_usize (label18, 40, 15);
+  gtk_widget_set_size_request (label18, 40, 15);
   gtk_label_set_justify (GTK_LABEL (label18), GTK_JUSTIFY_LEFT);
 
   label19 = gtk_label_new (_("j"));
   gtk_widget_show (label19);
   gtk_box_pack_start (GTK_BOX (hbox10), label19, FALSE, FALSE, 0);
-  gtk_widget_set_usize (label19, 40, 15);
+  gtk_widget_set_size_request (label19, 40, 15);
   gtk_label_set_justify (GTK_LABEL (label19), GTK_JUSTIFY_LEFT);
 
   scrolledwindow4 = gtk_scrolled_window_new (NULL, NULL);
   gtk_widget_show (scrolledwindow4);
-  gtk_table_attach (GTK_TABLE (table1), scrolledwindow4, 1, 2, 1, 2,
-                    (GtkAttachOptions) (GTK_FILL),
-                    (GtkAttachOptions) (GTK_FILL), 0, 0);
+  gtk_grid_attach (GTK_GRID (table1), scrolledwindow4, 1, 1, 1, 1);
   gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwindow4), GTK_POLICY_NEVER, GTK_POLICY_NEVER);
 
-  CNVS_GAMEBOARD = gnome_canvas_new ();
+  CNVS_GAMEBOARD = gtk_drawing_area_new ();
   gtk_widget_show (CNVS_GAMEBOARD);
   gtk_container_add (GTK_CONTAINER (scrolledwindow4), CNVS_GAMEBOARD);
-  gtk_widget_set_usize (CNVS_GAMEBOARD, 400, 400);
-  gnome_canvas_set_scroll_region (GNOME_CANVAS (CNVS_GAMEBOARD), 0, 0, 100, 100);
+  /* For some reason, increasing the size with 1 is necessary after
+     the migration from GtkTable to GtkGrid.  */
+  gtk_widget_set_size_request (CNVS_GAMEBOARD, 401, 401);
 
-  vbox2 = gtk_vbox_new (FALSE, 0);
+  vbox2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
   gtk_widget_show (vbox2);
   gtk_box_pack_start (GTK_BOX (hbox1), vbox2, TRUE, TRUE, 0);
 
-  vbox3 = gtk_vbox_new (FALSE, 0);
+  vbox3 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
   gtk_widget_show (vbox3);
   gtk_box_pack_start (GTK_BOX (vbox2), vbox3, TRUE, TRUE, 0);
 
-  vbox4 = gtk_vbox_new (FALSE, 0);
+  vbox4 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
   gtk_widget_show (vbox4);
   gtk_box_pack_start (GTK_BOX (vbox3), vbox4, TRUE, TRUE, 0);
 
   label1 = gtk_label_new (_("Move History:"));
   gtk_widget_show (label1);
   gtk_box_pack_start (GTK_BOX (vbox4), label1, FALSE, FALSE, 0);
-  gtk_widget_set_usize (label1, 0, 40);
-  gtk_label_set_justify (GTK_LABEL (label1), GTK_JUSTIFY_RIGHT);
-  gtk_misc_set_alignment (GTK_MISC (label1), 0.55, 0.72);
+  gtk_widget_set_size_request (label1, 0, 40);
+  gtk_widget_set_halign (label1, GTK_ALIGN_END);
+  gtk_label_set_xalign (GTK_LABEL (label1), 0.55);
+  gtk_label_set_yalign (GTK_LABEL (label1), 0.72);
 
   scrolledwindow3 = gtk_scrolled_window_new (NULL, NULL);
   gtk_widget_show (scrolledwindow3);
@@ -516,7 +532,7 @@ create_GamazonsMain (void)
   gtk_container_add (GTK_CONTAINER (scrolledwindow3), viewport3);
   gtk_viewport_set_shadow_type (GTK_VIEWPORT (viewport3), GTK_SHADOW_NONE);
 
-  hbox11 = gtk_hbox_new (FALSE, 0);
+  hbox11 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
   gtk_widget_show (hbox11);
   gtk_container_add (GTK_CONTAINER (viewport3), hbox11);
 
@@ -528,83 +544,85 @@ create_GamazonsMain (void)
   viewport4 = gtk_viewport_new (NULL, NULL);
   gtk_widget_show (viewport4);
   gtk_container_add (GTK_CONTAINER (scrolledwindow5), viewport4);
-  gtk_widget_set_usize (viewport4, -2, 17);
+  gtk_widget_set_size_request (viewport4, -1, 17);
   gtk_viewport_set_shadow_type (GTK_VIEWPORT (viewport4), GTK_SHADOW_NONE);
 
-  vbox9 = gtk_vbox_new (FALSE, 0);
+  vbox9 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
   gtk_widget_show (vbox9);
   gtk_container_add (GTK_CONTAINER (viewport4), vbox9);
 
-  vbuttonbox1 = gtk_vbutton_box_new ();
+  vbuttonbox1 = gtk_button_box_new (GTK_ORIENTATION_VERTICAL);
   gtk_widget_show (vbuttonbox1);
   gtk_box_pack_start (GTK_BOX (vbox9), vbuttonbox1, FALSE, TRUE, 0);
-  gtk_widget_set_usize (vbuttonbox1, -2, 105);
-  gtk_button_box_set_spacing (GTK_BUTTON_BOX (vbuttonbox1), 0);
+  gtk_widget_set_size_request (vbuttonbox1, -1, 105);
+  gtk_box_set_spacing (GTK_BOX (vbuttonbox1), 0);
 
   BT_UNDO = gtk_button_new_with_mnemonic (_("Undo"));
   gtk_widget_show (BT_UNDO);
   gtk_container_add (GTK_CONTAINER (vbuttonbox1), BT_UNDO);
-  gtk_widget_set_usize (BT_UNDO, -2, 30);
-  GTK_WIDGET_SET_FLAGS (BT_UNDO, GTK_CAN_DEFAULT);
+  gtk_widget_set_size_request (BT_UNDO, -1, 30);
+  gtk_widget_set_can_default (BT_UNDO, TRUE);
 
   BT_FORCEMOVE = gtk_button_new_with_mnemonic (_("Force Move"));
   gtk_widget_show (BT_FORCEMOVE);
   gtk_container_add (GTK_CONTAINER (vbuttonbox1), BT_FORCEMOVE);
-  gtk_widget_set_usize (BT_FORCEMOVE, 106, 30);
-  GTK_WIDGET_SET_FLAGS (BT_FORCEMOVE, GTK_CAN_DEFAULT);
+  gtk_widget_set_size_request (BT_FORCEMOVE, 106, 30);
+  gtk_widget_set_can_default (BT_FORCEMOVE, TRUE);
 
   BT_AUTOFINISH = gtk_button_new_with_mnemonic (_("Autofinish"));
   gtk_widget_show (BT_AUTOFINISH);
   gtk_container_add (GTK_CONTAINER (vbuttonbox1), BT_AUTOFINISH);
-  gtk_widget_set_usize (BT_AUTOFINISH, -2, 30);
-  GTK_WIDGET_SET_FLAGS (BT_AUTOFINISH, GTK_CAN_DEFAULT);
+  gtk_widget_set_size_request (BT_AUTOFINISH, -1, 30);
+  gtk_widget_set_can_default (BT_AUTOFINISH, TRUE);
 
-  hbox12 = gtk_hbox_new (FALSE, 0);
+  hbox12 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
   gtk_widget_show (hbox12);
   gtk_box_pack_start (GTK_BOX (vbox9), hbox12, TRUE, TRUE, 0);
 
-  vbox12 = gtk_vbox_new (FALSE, 0);
+  vbox12 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
   gtk_widget_show (vbox12);
   gtk_box_pack_start (GTK_BOX (hbox12), vbox12, TRUE, TRUE, 0);
 
-  hseparator2 = gtk_hseparator_new ();
+  hseparator2 = gtk_separator_new (GTK_ORIENTATION_HORIZONTAL);
   gtk_widget_show (hseparator2);
   gtk_box_pack_start (GTK_BOX (vbox12), hseparator2, FALSE, FALSE, 7);
 
-  vbuttonbox2 = gtk_vbutton_box_new ();
+  vbuttonbox2 = gtk_button_box_new (GTK_ORIENTATION_VERTICAL);
   gtk_widget_show (vbuttonbox2);
   gtk_box_pack_start (GTK_BOX (vbox12), vbuttonbox2, FALSE, FALSE, 0);
-  gtk_button_box_set_spacing (GTK_BUTTON_BOX (vbuttonbox2), 7);
+  gtk_box_set_spacing (GTK_BOX (vbuttonbox2), 7);
 
   BT_REPLAY = gtk_button_new_with_mnemonic (_("Replay"));
   gtk_widget_show (BT_REPLAY);
   gtk_container_add (GTK_CONTAINER (vbuttonbox2), BT_REPLAY);
-  gtk_widget_set_usize (BT_REPLAY, 107, -2);
-  GTK_WIDGET_SET_FLAGS (BT_REPLAY, GTK_CAN_DEFAULT);
+  gtk_widget_set_size_request (BT_REPLAY, 107, -1);
+  gtk_widget_set_can_default (BT_REPLAY, TRUE);
 
   BT_REPLAY_STOP = gtk_button_new_with_mnemonic (_("Stop"));
   gtk_widget_show (BT_REPLAY_STOP);
   gtk_container_add (GTK_CONTAINER (vbuttonbox2), BT_REPLAY_STOP);
-  gtk_widget_set_usize (BT_REPLAY_STOP, 37, -2);
-  GTK_WIDGET_SET_FLAGS (BT_REPLAY_STOP, GTK_CAN_DEFAULT);
+  gtk_widget_set_size_request (BT_REPLAY_STOP, 37, -1);
+  gtk_widget_set_can_default (BT_REPLAY_STOP, TRUE);
 
   label50 = gtk_label_new (_("Replay Delay"));
   gtk_widget_show (label50);
   gtk_box_pack_start (GTK_BOX (vbox12), label50, FALSE, FALSE, 0);
   gtk_label_set_justify (GTK_LABEL (label50), GTK_JUSTIFY_LEFT);
-  gtk_misc_set_alignment (GTK_MISC (label50), 0.5, 0);
-  gtk_misc_set_padding (GTK_MISC (label50), 0, 4);
+  gtk_label_set_xalign (GTK_LABEL (label50), 0.5);
+  gtk_label_set_yalign (GTK_LABEL (label50), 0);
+  gtk_widget_set_margin_top (label50, 4);
+  gtk_widget_set_margin_bottom (label50, 4);
 
   ReplayDelaySpinner_adj = gtk_adjustment_new (1, 1, 100, 1, 10, 10);
   ReplayDelaySpinner = gtk_spin_button_new (GTK_ADJUSTMENT (ReplayDelaySpinner_adj), 1, 0);
   gtk_widget_show (ReplayDelaySpinner);
   gtk_box_pack_start (GTK_BOX (vbox12), ReplayDelaySpinner, FALSE, FALSE, 0);
 
-  hseparator3 = gtk_hseparator_new ();
+  hseparator3 = gtk_separator_new (GTK_ORIENTATION_HORIZONTAL);
   gtk_widget_show (hseparator3);
   gtk_box_pack_start (GTK_BOX (vbox12), hseparator3, FALSE, FALSE, 7);
 
-  vbox13 = gtk_vbox_new (FALSE, 0);
+  vbox13 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
   gtk_widget_show (vbox13);
   gtk_box_pack_start (GTK_BOX (vbox12), vbox13, TRUE, TRUE, 0);
 
@@ -612,8 +630,10 @@ create_GamazonsMain (void)
   gtk_widget_show (label51);
   gtk_box_pack_start (GTK_BOX (vbox13), label51, FALSE, FALSE, 0);
   gtk_label_set_justify (GTK_LABEL (label51), GTK_JUSTIFY_LEFT);
-  gtk_misc_set_alignment (GTK_MISC (label51), 0.5, 0);
-  gtk_misc_set_padding (GTK_MISC (label51), 0, 4);
+  gtk_label_set_xalign (GTK_LABEL (label51), 0.5);
+  gtk_label_set_yalign (GTK_LABEL (label51), 0);
+  gtk_widget_set_margin_top (label51, 4);
+  gtk_widget_set_margin_bottom (label51, 4);
 
   MovementSpeedSpinner_adj = gtk_adjustment_new (1, 1, 10, 1, 10, 10);
   MovementSpeedSpinner = gtk_spin_button_new (GTK_ADJUSTMENT (MovementSpeedSpinner_adj), 1, 0);
@@ -628,7 +648,7 @@ create_GamazonsMain (void)
   textview1 = gtk_text_view_new ();
   gtk_widget_show (textview1);
   gtk_container_add (GTK_CONTAINER (scrolledwindow6), textview1);
-  gtk_widget_set_usize (textview1, 120, -2);
+  gtk_widget_set_size_request (textview1, 120, -1);
   gtk_text_view_set_editable (GTK_TEXT_VIEW (textview1), FALSE);
   gtk_text_view_set_cursor_visible (GTK_TEXT_VIEW (textview1), FALSE);
 
@@ -636,23 +656,23 @@ create_GamazonsMain (void)
   gtk_widget_show (statusbar1);
   gtk_box_pack_start (GTK_BOX (vbox1), statusbar1, FALSE, FALSE, 0);
 
-  gtk_signal_connect (GTK_OBJECT (GamazonsMain), "destroy",
-                      GTK_SIGNAL_FUNC (on_GamazonsMain_destroy),
+  g_signal_connect (G_OBJECT (GamazonsMain), "destroy",
+                    G_CALLBACK (on_GamazonsMain_destroy),
                       NULL);
-  gtk_signal_connect (GTK_OBJECT (BT_UNDO), "clicked",
-                      GTK_SIGNAL_FUNC (on_BT_UNDO_clicked),
+  g_signal_connect (G_OBJECT (BT_UNDO), "clicked",
+                    G_CALLBACK (on_BT_UNDO_clicked),
                       NULL);
-  gtk_signal_connect (GTK_OBJECT (BT_FORCEMOVE), "clicked",
-                      GTK_SIGNAL_FUNC (on_BT_FORCEMOVE_clicked),
+  g_signal_connect (G_OBJECT (BT_FORCEMOVE), "clicked",
+                    G_CALLBACK (on_BT_FORCEMOVE_clicked),
                       NULL);
-  gtk_signal_connect (GTK_OBJECT (BT_AUTOFINISH), "clicked",
-                      GTK_SIGNAL_FUNC (on_BT_AUTOFINISH_clicked),
+  g_signal_connect (G_OBJECT (BT_AUTOFINISH), "clicked",
+                    G_CALLBACK (on_BT_AUTOFINISH_clicked),
                       NULL);
-  gtk_signal_connect (GTK_OBJECT (BT_REPLAY), "clicked",
-                      GTK_SIGNAL_FUNC (on_BT_REPLAY_clicked),
+  g_signal_connect (G_OBJECT (BT_REPLAY), "clicked",
+                    G_CALLBACK (on_BT_REPLAY_clicked),
                       NULL);
-  gtk_signal_connect (GTK_OBJECT (BT_REPLAY_STOP), "clicked",
-                      GTK_SIGNAL_FUNC (on_BT_REPLAY_STOP_clicked),
+  g_signal_connect (G_OBJECT (BT_REPLAY_STOP), "clicked",
+                    G_CALLBACK (on_BT_REPLAY_STOP_clicked),
                       NULL);
 
   atko = gtk_widget_get_accessible (CNVS_GAMEBOARD);
@@ -663,18 +683,18 @@ create_GamazonsMain (void)
   GLADE_HOOKUP_OBJECT_NO_REF (GamazonsMain, GamazonsMain, "GamazonsMain");
   GLADE_HOOKUP_OBJECT (GamazonsMain, vbox1, "vbox1");
   GLADE_HOOKUP_OBJECT (GamazonsMain, menubar1, "menubar1");
-  GLADE_HOOKUP_OBJECT (GamazonsMain, menubar1_uiinfo[0].widget, "file1");
-  GLADE_HOOKUP_OBJECT (GamazonsMain, file1_menu_uiinfo[0].widget, "new1");
-  GLADE_HOOKUP_OBJECT (GamazonsMain, file1_menu_uiinfo[1].widget, "open");
-  GLADE_HOOKUP_OBJECT (GamazonsMain, file1_menu_uiinfo[2].widget, "save_as1");
-  GLADE_HOOKUP_OBJECT (GamazonsMain, file1_menu_uiinfo[3].widget, "separator1");
-  GLADE_HOOKUP_OBJECT (GamazonsMain, file1_menu_uiinfo[4].widget, "quit1");
-  GLADE_HOOKUP_OBJECT (GamazonsMain, menubar1_uiinfo[1].widget, "Settings");
-  GLADE_HOOKUP_OBJECT (GamazonsMain, Settings_menu_uiinfo[0].widget, "player1");
-  GLADE_HOOKUP_OBJECT (GamazonsMain, Settings_menu_uiinfo[1].widget, "theme1");
-  GLADE_HOOKUP_OBJECT (GamazonsMain, menubar1_uiinfo[2].widget, "help1");
-  GLADE_HOOKUP_OBJECT (GamazonsMain, help1_menu_uiinfo[0].widget, "how_to_play1");
-  GLADE_HOOKUP_OBJECT (GamazonsMain, help1_menu_uiinfo[1].widget, "about1");
+  GLADE_HOOKUP_OBJECT (GamazonsMain, file1_menu, "file1");
+  GLADE_HOOKUP_OBJECT (GamazonsMain, new_menu, "new1");
+  GLADE_HOOKUP_OBJECT (GamazonsMain, open_menu, "open");
+  GLADE_HOOKUP_OBJECT (GamazonsMain, save_menu, "save_as1");
+  GLADE_HOOKUP_OBJECT (GamazonsMain, separator1, "separator1");
+  GLADE_HOOKUP_OBJECT (GamazonsMain, quit_menu, "quit1");
+  GLADE_HOOKUP_OBJECT (GamazonsMain, settings1_menu, "Settings");
+  GLADE_HOOKUP_OBJECT (GamazonsMain, player_menu, "player1");
+  GLADE_HOOKUP_OBJECT (GamazonsMain, theme_menu, "theme1");
+  GLADE_HOOKUP_OBJECT (GamazonsMain, help1_menu, "help1");
+  GLADE_HOOKUP_OBJECT (GamazonsMain, howtoplay_menu, "how_to_play1");
+  GLADE_HOOKUP_OBJECT (GamazonsMain, about_menu, "about1");
   GLADE_HOOKUP_OBJECT (GamazonsMain, scrolledwindow1, "scrolledwindow1");
   GLADE_HOOKUP_OBJECT (GamazonsMain, viewport1, "viewport1");
   GLADE_HOOKUP_OBJECT (GamazonsMain, hbox1, "hbox1");
@@ -784,123 +804,117 @@ create_PlayerSettings (void)
   GtkWidget *SearchDepthLabel;
   GtkWidget *SearchWidthLabel;
   GtkWidget *hbox7;
-  GtkObject *TimeSpinner_adj;
+  GtkAdjustment *TimeSpinner_adj;
   GtkWidget *TimeSpinner;
-  GtkObject *DepthSpinner_adj;
+  GtkAdjustment *DepthSpinner_adj;
   GtkWidget *DepthSpinner;
-  GtkObject *WidthSpinner_adj;
+  GtkAdjustment *WidthSpinner_adj;
   GtkWidget *WidthSpinner;
   GtkWidget *hbuttonbox3;
   GtkWidget *PlayerOKButton;
   GtkWidget *PlayerCancelButton;
-  GtkWidget *alignment1;
   GtkWidget *hbox8;
   GtkWidget *image1;
   GtkWidget *label9;
 
   PlayerSettings = gtk_window_new (GTK_WINDOW_TOPLEVEL);
-  gtk_widget_set_usize (PlayerSettings, 370, 185);
+  gtk_widget_set_size_request (PlayerSettings, 370, 185);
   gtk_window_set_title (GTK_WINDOW (PlayerSettings), _("Player Settings"));
   gtk_window_set_default_size (GTK_WINDOW (PlayerSettings), 300, 185);
   gtk_window_set_resizable (GTK_WINDOW (PlayerSettings), FALSE);
 
-  vbox5 = gtk_vbox_new (FALSE, 0);
+  vbox5 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
   gtk_widget_show (vbox5);
   gtk_container_add (GTK_CONTAINER (PlayerSettings), vbox5);
-  gtk_widget_set_usize (vbox5, -2, 70);
+  gtk_widget_set_size_request (vbox5, -1, 70);
 
-  hbox3 = gtk_hbox_new (FALSE, 0);
+  hbox3 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
   gtk_widget_show (hbox3);
   gtk_box_pack_start (GTK_BOX (vbox5), hbox3, TRUE, TRUE, 0);
-  gtk_widget_set_usize (hbox3, -2, 2);
+  gtk_widget_set_size_request (hbox3, -1, 2);
 
   WhitePlayerLabel = gtk_label_new (_("White Player:"));
   gtk_widget_show (WhitePlayerLabel);
   gtk_box_pack_start (GTK_BOX (hbox3), WhitePlayerLabel, FALSE, FALSE, 0);
-  gtk_widget_set_usize (WhitePlayerLabel, 100, -2);
+  gtk_widget_set_size_request (WhitePlayerLabel, 100, -1);
   gtk_label_set_justify (GTK_LABEL (WhitePlayerLabel), GTK_JUSTIFY_LEFT);
-  gtk_misc_set_alignment (GTK_MISC (WhitePlayerLabel), 0.3, 0.5);
+  gtk_label_set_xalign (GTK_LABEL (WhitePlayerLabel), 0.3);
+  gtk_label_set_yalign (GTK_LABEL (WhitePlayerLabel), 0.5);
 
   WhiteHumanRadio = gtk_radio_button_new_with_mnemonic (NULL, _("Human"));
   gtk_widget_show (WhiteHumanRadio);
   gtk_box_pack_start (GTK_BOX (hbox3), WhiteHumanRadio, FALSE, FALSE, 0);
-  gtk_widget_set_usize (WhiteHumanRadio, 85, -2);
+  gtk_widget_set_size_request (WhiteHumanRadio, 85, -1);
   gtk_radio_button_set_group (GTK_RADIO_BUTTON (WhiteHumanRadio), WhiteHumanRadio_group);
-  WhiteHumanRadio_group = gtk_radio_button_group (GTK_RADIO_BUTTON (WhiteHumanRadio));
+  WhiteHumanRadio_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (WhiteHumanRadio));
 
   WhiteAIRadio = gtk_radio_button_new_with_mnemonic (NULL, _("AI"));
   gtk_widget_show (WhiteAIRadio);
   gtk_box_pack_start (GTK_BOX (hbox3), WhiteAIRadio, FALSE, FALSE, 0);
   gtk_radio_button_set_group (GTK_RADIO_BUTTON (WhiteAIRadio), WhiteHumanRadio_group);
-  WhiteHumanRadio_group = gtk_radio_button_group (GTK_RADIO_BUTTON (WhiteAIRadio));
+  WhiteHumanRadio_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (WhiteAIRadio));
 
-  hbox4 = gtk_hbox_new (FALSE, 0);
+  hbox4 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
   gtk_widget_show (hbox4);
   gtk_box_pack_start (GTK_BOX (vbox5), hbox4, TRUE, TRUE, 0);
-  gtk_widget_set_usize (hbox4, -2, 2);
+  gtk_widget_set_size_request (hbox4, -1, 2);
 
   BlackPlayerLabel = gtk_label_new (_("Black Player: "));
   gtk_widget_show (BlackPlayerLabel);
   gtk_box_pack_start (GTK_BOX (hbox4), BlackPlayerLabel, FALSE, FALSE, 0);
-  gtk_widget_set_usize (BlackPlayerLabel, 100, -2);
+  gtk_widget_set_size_request (BlackPlayerLabel, 100, -1);
   gtk_label_set_justify (GTK_LABEL (BlackPlayerLabel), GTK_JUSTIFY_LEFT);
 
   BlackHumanRadio = gtk_radio_button_new_with_mnemonic (NULL, _("Human"));
   gtk_widget_show (BlackHumanRadio);
   gtk_box_pack_start (GTK_BOX (hbox4), BlackHumanRadio, FALSE, FALSE, 0);
-  gtk_widget_set_usize (BlackHumanRadio, 85, -2);
+  gtk_widget_set_size_request (BlackHumanRadio, 85, -1);
   gtk_radio_button_set_group (GTK_RADIO_BUTTON (BlackHumanRadio), BlackHumanRadio_group);
-  BlackHumanRadio_group = gtk_radio_button_group (GTK_RADIO_BUTTON (BlackHumanRadio));
+  BlackHumanRadio_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (BlackHumanRadio));
 
   BlackAIRadio = gtk_radio_button_new_with_mnemonic (NULL, _("AI"));
   gtk_widget_show (BlackAIRadio);
   gtk_box_pack_start (GTK_BOX (hbox4), BlackAIRadio, FALSE, FALSE, 0);
   gtk_radio_button_set_group (GTK_RADIO_BUTTON (BlackAIRadio), BlackHumanRadio_group);
-  BlackHumanRadio_group = gtk_radio_button_group (GTK_RADIO_BUTTON (BlackAIRadio));
+  BlackHumanRadio_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (BlackAIRadio));
 
-  hseparator1 = gtk_hseparator_new ();
+  hseparator1 = gtk_separator_new (GTK_ORIENTATION_HORIZONTAL);
   gtk_widget_show (hseparator1);
   gtk_box_pack_start (GTK_BOX (vbox5), hseparator1, TRUE, TRUE, 0);
-  gtk_widget_set_usize (hseparator1, -2, 1);
+  gtk_widget_set_size_request (hseparator1, -1, 1);
 
   AISettings = gtk_label_new (_("AI Settings:"));
   gtk_widget_show (AISettings);
   gtk_box_pack_start (GTK_BOX (vbox5), AISettings, FALSE, FALSE, 0);
-  gtk_widget_set_usize (AISettings, -2, 15);
+  gtk_widget_set_size_request (AISettings, -1, 15);
   gtk_label_set_justify (GTK_LABEL (AISettings), GTK_JUSTIFY_LEFT);
 
-  hbox5 = gtk_hbox_new (FALSE, 0);
+  hbox5 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
   gtk_widget_show (hbox5);
   gtk_box_pack_start (GTK_BOX (vbox5), hbox5, TRUE, TRUE, 0);
 
-  vbox6 = gtk_vbox_new (FALSE, 0);
+  vbox6 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
   gtk_widget_show (vbox6);
   gtk_box_pack_start (GTK_BOX (hbox5), vbox6, TRUE, TRUE, 0);
-  gtk_widget_set_usize (vbox6, -2, 28);
+  gtk_widget_set_size_request (vbox6, -1, 28);
 
-  hbox6 = gtk_hbox_new (FALSE, 0);
+  hbox6 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
   gtk_widget_show (hbox6);
   gtk_box_pack_start (GTK_BOX (vbox6), hbox6, TRUE, TRUE, 0);
 
   TimeLabel = gtk_label_new (_("Search Time: "));
   gtk_widget_show (TimeLabel);
-  gtk_box_pack_start (GTK_BOX (hbox6), TimeLabel, FALSE, FALSE, 0);
-  gtk_widget_set_usize (TimeLabel, 121, -2);
-  gtk_label_set_justify (GTK_LABEL (TimeLabel), GTK_JUSTIFY_LEFT);
+  gtk_box_pack_start (GTK_BOX (hbox6), TimeLabel, TRUE, TRUE, 0);
 
   SearchDepthLabel = gtk_label_new (_("Max Search Depth"));
   gtk_widget_show (SearchDepthLabel);
-  gtk_box_pack_start (GTK_BOX (hbox6), SearchDepthLabel, FALSE, FALSE, 0);
-  gtk_widget_set_usize (SearchDepthLabel, 127, -2);
+  gtk_box_pack_start (GTK_BOX (hbox6), SearchDepthLabel, TRUE, TRUE, 0);
 
   SearchWidthLabel = gtk_label_new (_("Max Search Width"));
   gtk_widget_show (SearchWidthLabel);
-  gtk_box_pack_start (GTK_BOX (hbox6), SearchWidthLabel, FALSE, FALSE, 0);
-  gtk_widget_set_usize (SearchWidthLabel, 112, -2);
-  gtk_label_set_justify (GTK_LABEL (SearchWidthLabel), GTK_JUSTIFY_RIGHT);
-  gtk_misc_set_alignment (GTK_MISC (SearchWidthLabel), 1, 0.5);
+  gtk_box_pack_start (GTK_BOX (hbox6), SearchWidthLabel, TRUE, TRUE, 0);
 
-  hbox7 = gtk_hbox_new (FALSE, 0);
+  hbox7 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
   gtk_widget_show (hbox7);
   gtk_box_pack_start (GTK_BOX (vbox6), hbox7, TRUE, TRUE, 0);
 
@@ -908,49 +922,43 @@ create_PlayerSettings (void)
   TimeSpinner = gtk_spin_button_new (GTK_ADJUSTMENT (TimeSpinner_adj), 1, 0);
   gtk_widget_show (TimeSpinner);
   gtk_box_pack_start (GTK_BOX (hbox7), TimeSpinner, TRUE, TRUE, 10);
-  gtk_widget_set_usize (TimeSpinner, 10, -2);
+  gtk_widget_set_size_request (TimeSpinner, 10, -1);
 
   DepthSpinner_adj = gtk_adjustment_new (1, 1, 100, 1, 10, 10);
   DepthSpinner = gtk_spin_button_new (GTK_ADJUSTMENT (DepthSpinner_adj), 1, 0);
   gtk_widget_show (DepthSpinner);
   gtk_box_pack_start (GTK_BOX (hbox7), DepthSpinner, TRUE, TRUE, 10);
-  gtk_widget_set_usize (DepthSpinner, 10, -2);
+  gtk_widget_set_size_request (DepthSpinner, 10, -1);
 
   WidthSpinner_adj = gtk_adjustment_new (1, 1, 3000, 1, 10, 10);
   WidthSpinner = gtk_spin_button_new (GTK_ADJUSTMENT (WidthSpinner_adj), 1, 0);
   gtk_widget_show (WidthSpinner);
   gtk_box_pack_start (GTK_BOX (hbox7), WidthSpinner, TRUE, TRUE, 10);
-  gtk_widget_set_usize (WidthSpinner, 10, -2);
+  gtk_widget_set_size_request (WidthSpinner, 10, -1);
 
-  hbuttonbox3 = gtk_hbutton_box_new ();
+  hbuttonbox3 = gtk_button_box_new (GTK_ORIENTATION_HORIZONTAL);
   gtk_widget_show (hbuttonbox3);
   gtk_box_pack_start (GTK_BOX (vbox5), hbuttonbox3, TRUE, TRUE, 0);
-  gtk_widget_set_usize (hbuttonbox3, -2, 25);
-  gtk_container_set_border_width (GTK_CONTAINER (hbuttonbox3), 39);
-  gtk_button_box_set_spacing (GTK_BUTTON_BOX (hbuttonbox3), 0);
+  gtk_box_set_spacing (GTK_BOX (hbuttonbox3), 0);
 
-  PlayerOKButton = gtk_button_new_from_stock ("gtk-ok");
+  PlayerOKButton = gtk_button_new_with_label (_("OK"));
   gtk_widget_show (PlayerOKButton);
   gtk_container_add (GTK_CONTAINER (hbuttonbox3), PlayerOKButton);
-  gtk_widget_set_usize (PlayerOKButton, 50, -2);
+  gtk_widget_set_size_request (PlayerOKButton, 50, -1);
   gtk_container_set_border_width (GTK_CONTAINER (PlayerOKButton), 10);
-  GTK_WIDGET_SET_FLAGS (PlayerOKButton, GTK_CAN_DEFAULT);
+  gtk_widget_set_can_default (PlayerOKButton, TRUE);
 
   PlayerCancelButton = gtk_button_new ();
   gtk_widget_show (PlayerCancelButton);
   gtk_container_add (GTK_CONTAINER (hbuttonbox3), PlayerCancelButton);
   gtk_container_set_border_width (GTK_CONTAINER (PlayerCancelButton), 10);
-  GTK_WIDGET_SET_FLAGS (PlayerCancelButton, GTK_CAN_DEFAULT);
+  gtk_widget_set_can_default (PlayerCancelButton, TRUE);
 
-  alignment1 = gtk_alignment_new (0.5, 0.5, 0, 0);
-  gtk_widget_show (alignment1);
-  gtk_container_add (GTK_CONTAINER (PlayerCancelButton), alignment1);
-
-  hbox8 = gtk_hbox_new (FALSE, 2);
+  hbox8 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 2);
   gtk_widget_show (hbox8);
-  gtk_container_add (GTK_CONTAINER (alignment1), hbox8);
+  gtk_container_add (GTK_CONTAINER (PlayerCancelButton), hbox8);
 
-  image1 = gtk_image_new_from_stock ("gtk-cancel", GTK_ICON_SIZE_BUTTON);
+  image1 = gtk_image_new_from_icon_name ("gtk-cancel", GTK_ICON_SIZE_BUTTON);
   gtk_widget_show (image1);
   gtk_box_pack_start (GTK_BOX (hbox8), image1, FALSE, FALSE, 0);
 
@@ -958,12 +966,15 @@ create_PlayerSettings (void)
   gtk_widget_show (label9);
   gtk_box_pack_start (GTK_BOX (hbox8), label9, FALSE, FALSE, 0);
   gtk_label_set_justify (GTK_LABEL (label9), GTK_JUSTIFY_LEFT);
+  gtk_label_set_xalign (GTK_LABEL (label9), 0.5);
+  gtk_label_set_yalign (GTK_LABEL (label9), 0.5);
+
 
-  gtk_signal_connect (GTK_OBJECT (PlayerOKButton), "clicked",
-                      GTK_SIGNAL_FUNC (on_PlayerOKButton_clicked),
+  g_signal_connect (G_OBJECT (PlayerOKButton), "clicked",
+                    G_CALLBACK (on_PlayerOKButton_clicked),
                       NULL);
-  gtk_signal_connect (GTK_OBJECT (PlayerCancelButton), "clicked",
-                      GTK_SIGNAL_FUNC (on_PlayerCancelButton_clicked),
+  g_signal_connect (G_OBJECT (PlayerCancelButton), "clicked",
+                    G_CALLBACK (on_PlayerCancelButton_clicked),
                       NULL);
 
   /* Store pointers to all widgets, for use by lookup_widget(). */
@@ -992,7 +1003,6 @@ create_PlayerSettings (void)
   GLADE_HOOKUP_OBJECT (PlayerSettings, hbuttonbox3, "hbuttonbox3");
   GLADE_HOOKUP_OBJECT (PlayerSettings, PlayerOKButton, "PlayerOKButton");
   GLADE_HOOKUP_OBJECT (PlayerSettings, PlayerCancelButton, "PlayerCancelButton");
-  GLADE_HOOKUP_OBJECT (PlayerSettings, alignment1, "alignment1");
   GLADE_HOOKUP_OBJECT (PlayerSettings, hbox8, "hbox8");
   GLADE_HOOKUP_OBJECT (PlayerSettings, image1, "image1");
   GLADE_HOOKUP_OBJECT (PlayerSettings, label9, "label9");
diff --git a/src/main.c b/src/main.c
index 75ef51b..3f6adc6 100644
--- a/src/main.c
+++ b/src/main.c
@@ -7,7 +7,8 @@
 #  include <config.h>
 #endif
 
-#include <gnome.h>
+#include <gtk/gtk.h>
+#include <glib/gi18n.h>
 
 #include "interface.h"
 #include "support.h"
@@ -43,10 +44,7 @@ int main (int argc, char *argv[])
   textdomain (GETTEXT_PACKAGE);
 #endif
 
-  gnome_program_init (PACKAGE, VERSION, LIBGNOMEUI_MODULE,
-                      argc, argv,
-                      GNOME_PARAM_APP_DATADIR, PACKAGE_DATA_DIR,
-                      NULL);
+  gtk_init (&argc, &argv);
 
   /*
    * The following code was added by Glade to create one of each component
@@ -54,7 +52,7 @@ int main (int argc, char *argv[])
    * the project. Delete any components that you don't want shown initially.
    */
 
-  gnome_window_icon_set_default_from_file (PACKAGE_DATA_DIR "/pixmaps/gnome-gamazons.png");
+  gtk_window_set_default_icon_from_file (PACKAGE_DATA_DIR "/pixmaps/gnome-gamazons.png", NULL);
 
   init_engine();
   GamazonsMain = create_GamazonsMain ();
diff --git a/src/moves.c b/src/moves.c
index 65cac21..e864df8 100644
--- a/src/moves.c
+++ b/src/moves.c
@@ -23,7 +23,7 @@ Project URL:     http://www.yorgalily.org/amazons/
 #include <sys/poll.h>
 
 //#ifdef GAMAZONS
-#include <gnome.h>
+#include <gtk/gtk.h>
 //#endif
 
 #include "amazons.h"
diff --git a/src/support.c b/src/support.c
index 055fea2..76fcaec 100644
--- a/src/support.c
+++ b/src/support.c
@@ -12,7 +12,8 @@
 #include <string.h>
 #include <stdio.h>
 
-#include <gnome.h>
+#include <gtk/gtk.h>
+#include <glib/gi18n.h>
 
 #include "support.h"
 
@@ -27,76 +28,19 @@ lookup_widget                          (GtkWidget       *widget,
       if (GTK_IS_MENU (widget))
         parent = gtk_menu_get_attach_widget (GTK_MENU (widget));
       else
-        parent = widget->parent;
+        parent = gtk_widget_get_parent (widget);
       if (!parent)
-        parent = gtk_object_get_data (GTK_OBJECT (widget), "GladeParentKey");
-      if (parent == NULL)
         break;
       widget = parent;
     }
 
-  found_widget = (GtkWidget*) gtk_object_get_data (GTK_OBJECT (widget),
-                                                   widget_name);
+  found_widget = (GtkWidget*) g_object_get_data (G_OBJECT (widget),
+                                                 widget_name);
   if (!found_widget)
     g_warning ("Widget not found: %s", widget_name);
   return found_widget;
 }
 
-/* This is an internally used function to create pixmaps. */
-GtkWidget*
-create_pixmap                          (GtkWidget       *widget,
-                                        const gchar     *filename)
-{
-  GtkWidget *pixmap;
-  gchar *pathname;
-
-  if (!filename || !filename[0])
-      return gtk_image_new ();
-
-  pathname = gnome_program_locate_file (NULL, GNOME_FILE_DOMAIN_APP_PIXMAP,
-                                        filename, TRUE, NULL);
-  if (!pathname)
-    {
-      g_warning (_("Couldn't find pixmap file: %s"), filename);
-      return gtk_image_new ();
-    }
-
-  pixmap = gtk_image_new_from_file (pathname);
-  g_free (pathname);
-  return pixmap;
-}
-
-/* This is an internally used function to create pixmaps. */
-GdkPixbuf*
-create_pixbuf                          (const gchar     *filename)
-{
-  gchar *pathname = NULL;
-  GdkPixbuf *pixbuf;
-  GError *error = NULL;
-
-  if (!filename || !filename[0])
-      return NULL;
-
-  pathname = gnome_program_locate_file (NULL, GNOME_FILE_DOMAIN_APP_PIXMAP,
-                                        filename, TRUE, NULL);
-
-  if (!pathname)
-    {
-      g_warning (_("Couldn't find pixmap file: %s"), filename);
-      return NULL;
-    }
-
-  pixbuf = gdk_pixbuf_new_from_file (pathname, &error);
-  if (!pixbuf)
-    {
-      fprintf (stderr, "Failed to load pixbuf file: %s: %s\n",
-               pathname, error->message);
-      g_error_free (error);
-    }
-  g_free (pathname);
-  return pixbuf;
-}
-
 /* This is used to set ATK action descriptions. */
 void
 glade_set_atk_action_description       (AtkAction       *action,
diff --git a/src/support.h b/src/support.h
index 13d1746..c07a60b 100644
--- a/src/support.h
+++ b/src/support.h
@@ -2,7 +2,7 @@
  * DO NOT EDIT THIS FILE - it is generated by Glade.
  */
 
-#include <gnome.h>
+#include <gtk/gtk.h>
 
 /*
  * Public Functions.
@@ -23,13 +23,6 @@ GtkWidget*  lookup_widget              (GtkWidget       *widget,
  * Private Functions.
  */
 
-/* This is used to create the pixmaps used in the interface. */
-GtkWidget*  create_pixmap              (GtkWidget       *widget,
-                                        const gchar     *filename);
-
-/* This is used to create the pixbufs used in the interface. */
-GdkPixbuf*  create_pixbuf              (const gchar     *filename);
-
 /* This is used to set ATK action descriptions. */
 void        glade_set_atk_action_description (AtkAction       *action,
                                               const gchar     *action_name,