root/trunk/src/gtk/main-gtk.c

/*
 * File: main-gtk.c
 * Purpose: GTK port for Angband
 *
 * Copyright (c) 2000-2007 Robert Ruehlmann, Shanoah Alkire
 *
 * This work is free software; you can redistribute it and/or modify it
 * under the terms of either:
 *
 * a) the GNU General Public License as published by the Free Software
 *    Foundation, version 2, or
 *
 * b) the "Angband licence":
 *    This software may be copied and distributed for educational, research,
 *    and not for profit purposes provided that this copyright and statement
 *    are included in all such copies.  Other copyrights may also apply.
 */
 
#include "angband.h"

#ifdef USE_GTK
#include "main-gtk.h"
/* 
 *Add a bunch of debugger message, to trace where problems are. 
 */
/*#define GTK_DEBUG*/

/* 
 *Write all debugger messages to the command line, as well as the debugger window. 
*/
#define VERBOSE_DEBUG

#ifdef GTK_DEBUG
static void surface_status(cptr function_name, term_data *td)
{
        if (td->surface == NULL) 
                glog("No Surface for %s in '%s'", function_name, td->name);
        else
                if (cairo_surface_status(td->surface) != CAIRO_STATUS_SUCCESS)
                        glog("%s: Surface status for '%s': %s",function_name,td->name, cairo_status_to_string(cairo_surface_status(td->surface)));
}
#endif

/*#define USE_GTK_BUILDER*/

#ifdef USE_GTK_BUILDER
#define GTK_XML "angband.xml"

static GtkWidget *get_widget(GtkBuilder *xml, cptr name)
{
        return GTK_WIDGET(gtk_builder_get_object(xml, name));
}

static GtkBuilder *get_gtk_xml(cptr buf, cptr secondary)
{
        GtkBuilder *xml;
        int e = 0;
        
        xml = gtk_builder_new();
        e = gtk_builder_add_from_file (xml, buf, NULL);
        
        return xml;
}

#else
#define GTK_XML "angband.glade"

static GtkWidget *get_widget(GladeXML *xml, cptr name)
{
        return GTK_WIDGET(glade_xml_get_widget(xml, name));
}

static GladeXML *get_gtk_xml(cptr buf, cptr secondary)
{
        return glade_xml_new(buf, secondary, NULL);
}
#endif

static void recreate_surface(term_data *td)
{
        if ((td->drawing_area != NULL) && (cairo_surface_get_reference_count(td->surface) > 0))
        {
                cairo_surface_destroy(td->surface);
        }
        
        td->surface = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, td->size.w, td->size.h);
        set_term_matrix(td);    
}

static void set_term_menu(int number, bool value)
{
        term_data *td = &data[number];
        
        if (td->menu_item != NULL) 
                gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(td->menu_item), value);

}

static bool get_term_menu(int number)
{
        bool value = FALSE;
        term_data *td = &data[number];
        
        if (td->menu_item != NULL) 
                value = gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(td->menu_item));
        
        return value;

}

static int xtra_window_from_name(cptr s)
{
        xtra_win_data *xd;
        int i = 0,t = -1;
        
        for (i = 0; i < MAX_XTRA_WIN_DATA; i++)
        {
                xd = &xdata[i];
                if (GTK_IS_WIDGET(xd->win) && (xd->win != NULL) && (s == gtk_widget_get_name(xd->win)) )
                        t = i;
        }
        return(t);
}

static int xtra_window_from_drawing_area(cptr s)
{
        xtra_win_data *xd;
        int i = 0,t = -1;
        for (i = 0; i < MAX_XTRA_WIN_DATA; i ++)
        {
                xd = &xdata[i];
                if ((xd->drawing_area != NULL) && (s == gtk_widget_get_name(xd->drawing_area))) t = i;
        }
        return(t);
}

static int xtra_window_from_widget(GtkWidget *widget)
{
        return xtra_window_from_name(gtk_widget_get_name(widget));
}

static int td_from_name(cptr s, cptr pattern)
{
        int t = -1;
        sscanf(s, pattern, &t);
        return(t);
}
static int term_window_from_name(cptr s)
{
        return td_from_name(s, "term_window_%d");
}
static int td_from_widget(GtkWidget *widget, cptr pattern)
{
        return td_from_name(gtk_widget_get_name(widget), pattern);
}

static int term_window_from_widget(GtkWidget *widget)
{
        return term_window_from_name(gtk_widget_get_name(widget));
}

static int max_win_width(term_data *td)
{
        return (255 * td->font.w);
}

static int max_win_height(term_data *td)
{
        return(255 * td->font.h);
}

static int row_in_pixels(term_data *td, int x)
{
        return(x * td->font.w);
}

static int col_in_pixels(term_data *td, int y)
{
        return(y * td->font.h);
}

/*
 * Find the square a particular pixel is part of.
 */
static void pixel_to_square(int * const x, int * const y, const int ox, const int oy)
{
        term_data *td = (term_data*)(Term->data);

        (*x) = (ox / td->font.w);
        (*y) = (oy / td->font.h);
}

void set_term_matrix(term_data *td)
{
        /* Get a matrix set up to scale the graphics. */
        if ((td->surface != NULL) && (td->visible)) 
                matrix = cairo_font_scaling(td->surface, td->tile.w, td->tile.h, td->actual.w, td->actual.h);
}

gboolean on_big_tiles(GtkWidget *widget, GdkEventButton *event, gpointer user_data)
{
        term_data *td = &data[0];
        
        if ((widget != NULL) && (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(widget))))
                use_bigtile = FALSE;
        else
                use_bigtile = TRUE;
        
        load_font_by_name(td, td->font.name);
        term_data_redraw(td);
        return(TRUE);
}

static GdkRectangle cairo_rect_to_gdk(cairo_rectangle_t *r)
{
        GdkRectangle s;
        
        s.x = r->x;
        s.y = r->y;
        s.width = r->width;
        s.height = r->height;
        
        return(s);
}

static cairo_rectangle_t gdk_rect_to_cairo(GdkRectangle *r)
{
        cairo_rectangle_t s;
        
        s.x = r->x;
        s.y = r->y;
        s.width = r->width;
        s.height = r->height;
        
        return(s);
}

static void invalidate_drawing_area(GtkWidget *widget, cairo_rectangle_t r)
{
        GdkRectangle s;
        
        s = cairo_rect_to_gdk(&r);
        if (widget->window != NULL)
        {
                gdk_window_invalidate_rect(widget->window, &s, TRUE);
        }
}

void set_row_and_cols(term_data *td)
{
        int cols = td->cols;
        int rows = td->rows;
        
        td->cols = td->size.w / td->font.w;
        td->rows= td->size.h / td->font.h;
        
        if (MAIN_WINDOW(td))
        {
                if (td->cols < 80) td->cols = cols;
                if (td->rows < 24) td->rows = rows;
        }
        
        if ((cols != td->cols) || (rows != td->rows))
        { 
                recreate_surface(td);
                term_data_redraw(td);
        }
}
static void redraw_term(term_data *td)
{               
        set_window_size(td);
                
        recreate_surface(td);
        term_data_redraw(td);
        force_redraw();
}

gboolean set_term_row(GtkWidget *widget, GdkEventConfigure *event, gpointer user_data)
{
        int t = td_from_widget(widget, "row_%d");
        
        if (t != -1)
        {
                term_data *td = &data[t];
                td->rows = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(widget));
                redraw_term(td);
        }
        return(FALSE);
}

gboolean set_term_col(GtkWidget *widget, GdkEventConfigure *event, gpointer user_data)
{
        int t = td_from_widget(widget, "col_%d");
        
        if (t != -1)
        {
                term_data *td = &data[t];
                td->cols = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(widget));
                redraw_term(td);
        }
        return(FALSE);
}

/* 
 * Get the position of the window and save it.
 */
gboolean configure_event_handler(GtkWidget *widget, GdkEventConfigure *event, gpointer user_data)
{
        int t = -1;
        term_data *td;
        
        t = term_window_from_widget(widget);
        
        if (t != -1)
        {
                td = &data[t];
                
                if (td->initialized)
                {
                        if (event->x != 0) td->location.x = event->x;
                        if (event->y != 0) td->location.y = event->y;
                        if (event->width != 0)  td->size.w = event->width;
                        if (event->height != 0) td->size.h = event->height;
                }
        }
        return(FALSE);
}

gboolean xtra_configure_event_handler(GtkWidget *widget, GdkEventConfigure *event, gpointer user_data)
{
        xtra_win_data *xd;
        int t;
        
        t = xtra_window_from_widget(widget);
        if (t != -1)
        {
                int x = 0, y = 0, w = 0, h = 0;
                GdkRectangle r;
                
                xd = &xdata[t];
        
                if (GTK_WIDGET_VISIBLE(xd->win))
                {
                        gdk_window_get_frame_extents(xd->win->window, &r);
                        x = r.x;
                        y = r.y;
                        
                        gtk_window_get_size(GTK_WINDOW(xd->win), &w, &h);
                
                        if (x != 0)  xd->location.x = x;
                        if (y != 0)  xd->location.y = y;
                        if (w != 0) xd->size.w = w;
                        if (h != 0)  xd->size.h = h;
                
                        xd->visible = TRUE;
                }
                else
                        xd->visible = FALSE;
        }
        return(FALSE);
}

static void set_window_defaults(term_data *td)
{
        GdkGeometry geo;
        
        geo.width_inc = td->font.w;
        geo.height_inc = td->font.h;
        
        geo.max_width =(td->font.w * td->cols);
        geo.max_height = (td->font.h * td->rows);
        
        if (MAIN_WINDOW(td))
        {
                geo.min_width = geo.max_width;
                geo.min_height = geo.max_height;
        }
        else
        {
                geo.min_width = td->font.w;
                geo.min_height = td->font.h;
        }
        
        gtk_window_set_geometry_hints(GTK_WINDOW(td->win), td->drawing_area, &geo, 
        GDK_HINT_RESIZE_INC | GDK_HINT_MIN_SIZE | GDK_HINT_MAX_SIZE);
}

static void set_window_size(term_data *td)
{
        set_window_defaults(td);
        gtk_window_set_position(GTK_WINDOW(td->win),GTK_WIN_POS_NONE);
        
        if MAIN_WINDOW(td)
        {
                gtk_widget_set_size_request(GTK_WIDGET(td->drawing_area), td->size.w, td->size.h);
        }
        
        gtk_window_resize(GTK_WINDOW(td->win), td->size.w, td->size.h);
        
        gtk_window_move(GTK_WINDOW(td->win), td->location.x, td->location.y);
        
        gtk_window_get_size(GTK_WINDOW(td->win), &td->size.w, &td->size.h);
}

static void set_xtra_window_size(xtra_win_data *xd)
{
        gtk_window_set_position(GTK_WINDOW(xd->win),GTK_WIN_POS_NONE);
        if ((xd->size.w > 0) && (xd->size.h > 0))
                gtk_window_resize(GTK_WINDOW(xd->win), xd->size.w, xd->size.h);
        gtk_window_move(GTK_WINDOW(xd->win), xd->location.x, xd->location.y);
}

int button_add_gui(const char *label, unsigned char keypress)
{
        int i=0;
        bool assigned = FALSE;
        GtkWidget *widget;
        int length = strlen(label);
        
        /*static GtkWidget *toolbar;
        static GtkWidget *toolbar_items[12];
        static int toolbar_size;
        static unsigned char toolbar_keypress[12];*/
        

        /* Check we haven't already got a button for this keypress */
        for (i=0; i < toolbar_size; i++)
        {
                if (toolbar_keypress[i] == keypress)
                        assigned = TRUE;
        }
        /* Make the button */
        if (!assigned)
        {
                widget = gtk_button_new_with_label(label);
                toolbar_size++;
                toolbar_keypress[toolbar_size]=keypress;
                toolbar_items[toolbar_size] = widget;
                /*gtk_container_add(toolbar, widget);*/
        }

        /* Return the size of the button */
        return (length);
}

int button_kill_gui(unsigned char keypress)
{
        /*int length;*/

        /* Find the button */

        /* No such button */
        if (0)
        {
                return 0;
        }

        /* Find the length */

        /* Move each button up one */

        /* Wipe the data */

        /* Redraw */
        p_ptr->redraw |= (PR_BUTTONS);
        redraw_stuff();

        /* Return the size of the button */
        return 0 /*(length)*/;
}
/*
 * Erase the whole term.
 */
static errr Term_clear_gtk(void)
{
        term_data *td = (term_data*)(Term->data);
        cairo_rectangle_t r;
        
        init_cairo_rect(&r, 0, 0, max_win_width(td), max_win_height(td));
        cairo_clear(td->surface, r, TERM_DARK);
        invalidate_drawing_area(td->drawing_area, r);

        return (0);
}

/*
 * Erase some characters.
 */
static errr Term_wipe_gtk(int x, int y, int n)
{
        term_data *td = (term_data*)(Term->data);
        cairo_rectangle_t r;
        
        init_cairo_rect(&r, (td->actual.w * x), (td->actual.h * y), (td->actual.w * n), (td->actual.h));
        cairo_clear(td->surface, r, TERM_DARK);
        invalidate_drawing_area(td->drawing_area, r);

        return (0);
}

/*
 * Draw some textual characters.
 */
static errr Term_text_gtk(int x, int y, int n, byte a, cptr s)
{
        term_data *td = (term_data*)(Term->data);
        cairo_rectangle_t r;
        
        init_cairo_rect(&r, (td->font.w * x), (td->font.h * y),  (td->font.w * n), td->font.h);
        draw_text(td->surface, &td->font, &td->actual, x, y, n, a, s);
        invalidate_drawing_area(td->drawing_area, r);
                        
        return (0);
}

static errr Term_pict_gtk(int x, int y, int n, const byte *ap, const char *cp, const byte *tap, const char *tcp)
{
        term_data *td = (term_data*)(Term->data);
        cairo_rectangle_t r;
        
        init_cairo_rect(&r, (td->actual.w * x), (td->actual.h * y),  (td->actual.w * n), (td->actual.h));
        draw_tiles(td->surface, x, y, n, ap, cp, tap, tcp, &td->font, &td->actual, &td->tile);
        invalidate_drawing_area(td->drawing_area, r);
                        
        return (0);
}

static errr Term_flush_gtk(void)
{
        gdk_flush();
        return (0);
}

static errr Term_fresh_gtk(void)
{
        term_data *td = (term_data*)(Term->data);
        cairo_rectangle_t r;
        
        init_cairo_rect(&r, 0, 0, max_win_width(td), max_win_height(td));
        invalidate_drawing_area(td->drawing_area, r);
        gdk_window_process_updates(td->win->window, 1);
        return (0);
}

/*
 * Handle a "special request"
 */
static errr Term_xtra_gtk(int n, int v)
{
        /* Handle a subset of the legal requests */
        switch (n)
        {
                /* Make a noise */
                case TERM_XTRA_NOISE: 
                        return (0);

                /* Flush the output */
                case TERM_XTRA_FRESH: 
                        return (Term_fresh_gtk());

                /* Process random events */
                case TERM_XTRA_BORED: 
                        return (CheckEvent(0));

                /* Process Events */
                case TERM_XTRA_EVENT: 
                        return (CheckEvent(v));

                /* Flush the events */
                case TERM_XTRA_FLUSH: 
                        return (Term_flush_gtk());

                /* Handle change in the "level" */
                case TERM_XTRA_LEVEL: 
                        return (0);

                /* Clear the screen */
                case TERM_XTRA_CLEAR: 
                        return (Term_clear_gtk());

                /* Delay for some milliseconds */
                case TERM_XTRA_DELAY:
                        if (v > 0) usleep(1000 * v);
                        return (0);

                /* React to changes */
                case TERM_XTRA_REACT: 
                        return (0);
        }

        /* Unknown */
        return (1);
}

static errr Term_curs_gtk(int x, int y)
{
        term_data *td = (term_data*)(Term->data);
        cairo_rectangle_t r;
        
        init_cairo_rect(&r, row_in_pixels(td, x)+1, col_in_pixels(td, y) + 1,  (td->actual.w) - 2, (td->actual.h) - 2);
        cairo_cursor(td->surface, r, TERM_SLATE);
        invalidate_drawing_area(td->drawing_area, r);
        
        return (0);
}

/*
 * Hack -- redraw a term_data.
 * Note that "Term_redraw()" calls "TERM_XTRA_CLEAR"
 */
static void term_data_redraw(term_data *td)
{
        term *old = Term;
        
        /* Activate the term passed to it, not term 0! */
        Term_activate(&td->t);

        Term_resize(td->cols, td->rows);
        Term_redraw();
        Term_fresh();
        
        Term_activate(old);
}

static void force_redraw()
{
        if (game_in_progress)
        {
                reset_visuals(TRUE);
                Term_key_push(KTRL('R'));
        }
}
static errr CheckEvent(bool wait)
{
        if (wait)
                gtk_main_iteration();
        else
                while (gtk_events_pending())
                        gtk_main_iteration();

        return (0);
}

static bool save_game_gtk(void)
{
        if (game_in_progress && character_generated)
        {
                if (!inkey_flag)
                {
                        glog( "You may not do that right now.");
                        return(FALSE);
                }

                /* Hack -- Forget messages */
                msg_flag = FALSE;
                
                /* Save the game */
                do_cmd_save_game();
        }
        
        return(TRUE);
}

static void hook_quit(cptr str)
{
        gtk_log_fmt(TERM_RED,"%s", str);
        save_prefs();
        release_memory();
        exit(0);
}

gboolean quit_event_handler(GtkWidget *widget, GdkEventButton *event, gpointer user_data)
{
        if (save_game_gtk())
        {
                save_prefs();
                quit(NULL);
                exit(0);
                return(FALSE);
        }
        else
                return(TRUE);
}

gboolean destroy_event_handler(GtkWidget *widget, GdkEventButton *event, gpointer user_data)
{
        quit(NULL);
        exit(0);
        return(FALSE);
}

gboolean new_event_handler(GtkWidget *widget, GdkEventButton *event, gpointer user_data)
{
        if (game_in_progress)
        {
                glog( "You can't start a new game while you're still playing!");
                return(TRUE);
        }
        else
        {
                /* We'll return NEWGAME to the game. */ 
                cmd.command = CMD_NEWGAME;
                gtk_widget_set_sensitive(widget, FALSE);
                return(FALSE);
        }
}

static void load_font_by_name(term_data *td, cptr font_name)
{       
        PangoFontDescription *temp_font;
        char buf[80];
        unsigned int i, j = 0;

        my_strcpy(td->font.name, font_name, sizeof(td->font.name));

        for (i = 0; i < strlen(font_name); i++)
                if (font_name[i] == ' ') 
                        j = i;
        
        for (i = j; i < strlen(font_name); i++)
                buf[i - j] = font_name[i];

        temp_font = pango_font_description_from_string(font_name);
        my_strcpy(td->font.family, pango_font_description_get_family(temp_font), sizeof(td->font.family));
        td->font.size = atof(buf);
        if (td->font.size == 0) td->font.size = 12;
        get_font_size(&td->font);
        
        if (use_bigtile)
        {
                td->actual.w = td->font.w * 2;
                td->actual.h = td->font.h;
        }
        else
        {
                td->actual.w = td->font.w;
                td->actual.h = td->font.h;
        }
        
        td->size.w = td->cols * td->font.w;
        td->size.h = td->rows * td->font.h;
        
        if ((td->initialized == TRUE) && (td->win != NULL)  && (td->visible))
        {
                /* Get a matrix set up to scale the graphics. */
                set_term_matrix(td);
                
                gtk_widget_hide(td->win);
                set_window_size(td);
                gtk_widget_show(td->win);
                
                term_data_redraw(td);
        }
}

void set_term_font(GtkFontButton *widget, gpointer user_data)   
{
        term_data *td;

        const char *font_name;
        const char *s;
        int t;
        
        s = gtk_widget_get_name(GTK_WIDGET(widget));
        sscanf(s, "term_font_%d", &t);

        td = &data[t];

        font_name = gtk_font_button_get_font_name(widget);
        load_font_by_name(td, font_name);
}

void set_xtra_font(GtkFontButton *widget, gpointer user_data)   
{
        const char *temp, *s;
        int i, t = 0;
        xtra_win_data *xd;
        
        s = gtk_widget_get_name(GTK_WIDGET(widget));
        
        for (i = 0; i < MAX_XTRA_WIN_DATA; i ++)
        {
                xtra_win_data *xd = &xdata[i];
                if (s == xd->font_button_name) t = i;
        }
        
        xd=&xdata[t];
        
        temp = gtk_font_button_get_font_name(widget);
        my_strcpy(xd->font.name, temp, sizeof(xd->font.name));
        get_font_size(&xd->font);
        if (xd->text_view != NULL)
                gtk_widget_modify_font(GTK_WIDGET(xd->text_view), pango_font_description_from_string(xd->font.name));
        
        if ((xd->surface != NULL) && (xd->event != 0))
        {
                event_signal(xd->event);
        }
}

/*** Callbacks: savefile opening ***/

/* Filter function for the savefile list */
static gboolean file_open_filter(const GtkFileFilterInfo *filter_info, gpointer data)
{
        const char *name = filter_info->display_name;

        (void)data;

        /* Count out known non-savefiles */
        if (!strcmp(name, "Makefile") ||
            !strcmp(name, "delete.me"))
        {
                return FALSE;
        }

        /* Let it pass */
        return TRUE;
}

/*
 * Open/Save Dialog box
 */
static bool save_dialog_box(bool save)
{
        GtkFileFilter *filter;
        GtkWidget *selector_wid;
        GtkFileChooser *selector;
        bool accepted;
        
        char buf[1024];
        const char *filename;

        /* Forget it if the game is in progress */
        /* XXX Should disable the menu entry XXX */
        if (game_in_progress && !save)
        {
                glog( "You can't open a new game while you're still playing!");
                return(FALSE);
        }
                        
        if ((!game_in_progress || !character_generated) && save)
        {
                glog( "You can't save a new game unless you're still playing!");
                return(FALSE);
        }

        if (!inkey_flag && save)
        {
                glog( "You may not do that right now.");
                return(FALSE);
        }
        
        /* Create a new file selector dialogue box, with no parent */
        if (!save)
        {
        selector_wid = gtk_file_chooser_dialog_new("Select a savefile", NULL,
                                               GTK_FILE_CHOOSER_ACTION_OPEN,
                                               GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
                                               GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
                                               NULL);
        }
        else
        {
        selector_wid = gtk_file_chooser_dialog_new("Save your game", NULL,
                                               GTK_FILE_CHOOSER_ACTION_SAVE,
                                               GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
                                               GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT,
                                               NULL);
        gtk_file_chooser_set_current_name (GTK_FILE_CHOOSER (selector_wid), op_ptr->full_name);
        }
        /* For convenience */
        selector = GTK_FILE_CHOOSER(selector_wid);
        gtk_file_chooser_set_do_overwrite_confirmation (selector, TRUE);;
        
        /* Get the current directory (so we can find lib/save/) */
        filename = gtk_file_chooser_get_current_folder(selector);
        path_build(buf, sizeof buf, filename, ANGBAND_DIR_SAVE);
        gtk_file_chooser_set_current_folder(selector, buf);

        /* Restrict the showing of pointless files */
        filter = gtk_file_filter_new();
        gtk_file_filter_add_custom(filter, GTK_FILE_FILTER_DISPLAY_NAME, file_open_filter, NULL, NULL);
        gtk_file_chooser_set_filter(selector, filter);
        
        accepted = (gtk_dialog_run(GTK_DIALOG(selector_wid)) == GTK_RESPONSE_ACCEPT);
        
        /* Run the dialogue */
        if (accepted)
        {
                /* Get the filename, copy it into the savefile name */
                filename = gtk_file_chooser_get_filename(selector);
                my_strcpy(savefile, filename, sizeof(savefile));
                game_saved = TRUE;
        }
                
        /* Destroy it now that we're done with it */
        gtk_widget_destroy(selector_wid);
        
        /* Done */
        return accepted;
}

void open_event_handler(GtkButton *was_clicked, gpointer user_data)
{
        bool accepted;
        
        accepted = save_dialog_box(FALSE);
        
        /* Set the command now so that we skip the "Open File" prompt. */ 
        if (accepted) cmd.command = CMD_LOADFILE; 
        
        /* Done */
        return;
}

gboolean save_as_event_handler(GtkWidget *widget, GdkEvent *event, gpointer user_data)
{
        bool accepted;
        
        accepted = save_dialog_box(TRUE);
        
        if (accepted)
        {
                Term_flush();
                save_game_gtk();
        }
        /* Done */
        return(FALSE);
}

gboolean save_event_handler(GtkWidget *widget, GdkEvent *event, gpointer user_data)
{
        bool accepted;
        
        if (game_saved)
                do_cmd_save_game();
        else
        {
                accepted = save_dialog_box(TRUE);
        
                if (accepted)
                {
                        Term_flush();
                        save_game_gtk();
                }
        }
        /* Done */
        return(FALSE);
}

gboolean delete_event_handler(GtkWidget *widget, GdkEvent *event, gpointer user_data)
{
        save_game_gtk();
        return (FALSE);
}

gboolean keypress_event_handler(GtkWidget *widget, GdkEventKey *event, gpointer user_data)
{
        int i, mc, ms, mo, mx;
        guint modifiers;

        char msg[128];

        modifiers = gtk_accelerator_get_default_mod_mask ();
        
        /* Extract four "modifier flags" */
        mc = ((event->state & modifiers) == GDK_CONTROL_MASK) ? TRUE : FALSE;
        ms = ((event->state & modifiers) == GDK_SHIFT_MASK) ? TRUE : FALSE;
        mo = ((event->state & modifiers) == GDK_MOD1_MASK) ? TRUE : FALSE;
        mx = ((event->state & modifiers) == GDK_MOD3_MASK) ? TRUE : FALSE;

        /*
         * Hack XXX
         * Parse shifted numeric (keypad) keys specially.
         */
        if (ms && (event->keyval >= GDK_KP_0) && (event->keyval <= GDK_KP_9))
        {
                /* Build the macro trigger string */
                strnfmt(msg, sizeof(msg), "%cS_%X%c", 31, event->keyval, 13);

                /* Enqueue the "macro trigger" string */</