WebSVN – eduke32 – Diff – /polymer/eduke32/source/startgtk.game.c


//-------------------------------------------------------------------------
/*
Copyright (C) 2010 EDuke32 developers and contributors

This file is part of EDuke32.

EDuke32 is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License version 2
as published by the Free Software Foundation.

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 "gtkpixdata.h"

#if defined(LINKED_GTK)
#include <gtk/gtk.h>
#include <gdk-pixbuf/gdk-pixdata.h>
#else
#include "dynamicgtk.h"
#endif

#include "duke3d.h"
#include "grpscan.h"
#include "build.h"

#include "game.h"
#include "common.h"
#include "common_game.h"

enum
{
    NONE,
    ALL,
    POPULATE_VIDEO,
    POPULATE_CONFIG,
    POPULATE_GAME,
};

enum
{
    TAB_CONFIG,
    TAB_GAME,
    TAB_MESSAGES,
};

enum
{
    INPUT_KB,
    INPUT_MOUSE,
    INPUT_JOYSTICK,
    INPUT_ALL,
};

static struct
{
    GtkWidget *startwin;
    GtkWidget *hlayout;
    GtkWidget *banner;
    GtkWidget *vlayout;
    GtkWidget *tabs;
    GtkWidget *configtlayout;
    GtkWidget *displayvlayout;
    GtkWidget *vmode3dlabel;
    GtkWidget *vmode3dcombo;
    GtkWidget *fullscreencheck;
#ifdef POLYMER
    GtkWidget *polymercheck;
#endif
    GtkWidget *inputdevlabel;
    GtkWidget *inputdevcombo;
    GtkWidget *custommodlabel;
    GtkWidget *custommodcombo;
    GtkWidget *emptyhlayout;
    GtkWidget *autoloadcheck;
    GtkWidget *alwaysshowcheck;
    GtkWidget *configtab;
    GtkWidget *gamevlayout;
    GtkWidget *gamelabel;
    GtkWidget *gamescroll;
    GtkWidget *gamelist;
    GtkWidget *gametab;
    GtkWidget *messagesscroll;
    GtkWidget *messagestext;
    GtkWidget *messagestab;
    GtkWidget *buttons;
    GtkWidget *cancelbutton;
    GtkWidget *cancelbuttonalign;
    GtkWidget *cancelbuttonlayout;
    GtkWidget *cancelbuttonicon;
    GtkWidget *cancelbuttonlabel;
    GtkWidget *startbutton;
    GtkWidget *startbuttonalign;
    GtkWidget *startbuttonlayout;
    GtkWidget *startbuttonicon;
    GtkWidget *startbuttonlabel;
} stwidgets;

static struct
{
    int32_t fullscreen;
#ifdef POLYMER
    int32_t polymer;
#endif
    int32_t xdim3d, ydim3d, bpp3d;
    int32_t forcesetup;
    int32_t autoload;
    int32_t usemouse, usejoy;
    int32_t game;
    int32_t crcval;
    char *custommoddir;
    char selectedgrp[BMAX_PATH];
} settings;

static int32_t retval = -1, mode = TAB_MESSAGES;
extern int32_t gtkenabled;
static void PopulateForm(unsigned char pgs);


// -- EVENT CALLBACKS AND CREATION STUFF --------------------------------------

static void on_vmode3dcombo_changed(GtkComboBox *combobox, gpointer user_data)
{
    GtkTreeModel *data;
    GtkTreeIter iter;
    int32_t val;
    UNREFERENCED_PARAMETER(user_data);

    if (!gtk_combo_box_get_active_iter(combobox, &iter)) return;
    if (!(data = gtk_combo_box_get_model(combobox))) return;
    gtk_tree_model_get(data, &iter, 1, &val, -1);
    settings.xdim3d = validmode[val].xdim;
    settings.ydim3d = validmode[val].ydim;
}

static void on_fullscreencheck_toggled(GtkToggleButton *togglebutton, gpointer user_data)
{
    UNREFERENCED_PARAMETER(user_data);
    settings.fullscreen = gtk_toggle_button_get_active(togglebutton);
    PopulateForm(POPULATE_VIDEO);
}

#ifdef POLYMER
static void on_polymercheck_toggled(GtkToggleButton *togglebutton, gpointer user_data)
{
    UNREFERENCED_PARAMETER(user_data);
    if (gtk_toggle_button_get_active(togglebutton))
    {
        glrendmode = REND_POLYMER;
        settings.polymer = TRUE;
        if (settings.bpp3d == 8)
        {
            settings.bpp3d = 32;
            PopulateForm(POPULATE_VIDEO);
        }
    }
    else
    {
        glrendmode = REND_POLYMOST;
        settings.polymer = FALSE;
    }
}
#endif

static void on_inputdevcombo_changed(GtkComboBox *combobox, gpointer user_data)
{
    UNREFERENCED_PARAMETER(user_data);
    switch (gtk_combo_box_get_active(combobox))
    {
    case 0: settings.usemouse = 0; settings.usejoy = 0; break;
    case 1:     settings.usemouse = 1; settings.usejoy = 0; break;
    case 2:     settings.usemouse = 0; settings.usejoy = 1; break;
    case 3:     settings.usemouse = 1; settings.usejoy = 1; break;
    }
}

static void on_custommodcombo_changed(GtkComboBox *combobox, gpointer user_data)
{
    GtkTreeIter iter;
    GtkTreeModel *model;
    GtkTreePath *path;
    char *value;
    UNREFERENCED_PARAMETER(user_data);

    if (gtk_combo_box_get_active_iter(combobox, &iter))
    {
        model = gtk_combo_box_get_model(combobox);
        gtk_tree_model_get(model, &iter, 0,&value, -1);
        path = gtk_tree_model_get_path(model, &iter);

        if (*gtk_tree_path_get_indices(path) == NONE)
            settings.custommoddir = NULL;
        else settings.custommoddir = value;
    }
}

static void on_autoloadcheck_toggled(GtkToggleButton *togglebutton, gpointer user_data)
{
    UNREFERENCED_PARAMETER(user_data);
    settings.autoload = gtk_toggle_button_get_active(togglebutton);
}

static void on_alwaysshowcheck_toggled(GtkToggleButton *togglebutton, gpointer user_data)
{
    UNREFERENCED_PARAMETER(user_data);
    settings.forcesetup = gtk_toggle_button_get_active(togglebutton);
}

static void on_cancelbutton_clicked(GtkButton *button, gpointer user_data)
{
    UNREFERENCED_PARAMETER(button);
    UNREFERENCED_PARAMETER(user_data);
    if (mode == TAB_CONFIG) { retval = 0; gtk_main_quit(); }
    else quitevent++;
}

static void on_startbutton_clicked(GtkButton *button, gpointer user_data)
{
    UNREFERENCED_PARAMETER(button);
    UNREFERENCED_PARAMETER(user_data);
    retval = 1;
    gtk_main_quit();
}

static void on_gamelist_selection_changed(GtkTreeSelection *selection, gpointer user_data)
{
    GtkTreeIter iter;
    GtkTreeModel *model;
    struct grpfile *fg;
    UNREFERENCED_PARAMETER(user_data);

    if (gtk_tree_selection_get_selected(selection, &model, &iter))
    {
        gtk_tree_model_get(model, &iter, 2, (gpointer)&fg, -1);
        strcpy(settings.selectedgrp, fg->name);
        settings.game = fg->game;
        settings.crcval = fg->crcval;
    }
}

static gboolean on_startwin_delete_event(GtkWidget *widget, GdkEvent *event, gpointer user_data)
{
    UNREFERENCED_PARAMETER(widget);
    UNREFERENCED_PARAMETER(event);
    UNREFERENCED_PARAMETER(user_data);
    if (mode == TAB_CONFIG) { retval = 0; gtk_main_quit(); }
    else quitevent++;
    return TRUE;        // FALSE would let the event go through. we want the game to decide when to close
}


// -- SUPPORT FUNCTIONS -------------------------------------------------------

static GdkPixbuf *load_banner(void)
{
    return gdk_pixbuf_from_pixdata((GdkPixdata*)&startbanner_pixdata, FALSE, NULL);
}

static void SetPage(int32_t n)
{
    if (!gtkenabled || !stwidgets.startwin) return;
    mode = n;
    gtk_notebook_set_current_page(GTK_NOTEBOOK(stwidgets.tabs), n);

    // each control in the config page vertical layout plus the start button should be made (in)sensitive
    if (n == TAB_CONFIG) n = TRUE; else n = FALSE;
    gtk_widget_set_sensitive(stwidgets.startbutton, n);
    gtk_container_foreach(GTK_CONTAINER(stwidgets.configtlayout),
                          (GtkCallback)gtk_widget_set_sensitive,
                          (gpointer)&n);
}

static unsigned char GetModsDirNames(GtkListStore *list)
{
    char *homedir;
    char pdir[BMAX_PATH];
    unsigned char iternumb = 0;
    CACHE1D_FIND_REC *dirs = NULL;
    GtkTreeIter iter;

    pathsearchmode = 1;

    if ((homedir = Bgethomedir()))
    {
        Bsnprintf(pdir, sizeof(pdir), "%s/" ".eduke32", homedir);
        dirs = klistpath(pdir, "*", CACHE1D_FIND_DIR);
        for (dirs=dirs; dirs != NULL; dirs=dirs->next)
        {
            if ((Bstrcmp(dirs->name, "autoload") == 0) ||
                    (Bstrcmp(dirs->name, "..") == 0) ||
                    (Bstrcmp(dirs->name, ".") == 0))
                continue;
            else
            {
                gtk_list_store_append(list, &iter);
                gtk_list_store_set(list, &iter, 0,dirs->name, -1);
                iternumb++;
            }
        }
    }

    klistfree(dirs);
    dirs = NULL;

    return iternumb;
}

static void PopulateForm(unsigned char pgs)
{
    if ((pgs == ALL) || (pgs == POPULATE_VIDEO))
    {
        int32_t mode3d, i;
        GtkListStore *modes3d;
        GtkTreeIter iter;
        char buf[64];

        mode3d = checkvideomode(&settings.xdim3d, &settings.ydim3d, settings.bpp3d, settings.fullscreen, 1);
        if (mode3d < 0)
        {
            int32_t i, cd[] = { 32, 24, 16, 15, 8, 0 };

            for (i=0; cd[i];) { if (cd[i] >= settings.bpp3d) i++; else break; }
            for (; cd[i]; i++)
            {
                mode3d = checkvideomode(&settings.xdim3d, &settings.ydim3d, cd[i], settings.fullscreen, 1);
                if (mode3d < 0) continue;
                settings.bpp3d = cd[i];
                break;
            }
        }

        modes3d = GTK_LIST_STORE(gtk_combo_box_get_model(GTK_COMBO_BOX(stwidgets.vmode3dcombo)));
        gtk_list_store_clear(modes3d);

        for (i=0; i<validmodecnt; i++)
        {
            if (validmode[i].fs != settings.fullscreen) continue;

            // all modes get added to the 3D mode list
            Bsprintf(buf, "%d x %d %dbpp", validmode[i].xdim, validmode[i].ydim, validmode[i].bpp);
            gtk_list_store_append(modes3d, &iter);
            gtk_list_store_set(modes3d, &iter, 0,buf, 1,i, -1);
            if (i == mode3d)
            {
                g_signal_handlers_block_by_func(stwidgets.vmode3dcombo, (gpointer)on_vmode3dcombo_changed, NULL);
                gtk_combo_box_set_active_iter(GTK_COMBO_BOX(stwidgets.vmode3dcombo), &iter);
                g_signal_handlers_unblock_by_func(stwidgets.vmode3dcombo, (gpointer)on_vmode3dcombo_changed, NULL);
            }
        }
    }

    if ((pgs == ALL) || (pgs == POPULATE_CONFIG))
    {
        GtkListStore *devlist, *modsdir;
        GtkTreeIter iter;
        GtkTreePath *path;
        char *value;
        unsigned char i, r = 0;
        const char *availabledev[] =
        {
            "Keyboard only",
            "Keyboard and mouse",
            "Keyboard and joystick",
            "All supported devices"
        };

        // populate input devices combo
        devlist = GTK_LIST_STORE(gtk_combo_box_get_model(GTK_COMBO_BOX(stwidgets.inputdevcombo)));
        gtk_list_store_clear(devlist);

        for (i=0; i<(int32_t)G_N_ELEMENTS(availabledev); i++)
        {
            gtk_list_store_append(devlist, &iter);
            gtk_list_store_set(devlist, &iter, 0,availabledev[i], -1);
        }
        switch (settings.usemouse)
        {
        case 0: if (settings.usejoy)
                gtk_combo_box_set_active(GTK_COMBO_BOX(stwidgets.inputdevcombo), INPUT_JOYSTICK);
            else
                gtk_combo_box_set_active(GTK_COMBO_BOX(stwidgets.inputdevcombo), INPUT_KB);
            break;
        case 1: if (settings.usejoy)
                gtk_combo_box_set_active(GTK_COMBO_BOX(stwidgets.inputdevcombo), INPUT_ALL);
            else
                gtk_combo_box_set_active(GTK_COMBO_BOX(stwidgets.inputdevcombo), INPUT_MOUSE);
            break;
        }

        // populate custom mod combo
        modsdir = GTK_LIST_STORE(gtk_combo_box_get_model(GTK_COMBO_BOX(stwidgets.custommodcombo)));
        gtk_list_store_clear(modsdir);

        gtk_list_store_append(modsdir, &iter);
        gtk_list_store_set(modsdir, &iter, 0,"None", -1);
        r = GetModsDirNames(modsdir);

        for (i=0; i<=r; i++)
        {
            path = gtk_tree_path_new_from_indices(i, -1);
            gtk_tree_model_get_iter(GTK_TREE_MODEL(modsdir), &iter, path);
            gtk_tree_model_get(GTK_TREE_MODEL(modsdir), &iter, 0,&value, -1);

            if (Bstrcmp(settings.custommoddir, "/") == 0)
            {
                gtk_combo_box_set_active(GTK_COMBO_BOX(stwidgets.custommodcombo), NONE);
                settings.custommoddir = NULL;

                break;
            }
            if (Bstrcmp(settings.custommoddir, value) == 0)
            {
                gtk_combo_box_set_active_iter(GTK_COMBO_BOX(stwidgets.custommodcombo),
                                              &iter);

                break;
            }
        }

        // populate check buttons
        gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(stwidgets.fullscreencheck), settings.fullscreen);
#ifdef POLYMER
        gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(stwidgets.polymercheck), settings.polymer);
#endif
        gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(stwidgets.autoloadcheck), settings.autoload);
        gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(stwidgets.alwaysshowcheck), settings.forcesetup);
    }

    if ((pgs == ALL) || (pgs == POPULATE_GAME))
    {
        struct grpfile *fg;
        GtkListStore *list;
        GtkTreeIter iter;
        GtkTreeView *gamelist;

        gamelist = GTK_TREE_VIEW(stwidgets.gamelist);
        list = GTK_LIST_STORE(gtk_tree_view_get_model(gamelist));
        gtk_list_store_clear(list);

        for (fg = foundgrps; fg; fg=fg->next)
        {
            struct grpfile *grp;
            for (grp = listgrps; grp; grp=grp->next)
                if (fg->crcval == grp->crcval) break;

            if (grp == NULL)
                continue;

            gtk_list_store_append(list, &iter);
            gtk_list_store_set(list, &iter, 0, grp->name, 1, fg->name, 2, (gpointer)fg, -1);
            if (!Bstrcasecmp(fg->name, settings.selectedgrp))
            {
                GtkTreeSelection *sel = gtk_tree_view_get_selection(gamelist);
                g_signal_handlers_block_by_func(sel, (gpointer)on_gamelist_selection_changed, NULL);
                gtk_tree_selection_select_iter(sel, &iter);
                g_signal_handlers_unblock_by_func(sel, (gpointer)on_gamelist_selection_changed, NULL);
            }
        }
    }
}

static gint name_sorter(GtkTreeModel *model, GtkTreeIter *a, GtkTreeIter *b, gpointer user_data)
{
    gchar *as, *bs;
    gint r;
    UNREFERENCED_PARAMETER(user_data);
    gtk_tree_model_get(model, a, 0, &as, -1);
    gtk_tree_model_get(model, b, 0, &bs, -1);

    r = g_utf8_collate(as,bs);

    g_free(as);
    g_free(bs);

    return r;
}

static GtkWidget *create_window(void)
{
    // Basic window
    stwidgets.startwin = gtk_window_new(GTK_WINDOW_TOPLEVEL);
    gtk_window_set_title(GTK_WINDOW(stwidgets.startwin), apptitle);     // NOTE: use global app title
    gtk_window_set_position(GTK_WINDOW(stwidgets.startwin), GTK_WIN_POS_CENTER);
    gtk_window_set_resizable(GTK_WINDOW(stwidgets.startwin), FALSE);
    gtk_window_set_type_hint(GTK_WINDOW(stwidgets.startwin), GDK_WINDOW_TYPE_HINT_DIALOG);

    // Horizontal layout of banner and controls
    stwidgets.hlayout = gtk_hbox_new(FALSE, 0);
    gtk_container_add(GTK_CONTAINER(stwidgets.startwin), stwidgets.hlayout);

    // banner
    {
        GdkPixbuf *pixbuf = load_banner();
        stwidgets.banner = gtk_image_new_from_pixbuf(pixbuf);
        g_object_unref((gpointer)pixbuf);
    }
    gtk_box_pack_start(GTK_BOX(stwidgets.hlayout), stwidgets.banner, FALSE, FALSE, 0);
    gtk_misc_set_alignment(GTK_MISC(stwidgets.banner), 0.5, 0);

    // Vertical layout of tab control and start+cancel buttons
    stwidgets.vlayout = gtk_vbox_new(FALSE, 0);
    gtk_box_pack_start(GTK_BOX(stwidgets.hlayout), stwidgets.vlayout, TRUE, TRUE, 0);

    // Tab control
    stwidgets.tabs = gtk_notebook_new();
    gtk_box_pack_start(GTK_BOX(stwidgets.vlayout), stwidgets.tabs, TRUE, TRUE, 0);
    gtk_container_set_border_width(GTK_CONTAINER(stwidgets.tabs), 4);

    // layout table of config page
    stwidgets.configtlayout = gtk_table_new(6, 3, FALSE);
    gtk_container_add(GTK_CONTAINER(stwidgets.tabs), stwidgets.configtlayout);

    // 3D video mode LabelText
    stwidgets.vmode3dlabel = gtk_label_new_with_mnemonic("_Video mode:");
    gtk_misc_set_alignment(GTK_MISC(stwidgets.vmode3dlabel), 0.3, 0);
#ifdef POLYMER
    gtk_table_attach(GTK_TABLE(stwidgets.configtlayout), stwidgets.vmode3dlabel, 0,1, 0,1, GTK_FILL, (GtkAttachOptions)0, 4, 0);
#else
    gtk_table_attach(GTK_TABLE(stwidgets.configtlayout), stwidgets.vmode3dlabel, 0,1, 0,1, GTK_FILL, (GtkAttachOptions)0, 4, 7);
#endif

    // 3D video mode combo
    {
        GtkListStore *list = gtk_list_store_new(2, G_TYPE_STRING, G_TYPE_INT);
        GtkCellRenderer *cell;

        stwidgets.vmode3dcombo = gtk_combo_box_new_with_model(GTK_TREE_MODEL(list));
        g_object_unref(G_OBJECT(list));

        cell = gtk_cell_renderer_text_new();
        gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(stwidgets.vmode3dcombo), cell, FALSE);
        gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(stwidgets.vmode3dcombo), cell, "text", 0, NULL);
    }
   
#ifdef POLYMER
   gtk_table_attach(GTK_TABLE(stwidgets.configtlayout), stwidgets.vmode3dcombo, 1,2, 0,1,
       (GtkAttachOptions)(GTK_EXPAND | GTK_FILL), (GtkAttachOptions)0, 4, 0);
#else
   gtk_table_attach(GTK_TABLE(stwidgets.configtlayout), stwidgets.vmode3dcombo, 1,2, 0,1, (GtkAttachOptions)(GTK_EXPAND | GTK_FILL), (GtkAttachOptions)0, 4, 7);
#endif

    // Fullscreen checkbox
    stwidgets.displayvlayout = gtk_vbox_new(TRUE, 0);
#ifdef POLYMER
    gtk_table_attach(GTK_TABLE(stwidgets.configtlayout), stwidgets.displayvlayout, 2,3, 0,1, GTK_FILL, (GtkAttachOptions)0, 4, 0);
#else
    gtk_table_attach(GTK_TABLE(stwidgets.configtlayout), stwidgets.displayvlayout, 2,3, 0,1, GTK_FILL, (GtkAttachOptions)0, 4, 7);
#endif

    stwidgets.fullscreencheck = gtk_check_button_new_with_mnemonic("_Fullscreen");
    gtk_box_pack_start(GTK_BOX(stwidgets.displayvlayout), stwidgets.fullscreencheck, FALSE, FALSE, 0);

#ifdef POLYMER
    // Polymer checkbox
    stwidgets.polymercheck = gtk_check_button_new_with_mnemonic("_Polymer");
    gtk_box_pack_start(GTK_BOX(stwidgets.displayvlayout), stwidgets.polymercheck, FALSE, FALSE, 0);
#endif

    // Input devices LabelText
    stwidgets.inputdevlabel = gtk_label_new_with_mnemonic("_Input devices:");
    gtk_misc_set_alignment(GTK_MISC(stwidgets.inputdevlabel), 0.3, 0);
    gtk_table_attach(GTK_TABLE(stwidgets.configtlayout), stwidgets.inputdevlabel, 0,1, 1,2, GTK_FILL, (GtkAttachOptions)0, 4, 0);

    // Input devices combo
    {
        GtkListStore *list = gtk_list_store_new(1, G_TYPE_STRING);
        GtkCellRenderer *cell;

        stwidgets.inputdevcombo = gtk_combo_box_new_with_model(GTK_TREE_MODEL(list));
        g_object_unref(G_OBJECT(list));

        cell = gtk_cell_renderer_text_new();
        gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(stwidgets.inputdevcombo), cell, FALSE);
        gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(stwidgets.inputdevcombo), cell, "text", 0, NULL);
    }
    gtk_table_attach(GTK_TABLE(stwidgets.configtlayout), stwidgets.inputdevcombo, 1,2, 1,2,
        (GtkAttachOptions)(GTK_EXPAND | GTK_FILL), (GtkAttachOptions)0, 4, 0);

    // Custom mod LabelText
    stwidgets.custommodlabel = gtk_label_new_with_mnemonic("Custom _game:");
    gtk_misc_set_alignment(GTK_MISC(stwidgets.custommodlabel), 0.3, 0);
    gtk_table_attach(GTK_TABLE(stwidgets.configtlayout), stwidgets.custommodlabel, 0,1, 2,3, GTK_FILL, (GtkAttachOptions)0, 4, 7);

    // Custom mod combo
    {
        GtkListStore *list = gtk_list_store_new(1, G_TYPE_STRING);
        GtkCellRenderer *cell;

        stwidgets.custommodcombo = gtk_combo_box_new_with_model(GTK_TREE_MODEL(list));
        g_object_unref(G_OBJECT(list));

        cell = gtk_cell_renderer_text_new();
        gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(stwidgets.custommodcombo), cell, FALSE);
        gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(stwidgets.custommodcombo), cell, "text", 0, NULL);
    }
    gtk_table_attach(GTK_TABLE(stwidgets.configtlayout), stwidgets.custommodcombo, 1,2, 2,3,
        (GtkAttachOptions)(GTK_EXPAND | GTK_FILL), (GtkAttachOptions)0, 4, 7);

    // Empty horizontal layout
    stwidgets.emptyhlayout = gtk_hbox_new(TRUE, 0);
    gtk_table_attach(GTK_TABLE(stwidgets.configtlayout), stwidgets.emptyhlayout, 0,3, 3,4, (GtkAttachOptions)0,
        (GtkAttachOptions)(GTK_EXPAND | GTK_FILL), 4, 0);

    // Autoload checkbox
    stwidgets.autoloadcheck = gtk_check_button_new_with_mnemonic("_Enable \"autoload\" folder");
    gtk_table_attach(GTK_TABLE(stwidgets.configtlayout), stwidgets.autoloadcheck, 0,3, 4,5, GTK_FILL, (GtkAttachOptions)0, 2, 2);

    // Always show config checkbox
    stwidgets.alwaysshowcheck = gtk_check_button_new_with_mnemonic("_Always show this window at startup");
    gtk_table_attach(GTK_TABLE(stwidgets.configtlayout), stwidgets.alwaysshowcheck, 0,3, 5,6, GTK_FILL, (GtkAttachOptions)0, 2, 2);

    // Configuration tab
    stwidgets.configtab = gtk_label_new("Configuration");
    gtk_notebook_set_tab_label(GTK_NOTEBOOK(stwidgets.tabs), gtk_notebook_get_nth_page(GTK_NOTEBOOK(stwidgets.tabs), 0), stwidgets.configtab);

    // Game data layout
    stwidgets.gamevlayout = gtk_vbox_new(FALSE, 0);
    gtk_container_add(GTK_CONTAINER(stwidgets.tabs), stwidgets.gamevlayout);
    gtk_container_set_border_width(GTK_CONTAINER(stwidgets.gamevlayout), 4);

    // Game data field LabelText
    stwidgets.gamelabel = gtk_label_new_with_mnemonic("_Game:");
    gtk_box_pack_start(GTK_BOX(stwidgets.gamevlayout), stwidgets.gamelabel, FALSE, FALSE, 0);
    gtk_misc_set_alignment(GTK_MISC(stwidgets.gamelabel), 0, 0.5);

    // Game data scrollable area
    stwidgets.gamescroll = gtk_scrolled_window_new(NULL, NULL);
    gtk_box_pack_start(GTK_BOX(stwidgets.gamevlayout), stwidgets.gamescroll, TRUE, TRUE, 0);
    gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(stwidgets.gamescroll), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
    gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(stwidgets.gamescroll), GTK_SHADOW_IN);

    // Game data list
    {
        GtkListStore *list = gtk_list_store_new(3, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_POINTER);
        GtkCellRenderer *cell;
        GtkTreeViewColumn *col;

        gtk_tree_sortable_set_sort_func(GTK_TREE_SORTABLE(list), 0, name_sorter, NULL, NULL);
        gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(list), 0, GTK_SORT_ASCENDING);

        stwidgets.gamelist = gtk_tree_view_new_with_model(GTK_TREE_MODEL(list));
        g_object_unref(G_OBJECT(list));

        cell = gtk_cell_renderer_text_new();
        col = gtk_tree_view_column_new_with_attributes("Game", cell, "text", 0, NULL);
        gtk_tree_view_column_set_expand(col, TRUE);
        gtk_tree_view_append_column(GTK_TREE_VIEW(stwidgets.gamelist), col);
        col = gtk_tree_view_column_new_with_attributes("GRP file", cell, "text", 1, NULL);
        gtk_tree_view_column_set_min_width(col, 64);
        gtk_tree_view_append_column(GTK_TREE_VIEW(stwidgets.gamelist), col);
    }
    gtk_container_add(GTK_CONTAINER(stwidgets.gamescroll), stwidgets.gamelist);

    gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(stwidgets.gamelist), FALSE);
    gtk_tree_view_set_enable_search(GTK_TREE_VIEW(stwidgets.gamelist), FALSE);

    // Game tab
    stwidgets.gametab = gtk_label_new("Game");
    gtk_notebook_set_tab_label(GTK_NOTEBOOK(stwidgets.tabs), gtk_notebook_get_nth_page(GTK_NOTEBOOK(stwidgets.tabs), 1), stwidgets.gametab);

    // Messages scrollable area
    stwidgets.messagesscroll = gtk_scrolled_window_new(NULL, NULL);
    gtk_container_add(GTK_CONTAINER(stwidgets.tabs), stwidgets.messagesscroll);
    gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(stwidgets.messagesscroll), GTK_POLICY_NEVER, GTK_POLICY_ALWAYS);

    // Messages text area
    stwidgets.messagestext = gtk_text_view_new();
    gtk_container_add(GTK_CONTAINER(stwidgets.messagesscroll), stwidgets.messagestext);
    gtk_text_view_set_editable(GTK_TEXT_VIEW(stwidgets.messagestext), FALSE);
    gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(stwidgets.messagestext), GTK_WRAP_WORD);
    gtk_text_view_set_cursor_visible(GTK_TEXT_VIEW(stwidgets.messagestext), FALSE);
    gtk_text_view_set_left_margin(GTK_TEXT_VIEW(stwidgets.messagestext), 2);
    gtk_text_view_set_right_margin(GTK_TEXT_VIEW(stwidgets.messagestext), 2);

    // Messages tab
    stwidgets.messagestab = gtk_label_new("Messages");
    gtk_notebook_set_tab_label(GTK_NOTEBOOK(stwidgets.tabs), gtk_notebook_get_nth_page(GTK_NOTEBOOK(stwidgets.tabs), 2), stwidgets.messagestab);

    // Dialogue box buttons layout
    stwidgets.buttons = gtk_hbutton_box_new();
    gtk_box_pack_start(GTK_BOX(stwidgets.vlayout), stwidgets.buttons, FALSE, TRUE, 0);
    gtk_container_set_border_width(GTK_CONTAINER(stwidgets.buttons), 3);
    gtk_button_box_set_layout(GTK_BUTTON_BOX(stwidgets.buttons), GTK_BUTTONBOX_END);

    // Cancel button
    stwidgets.cancelbutton = gtk_button_new();
    gtk_container_add(GTK_CONTAINER(stwidgets.buttons), stwidgets.cancelbutton);
    GTK_WIDGET_SET_FLAGS(stwidgets.cancelbutton, GTK_CAN_DEFAULT);

    stwidgets.cancelbuttonalign = gtk_alignment_new(0.5, 0.5, 0, 0);
    gtk_container_add(GTK_CONTAINER(stwidgets.cancelbutton), stwidgets.cancelbuttonalign);

    stwidgets.cancelbuttonlayout = gtk_hbox_new(FALSE, 2);
    gtk_container_add(GTK_CONTAINER(stwidgets.cancelbuttonalign), stwidgets.cancelbuttonlayout);

    stwidgets.cancelbuttonicon = gtk_image_new_from_stock("gtk-cancel", GTK_ICON_SIZE_BUTTON);
    gtk_box_pack_start(GTK_BOX(stwidgets.cancelbuttonlayout), stwidgets.cancelbuttonicon, FALSE, FALSE, 0);

    stwidgets.cancelbuttonlabel = gtk_label_new_with_mnemonic("_Cancel");
    gtk_box_pack_start(GTK_BOX(stwidgets.cancelbuttonlayout), stwidgets.cancelbuttonlabel, FALSE, FALSE, 0);

    // Start button
    stwidgets.startbutton = gtk_button_new();
    gtk_container_add(GTK_CONTAINER(stwidgets.buttons), stwidgets.startbutton);
    GTK_WIDGET_SET_FLAGS(stwidgets.startbutton, GTK_CAN_DEFAULT);

    gtk_window_set_default(GTK_WINDOW(stwidgets.startwin), stwidgets.startbutton);

    stwidgets.startbuttonalign = gtk_alignment_new(0.5, 0.5, 0, 0);
    gtk_container_add(GTK_CONTAINER(stwidgets.startbutton), stwidgets.startbuttonalign);

    stwidgets.startbuttonlayout = gtk_hbox_new(FALSE, 2);
    gtk_container_add(GTK_CONTAINER(stwidgets.startbuttonalign), stwidgets.startbuttonlayout);

    stwidgets.startbuttonicon = gtk_image_new_from_stock("gtk-execute", GTK_ICON_SIZE_BUTTON);
    gtk_box_pack_start(GTK_BOX(stwidgets.startbuttonlayout), stwidgets.startbuttonicon, FALSE, FALSE, 0);

    stwidgets.startbuttonlabel = gtk_label_new_with_mnemonic("_Start");
    gtk_box_pack_start(GTK_BOX(stwidgets.startbuttonlayout), stwidgets.startbuttonlabel, FALSE, FALSE, 0);

    // Wire up the signals
    g_signal_connect((gpointer) stwidgets.startwin, "delete_event",
                     G_CALLBACK(on_startwin_delete_event),
                     NULL);
    g_signal_connect((gpointer) stwidgets.vmode3dcombo, "changed",
                     G_CALLBACK(on_vmode3dcombo_changed),
                     NULL);
    g_signal_connect((gpointer) stwidgets.fullscreencheck, "toggled",
                     G_CALLBACK(on_fullscreencheck_toggled),
                     NULL);
#ifdef POLYMER
    g_signal_connect((gpointer) stwidgets.polymercheck, "toggled",
                     G_CALLBACK(on_polymercheck_toggled),
                     NULL);
#endif
    g_signal_connect((gpointer) stwidgets.inputdevcombo, "changed",
                     G_CALLBACK(on_inputdevcombo_changed),
                     NULL);
    g_signal_connect((gpointer) stwidgets.custommodcombo, "changed",
                     G_CALLBACK(on_custommodcombo_changed),
                     NULL);
    g_signal_connect((gpointer) stwidgets.autoloadcheck, "toggled",
                     G_CALLBACK(on_autoloadcheck_toggled),
                     NULL);
    g_signal_connect((gpointer) stwidgets.alwaysshowcheck, "toggled",
                     G_CALLBACK(on_alwaysshowcheck_toggled),
                     NULL);
    g_signal_connect((gpointer) stwidgets.cancelbutton, "clicked",
                     G_CALLBACK(on_cancelbutton_clicked),
                     NULL);
    g_signal_connect((gpointer) stwidgets.startbutton, "clicked",
                     G_CALLBACK(on_startbutton_clicked),
                     NULL);
    {
        GtkTreeSelection *sel = gtk_tree_view_get_selection(GTK_TREE_VIEW(stwidgets.gamelist));
        gtk_tree_selection_set_mode(sel, GTK_SELECTION_SINGLE);
        g_signal_connect((gpointer) sel, "changed",
                         G_CALLBACK(on_gamelist_selection_changed),
                         NULL);
    }

    // Associate labels with their controls
    gtk_label_set_mnemonic_widget(GTK_LABEL(stwidgets.vmode3dlabel), stwidgets.vmode3dcombo);
    gtk_label_set_mnemonic_widget(GTK_LABEL(stwidgets.inputdevlabel), stwidgets.inputdevcombo);
    gtk_label_set_mnemonic_widget(GTK_LABEL(stwidgets.custommodlabel), stwidgets.custommodcombo);
    gtk_label_set_mnemonic_widget(GTK_LABEL(stwidgets.gamelabel), stwidgets.gamelist);

    return stwidgets.startwin;
}


// -- BUILD ENTRY POINTS ------------------------------------------------------

int32_t startwin_open(void)
{
    if (!gtkenabled) return 0;
    if (stwidgets.startwin) return 1;

    stwidgets.startwin = create_window();
    if (stwidgets.startwin)
    {
        SetPage(TAB_MESSAGES);
        gtk_widget_show_all(stwidgets.startwin);
        gtk_main_iteration_do(FALSE);
        return 0;
    }
    return -1;
}

int32_t startwin_close(void)
{
    if (!gtkenabled) return 0;
    if (!stwidgets.startwin) return 1;
    gtk_widget_destroy(stwidgets.startwin);
    stwidgets.startwin = NULL;
    return 0;
}

int32_t startwin_puts(const char *str)
{
    GtkWidget *textview;
    GtkTextBuffer *textbuffer;
    GtkTextIter enditer;
    GtkTextMark *mark;
    const char *aptr, *bptr;

    if (!gtkenabled || !str) return 0;
    if (!stwidgets.startwin) return 1;
    if (!(textview = stwidgets.messagestext)) return -1;
    textbuffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(textview));

    gtk_text_buffer_get_end_iter(textbuffer, &enditer);
    for (aptr = bptr = str; *aptr != 0;)
    {
        switch (*bptr)
        {
        case '\b':
            if (bptr > aptr)
                gtk_text_buffer_insert(textbuffer, &enditer, (const gchar *)aptr, (gint)(bptr-aptr)-1);
#if GTK_CHECK_VERSION(2,6,0)
            gtk_text_buffer_backspace(textbuffer, &enditer, FALSE, TRUE);
#else
            {
                GtkTextIter iter2 = enditer;
                gtk_text_iter_backward_cursor_position(&iter2);
                //FIXME: this seems be deleting one too many chars somewhere!
                if (!gtk_text_iter_equal(&iter2, &enditer))
                    gtk_text_buffer_delete_interactive(textbuffer, &iter2, &enditer, TRUE);
            }
#endif
            aptr = ++bptr;
            break;
        case 0:
            if (bptr > aptr)
                gtk_text_buffer_insert(textbuffer, &enditer, (const gchar *)aptr, (gint)(bptr-aptr));
            aptr = bptr;
            break;
        case '\r':      // FIXME
        default:
            bptr++;
            break;
        }
    }

    mark = gtk_text_buffer_create_mark(textbuffer, NULL, &enditer, 1);
    gtk_text_view_scroll_to_mark(GTK_TEXT_VIEW(textview), mark, 0.0, FALSE, 0.0, 1.0);
    gtk_text_buffer_delete_mark(textbuffer, mark);

    return 0;
}

int32_t startwin_settitle(const char *title)
{
    if (!gtkenabled) return 0;
    if (!stwidgets.startwin) return 1;
    gtk_window_set_title(GTK_WINDOW(stwidgets.startwin), title);
    return 0;
}

int32_t startwin_idle(void *s)
{
    UNREFERENCED_PARAMETER(s);
    if (!gtkenabled) return 0;
    //if (!stwidgets.startwin) return 1;
    gtk_main_iteration_do(FALSE);
    return 0;
}

int32_t startwin_run(void)
{
    if (!gtkenabled) return 1;
    if (!stwidgets.startwin) return 1;

    SetPage(TAB_CONFIG);

    settings.xdim3d = ud.config.ScreenWidth;
    settings.ydim3d = ud.config.ScreenHeight;
    settings.bpp3d = ud.config.ScreenBPP;
    settings.fullscreen = ud.config.ScreenMode;
    settings.usemouse = ud.config.UseMouse;
    settings.usejoy = ud.config.UseJoystick;
    settings.custommoddir = g_modDir;
    settings.forcesetup = ud.config.ForceSetup;
    settings.game = g_gameType;
    Bstrncpyz(settings.selectedgrp, G_GrpFile(), BMAX_PATH);
    if (ud.config.NoAutoLoad) settings.autoload = FALSE;
    else settings.autoload = TRUE;
#ifdef POLYMER
    if (glrendmode == REND_POLYMER)
    {
        if (settings.bpp3d == 8) settings.bpp3d = 32;
        settings.polymer = TRUE;
    }
#endif
    PopulateForm(ALL);

    gtk_main();

    SetPage(TAB_MESSAGES);
    if (retval) // launch the game with these parameters
    {
        ud.config.ScreenWidth = settings.xdim3d;
        ud.config.ScreenHeight = settings.ydim3d;
        ud.config.ScreenBPP = settings.bpp3d;
        ud.config.ScreenMode = settings.fullscreen;
        ud.config.UseMouse = settings.usemouse;
        ud.config.UseJoystick = settings.usejoy;
        ud.config.ForceSetup = settings.forcesetup;

        clearGrpNamePtr();
        g_grpNamePtr = dup_filename(settings.selectedgrp);

        g_gameType = settings.game;
        if (settings.custommoddir != NULL)
            Bstrcpy(g_modDir, settings.custommoddir);
        else Bsprintf(g_modDir, "/");

        if (settings.autoload) ud.config.NoAutoLoad = FALSE;
        else ud.config.NoAutoLoad = TRUE;

        {
            struct grpfile *grp;
            for (grp = listgrps; grp; grp=grp->next)
                if (settings.crcval == grp->crcval) break;

            if (grp)
            {
                g_gameNamePtr = grp->name;
                g_dependencyCRC = grp->dependency;
                g_postprocessing = grp->postprocessing;

                if (grp->scriptname && g_scriptNamePtr == NULL)
                    g_scriptNamePtr = dup_filename(grp->scriptname);

                if (grp->defname && g_defNamePtr == NULL)
                    g_defNamePtr = dup_filename(grp->defname);
            }
        }
    }

    return retval;
}
 

Rev 4773	Rev 5062
1	//-------------------------------------------------------------------------	1	//-------------------------------------------------------------------------
2	/*	2	/*
3	Copyright (C) 2010 EDuke32 developers and contributors	3	Copyright (C) 2010 EDuke32 developers and contributors
4		4
5	This file is part of EDuke32.	5	This file is part of EDuke32.
6		6
7	EDuke32 is free software; you can redistribute it and/or	7	EDuke32 is free software; you can redistribute it and/or
8	modify it under the terms of the GNU General Public License version 2	8	modify it under the terms of the GNU General Public License version 2
9	as published by the Free Software Foundation.	9	as published by the Free Software Foundation.
10		10
11	This program is distributed in the hope that it will be useful,	11	This program is distributed in the hope that it will be useful,
12	but WITHOUT ANY WARRANTY; without even the implied warranty of	12	but WITHOUT ANY WARRANTY; without even the implied warranty of
13	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.	13	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
14		14
15	See the GNU General Public License for more details.	15	See the GNU General Public License for more details.
16		16
17	You should have received a copy of the GNU General Public License	17	You should have received a copy of the GNU General Public License
18	along with this program; if not, write to the Free Software	18	along with this program; if not, write to the Free Software
19	Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.	19	Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
20	*/	20	*/
21	//-------------------------------------------------------------------------	21	//-------------------------------------------------------------------------
22		22
23	#include "gtkpixdata.h"	23	#include "gtkpixdata.h"
24		24
25	#if defined(LINKED_GTK)	25	#if defined(LINKED_GTK)
26	#include <gtk/gtk.h>	26	#include <gtk/gtk.h>
27	#include <gdk-pixbuf/gdk-pixdata.h>	27	#include <gdk-pixbuf/gdk-pixdata.h>
28	#else	28	#else
29	#include "dynamicgtk.h"	29	#include "dynamicgtk.h"
30	#endif	30	#endif
31		31
32	#include "duke3d.h"	32	#include "duke3d.h"
33	#include "grpscan.h"	33	#include "grpscan.h"
34	#include "build.h"	34	#include "build.h"
35		35
36	#include "game.h"	36	#include "game.h"
37	#include "common.h"	37	#include "common.h"
38	#include "common_game.h"	38	#include "common_game.h"
39		39
40	enum	40	enum
41	{	41	{
42	NONE,	42	NONE,
43	ALL,	43	ALL,
44	POPULATE_VIDEO,	44	POPULATE_VIDEO,
45	POPULATE_CONFIG,	45	POPULATE_CONFIG,
46	POPULATE_GAME,	46	POPULATE_GAME,
47	};	47	};
48		48
49	enum	49	enum
50	{	50	{
51	TAB_CONFIG,	51	TAB_CONFIG,
52	TAB_GAME,	52	TAB_GAME,
53	TAB_MESSAGES,	53	TAB_MESSAGES,
54	};	54	};
55		55
56	enum	56	enum
57	{	57	{
58	INPUT_KB,	58	INPUT_KB,
59	INPUT_MOUSE,	59	INPUT_MOUSE,
60	INPUT_JOYSTICK,	60	INPUT_JOYSTICK,
61	INPUT_ALL,	61	INPUT_ALL,
62	};	62	};
63		63
64	static struct	64	static struct
65	{	65	{
66	GtkWidget *startwin;	66	GtkWidget *startwin;
67	GtkWidget *hlayout;	67	GtkWidget *hlayout;
68	GtkWidget *banner;	68	GtkWidget *banner;
69	GtkWidget *vlayout;	69	GtkWidget *vlayout;
70	GtkWidget *tabs;	70	GtkWidget *tabs;
71	GtkWidget *configtlayout;	71	GtkWidget *configtlayout;
72	GtkWidget *displayvlayout;	72	GtkWidget *displayvlayout;
73	GtkWidget *vmode3dlabel;	73	GtkWidget *vmode3dlabel;
74	GtkWidget *vmode3dcombo;	74	GtkWidget *vmode3dcombo;
75	GtkWidget *fullscreencheck;	75	GtkWidget *fullscreencheck;
76	#ifdef POLYMER	76	#ifdef POLYMER
77	GtkWidget *polymercheck;	77	GtkWidget *polymercheck;
78	#endif	78	#endif
79	GtkWidget *inputdevlabel;	79	GtkWidget *inputdevlabel;
80	GtkWidget *inputdevcombo;	80	GtkWidget *inputdevcombo;
81	GtkWidget *custommodlabel;	81	GtkWidget *custommodlabel;
82	GtkWidget *custommodcombo;	82	GtkWidget *custommodcombo;
83	GtkWidget *emptyhlayout;	83	GtkWidget *emptyhlayout;
84	GtkWidget *autoloadcheck;	84	GtkWidget *autoloadcheck;
85	GtkWidget *alwaysshowcheck;	85	GtkWidget *alwaysshowcheck;
86	GtkWidget *configtab;	86	GtkWidget *configtab;
87	GtkWidget *gamevlayout;	87	GtkWidget *gamevlayout;
88	GtkWidget *gamelabel;	88	GtkWidget *gamelabel;
89	GtkWidget *gamescroll;	89	GtkWidget *gamescroll;
90	GtkWidget *gamelist;	90	GtkWidget *gamelist;
91	GtkWidget *gametab;	91	GtkWidget *gametab;
92	GtkWidget *messagesscroll;	92	GtkWidget *messagesscroll;
93	GtkWidget *messagestext;	93	GtkWidget *messagestext;
94	GtkWidget *messagestab;	94	GtkWidget *messagestab;
95	GtkWidget *buttons;	95	GtkWidget *buttons;
96	GtkWidget *cancelbutton;	96	GtkWidget *cancelbutton;
97	GtkWidget *cancelbuttonalign;	97	GtkWidget *cancelbuttonalign;
98	GtkWidget *cancelbuttonlayout;	98	GtkWidget *cancelbuttonlayout;
99	GtkWidget *cancelbuttonicon;	99	GtkWidget *cancelbuttonicon;
100	GtkWidget *cancelbuttonlabel;	100	GtkWidget *cancelbuttonlabel;
101	GtkWidget *startbutton;	101	GtkWidget *startbutton;
102	GtkWidget *startbuttonalign;	102	GtkWidget *startbuttonalign;
103	GtkWidget *startbuttonlayout;	103	GtkWidget *startbuttonlayout;
104	GtkWidget *startbuttonicon;	104	GtkWidget *startbuttonicon;
105	GtkWidget *startbuttonlabel;	105	GtkWidget *startbuttonlabel;
106	} stwidgets;	106	} stwidgets;
107		107
108	static struct	108	static struct
109	{	109	{
110	int32_t fullscreen;	110	int32_t fullscreen;
111	#ifdef POLYMER	111	#ifdef POLYMER
112	int32_t polymer;	112	int32_t polymer;
113	#endif	113	#endif
114	int32_t xdim3d, ydim3d, bpp3d;	114	int32_t xdim3d, ydim3d, bpp3d;
115	int32_t forcesetup;	115	int32_t forcesetup;
116	int32_t autoload;	116	int32_t autoload;
117	int32_t usemouse, usejoy;	117	int32_t usemouse, usejoy;
118	int32_t game;	118	int32_t game;
119	int32_t crcval;	119	int32_t crcval;
120	char *custommoddir;	120	char *custommoddir;
121	char selectedgrp[BMAX_PATH];	121	char selectedgrp[BMAX_PATH];
122	} settings;	122	} settings;
123		123
124	static int32_t retval = -1, mode = TAB_MESSAGES;	124	static int32_t retval = -1, mode = TAB_MESSAGES;
125	extern int32_t gtkenabled;	125	extern int32_t gtkenabled;
126	static void PopulateForm(unsigned char pgs);	126	static void PopulateForm(unsigned char pgs);
127		127
128		128
129	// -- EVENT CALLBACKS AND CREATION STUFF --------------------------------------	129	// -- EVENT CALLBACKS AND CREATION STUFF --------------------------------------
130		130
131	static void on_vmode3dcombo_changed(GtkComboBox *combobox, gpointer user_data)	131	static void on_vmode3dcombo_changed(GtkComboBox *combobox, gpointer user_data)
132	{	132	{
133	GtkTreeModel *data;	133	GtkTreeModel *data;
134	GtkTreeIter iter;	134	GtkTreeIter iter;
135	int32_t val;	135	int32_t val;
136	UNREFERENCED_PARAMETER(user_data);	136	UNREFERENCED_PARAMETER(user_data);
137		137
138	if (!gtk_combo_box_get_active_iter(combobox, &iter)) return;	138	if (!gtk_combo_box_get_active_iter(combobox, &iter)) return;
139	if (!(data = gtk_combo_box_get_model(combobox))) return;	139	if (!(data = gtk_combo_box_get_model(combobox))) return;
140	gtk_tree_model_get(data, &iter, 1, &val, -1);	140	gtk_tree_model_get(data, &iter, 1, &val, -1);
141	settings.xdim3d = validmode[val].xdim;	141	settings.xdim3d = validmode[val].xdim;
142	settings.ydim3d = validmode[val].ydim;	142	settings.ydim3d = validmode[val].ydim;
143	}	143	}
144		144
145	static void on_fullscreencheck_toggled(GtkToggleButton *togglebutton, gpointer user_data)	145	static void on_fullscreencheck_toggled(GtkToggleButton *togglebutton, gpointer user_data)
146	{	146	{
147	UNREFERENCED_PARAMETER(user_data);	147	UNREFERENCED_PARAMETER(user_data);
148	settings.fullscreen = gtk_toggle_button_get_active(togglebutton);	148	settings.fullscreen = gtk_toggle_button_get_active(togglebutton);
149	PopulateForm(POPULATE_VIDEO);	149	PopulateForm(POPULATE_VIDEO);
150	}	150	}
151		151
152	#ifdef POLYMER	152	#ifdef POLYMER
153	static void on_polymercheck_toggled(GtkToggleButton *togglebutton, gpointer user_data)	153	static void on_polymercheck_toggled(GtkToggleButton *togglebutton, gpointer user_data)
154	{	154	{
155	UNREFERENCED_PARAMETER(user_data);	155	UNREFERENCED_PARAMETER(user_data);
156	if (gtk_toggle_button_get_active(togglebutton))	156	if (gtk_toggle_button_get_active(togglebutton))
157	{	157	{
158	glrendmode = REND_POLYMER;	158	glrendmode = REND_POLYMER;
159	settings.polymer = TRUE;	159	settings.polymer = TRUE;
160	if (settings.bpp3d == 8)	160	if (settings.bpp3d == 8)
161	{	161	{
162	settings.bpp3d = 32;	162	settings.bpp3d = 32;
163	PopulateForm(POPULATE_VIDEO);	163	PopulateForm(POPULATE_VIDEO);
164	}	164	}
165	}	165	}
166	else	166	else
167	{	167	{
168	glrendmode = REND_POLYMOST;	168	glrendmode = REND_POLYMOST;
169	settings.polymer = FALSE;	169	settings.polymer = FALSE;
170	}	170	}
171	}	171	}
172	#endif	172	#endif
173		173
174	static void on_inputdevcombo_changed(GtkComboBox *combobox, gpointer user_data)	174	static void on_inputdevcombo_changed(GtkComboBox *combobox, gpointer user_data)
175	{	175	{
176	UNREFERENCED_PARAMETER(user_data);	176	UNREFERENCED_PARAMETER(user_data);
177	switch (gtk_combo_box_get_active(combobox))	177	switch (gtk_combo_box_get_active(combobox))
178	{	178	{
179	case 0: settings.usemouse = 0; settings.usejoy = 0; break;	179	case 0: settings.usemouse = 0; settings.usejoy = 0; break;
180	case 1: settings.usemouse = 1; settings.usejoy = 0; break;	180	case 1: settings.usemouse = 1; settings.usejoy = 0; break;
181	case 2: settings.usemouse = 0; settings.usejoy = 1; break;	181	case 2: settings.usemouse = 0; settings.usejoy = 1; break;
182	case 3: settings.usemouse = 1; settings.usejoy = 1; break;	182	case 3: settings.usemouse = 1; settings.usejoy = 1; break;
183	}	183	}
184	}	184	}
185		185
186	static void on_custommodcombo_changed(GtkComboBox *combobox, gpointer user_data)	186	static void on_custommodcombo_changed(GtkComboBox *combobox, gpointer user_data)
187	{	187	{
188	GtkTreeIter iter;	188	GtkTreeIter iter;
189	GtkTreeModel *model;	189	GtkTreeModel *model;
190	GtkTreePath *path;	190	GtkTreePath *path;
191	char *value;	191	char *value;
192	UNREFERENCED_PARAMETER(user_data);	192	UNREFERENCED_PARAMETER(user_data);
193		193
194	if (gtk_combo_box_get_active_iter(combobox, &iter))	194	if (gtk_combo_box_get_active_iter(combobox, &iter))
195	{	195	{
196	model = gtk_combo_box_get_model(combobox);	196	model = gtk_combo_box_get_model(combobox);
197	gtk_tree_model_get(model, &iter, 0,&value, -1);	197	gtk_tree_model_get(model, &iter, 0,&value, -1);
198	path = gtk_tree_model_get_path(model, &iter);	198	path = gtk_tree_model_get_path(model, &iter);
199		199
200	if (*gtk_tree_path_get_indices(path) == NONE)	200	if (*gtk_tree_path_get_indices(path) == NONE)
201	settings.custommoddir = NULL;	201	settings.custommoddir = NULL;
202	else settings.custommoddir = value;	202	else settings.custommoddir = value;
203	}	203	}
204	}	204	}
205		205
206	static void on_autoloadcheck_toggled(GtkToggleButton *togglebutton, gpointer user_data)	206	static void on_autoloadcheck_toggled(GtkToggleButton *togglebutton, gpointer user_data)
207	{	207	{
208	UNREFERENCED_PARAMETER(user_data);	208	UNREFERENCED_PARAMETER(user_data);
209	settings.autoload = gtk_toggle_button_get_active(togglebutton);	209	settings.autoload = gtk_toggle_button_get_active(togglebutton);
210	}	210	}
211		211
212	static void on_alwaysshowcheck_toggled(GtkToggleButton *togglebutton, gpointer user_data)	212	static void on_alwaysshowcheck_toggled(GtkToggleButton *togglebutton, gpointer user_data)
213	{	213	{
214	UNREFERENCED_PARAMETER(user_data);	214	UNREFERENCED_PARAMETER(user_data);
215	settings.forcesetup = gtk_toggle_button_get_active(togglebutton);	215	settings.forcesetup = gtk_toggle_button_get_active(togglebutton);
216	}	216	}
217		217
218	static void on_cancelbutton_clicked(GtkButton *button, gpointer user_data)	218	static void on_cancelbutton_clicked(GtkButton *button, gpointer user_data)
219	{	219	{
220	UNREFERENCED_PARAMETER(button);	220	UNREFERENCED_PARAMETER(button);
221	UNREFERENCED_PARAMETER(user_data);	221	UNREFERENCED_PARAMETER(user_data);
222	if (mode == TAB_CONFIG) { retval = 0; gtk_main_quit(); }	222	if (mode == TAB_CONFIG) { retval = 0; gtk_main_quit(); }
223	else quitevent++;	223	else quitevent++;
224	}	224	}
225		225
226	static void on_startbutton_clicked(GtkButton *button, gpointer user_data)	226	static void on_startbutton_clicked(GtkButton *button, gpointer user_data)
227	{	227	{
228	UNREFERENCED_PARAMETER(button);	228	UNREFERENCED_PARAMETER(button);
229	UNREFERENCED_PARAMETER(user_data);	229	UNREFERENCED_PARAMETER(user_data);
230	retval = 1;	230	retval = 1;
231	gtk_main_quit();	231	gtk_main_quit();
232	}	232	}
233		233
234	static void on_gamelist_selection_changed(GtkTreeSelection *selection, gpointer user_data)	234	static void on_gamelist_selection_changed(GtkTreeSelection *selection, gpointer user_data)
235	{	235	{
236	GtkTreeIter iter;	236	GtkTreeIter iter;
237	GtkTreeModel *model;	237	GtkTreeModel *model;
238	struct grpfile *fg;	238	struct grpfile *fg;
239	UNREFERENCED_PARAMETER(user_data);	239	UNREFERENCED_PARAMETER(user_data);
240		240
241	if (gtk_tree_selection_get_selected(selection, &model, &iter))	241	if (gtk_tree_selection_get_selected(selection, &model, &iter))
242	{	242	{
243	gtk_tree_model_get(model, &iter, 2, (gpointer)&fg, -1);	243	gtk_tree_model_get(model, &iter, 2, (gpointer)&fg, -1);
244	strcpy(settings.selectedgrp, fg->name);	244	strcpy(settings.selectedgrp, fg->name);
245	settings.game = fg->game;	245	settings.game = fg->game;
246	settings.crcval = fg->crcval;	246	settings.crcval = fg->crcval;
247	}	247	}
248	}	248	}
249		249
250	static gboolean on_startwin_delete_event(GtkWidget widget, GdkEvent event, gpointer user_data)	250	static gboolean on_startwin_delete_event(GtkWidget widget, GdkEvent event, gpointer user_data)
251	{	251	{
252	UNREFERENCED_PARAMETER(widget);	252	UNREFERENCED_PARAMETER(widget);
253	UNREFERENCED_PARAMETER(event);	253	UNREFERENCED_PARAMETER(event);
254	UNREFERENCED_PARAMETER(user_data);	254	UNREFERENCED_PARAMETER(user_data);
255	if (mode == TAB_CONFIG) { retval = 0; gtk_main_quit(); }	255	if (mode == TAB_CONFIG) { retval = 0; gtk_main_quit(); }
256	else quitevent++;	256	else quitevent++;
257	return TRUE; // FALSE would let the event go through. we want the game to decide when to close	257	return TRUE; // FALSE would let the event go through. we want the game to decide when to close
258	}	258	}
259		259
260		260
261	// -- SUPPORT FUNCTIONS -------------------------------------------------------	261	// -- SUPPORT FUNCTIONS -------------------------------------------------------
262		262
263	static GdkPixbuf *load_banner(void)	263	static GdkPixbuf *load_banner(void)
264	{	264	{
265	return gdk_pixbuf_from_pixdata((GdkPixdata*)&startbanner_pixdata, FALSE, NULL);	265	return gdk_pixbuf_from_pixdata((GdkPixdata*)&startbanner_pixdata, FALSE, NULL);
266	}	266	}
267		267
268	static void SetPage(int32_t n)	268	static void SetPage(int32_t n)
269	{	269	{
270	if (!gtkenabled \|\| !stwidgets.startwin) return;	270	if (!gtkenabled \|\| !stwidgets.startwin) return;
271	mode = n;	271	mode = n;
272	gtk_notebook_set_current_page(GTK_NOTEBOOK(stwidgets.tabs), n);	272	gtk_notebook_set_current_page(GTK_NOTEBOOK(stwidgets.tabs), n);
273		273
274	// each control in the config page vertical layout plus the start button should be made (in)sensitive	274	// each control in the config page vertical layout plus the start button should be made (in)sensitive
275	if (n == TAB_CONFIG) n = TRUE; else n = FALSE;	275	if (n == TAB_CONFIG) n = TRUE; else n = FALSE;
276	gtk_widget_set_sensitive(stwidgets.startbutton, n);	276	gtk_widget_set_sensitive(stwidgets.startbutton, n);
277	gtk_container_foreach(GTK_CONTAINER(stwidgets.configtlayout),	277	gtk_container_foreach(GTK_CONTAINER(stwidgets.configtlayout),
278	(GtkCallback)gtk_widget_set_sensitive,	278	(GtkCallback)gtk_widget_set_sensitive,
279	(gpointer)&n);	279	(gpointer)&n);
280	}	280	}
281		281
282	static unsigned char GetModsDirNames(GtkListStore *list)	282	static unsigned char GetModsDirNames(GtkListStore *list)
283	{	283	{
284	char *homedir;	284	char *homedir;
285	char pdir[BMAX_PATH];	285	char pdir[BMAX_PATH];
286	unsigned char iternumb = 0;	286	unsigned char iternumb = 0;
287	CACHE1D_FIND_REC *dirs = NULL;	287	CACHE1D_FIND_REC *dirs = NULL;
288	GtkTreeIter iter;	288	GtkTreeIter iter;
289		289
290	pathsearchmode = 1;	290	pathsearchmode = 1;
291		291
292	if ((homedir = Bgethomedir()))	292	if ((homedir = Bgethomedir()))
293	{	293	{
294	Bsnprintf(pdir, sizeof(pdir), "%s/" ".eduke32", homedir);	294	Bsnprintf(pdir, sizeof(pdir), "%s/" ".eduke32", homedir);
295	dirs = klistpath(pdir, "*", CACHE1D_FIND_DIR);	295	dirs = klistpath(pdir, "*", CACHE1D_FIND_DIR);
296	for (dirs=dirs; dirs != NULL; dirs=dirs->next)	296	for (dirs=dirs; dirs != NULL; dirs=dirs->next)
297	{	297	{
298	if ((Bstrcmp(dirs->name, "autoload") == 0) \|\|	298	if ((Bstrcmp(dirs->name, "autoload") == 0) \|\|
299	(Bstrcmp(dirs->name, "..") == 0) \|\|	299	(Bstrcmp(dirs->name, "..") == 0) \|\|
300	(Bstrcmp(dirs->name, ".") == 0))	300	(Bstrcmp(dirs->name, ".") == 0))
301	continue;	301	continue;
302	else	302	else
303	{	303	{
304	gtk_list_store_append(list, &iter);	304	gtk_list_store_append(list, &iter);
305	gtk_list_store_set(list, &iter, 0,dirs->name, -1);	305	gtk_list_store_set(list, &iter, 0,dirs->name, -1);
306	iternumb++;	306	iternumb++;
307	}	307	}
308	}	308	}
309	}	309	}
310		310
311	klistfree(dirs);	311	klistfree(dirs);
312	dirs = NULL;	312	dirs = NULL;
313		313
314	return iternumb;	314	return iternumb;
315	}	315	}
316		316
317	static void PopulateForm(unsigned char pgs)	317	static void PopulateForm(unsigned char pgs)
318	{	318	{
319	if ((pgs == ALL) \|\| (pgs == POPULATE_VIDEO))	319	if ((pgs == ALL) \|\| (pgs == POPULATE_VIDEO))
320	{	320	{
321	int32_t mode3d, i;	321	int32_t mode3d, i;
322	GtkListStore *modes3d;	322	GtkListStore *modes3d;
323	GtkTreeIter iter;	323	GtkTreeIter iter;
324	char buf[64];	324	char buf[64];
325		325
326	mode3d = checkvideomode(&settings.xdim3d, &settings.ydim3d, settings.bpp3d, settings.fullscreen, 1);	326	mode3d = checkvideomode(&settings.xdim3d, &settings.ydim3d, settings.bpp3d, settings.fullscreen, 1);
327	if (mode3d < 0)	327	if (mode3d < 0)
328	{	328	{
329	int32_t i, cd[] = { 32, 24, 16, 15, 8, 0 };	329	int32_t i, cd[] = { 32, 24, 16, 15, 8, 0 };
330		330
331	for (i=0; cd[i];) { if (cd[i] >= settings.bpp3d) i++; else break; }	331	for (i=0; cd[i];) { if (cd[i] >= settings.bpp3d) i++; else break; }
332	for (; cd[i]; i++)	332	for (; cd[i]; i++)
333	{	333	{
334	mode3d = checkvideomode(&settings.xdim3d, &settings.ydim3d, cd[i], settings.fullscreen, 1);	334	mode3d = checkvideomode(&settings.xdim3d, &settings.ydim3d, cd[i], settings.fullscreen, 1);
335	if (mode3d < 0) continue;	335	if (mode3d < 0) continue;
336	settings.bpp3d = cd[i];	336	settings.bpp3d = cd[i];
337	break;	337	break;
338	}	338	}
339	}	339	}
340		340
341	modes3d = GTK_LIST_STORE(gtk_combo_box_get_model(GTK_COMBO_BOX(stwidgets.vmode3dcombo)));	341	modes3d = GTK_LIST_STORE(gtk_combo_box_get_model(GTK_COMBO_BOX(stwidgets.vmode3dcombo)));
342	gtk_list_store_clear(modes3d);	342	gtk_list_store_clear(modes3d);
343		343
344	for (i=0; i<validmodecnt; i++)	344	for (i=0; i<validmodecnt; i++)
345	{	345	{
346	if (validmode[i].fs != settings.fullscreen) continue;	346	if (validmode[i].fs != settings.fullscreen) continue;
347		347
348	// all modes get added to the 3D mode list	348	// all modes get added to the 3D mode list
349	Bsprintf(buf, "%d x %d %dbpp", validmode[i].xdim, validmode[i].ydim, validmode[i].bpp);	349	Bsprintf(buf, "%d x %d %dbpp", validmode[i].xdim, validmode[i].ydim, validmode[i].bpp);
350	gtk_list_store_append(modes3d, &iter);	350	gtk_list_store_append(modes3d, &iter);
351	gtk_list_store_set(modes3d, &iter, 0,buf, 1,i, -1);	351	gtk_list_store_set(modes3d, &iter, 0,buf, 1,i, -1);
352	if (i == mode3d)	352	if (i == mode3d)
353	{	353	{
354	g_signal_handlers_block_by_func(stwidgets.vmode3dcombo, (gpointer)on_vmode3dcombo_changed, NULL);	354	g_signal_handlers_block_by_func(stwidgets.vmode3dcombo, (gpointer)on_vmode3dcombo_changed, NULL);
355	gtk_combo_box_set_active_iter(GTK_COMBO_BOX(stwidgets.vmode3dcombo), &iter);	355	gtk_combo_box_set_active_iter(GTK_COMBO_BOX(stwidgets.vmode3dcombo), &iter);
356	g_signal_handlers_unblock_by_func(stwidgets.vmode3dcombo, (gpointer)on_vmode3dcombo_changed, NULL);	356	g_signal_handlers_unblock_by_func(stwidgets.vmode3dcombo, (gpointer)on_vmode3dcombo_changed, NULL);
357	}	357	}
358	}	358	}
359	}	359	}
360		360
361	if ((pgs == ALL) \|\| (pgs == POPULATE_CONFIG))	361	if ((pgs == ALL) \|\| (pgs == POPULATE_CONFIG))
362	{	362	{
363	GtkListStore devlist, modsdir;	363	GtkListStore devlist, modsdir;
364	GtkTreeIter iter;	364	GtkTreeIter iter;
365	GtkTreePath *path;	365	GtkTreePath *path;
366	char *value;	366	char *value;
367	unsigned char i, r = 0;	367	unsigned char i, r = 0;
368	const char *availabledev[] =	368	const char *availabledev[] =
369	{	369	{
370	"Keyboard only",	370	"Keyboard only",
371	"Keyboard and mouse",	371	"Keyboard and mouse",
372	"Keyboard and joystick",	372	"Keyboard and joystick",
373	"All supported devices"	373	"All supported devices"
374	};	374	};
375		375
376	// populate input devices combo	376	// populate input devices combo
377	devlist = GTK_LIST_STORE(gtk_combo_box_get_model(GTK_COMBO_BOX(stwidgets.inputdevcombo)));	377	devlist = GTK_LIST_STORE(gtk_combo_box_get_model(GTK_COMBO_BOX(stwidgets.inputdevcombo)));
378	gtk_list_store_clear(devlist);	378	gtk_list_store_clear(devlist);
379		379
380	for (i=0; i<(int32_t)G_N_ELEMENTS(availabledev); i++)	380	for (i=0; i<(int32_t)G_N_ELEMENTS(availabledev); i++)
381	{	381	{
382	gtk_list_store_append(devlist, &iter);	382	gtk_list_store_append(devlist, &iter);
383	gtk_list_store_set(devlist, &iter, 0,availabledev[i], -1);	383	gtk_list_store_set(devlist, &iter, 0,availabledev[i], -1);
384	}	384	}
385	switch (settings.usemouse)	385	switch (settings.usemouse)
386	{	386	{
387	case 0: if (settings.usejoy)	387	case 0: if (settings.usejoy)
388	gtk_combo_box_set_active(GTK_COMBO_BOX(stwidgets.inputdevcombo), INPUT_JOYSTICK);	388	gtk_combo_box_set_active(GTK_COMBO_BOX(stwidgets.inputdevcombo), INPUT_JOYSTICK);
389	else	389	else
390	gtk_combo_box_set_active(GTK_COMBO_BOX(stwidgets.inputdevcombo), INPUT_KB);	390	gtk_combo_box_set_active(GTK_COMBO_BOX(stwidgets.inputdevcombo), INPUT_KB);
391	break;	391	break;
392	case 1: if (settings.usejoy)	392	case 1: if (settings.usejoy)
393	gtk_combo_box_set_active(GTK_COMBO_BOX(stwidgets.inputdevcombo), INPUT_ALL);	393	gtk_combo_box_set_active(GTK_COMBO_BOX(stwidgets.inputdevcombo), INPUT_ALL);
394	else	394	else
395	gtk_combo_box_set_active(GTK_COMBO_BOX(stwidgets.inputdevcombo), INPUT_MOUSE);	395	gtk_combo_box_set_active(GTK_COMBO_BOX(stwidgets.inputdevcombo), INPUT_MOUSE);
396	break;	396	break;
397	}	397	}
398		398
399	// populate custom mod combo	399	// populate custom mod combo
400	modsdir = GTK_LIST_STORE(gtk_combo_box_get_model(GTK_COMBO_BOX(stwidgets.custommodcombo)));	400	modsdir = GTK_LIST_STORE(gtk_combo_box_get_model(GTK_COMBO_BOX(stwidgets.custommodcombo)));
401	gtk_list_store_clear(modsdir);	401	gtk_list_store_clear(modsdir);
402		402
403	gtk_list_store_append(modsdir, &iter);	403	gtk_list_store_append(modsdir, &iter);
404	gtk_list_store_set(modsdir, &iter, 0,"None", -1);	404	gtk_list_store_set(modsdir, &iter, 0,"None", -1);
405	r = GetModsDirNames(modsdir);	405	r = GetModsDirNames(modsdir);
406		406
407	for (i=0; i<=r; i++)	407	for (i=0; i<=r; i++)
408	{	408	{
409	path = gtk_tree_path_new_from_indices(i, -1);	409	path = gtk_tree_path_new_from_indices(i, -1);
410	gtk_tree_model_get_iter(GTK_TREE_MODEL(modsdir), &iter, path);	410	gtk_tree_model_get_iter(GTK_TREE_MODEL(modsdir), &iter, path);
411	gtk_tree_model_get(GTK_TREE_MODEL(modsdir), &iter, 0,&value, -1);	411	gtk_tree_model_get(GTK_TREE_MODEL(modsdir), &iter, 0,&value, -1);
412		412
413	if (Bstrcmp(settings.custommoddir, "/") == 0)	413	if (Bstrcmp(settings.custommoddir, "/") == 0)
414	{	414	{
415	gtk_combo_box_set_active(GTK_COMBO_BOX(stwidgets.custommodcombo), NONE);	415	gtk_combo_box_set_active(GTK_COMBO_BOX(stwidgets.custommodcombo), NONE);
416	settings.custommoddir = NULL;	416	settings.custommoddir = NULL;
417		417
418	break;	418	break;
419	}	419	}
420	if (Bstrcmp(settings.custommoddir, value) == 0)	420	if (Bstrcmp(settings.custommoddir, value) == 0)
421	{	421	{
422	gtk_combo_box_set_active_iter(GTK_COMBO_BOX(stwidgets.custommodcombo),	422	gtk_combo_box_set_active_iter(GTK_COMBO_BOX(stwidgets.custommodcombo),
423	&iter);	423	&iter);
424		424
425	break;	425	break;
426	}	426	}
427	}	427	}
428		428
429	// populate check buttons	429	// populate check buttons
430	gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(stwidgets.fullscreencheck), settings.fullscreen);	430	gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(stwidgets.fullscreencheck), settings.fullscreen);
431	#ifdef POLYMER	431	#ifdef POLYMER
432	gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(stwidgets.polymercheck), settings.polymer);	432	gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(stwidgets.polymercheck), settings.polymer);
433	#endif	433	#endif
434	gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(stwidgets.autoloadcheck), settings.autoload);	434	gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(stwidgets.autoloadcheck), settings.autoload);
435	gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(stwidgets.alwaysshowcheck), settings.forcesetup);	435	gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(stwidgets.alwaysshowcheck), settings.forcesetup);
436	}	436	}
437		437
438	if ((pgs == ALL) \|\| (pgs == POPULATE_GAME))	438	if ((pgs == ALL) \|\| (pgs == POPULATE_GAME))
439	{	439	{
440	struct grpfile *fg;	440	struct grpfile *fg;
441	GtkListStore *list;	441	GtkListStore *list;
442	GtkTreeIter iter;	442	GtkTreeIter iter;
443	GtkTreeView *gamelist;	443	GtkTreeView *gamelist;
444		444
445	gamelist = GTK_TREE_VIEW(stwidgets.gamelist);	445	gamelist = GTK_TREE_VIEW(stwidgets.gamelist);
446	list = GTK_LIST_STORE(gtk_tree_view_get_model(gamelist));	446	list = GTK_LIST_STORE(gtk_tree_view_get_model(gamelist));
447	gtk_list_store_clear(list);	447	gtk_list_store_clear(list);
448		448
449	for (fg = foundgrps; fg; fg=fg->next)	449	for (fg = foundgrps; fg; fg=fg->next)
450	{	450	{
451	struct grpfile *grp;	451	struct grpfile *grp;
452	for (grp = listgrps; grp; grp=grp->next)	452	for (grp = listgrps; grp; grp=grp->next)
453	if (fg->crcval == grp->crcval) break;	453	if (fg->crcval == grp->crcval) break;
454		454
455	if (grp == NULL)	455	if (grp == NULL)
456	continue;	456	continue;
457		457
458	gtk_list_store_append(list, &iter);	458	gtk_list_store_append(list, &iter);
459	gtk_list_store_set(list, &iter, 0, grp->name, 1, fg->name, 2, (gpointer)fg, -1);	459	gtk_list_store_set(list, &iter, 0, grp->name, 1, fg->name, 2, (gpointer)fg, -1);
460	if (!Bstrcasecmp(fg->name, settings.selectedgrp))	460	if (!Bstrcasecmp(fg->name, settings.selectedgrp))
461	{	461	{
462	GtkTreeSelection *sel = gtk_tree_view_get_selection(gamelist);	462	GtkTreeSelection *sel = gtk_tree_view_get_selection(gamelist);
463	g_signal_handlers_block_by_func(sel, (gpointer)on_gamelist_selection_changed, NULL);	463	g_signal_handlers_block_by_func(sel, (gpointer)on_gamelist_selection_changed, NULL);
464	gtk_tree_selection_select_iter(sel, &iter);	464	gtk_tree_selection_select_iter(sel, &iter);
465	g_signal_handlers_unblock_by_func(sel, (gpointer)on_gamelist_selection_changed, NULL);	465	g_signal_handlers_unblock_by_func(sel, (gpointer)on_gamelist_selection_changed, NULL);
466	}	466	}
467	}	467	}
468	}	468	}
469	}	469	}
470		470
471	static gint name_sorter(GtkTreeModel model, GtkTreeIter a, GtkTreeIter *b, gpointer user_data)	471	static gint name_sorter(GtkTreeModel model, GtkTreeIter a, GtkTreeIter *b, gpointer user_data)
472	{	472	{
473	gchar as, bs;	473	gchar as, bs;
474	gint r;	474	gint r;
475	UNREFERENCED_PARAMETER(user_data);	475	UNREFERENCED_PARAMETER(user_data);
476	gtk_tree_model_get(model, a, 0, &as, -1);	476	gtk_tree_model_get(model, a, 0, &as, -1);
477	gtk_tree_model_get(model, b, 0, &bs, -1);	477	gtk_tree_model_get(model, b, 0, &bs, -1);
478		478
479	r = g_utf8_collate(as,bs);	479	r = g_utf8_collate(as,bs);
480		480
481	g_free(as);	481	g_free(as);
482	g_free(bs);	482	g_free(bs);
483		483
484	return r;	484	return r;
485	}	485	}
486		486
487	static GtkWidget *create_window(void)	487	static GtkWidget *create_window(void)
488	{	488	{
489	// Basic window	489	// Basic window
490	stwidgets.startwin = gtk_window_new(GTK_WINDOW_TOPLEVEL);	490	stwidgets.startwin = gtk_window_new(GTK_WINDOW_TOPLEVEL);
491	gtk_window_set_title(GTK_WINDOW(stwidgets.startwin), apptitle); // NOTE: use global app title	491	gtk_window_set_title(GTK_WINDOW(stwidgets.startwin), apptitle); // NOTE: use global app title
492	gtk_window_set_position(GTK_WINDOW(stwidgets.startwin), GTK_WIN_POS_CENTER);	492	gtk_window_set_position(GTK_WINDOW(stwidgets.startwin), GTK_WIN_POS_CENTER);
493	gtk_window_set_resizable(GTK_WINDOW(stwidgets.startwin), FALSE);	493	gtk_window_set_resizable(GTK_WINDOW(stwidgets.startwin), FALSE);
494	gtk_window_set_type_hint(GTK_WINDOW(stwidgets.startwin), GDK_WINDOW_TYPE_HINT_DIALOG);	494	gtk_window_set_type_hint(GTK_WINDOW(stwidgets.startwin), GDK_WINDOW_TYPE_HINT_DIALOG);
495		495
496	// Horizontal layout of banner and controls	496	// Horizontal layout of banner and controls
497	stwidgets.hlayout = gtk_hbox_new(FALSE, 0);	497	stwidgets.hlayout = gtk_hbox_new(FALSE, 0);
498	gtk_container_add(GTK_CONTAINER(stwidgets.startwin), stwidgets.hlayout);	498	gtk_container_add(GTK_CONTAINER(stwidgets.startwin), stwidgets.hlayout);
499		499
500	// banner	500	// banner

Subversion Repositories eduke32

(root)/polymer/eduke32/source/startgtk.game.c – Rev 4773 → 5062