Subversion Repositories connect-6

/*

connectk -- a program to play the connect-k family of games

Copyright (C) 2007 Michael Levin

This program is free software; you can redistribute it and/or

modify it under the terms of the GNU General Public License

as published by the Free Software Foundation; either version 2

of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,

but WITHOUT ANY WARRANTY; without even the implied warranty of

MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

GNU General Public License for more details.

You should have received a copy of the GNU General Public License

along with this program; if not, write to the Free Software

Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.

*/

#include "config.h"

#include <gtk/gtk.h>

#include "shared.h"

#include "connectk.h"

/*

 *      New game dialog

 */

static GtkWidget *window = NULL, *new_game_dialog, *ngd_board_size,

                 *ngd_connect_k, *ngd_place_p, *ngd_start_q, *ngd_combo;

/* Clear the board and history for a new game */

void new_game(unsigned int size)

{

        tree_view_clear(1);

        clear_history(0);

        set_board_size(size);

        board = NULL;

        go_to_move(0);

        board->moves_left = start_q;

        board->turn = PIECE_BLACK;

        draw_board();

        stop_ai();

        setup_move();

}

// Close the new game dialog

static void new_game_dialog_cancel(GtkButton *button, gpointer user_data)

{

        gtk_widget_hide(new_game_dialog);

}

// Accept the new game dialog

static void new_game_dialog_ok(GtkButton *button, gpointer user_data)

{

        new_game_dialog_cancel(button, user_data);

        connect_k = gtk_spin_button_get_value_as_int(

                                                GTK_SPIN_BUTTON(ngd_connect_k));

        place_p = gtk_spin_button_get_value_as_int(

                                                  GTK_SPIN_BUTTON(ngd_place_p));

        start_q = gtk_spin_button_get_value_as_int(

                                                  GTK_SPIN_BUTTON(ngd_start_q));

        new_game(gtk_spin_button_get_value_as_int(

                                              GTK_SPIN_BUTTON(ngd_board_size)));

}

// Create a spin button and label

static GtkWidget *labeled_spin_new(const gchar *text, double spin_from,

                                   double spin_to, double spin_set,

                                   GtkWidget **spin, GCallback func)

{

        GtkWidget *hbox, *label;

        hbox = gtk_hbox_new(FALSE, 4);

        label = gtk_label_new(text);

        gtk_misc_set_alignment(GTK_MISC(label), 1., 0.5);

        *spin = gtk_spin_button_new_with_range(spin_from, spin_to, 1.);

        gtk_spin_button_set_value(GTK_SPIN_BUTTON(*spin), spin_set);

        if (func)

                g_signal_connect(*spin, "value-changed", G_CALLBACK(func),

                                 NULL);

        gtk_box_pack_start(GTK_BOX(hbox), label, TRUE, TRUE, 0);

        gtk_box_pack_start(GTK_BOX(hbox), *spin, FALSE, FALSE, 0);

        return hbox;

}

static void new_game_set_custom(void)

/* Called when the user changes some parameter */

{

        gtk_combo_box_set_active(GTK_COMBO_BOX(ngd_combo), 3);

}

static void new_game_set_combo(GtkComboBox *combo)

/* Called when the combo box value changes */

{

        int new_size = 19, new_k = 6, new_p = 2, new_q = 1;

        switch(gtk_combo_box_get_active(combo)) {

        case 0:

                new_size = 3;

                new_k = 3;

                new_p = 1;

                break;

        case 1:

                new_k = 5;

                new_p = 1;

        case 2:

                break;

        default:

                return;

        }

        /* Keep the values from resetting the combo box to custom */

        g_signal_handlers_block_by_func(G_OBJECT(ngd_board_size),

                                        new_game_set_custom, NULL);

        g_signal_handlers_block_by_func(G_OBJECT(ngd_place_p),

                                        new_game_set_custom, NULL);

        g_signal_handlers_block_by_func(G_OBJECT(ngd_start_q),

                                        new_game_set_custom, NULL);

        g_signal_handlers_block_by_func(G_OBJECT(ngd_connect_k),

                                        new_game_set_custom, NULL);

        /* Set the preset values */

        gtk_spin_button_set_value(GTK_SPIN_BUTTON(ngd_board_size), new_size);

        gtk_spin_button_set_value(GTK_SPIN_BUTTON(ngd_place_p), new_p);

        gtk_spin_button_set_value(GTK_SPIN_BUTTON(ngd_start_q), new_q);

        gtk_spin_button_set_value(GTK_SPIN_BUTTON(ngd_connect_k), new_k);

        /* Re-enable the signal handlers */

        g_signal_handlers_unblock_by_func(G_OBJECT(ngd_board_size),

                                          new_game_set_custom, NULL);

        g_signal_handlers_unblock_by_func(G_OBJECT(ngd_place_p),

                                          new_game_set_custom, NULL);

        g_signal_handlers_unblock_by_func(G_OBJECT(ngd_start_q),

                                          new_game_set_custom, NULL);

        g_signal_handlers_unblock_by_func(G_OBJECT(ngd_connect_k),

                                          new_game_set_custom, NULL);

}

// Create new game dialog

void new_game_dialog_init(void)

{

        GtkWidget *vbox, *hbox, *w;

        vbox = gtk_vbox_new(FALSE, 4);

        /* Stock games */

        ngd_combo = gtk_combo_box_new_text();

        gtk_combo_box_append_text(GTK_COMBO_BOX(ngd_combo), "Tic Tac Toe");

        gtk_combo_box_append_text(GTK_COMBO_BOX(ngd_combo), "Go Moku");

        gtk_combo_box_append_text(GTK_COMBO_BOX(ngd_combo), "Connect 6");

        gtk_combo_box_append_text(GTK_COMBO_BOX(ngd_combo), "Custom");

        gtk_combo_box_set_active(GTK_COMBO_BOX(ngd_combo), 2);

        gtk_box_pack_start(GTK_BOX(vbox), ngd_combo, FALSE, FALSE, 0);

        g_signal_connect(ngd_combo, "changed", G_CALLBACK(new_game_set_combo),

                         NULL);

        // Parameters

        hbox = labeled_spin_new("Board size:", 2., MAX_BOARD_SIZE, 19.,

                                &ngd_board_size, new_game_set_custom);

        gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);

        hbox = labeled_spin_new("Connect to win:", 2., MAX_CONNECT_K, 6.,

                                &ngd_connect_k, new_game_set_custom);

        gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);

        hbox = labeled_spin_new("Moves per turn:", 1., MAX_PLACE_P, 2.,

                                &ngd_place_p, new_game_set_custom);

        gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);

        hbox = labeled_spin_new("Starting moves:", 1., MAX_START_Q, 1.,

                                &ngd_start_q, new_game_set_custom);

        gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);

        /* Separator */

        w = gtk_vbox_new(FALSE, 0);

        gtk_box_pack_start(GTK_BOX(vbox), w, FALSE, FALSE, 4);

        /* Cancel/Ok buttons */

        hbox = gtk_hbox_new(TRUE, 4);

        w = gtk_button_new_from_stock(GTK_STOCK_CANCEL);

        g_signal_connect(G_OBJECT(w), "clicked",

                         G_CALLBACK(new_game_dialog_cancel), NULL);

        gtk_box_pack_start(GTK_BOX(hbox), w, TRUE, TRUE, 0);

        w = gtk_button_new_from_stock(GTK_STOCK_OK);

        g_signal_connect(G_OBJECT(w), "clicked",

                         G_CALLBACK(new_game_dialog_ok), NULL);

        gtk_box_pack_end(GTK_BOX(hbox), w, TRUE, TRUE, 0);

        gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);

        // Create dialog window

        new_game_dialog = gtk_window_new(GTK_WINDOW_TOPLEVEL);

        g_signal_connect(G_OBJECT(new_game_dialog), "delete-event",

                         G_CALLBACK(gtk_widget_hide_on_delete), NULL);

        gtk_window_set_title(GTK_WINDOW(new_game_dialog), "New game...");

        gtk_window_set_transient_for(GTK_WINDOW(new_game_dialog),

                                     GTK_WINDOW(window));

        gtk_window_set_modal(GTK_WINDOW(new_game_dialog), TRUE);

        gtk_window_set_resizable(GTK_WINDOW(new_game_dialog), FALSE);

        gtk_container_add(GTK_CONTAINER(new_game_dialog), vbox);

        gtk_container_border_width(GTK_CONTAINER(new_game_dialog), 12);

}

// Game -> New activated

void open_new_game_dialog(GtkMenuItem *item, gpointer user_data)

{

        gtk_widget_show_all(new_game_dialog);

}

/*

 *      Open/save as dialogs

 */

/* Game -> Open activated */

void open_file_dialog(GtkMenuItem *item, gpointer user_data)

{

        GtkWidget *dialog;

        halt_ai_thread();

        dialog = gtk_file_chooser_dialog_new("Open File",

                                             GTK_WINDOW(window),

                                             GTK_FILE_CHOOSER_ACTION_OPEN,

                                             GTK_STOCK_CANCEL,

                                             GTK_RESPONSE_CANCEL,

                                             GTK_STOCK_OPEN,

                                             GTK_RESPONSE_ACCEPT,

                                             NULL);

        if (gtk_dialog_run(GTK_DIALOG (dialog)) == GTK_RESPONSE_ACCEPT) {

            char *filename;

            filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog));

            load_moves_list(filename);

            g_free(filename);

        }

        gtk_widget_destroy(dialog);

        start_ai_thread();

}

/* Game -> Save as activated */

void save_file_dialog(GtkMenuItem *item, gpointer user_data)

{

        GtkWidget *dialog;

        halt_ai_thread();

        dialog = gtk_file_chooser_dialog_new("Save File",

                                             GTK_WINDOW(window),

                                             GTK_FILE_CHOOSER_ACTION_SAVE,

                                             GTK_STOCK_CANCEL,

                                             GTK_RESPONSE_CANCEL,

                                             GTK_STOCK_SAVE,

                                             GTK_RESPONSE_ACCEPT,

                                             NULL);

        gtk_file_chooser_set_do_overwrite_confirmation(GTK_FILE_CHOOSER(dialog),

                                                       TRUE);

        if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) {

            char *filename;

            filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog));

            save_moves_list(filename);

            g_free(filename);

        }

        gtk_widget_destroy(dialog);

        start_ai_thread();

}

/*

 *      Tournament dialog

 */

static GtkWidget *tourney_dialog = NULL, *tourney_games, *tourney_save,

                 *tourney_prefix, *tourney_view, *tourney_exec, *tourney_halt;

static GtkListStore *tourney_store;

static const char *tourney_prefix_str = NULL;

static int tourney_total, tourney_wins[PIECES];

int tournament = 0;

static void tourney_dialog_close(GtkWidget *button)

{

        gtk_widget_hide(tourney_dialog);

}

static void tourney_dialog_stop(GtkWidget *button)

{

        int total = tourney_wins[PIECE_BLACK] + tourney_wins[PIECE_WHITE] +

                    tourney_wins[PIECE_NONE];

        gtk_widget_hide(tourney_halt);

        gtk_widget_show(tourney_exec);

        tournament = 0;

        if (tourney_wins[PIECE_BLACK] > tourney_wins[PIECE_WHITE])

                window_status(va("Black won tournament (%d%% of games won)",

                                 tourney_wins[PIECE_BLACK] * 100 / total));

        else if (tourney_wins[PIECE_WHITE] > tourney_wins[PIECE_BLACK])

                window_status(va("White won tournament (%d%% of games won)",

                                 tourney_wins[PIECE_WHITE] * 100 / total));

        else

                window_status("Tournament was a draw");

        draw_board();

}

static void tourney_dialog_execute(GtkWidget *button)

{

        gtk_list_store_clear(tourney_store);

        gtk_widget_hide(tourney_exec);

        gtk_widget_show(tourney_halt);

        tourney_total = tournament =

               gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(tourney_games));

        if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(tourney_save)))

                tourney_prefix_str =

                                  gtk_entry_get_text(GTK_ENTRY(tourney_prefix));

        else

                tourney_prefix_str = NULL;

        new_game(board_size);

        tourney_wins[PIECE_NONE] = 0;

        tourney_wins[PIECE_BLACK] = 0;

        tourney_wins[PIECE_WHITE] = 0;

        window_status("Running tournament...");

}

void tourney_result(PIECE win, int moves)

{

        GtkTreeIter iter;

        GtkTreePath *path;

        int game = tourney_total - tournament + 1;

        char *filename;

        tourney_wins[win]++;

        /* Add game to list */

        gtk_list_store_append(tourney_store, &iter);

        gtk_list_store_set(tourney_store, &iter, 0, piece_to_string(win),

                           1, moves, 2, game, -1);

        /* Scroll games list down */

        path = gtk_tree_model_get_path(GTK_TREE_MODEL(tourney_store), &iter);

        gtk_tree_view_scroll_to_cell(GTK_TREE_VIEW(tourney_view), path,

                                     NULL, FALSE, 0., 0.);

        gtk_tree_path_free(path);

        /* Save the tournament game */

        if (tourney_prefix_str) {

                filename = g_strdup(va("%s%d", tourney_prefix_str, game));

                save_moves_list(filename);

                g_free(filename);

        }

        if (--tournament > 0) {

                new_game(board_size);

                return;

        }

        tourney_dialog_stop(NULL);

}

void tourney_dialog_init(void)

{

        GtkWidget *vbox, *hbox, *w, *scrolled;

        GtkTreeViewColumn *column;

        if (tourney_dialog)

                return;

        vbox = gtk_vbox_new(FALSE, 4);

        /* Games spin button */

        hbox = gtk_hbox_new(FALSE, 0);

        w = gtk_label_new("Number of games:");

        gtk_box_pack_start(GTK_BOX(hbox), w, FALSE, FALSE, 0);

        tourney_games = gtk_spin_button_new_with_range(1., 1000., 1.);

        gtk_box_pack_start(GTK_BOX(hbox), tourney_games, FALSE, FALSE, 0);

        gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);

        /* Games list */

        tourney_store = gtk_list_store_new(3, G_TYPE_STRING, G_TYPE_INT,

                                           G_TYPE_INT);

        tourney_view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(

                                                                tourney_store));

        gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(tourney_view), TRUE);

        column = gtk_tree_view_column_new_with_attributes("Game",

                                                   gtk_cell_renderer_text_new(),

                                                          "text", 2, NULL);

        gtk_tree_view_append_column(GTK_TREE_VIEW(tourney_view), column);

        column = gtk_tree_view_column_new_with_attributes("Moves",

                                                   gtk_cell_renderer_text_new(),

                                                          "text", 1, NULL);

        gtk_tree_view_append_column(GTK_TREE_VIEW(tourney_view), column);

        column = gtk_tree_view_column_new_with_attributes("Winner",

                                                   gtk_cell_renderer_text_new(),

                                                          "text", 0, NULL);

        gtk_tree_view_append_column(GTK_TREE_VIEW(tourney_view), column);

        /* Scrolled container for tree view */

        scrolled = gtk_scrolled_window_new(NULL, NULL);

        gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled),

                                       GTK_POLICY_NEVER,

                                       GTK_POLICY_AUTOMATIC);

        gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolled),

                                            GTK_SHADOW_IN);

        gtk_container_add(GTK_CONTAINER(scrolled), tourney_view);

        gtk_box_pack_start(GTK_BOX(vbox), scrolled, TRUE, TRUE, 0);

        /* Save games checkbox */

        hbox = gtk_hbox_new(FALSE, 0);

        tourney_save = gtk_check_button_new_with_label("Save games with "

                                                       "prefix:");

        gtk_box_pack_start(GTK_BOX(hbox), tourney_save, FALSE, FALSE, 0);

        tourney_prefix = gtk_entry_new();

        gtk_box_pack_start(GTK_BOX(hbox), tourney_prefix, TRUE, TRUE, 0);

        gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);

        /* Execute button */

        hbox = gtk_hbox_new(TRUE, 0);

        tourney_exec = gtk_button_new_from_stock(GTK_STOCK_EXECUTE);

        g_signal_connect(G_OBJECT(tourney_exec), "clicked",

                         G_CALLBACK(tourney_dialog_execute), NULL);

        gtk_widget_set_no_show_all(tourney_exec, TRUE);

        gtk_widget_show(tourney_exec);

        gtk_box_pack_start(GTK_BOX(hbox), tourney_exec, TRUE, TRUE, 0);

        /* Halt button */

        tourney_halt = gtk_button_new_from_stock(GTK_STOCK_STOP);

        g_signal_connect(G_OBJECT(tourney_halt), "clicked",

                         G_CALLBACK(tourney_dialog_stop), NULL);

        gtk_widget_set_no_show_all(tourney_halt, TRUE);

        gtk_widget_hide(tourney_halt);

        gtk_box_pack_start(GTK_BOX(hbox), tourney_halt, TRUE, TRUE, 0);

        /* Close button */

        w = gtk_button_new_from_stock(GTK_STOCK_CLOSE);

        g_signal_connect(G_OBJECT(w), "clicked",

                         G_CALLBACK(tourney_dialog_close), NULL);

        gtk_box_pack_start(GTK_BOX(hbox), w, TRUE, TRUE, 0);

        gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);

        /* Create dialog window */

        tourney_dialog = gtk_window_new(GTK_WINDOW_TOPLEVEL);

        g_signal_connect(G_OBJECT(tourney_dialog), "delete-event",

                         G_CALLBACK(gtk_widget_hide_on_delete), NULL);

        gtk_window_set_title(GTK_WINDOW(tourney_dialog), "Tournament");

        gtk_window_set_transient_for(GTK_WINDOW(tourney_dialog),

                                     GTK_WINDOW(window));

        gtk_window_set_modal(GTK_WINDOW(tourney_dialog), TRUE);

        gtk_container_add(GTK_CONTAINER(tourney_dialog), vbox);

        gtk_container_border_width(GTK_CONTAINER(tourney_dialog), 12);

        gtk_window_resize(GTK_WINDOW(tourney_dialog), 256, 384);

}

void open_tourney_dialog(GtkWidget *menuitem)

{

        if (!players[PIECE_BLACK].ai || !players[PIECE_WHITE].ai) {

                GtkWidget * dialog;

                dialog = gtk_message_dialog_new(GTK_WINDOW(window),

                                                GTK_DIALOG_DESTROY_WITH_PARENT,

                                                GTK_MESSAGE_ERROR,

                                                GTK_BUTTONS_OK,

                                                "Cannot run a tournament with "

                                                "human players.");

                gtk_dialog_run(GTK_DIALOG(dialog));

                gtk_widget_destroy(dialog);

                return;

        }

        gtk_widget_show_all(tourney_dialog);

}

/*

 *      Player dialog

 */

PlayerDialog player_dialog[PIECES];

static void player_dialog_ok(GtkWidget *button, PlayerDialog *pd)

{

        int i, index;

        gtk_widget_hide(pd->window);

        index = gtk_combo_box_get_active(GTK_COMBO_BOX(pd->combo));

        /* Search options */

        pd->player->depth =

                   gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(pd->depth));

        pd->player->branch =

                  gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(pd->branch));

        pd->player->cache =

                     gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(pd->cache));

        pd->player->tss =

                       gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(pd->tss));

        for (i = 0; i < SEARCHES; i++)

                if (gtk_toggle_button_get_active(

                                            GTK_TOGGLE_BUTTON(pd->search[i]))) {

                        pd->player->search = i;

                        break;

                }

        /* Marker player */

        if (pd->player == players) {

                AIMoves *moves;

                if (index == PLAYER_HUMAN) {

                        draw_marks(NULL, FALSE);

                        return;

                }

                pd->player->ai = index;

                stop_ai();

                moves = run_ai(players);

                if (opt_print_u)

                        g_debug("AI %s utility %d (0x%x)", ai(index)->s_desc,

                                moves->utility, moves->utility);

                setup_move();

                draw_marks(moves, TRUE);

                return;

        }

        /* White or black player changed */

        if (pd->player->ai != index) {

                pd->player->ai = index;

                stop_ai();

                setup_move();

        }

}

void player_dialog_init(PlayerDialog *pd, PIECE player)

{

        GtkWidget *vbox, *hbox, *fbox, *w;

        GSList *group = NULL;

        int i, i_max;

        const char *label;

        pd->player = players + player;

        vbox = gtk_vbox_new(FALSE, 4);

        /* Controller combo box */

        hbox = gtk_hbox_new(FALSE, 0);

        w = gtk_label_new("Controller:");

        gtk_box_pack_start(GTK_BOX(hbox), w, FALSE, FALSE, 8);

        w = gtk_combo_box_new_text();

        i_max = number_of_ais();

        for (i = 0; i < i_max; i++) {

                AI *a = ai(i);

                label = "Human";

                if (a->func)

                        label = player_to_string(i);

                gtk_combo_box_append_text(GTK_COMBO_BOX(w), label);

        }

        gtk_combo_box_set_active(GTK_COMBO_BOX(w), 0);

        pd->combo = w;

        gtk_box_pack_start(GTK_BOX(hbox), w, FALSE, FALSE, 0);

        gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);

        /* Search box frame */

        w = gtk_frame_new("Search");

        gtk_box_pack_start(GTK_BOX(vbox), w, FALSE, FALSE, 4);

        fbox = gtk_vbox_new(FALSE, 4);

        gtk_container_add(GTK_CONTAINER(w), fbox);

        gtk_container_border_width(GTK_CONTAINER(fbox), 8);

        /* Search radio buttons */

        for (i = 0; i < SEARCHES; i++) {

                w = gtk_radio_button_new_with_label(group, search_to_string(i));

                group = gtk_radio_button_get_group(GTK_RADIO_BUTTON(w));

                gtk_box_pack_start(GTK_BOX(fbox), w, FALSE, FALSE, 0);

                pd->search[i] = w;

        }

        /* Cache toggle button */

        pd->cache = gtk_check_button_new_with_label("Use search cache");

        gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(pd->cache), TRUE);

        gtk_box_pack_start(GTK_BOX(fbox), pd->cache, FALSE, FALSE, 0);

        /* Threat-space search toggle button */

        pd->tss = gtk_check_button_new_with_label("Threat-space search");

        gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(pd->tss), FALSE);

        /*gtk_box_pack_start(GTK_BOX(fbox), pd->tss, FALSE, FALSE, 0);*/

        /* Search depth spin button */

        w = labeled_spin_new("Depth in moves:", 1., MAX_DEPTH, 1., &pd->depth,

                             NULL);

        gtk_box_pack_start(GTK_BOX(fbox), w, FALSE, FALSE, 0);

        /* Minimum branching factor spin button */

        w = labeled_spin_new("Minimum branches:", 0., MAX_BRANCH, 2.,

                             &pd->branch, NULL);

        gtk_box_pack_start(GTK_BOX(fbox), w, FALSE, FALSE, 0);

        /* Ok button */

        hbox = gtk_hbox_new(TRUE, 0);

        w = gtk_hbox_new(FALSE, 0);

        gtk_box_pack_start(GTK_BOX(hbox), w, FALSE, FALSE, 0);

        w = gtk_button_new_from_stock(GTK_STOCK_OK);

        g_signal_connect(G_OBJECT(w), "clicked",

                         G_CALLBACK(player_dialog_ok), pd);

        gtk_box_pack_start(GTK_BOX(hbox), w, TRUE, TRUE, 0);

        gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);

        /* Create dialog window */

        pd->window = gtk_window_new(GTK_WINDOW_TOPLEVEL);

        g_signal_connect(G_OBJECT(pd->window), "delete-event",

                         G_CALLBACK(gtk_widget_hide_on_delete), NULL);

        label = "Mark Player";

        if (player)

                label = va("%s Player", piece_to_string(player));

        gtk_window_set_title(GTK_WINDOW(pd->window), label);

        gtk_window_set_transient_for(GTK_WINDOW(pd->window),

                                     GTK_WINDOW(window));

        gtk_window_set_modal(GTK_WINDOW(pd->window), TRUE);

        gtk_window_set_resizable(GTK_WINDOW(pd->window), FALSE);

        gtk_container_add(GTK_CONTAINER(pd->window), vbox);

        gtk_container_border_width(GTK_CONTAINER(pd->window), 12);

}

void open_player_dialog(GtkWidget *menuitem, PlayerDialog *pd)

{

        gtk_widget_show_all(pd->window);