studio.cc

Go to the documentation of this file.

/*
Copyright (C) 2000-2001 The Exult Team

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., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
*/

#ifdef HAVE_CONFIG_H
#  include <config.h>
#endif

#ifdef HAVE_SYS_TYPES_H
#include <sys/types.h>
#endif
#include <dirent.h>
#include <gtk/gtk.h>
#ifdef XWIN
#include <gdk/gdkx.h>
#endif
#include <glib.h>
#include <unistd.h>
#include <errno.h>

#include <cstdio>     /* These are for sockets. */
#ifdef WIN32
#include <windows.h>
#include <ole2.h>
#include "servewin32.h"
#else
#include <sys/socket.h>
#include <sys/un.h>
#endif
#include <fcntl.h>
#include <cstdarg>

#include "shapelst.h"
#include "shapevga.h"
#include "Flex.h"
#include "studio.h"
#include "utils.h"
#include "u7drag.h"
#include "shapegroup.h"
#include "shapefile.h"
#include "locator.h"
#include "combo.h"
#include "Configuration.h"
#include "objserial.h"
#include "exceptions.h"
#include "logo.xpm"
#include "fnames.h"
#include "execbox.h"

using std::cerr;
using std::cout;
using std::endl;
using std::string;
using std::vector;
using std::ofstream;

ExultStudio *ExultStudio::self = 0;
Configuration *config = 0;
const std::string c_empty_string; // Used by config. library.

          // Mode menu items:
static char *mode_names[4] = {"move1", "paint1", "paint_with_chunks1", 
              "pick_for_combo1"};

enum ExultFileTypes {
  ShapeArchive =1,
  ChunkArchive,
  PaletteFile,
  FlexArchive,
  ComboArchive
};

typedef struct _FileTreeItem FileTreeItem;
struct _FileTreeItem
{
  const gchar    *label;
  ExultFileTypes datatype;
  FileTreeItem   *children;
};

/* columns */
enum
{
  FOLDER_COLUMN = 0,
  FILE_COLUMN,
  DATA_COLUMN,
  NUM_COLUMNS
};


static void Filelist_selection(GtkTreeView *treeview, GtkTreePath *path)
{
  int type = -1;
  char *text;
  GtkTreeIter iter;
  GtkTreeModel *model = gtk_tree_view_get_model(GTK_TREE_VIEW(treeview));

  gtk_tree_model_get_iter(model, &iter, path);
  gtk_tree_model_get(model, &iter, FILE_COLUMN, &text, DATA_COLUMN, 
                &type,-1);
  printf("%s %d\n",text,type);
  
  ExultStudio *studio = ExultStudio::get_instance();
  switch(type) {
  case ShapeArchive:
    studio->set_browser("Shape Browser", 
          studio->create_browser(text));
    break;
  case ComboArchive:
    studio->set_browser("Combo Browser", 
          studio->create_browser(text));
    break;
  case ChunkArchive:
    studio->set_browser("Chunk Browser", 
          studio->create_browser(text));
    break;
  case PaletteFile:
    studio->set_browser("Palette Browser", 
          studio->create_browser(text));
    break;
  default:
    break;
  }
  g_free(text);
}                                     

C_EXPORT void on_filelist_tree_cursor_changed(GtkTreeView *treeview)
{
  GtkTreePath *path;
  GtkTreeViewColumn *col;

  gtk_tree_view_get_cursor(treeview, &path, &col);
  Filelist_selection(treeview, path);
}

C_EXPORT void
on_open_game_activate                  (GtkMenuItem     *menuitem,
                                        gpointer         user_data)
{
  ExultStudio::get_instance()->choose_game_path();
}

C_EXPORT void
on_new_game_activate                   (GtkMenuItem     *menuitem,
                                        gpointer         user_data)
{
  ExultStudio::get_instance()->new_game();
}

C_EXPORT void
on_connect_activate                    (GtkMenuItem     *menuitem,
                                        gpointer         user_data)
{
  ExultStudio::get_instance()->connect_to_server();
}

C_EXPORT void
on_save_all1_activate                  (GtkMenuItem     *menuitem,
                                        gpointer         user_data)
{
  ExultStudio::get_instance()->save_all();
}

C_EXPORT void
on_new_shapes_file_activate             (GtkMenuItem     *menuitem,
                                        gpointer         user_data)
{
  ExultStudio::get_instance()->new_shape_file(false);
}

C_EXPORT void
on_new_shape_file_activate             (GtkMenuItem     *menuitem,
                                        gpointer         user_data)
{
  ExultStudio::get_instance()->new_shape_file(true);
}

C_EXPORT void
on_save_map_menu_activate              (GtkMenuItem     *menuitem,
                                        gpointer         user_data)
{
  ExultStudio::get_instance()->write_map();
}

C_EXPORT void
on_read_map_menu_activate              (GtkMenuItem     *menuitem,
                                        gpointer         user_data)
{
  ExultStudio::get_instance()->read_map();
}

C_EXPORT void
on_save_shape_info1_activate           (GtkMenuItem     *menuitem,
                                        gpointer         user_data)
{
  ExultStudio::get_instance()->write_shape_info();
}

C_EXPORT void
on_reload_usecode_menu_activate        (GtkMenuItem     *menuitem,
                                        gpointer         user_data)
{
  ExultStudio::get_instance()->reload_usecode();
}

C_EXPORT void
on_compile_usecode_menu_activate       (GtkMenuItem     *menuitem,
                                        gpointer         user_data)
{
  ExultStudio::get_instance()->compile();
}

C_EXPORT void
on_save_groups1_activate               (GtkMenuItem     *menuitem,
                                        gpointer         user_data)
{
  ExultStudio::get_instance()->save_groups();
}

C_EXPORT void
on_save_combos1_activate               (GtkMenuItem     *menuitem,
                                        gpointer         user_data)
{
  ExultStudio::get_instance()->save_combos();
}

C_EXPORT void
on_preferences_activate                (GtkMenuItem     *menuitem,
                                        gpointer         user_data)
{
  ExultStudio::get_instance()->open_preferences();
}

C_EXPORT void
on_cut1_activate                       (GtkMenuItem     *menuitem,
                                        gpointer         user_data)
{
  unsigned char z = 0;
  ExultStudio::get_instance()->send_to_server(Exult_server::cut,
              &z, 1);
}

C_EXPORT void
on_copy1_activate                      (GtkMenuItem     *menuitem,
                                        gpointer         user_data)
{
  unsigned char o = 1;
  ExultStudio::get_instance()->send_to_server(Exult_server::cut,
              &o, 1);
}

C_EXPORT void
on_paste1_activate                       (GtkMenuItem     *menuitem,
                                        gpointer         user_data)
{
  ExultStudio::get_instance()->send_to_server(Exult_server::paste);
}

C_EXPORT void
on_properties1_activate                (GtkMenuItem     *menuitem,
                                        gpointer         user_data)
{
  unsigned char o = 0;    // 0=npc/egg properties.
  ExultStudio::get_instance()->send_to_server(
        Exult_server::edit_selected, &o, 1);
}

C_EXPORT void
on_basic_properties1_activate          (GtkMenuItem     *menuitem,
                                        gpointer         user_data)
{
  unsigned char o = 1;    // 1=basic object properties.
  ExultStudio::get_instance()->send_to_server(
        Exult_server::edit_selected, &o, 1);
}

C_EXPORT void
on_move1_activate                (GtkMenuItem     *menuitem,
                                        gpointer         user_data)
{
          // NOTE:  modes are defined in cheat.h.
  if (GTK_CHECK_MENU_ITEM(menuitem)->active)
    ExultStudio::get_instance()->set_edit_mode(0);
}

C_EXPORT void
on_paint1_activate                 (GtkMenuItem     *menuitem,
                                        gpointer         user_data)
{
  if (GTK_CHECK_MENU_ITEM(menuitem)->active)
    ExultStudio::get_instance()->set_edit_mode(1);
}

C_EXPORT void
on_paint_with_chunks1_activate         (GtkMenuItem     *menuitem,
                                        gpointer         user_data)
{
  if (GTK_CHECK_MENU_ITEM(menuitem)->active)
    ExultStudio::get_instance()->set_edit_mode(2);
}

C_EXPORT void
on_pick_for_combo1_activate            (GtkMenuItem     *menuitem,
                                        gpointer         user_data)
{
  if (GTK_CHECK_MENU_ITEM(menuitem)->active)
    ExultStudio::get_instance()->set_edit_mode(3);
}

C_EXPORT void
on_unused_shapes1_activate             (GtkMenuItem     *menuitem,
                                        gpointer         user_data)
{
  if (EStudio::Prompt(
    "Finding unused shapes may take several minutes\nProceed?",
          "Yes", "No") != 0)
    return;
  ExultStudio::get_instance()->send_to_server(
            Exult_server::unused_shapes);
}

C_EXPORT void
on_play_button_clicked      (GtkToggleButton *button,
           gpointer   user_data)
{
  ExultStudio::get_instance()->set_play(
        gtk_toggle_button_get_active(button));
}

C_EXPORT void
on_tile_grid_button_toggled   (GtkToggleButton *button,
           gpointer   user_data)
{
  ExultStudio::get_instance()->set_tile_grid(
        gtk_toggle_button_get_active(button));
}

C_EXPORT void
on_edit_lift_spin_changed   (GtkSpinButton *button,
           gpointer   user_data)
{
  ExultStudio::get_instance()->set_edit_lift(
        gtk_spin_button_get_value_as_int(button));
}

C_EXPORT void
on_hide_lift_spin_changed   (GtkSpinButton *button,
           gpointer   user_data)
{
  ExultStudio::get_instance()->set_hide_lift(
        gtk_spin_button_get_value_as_int(button));
}

C_EXPORT void
on_edit_terrain_button_toggled    (GtkToggleButton *button,
           gpointer   user_data)
{
  ExultStudio::get_instance()->set_edit_terrain(
        gtk_toggle_button_get_active(button));
}

void on_choose_directory               (gchar *dir,
          gpointer  user_data)
{
  ExultStudio::get_instance()->set_game_path(dir);
}

/*
 *  Configure main window.
 */
C_EXPORT gint on_main_window_configure_event
  (
  GtkWidget *widget,    // The view window.
  GdkEventConfigure *event,
  gpointer data
  )
  {
  ExultStudio *studio = ExultStudio::get_instance();
          // Configure "Hide lift" spin range.
  studio->set_spin("hide_lift_spin", 
        studio->get_spin("hide_lift_spin"), 1, 16);
  return FALSE;
  }

/*
 *  Main window's close button.
 */
C_EXPORT gboolean on_main_window_delete_event
  (
  GtkWidget *widget,
  GdkEvent *event,
  gpointer user_data
  )
  {
  if (!ExultStudio::get_instance()->okay_to_close())
    return TRUE;    // Can't quit.
  return FALSE;
  }
C_EXPORT void on_main_window_destroy_event
  (
  GtkWidget *widget,
  gpointer data
  )
  {
  gtk_main_quit();
  }
/*
 *  "Exit" in main window.
 */
C_EXPORT void
on_main_window_quit                    (GtkMenuItem     *menuitem,
                                        gpointer         user_data)
{
  if (ExultStudio::get_instance()->okay_to_close())
    gtk_main_quit();
}
/*
 *  Main window got focus.
 */
C_EXPORT gboolean on_main_window_focus_in_event
  (
  GtkWidget *widget,
  GdkEventFocus *event,
  gpointer user_data
  )
  {
  Shape_chooser::check_editing_files();
  return FALSE;
  }


/*
 *  Set up everything.
 */

ExultStudio::ExultStudio(int argc, char **argv): files(0), curfile(0), 
  names(0), glade_path(0), shape_info_modified(false),
  shape_names_modified(false),
  vgafile(0), facefile(0), eggwin(0), 
  server_socket(-1), server_input_tag(-1), 
  static_path(0), image_editor(0), default_game(0), background_color(0),
  browser(0), palbuf(0), egg_monster_draw(0), 
  egg_ctx(0),
  waiting_for_server(0), npcwin(0), npc_draw(0), npc_face_draw(0),
  npc_ctx(0), npc_status_id(0),
  objwin(0), obj_draw(0), shapewin(0), shape_draw(0),
  equipwin(0), locwin(0), combowin(0), compilewin(0), compile_box(0)
{
  // Initialize the various subsystems
  self = this;
  gtk_init( &argc, &argv );
  gdk_rgb_init();
  glade_init();
  config = new Configuration;
  config->read_config_file(USER_CONFIGURATION_FILE);
          // Get options.
  const char *xmldir = 0;   // Default:  Look here for .glade.
  const char *game = 0;   // Game to look up in .exult.cfg.
  static char *optstring = "g:x:d:";
  extern int optind, opterr, optopt;
  extern char *optarg;
  opterr = 0;     // Don't let getopt() print errs.
  int optchr;
  while ((optchr = getopt(argc, argv, optstring)) != -1)
    switch (optchr)
      {
    case 'g':   // Game.  Replaces use of -d, -x.
      game = optarg;
      break;
    case 'x':   // XML (.glade) directory.
      xmldir = optarg;
      break;
      }
  string dirstr, datastr;
  if (!xmldir)
    {
    config->value("config/disk/data_path", datastr, EXULT_DATADIR);
    xmldir = datastr.c_str();
    }
  string defgame;     // Default game name.
  config->value("config/estudio/default_game", defgame, "blackgate");
  default_game = g_strdup(defgame.c_str());
  if (!game)
    game = default_game;
  config->set("config/estudio/default_game", defgame, true);
  char path[256];     // Set up paths.
  if(xmldir)
    strcpy(path, xmldir);
  else if(U7exists(EXULT_DATADIR"/exult_studio.glade"))
    strcpy(path,EXULT_DATADIR);
  else
    strcpy(path,".");
  strcat(path, "/exult_studio.glade");
  // Load the Glade interface
  app_xml = glade_xml_new(path, NULL, NULL);
  app = glade_xml_get_widget( app_xml, "main_window" );
  glade_path = g_strdup(path);

  // More setting up...
          // Connect signals automagically.
  glade_xml_signal_autoconnect(app_xml);
  int w, h;     // Get main window dims.
  config->value("config/estudio/main/width", w, 0);
  config->value("config/estudio/main/height", h, 0);
  if (w > 0 && h > 0)
//++++Used to work  gtk_window_set_default_size(GTK_WINDOW(app), w, h);
    gtk_window_resize(GTK_WINDOW(app), w, h);
  gtk_widget_show( app );
          // Background color for shape browser.
  int bcolor;
  config->value("config/estudio/background_color", bcolor, 0);
  background_color = bcolor;
  if (game)     // Game given?
    {
    string d("config/disk/game/");
    d += game; 
    string gd = d + "/path";
    config->value(gd.c_str(), dirstr, "");
    if (dirstr == "")
      {
      cerr << "Game '" << game << 
        "' path not found in config. file" << endl;
      exit(1);
      }
    string pd = d + "/patch"; // Look up patch dir. too.
    string ptchstr;
    config->value(pd.c_str(), ptchstr, "");
    set_game_path(dirstr.c_str(), ptchstr == "" ? 0 
            : ptchstr.c_str());
    }
  string iedit;     // Get image-editor command.
  config->value("config/estudio/image_editor", iedit, "gimp-remote -n");
  image_editor = g_strdup(iedit.c_str());
  config->set("config/estudio/image_editor", iedit, true);
#ifdef WIN32
    OleInitialize(NULL);
#endif
          // Init. 'Mode' menu, since Glade
          //   doesn't seem to do it right.
  GSList *group = NULL;
  for (int i = 0; i < sizeof(mode_names)/sizeof(mode_names[0]); i++)
    {
    GtkWidget *item = glade_xml_get_widget(app_xml, mode_names[i]);
    gtk_radio_menu_item_set_group(GTK_RADIO_MENU_ITEM(item),
                group);
    group = gtk_radio_menu_item_group(GTK_RADIO_MENU_ITEM(item));
    gtk_check_menu_item_set_active(
        GTK_CHECK_MENU_ITEM(item), i == 0);
    }
}

ExultStudio::~ExultStudio()
{
#ifdef WIN32
    OleUninitialize();
#endif
          // Store main window size.
  int w = app->allocation.width, h = app->allocation.height;
          // Finish up external edits.
  Shape_chooser::clear_editing_files();
  config->set("config/estudio/main/width", w, true);
  config->set("config/estudio/main/height", h, true);
  int num_names = names.size();
  for (int i = 0; i < num_names; i++)
    delete names[i];
  names.resize(0);
  g_free(glade_path);
  delete files;
  files = 0;
  delete [] palbuf;
  palbuf = 0;
  if (objwin)
    gtk_widget_destroy(objwin);
  delete obj_draw;
  if (eggwin)
    gtk_widget_destroy(eggwin);
  delete egg_monster_draw;
  eggwin = 0;
  if (npcwin)
    gtk_widget_destroy(npcwin);
  delete npc_draw;
  npcwin = 0;
  if (shapewin)
    gtk_widget_destroy(shapewin);
  delete shape_draw;
  shapewin = 0;
  if (equipwin)
    gtk_widget_destroy(equipwin);
  equipwin = 0;
  if (compilewin)
    gtk_widget_destroy(compilewin);
  compilewin = 0;
  delete compile_box;
  compile_box = 0;
  if (locwin)
    delete locwin;
  if (combowin)
    delete combowin;
  locwin = 0;
  g_object_unref( G_OBJECT( app_xml ) );
#ifndef WIN32
  if (server_input_tag >= 0)
    gdk_input_remove(server_input_tag);
  if (server_socket >= 0)
    close(server_socket);
#else
  if (server_input_tag >= 0)
    gtk_timeout_remove(server_input_tag);
  if (server_socket >= 0)
    Exult_server::disconnect_from_server();
#endif
  g_free(static_path);
  g_free(image_editor);
  g_free(default_game);
  self = 0;
  delete config;
  config = 0;
}

/*
 *  Okay to close game?
 */

bool ExultStudio::okay_to_close
  (
  )
  {
  if (need_to_save())
    {
    int choice = prompt("File(s) modified.  Save?",
            "Yes", "No", "Cancel");
    if (choice == 2)  // Cancel?
      return false;
    if (choice == 0)
      save_all(); // Write out changes.
    }
  return true;
  }

/*
 *  See if given window has focus (experimental).
 */

inline bool Window_has_focus(GtkWindow *win)
  {
  return (win->focus_widget != 0 &&
    GTK_WIDGET_HAS_FOCUS(win->focus_widget));
  }

/*
 *  Do we have focus?  Currently only checks main window and group
 *  windows.
 */

bool ExultStudio::has_focus
  (
  )
  {
  if (Window_has_focus(GTK_WINDOW(app)))
    return true;    // Main window.
          // Group windows:
  vector<GtkWindow*>::const_iterator it;
  for (it = group_windows.begin(); it != group_windows.end(); ++it)
    if (Window_has_focus(*it))
      return true;
  return false;
  }

/*
 *  Set browser area.  NOTE:  obj may be null.
 */
void ExultStudio::set_browser(const char *name, Object_browser *obj)
{
  GtkWidget *browser_frame = glade_xml_get_widget(app_xml, 
              "browser_frame" );
  GtkWidget *browser_box = glade_xml_get_widget(app_xml, "browser_box" );
//+++Now owned by Shape_file_info.  delete browser;
  if (browser)
    gtk_container_remove(GTK_CONTAINER(browser_box),
              browser->get_widget());
  browser = obj;
  
  gtk_frame_set_label( GTK_FRAME( browser_frame ), name );
  gtk_widget_show( browser_box );
  if (browser)
    gtk_box_pack_start(GTK_BOX(browser_box), 
          browser->get_widget(), TRUE, TRUE, 0);
}

Object_browser *ExultStudio::create_browser(const char *fname)
{
  curfile = open_shape_file(fname);
  if (!curfile)
    return 0;
  Object_browser *chooser = curfile->get_browser(vgafile, palbuf);
  setup_groups();     // Set up 'groups' page.
  return chooser;
}

/*
 *  Get current groups.
 */

Shape_group_file *ExultStudio::get_cur_groups
  (
  )
  {
  return curfile ? curfile->get_groups() : 0;
  }

/*
 *  Test for a directory 'slash' or colon.
 */

inline bool Is_dir_marker
  (
  char c
  )
  {
  return (c == '/' || c == '\\' || c == ':');
  }

/*
 *  New game directory was chosen.
 */

void on_choose_new_game_dir
  (
  const char *dir,
  gpointer udata      // ->studio.
  )
  {
  ((ExultStudio *) udata)->create_new_game(dir);
  }
void ExultStudio::create_new_game
  (
  const char *dir     // Directory for new game.
  )
  {
          // Take basename as game name.
  const char *eptr = dir + strlen(dir) - 1;
  while (eptr >= dir && Is_dir_marker(*eptr))
    eptr--;
  eptr++;
  const char *ptr = eptr - 1;
  for ( ; ptr >= dir; ptr--)
    if (Is_dir_marker(*ptr))
      {
      ptr++;
      break;
      }
  if (ptr < dir || eptr - ptr <= 0)
    {
    EStudio::Alert("Can't find base game name in '%s'", dir);
    return;
    }
  string gamestr(ptr, eptr - ptr);
  string dirstr(dir);
  string static_path = dirstr + "/static";
  if (U7exists(static_path))
    {
    string msg("Directory '");
    msg += static_path;
    msg += "' already exists.\n";
    msg += "Files within may be overwritten.\n";
    msg += "Proceed?";
    if (prompt(msg.c_str(), "Yes", "No") != 0)
      return;
    }
  U7mkdir(dir, 0755);   // Create "game", "game/static",
          //   "game/patch".
  U7mkdir(static_path.c_str(), 0755);
  string patch_path = dirstr + "/patch";
  U7mkdir(patch_path.c_str(), 0755);
          // Set .exult.cfg.
  string d("config/disk/game/");
  string gameconfig = d + gamestr;
  d = gameconfig + "/path";
  config->set(d.c_str(), dirstr, false);
  d = gameconfig + "/patch";
  config->set(d.c_str(), patch_path, false);
  d = gameconfig + "/editing";  // We are editing.
  config->set(d.c_str(), "yes", true);
  string esdir;     // Get dir. for new files.
  config->value("config/disk/data_path", esdir, EXULT_DATADIR);
  esdir += "/estudio/new";
  DIR *dirrd = opendir(esdir.c_str());
  if (!dirrd)
    EStudio::Alert("'%s' for initial data files not found",
                esdir.c_str());
  else
    {
    struct dirent *entry;
    while(entry=readdir(dirrd)) 
      {
      char *fname = entry->d_name;
      int flen = strlen(fname);
          // Ignore case of extension.
      if(!strcmp(fname, ".") || !strcmp(fname,".."))
        continue;
      string src = esdir + '/' + fname;
      string dest = static_path + '/' + fname;
      try {
        U7copy(src.c_str(), dest.c_str());
      } catch (exult_exception& e) {
        EStudio::Alert(e.what());
      }
      }
    closedir(dirrd);
    }
  set_game_path(dir);   // Open as current game.
  write_shape_info(true);   // Create initial .dat files.
  }

/*
 *  Prompt for a 'new game' directory.
 */

void ExultStudio::new_game()
{
  if (!okay_to_close())   // Okay to close prev. game?
    return;
  GtkFileSelection *fsel = Create_file_selection(
      "Choose new game directory",
      on_choose_new_game_dir, this);
  gtk_widget_show(GTK_WIDGET(fsel));
}

/*
 *  Choose game directory.
 */
void ExultStudio::choose_game_path()
{
  if (!okay_to_close())   // Okay to close prev. game?
    return;
  size_t  bufsize=128;
  char * cwd(new char[bufsize]);
  while(!getcwd(cwd,bufsize))
    {
    if(errno==ERANGE)
      {
      bufsize+=128;
      delete [] cwd;
      cwd=new char[bufsize];
      }
    else
      {
      // Ooops. getcwd() has failed
      delete [] cwd;  // Prevent leakage
      return;
      }
    }
  GtkFileSelection *fsel = Create_file_selection(
          "Select game directory",
      (File_sel_okay_fun) on_choose_directory, 0L);
  gtk_file_selection_set_filename(fsel, cwd);
  gtk_widget_show(GTK_WIDGET(fsel));
  delete [] cwd;  // Prevent leakage
}



/*
 *  Note: Patchpath may be NULL,in which case gamepath/patch is used.
 */
void ExultStudio::set_game_path(const char *gamepath, const char *patchpath)
{
          // Finish up external edits.
  Shape_chooser::clear_editing_files();
          // Set top-level path.
  add_system_path("<GAME>", gamepath);
  if (static_path)
    g_free(static_path);
          // Set up path to static.
  static_path = g_strdup_printf("%s/static", gamepath);
  add_system_path("<STATIC>", static_path);
  char *patch_path = patchpath ? g_strdup(patchpath) :
          g_strdup_printf("%s/patch", gamepath);
  add_system_path("<PATCH>", patch_path);
  if (!U7exists(patch_path))  // Create patch if not there.
    U7mkdir(patch_path, 0755);
  g_free(patch_path);
          // Clear file cache!
  U7FileManager::get_ptr()->reset();
  delete palbuf;      // Delete old.
  string palname("<PATCH>/"); // 1st look in patch for palettes.
  palname += "palettes.flx";
  size_t len;
  if (!U7exists(palname.c_str()))
    (palname = "<STATIC>/") += "palettes.flx";
  if (!U7exists(palname.c_str()))
    {     // No palette file, so create fake.
    palbuf = new unsigned char[3*256];  // How about all white?
    memset(palbuf, (63<<16)|(63<<8)|63, 3*256);
    }
  else
    {
    U7object pal(palname.c_str(), 0);
          // this may throw an exception
    palbuf = (unsigned char *) pal.retrieve(len);
    }
          // Set background color.
  palbuf[3*255] = (background_color>>18)&0x3f;
  palbuf[3*255 + 1] = (background_color>>10)&0x3f;
  palbuf[3*255 + 2] = (background_color>>2)&0x3f;
          // Delete old names.
  int num_names = names.size();
  for (int i = 0; i < num_names; i++)
    delete names[i];
  names.resize(0);
  delete files;     // Close old shape files.
  browser = 0;      // This was owned by 'files'.
  files = new Shape_file_set();
  vgafile = open_shape_file("shapes.vga");
  facefile = open_shape_file("faces.vga");
          // Read in shape names.
  string txtname("<PATCH>/text.flx");
  if (!U7exists(txtname.c_str()))
    txtname = "<STATIC>/text.flx";
  if (U7exists(txtname.c_str()))
    {
    Flex *items = new Flex(txtname.c_str());
    int num_names = items->number_of_objects();
    names.resize(num_names);
    int i;
    for (i = 0; i < num_names; i++)
      names[i] = items->retrieve(i, len);
    delete items;
    }
  setup_file_list();    // Set up file-list window.
  set_browser("", 0);   // No browser.
  connect_to_server();    // Connect to server with 'gamedat'.
}

void add_to_tree(GtkTreeStore *model, const char *folderName, const char *files, ExultFileTypes file_type)
{
  struct dirent *entry;
  GtkTreeIter iter;
  
  // First, we add the folder
  gtk_tree_store_append(model, &iter, NULL);
  gtk_tree_store_set(model, &iter,
    FOLDER_COLUMN, folderName,
    FILE_COLUMN, NULL,
    DATA_COLUMN, -1,
    -1);
  
  // Scan the files which are separated by commas
  GtkTreeIter child_iter;
  char *startpos = (char *)files;
  int adding_children = 1;
  do {
    char *pattern;
    char *commapos = strstr(startpos, ",");
    if(commapos==0) {
      pattern = strdup(startpos);
      adding_children = 0;
    } else {
      pattern = g_strndup(startpos, commapos-startpos);
      startpos = commapos+1;
    }
    
    string spath("<STATIC>"), ppath("<PATCH>");
          spath = get_system_path(spath);
          ppath = get_system_path(ppath);
          char *ext = strstr(pattern,"*");
    if(!ext)
      ext = pattern;
    else
      ext++;
    DIR *dir = opendir(ppath.c_str());// Get names from 'patch' first.
    if (dir) {
      while(entry=readdir(dir)) {
        char *fname = entry->d_name;
                          int flen = strlen(fname);
                                        // Ignore case of extension.
                          if(!strcmp(fname,".")||!strcmp(fname,"..") ||strcasecmp(fname + flen - strlen(ext), ext) != 0)
                                  continue;
        gtk_tree_store_append (model, &child_iter, &iter);
        gtk_tree_store_set (model, &child_iter,
                FOLDER_COLUMN, NULL,
                FILE_COLUMN, fname,
          DATA_COLUMN, file_type,
                -1);
                          
                  }
                  closedir(dir);
          }
    dir = opendir(spath.c_str());   // Now go through 'static'.
          if (dir) {
                  while(entry=readdir(dir)) {
                          char *fname = entry->d_name;
                          int flen = strlen(fname);
                                        // Ignore case of extension.
                          if(!strcmp(fname,".")||!strcmp(fname,"..")||strcasecmp(fname + flen - strlen(ext), ext) != 0)
                                  continue;
                                        // See if also in 'patch'.
                          string fullpath(ppath);
                          fullpath += "/";
                          fullpath += fname;
                          if (U7exists(fullpath))
                                  continue;
        gtk_tree_store_append (model, &child_iter, &iter);
        gtk_tree_store_set (model, &child_iter,
                FOLDER_COLUMN, NULL,
                FILE_COLUMN, fname,
          DATA_COLUMN, file_type,
                -1);
                  }
                  closedir(dir);
          }

    free(pattern);
  } while (adding_children);
}

/*
 *  Set up the file list to the left of the main window.
 */

void ExultStudio::setup_file_list() {
  GtkWidget *file_list = glade_xml_get_widget( app_xml, "file_list" );
  
    /* create tree store */
  GtkTreeModel *oldmod = gtk_tree_view_get_model(
            GTK_TREE_VIEW(file_list));
    GtkTreeStore *model;
  if (oldmod)
    model = GTK_TREE_STORE(oldmod);
  else        // Create the first time.
    {
    model = gtk_tree_store_new(
      NUM_COLUMNS, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_INT);
    gtk_tree_view_set_model(GTK_TREE_VIEW(file_list), 
              GTK_TREE_MODEL(model));
    g_object_unref(model);
    gint col_offset;
      GtkCellRenderer *renderer = gtk_cell_renderer_text_new ();
    GtkTreeViewColumn *column;
    
    /* column for folder names */
    g_object_set (renderer, "xalign", 0.0, NULL);
    col_offset = gtk_tree_view_insert_column_with_attributes(
          GTK_TREE_VIEW(file_list),
          -1, "Folders",
          renderer, "text",
          FOLDER_COLUMN, NULL);
    column = gtk_tree_view_get_column(GTK_TREE_VIEW(file_list), 
              col_offset - 1);
    gtk_tree_view_column_set_clickable(
          GTK_TREE_VIEW_COLUMN(column), TRUE);
    /* column for file names */
    col_offset = gtk_tree_view_insert_column_with_attributes(
          GTK_TREE_VIEW(file_list),
          -1, "Files",
          renderer, "text",
          FILE_COLUMN, NULL);
    column = gtk_tree_view_get_column(GTK_TREE_VIEW(file_list), 
              col_offset - 1);
    gtk_tree_view_column_set_clickable(
          GTK_TREE_VIEW_COLUMN(column), TRUE);
    }
  gtk_tree_store_clear(model);
  add_to_tree(model, "Shape Files", "*.vga,*.shp,combos.flx", ShapeArchive);
  add_to_tree(model, "Map Files", "u7chunks", ChunkArchive);
  add_to_tree(model, "Palette Files", "*.pal,palettes.flx", PaletteFile);
  
#if 0 /* Skip this until we can do something with these files. */
  add_to_tree(model, "FLEX Files", "*.flx", FlexArchive);
#endif
          // Expand all entries.
  gtk_tree_view_expand_all(GTK_TREE_VIEW(file_list));
  gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(file_list), TRUE);
  gtk_tree_selection_set_mode(gtk_tree_view_get_selection(GTK_TREE_VIEW(file_list)), GTK_SELECTION_SINGLE);
}

/*
 *  Save all the files we've changed:
 *    Object browser.
 *    Group files.
 *    Shape files.
 *    Shape info (tfa.dat, weapons.dat, etc.)
 *    Game map.
 */

void ExultStudio::save_all
  (
  )
  {
  save_groups();      // Group files.
  if (files)
    {     // Get back any changed images.
    Shape_chooser::check_editing_files();
    files->flush();   // Write out the .vga files.
    }
  write_shape_info();
  write_map();
  }

/*
 *  Any files need saving?
 */

bool ExultStudio::need_to_save
  (
  )
  {
  if (groups_modified())
    return true;
  if (files && files->is_modified())
    return true;
  if (shape_info_modified || shape_names_modified)
    return true;
          // Ask Exult about the map.
  if (Send_data(server_socket, Exult_server::info) != -1)
    {     // Should get immediate answer.
    unsigned char data[Exult_server::maxlength];
    Exult_server::Msg_type id;
    Exult_server::wait_for_response(server_socket, 100);
    int len = Exult_server::Receive_data(server_socket, 
            id, data, sizeof(data));
    unsigned char *ptr = &data[0];
    int vers, edlift, hdlift, edmode;
    bool editing, grid, mod;
    if (id == Exult_server::info &&
        Game_info_in(data, len, vers, edlift, hdlift, 
            editing, grid, mod, edmode) &&
        mod == true)
      return true;
    }
  return false;
  }

/*
 *  Write out map.
 */

void ExultStudio::write_map
  (
  )
  {
  send_to_server(Exult_server::write_map);
  }

/*
 *  Read in map.
 */

void ExultStudio::read_map
  (
  )
  {
  send_to_server(Exult_server::read_map);
  }

/*
 *  Write out shape info. and text.
 */

void ExultStudio::write_shape_info
  (
  bool force      // If set, always write.
  )
  {
  if ((force || shape_info_modified) && vgafile)
    {
    Shapes_vga_file *svga = 
        (Shapes_vga_file *) vgafile->get_ifile();
          // Make sure data's been read in.
    svga->read_info(false, true);//+++++BG?
    svga->write_info(false);//++++BG?
    }
  shape_info_modified = false;
  if (force || shape_names_modified)
    {
    shape_names_modified = false;
    int cnt = names.size();
    std::ofstream out;
    U7open(out, "<PATCH>/text.flx");
    Flex_writer writer(out, "Text created by ExultStudio", cnt);
    for (int i = 0; i < cnt; i++)
      {
      char *str = names[i];
      if (str)
        out << str;
      out.put((char) 0);  // 0-delimit.
      writer.mark_section_done();
      }
    if (!writer.close())
      EStudio::Alert("Error writing 'text.flx'");
    }
  }

/*
 *  Reload usecode.
 */

void ExultStudio::reload_usecode
  (
  )
  {
  send_to_server(Exult_server::reload_usecode);
  }

/*
 *  Tell Exult to start/stop playing.
 */

void ExultStudio::set_play
  (
  gboolean play     // True to play, false to edit.
  )
  {
  unsigned char data[Exult_server::maxlength];
  unsigned char *ptr = &data[0];
  Write2(ptr, play ? 0 : 1);  // Map_edit = !play.
  send_to_server(Exult_server::map_editing_mode, data, ptr - data);
  }

/*
 *  Tell Exult to show or not show the tile grid.
 */

void ExultStudio::set_tile_grid
  (
  gboolean grid     // True to show.
  )
  {
  unsigned char data[Exult_server::maxlength];
  unsigned char *ptr = &data[0];
  Write2(ptr, grid ? 1 : 0);  // Map_edit = !play.
  send_to_server(Exult_server::tile_grid, data, ptr - data);
  }

/*
 *  Tell Exult to edit at a given lift.
 */

void ExultStudio::set_edit_lift
  (
  int lift
  )
  {
  unsigned char data[Exult_server::maxlength];
  unsigned char *ptr = &data[0];
  Write2(ptr, lift);
  send_to_server(Exult_server::edit_lift, data, ptr - data);
  }

/*
 *  Tell Exult to hide objects at or above a given lift.
 */

void ExultStudio::set_hide_lift
  (
  int lift
  )
  {
  unsigned char data[Exult_server::maxlength];
  unsigned char *ptr = &data[0];
  Write2(ptr, lift);
  send_to_server(Exult_server::hide_lift, data, ptr - data);
  }

/*
 *  Tell Exult to enter/leave 'terrain-edit' mode.
 */

void ExultStudio::set_edit_terrain
  (
  gboolean terrain    // True/false
  )
  {
  unsigned char data[Exult_server::maxlength];
  unsigned char *ptr = &data[0];
  Write2(ptr, terrain ? 1 : 0); // NOTE:  Pass -1 to abort.  But I
          //   haven't got an interface yet.
  send_to_server(Exult_server::terrain_editing_mode, data, ptr - data);
  if (!terrain)
    {     // Turning it off.
    if (browser)
      browser->end_terrain_editing();
          // FOR NOW, skip_lift is reset.
    set_spin("hide_lift_spin", 16, true);
    }
  else        // Disable "Hide lift".
    set_sensitive("hide_lift_spin", false);
          // Set edit-mode to paint.
  GtkWidget *mitem = glade_xml_get_widget(app_xml, 
            terrain ? "paint1" : "move1");
  gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(mitem), TRUE);
  }

void ExultStudio::set_edit_mode
  (
  int md        // 0-2 (drag, paint, pick.
  )
  {
  unsigned char data[Exult_server::maxlength];
  unsigned char *ptr = &data[0];
  Write2(ptr, md);
          //   haven't got an interface yet.
  send_to_server(Exult_server::set_edit_mode, data, ptr - data);
  }

/*
 *  Insert 0-delimited text into an edit box.
 */

static void Insert_text
  (
  GtkEditable *ed,
  const char *text,
  int& pos      // Where to insert.  Updated.
  )
  {
  gtk_editable_insert_text(ed, text, strlen(text), &pos);
  }

/*
 *  Show unused shape list received from exult.
 */

void ExultStudio::show_unused_shapes
  (
  unsigned char *data,    // Bits set for unused shapes.
  int datalen     // #bytes.
  )
  {
  int nshapes = datalen*8;
  GtkTextView *text = GTK_TEXT_VIEW(glade_xml_get_widget(app_xml, "msg_text"));
  GtkTextBuffer *buffer = gtk_text_view_get_buffer(text);
  gtk_text_buffer_set_text(buffer, "", 0);  // Clear out old text
  set_visible("msg_win", TRUE); // Show message window.
  int pos = 0;
  GtkEditable *ed = GTK_EDITABLE(text);
  Insert_text(ed,
    "The following shapes were not found.\n", pos);
  Insert_text(ed,
    "Note that some may be created by usecode (script)\n\n", pos);
  for (int i = 0x96; i < nshapes; i++)  // Ignore flats (<0x96).
    if (!(data[i/8]&(1<<(i%8))))
      {
      const char *nm = get_shape_name(i);
      char *msg = g_strdup_printf("  Shape %4d:    %s\n",
              i, nm ? nm : "");
      Insert_text(ed, msg, pos);
      g_free(msg);
      }
  // FIXME: gtk_text_set_point(text, 0);  // Scroll back to top.
  }


/*
 *  Open a shape (or chunks) file in 'patch' or 'static' directory.
 *
 *  Output: ->file info (may already have existed), or 0 if error.
 */

Shape_file_info *ExultStudio::open_shape_file
  (
  const char *basename    // Base name of file to open.
  )
  {
  Shape_file_info *info = files->create(basename);
  if (!info)
    EStudio::Alert("'%s' not found in static or patch directories",
              basename);
  return info;
  }

/*
 *  Prompt for a new shape file name.
 */

void ExultStudio::new_shape_file
  (
  bool single     // Not a FLEX file.
  )
  {
  GtkFileSelection *fsel = Create_file_selection(
    single ? "Write new .shp file" : "Write new .vga file",
      (File_sel_okay_fun) create_shape_file,
              (gpointer) single);
//  This doesn't work very well in GTK 1.2.  Try again later.
//  gtk_file_selection_complete(fsel, single ? "*.shp" : "*.vga");
  if (is_system_path_defined("<PATCH>"))
    {     // Default to 'patch'.
    string patch = get_system_path("<PATCH>/");
    gtk_file_selection_set_filename(fsel, patch.c_str());
    }
  gtk_widget_show(GTK_WIDGET(fsel));
  }

/*
 *  Create a new shape/shapes file.
 */

void ExultStudio::create_shape_file
  (
  char *pathname,     // Full path.
  gpointer udata      // 1 if NOT a FLEX file.
  )
  {
  bool oneshape = (bool) udata;
  Shape *shape = 0;
  if (oneshape)     // Single-shape?
    {     // Create one here.
    const int w = 8, h = 8;
    unsigned char pixels[w*h];  // Create an 8x8 shape.
    memset(&pixels[0], 1, w*h); // Just use color #1.
    shape = new Shape(new Shape_frame(&pixels[0],
        w, h, w - 1, h - 1, true));
    }
  try {       // Write file.
    if (oneshape)
      Image_file_info::write_file(pathname, &shape, 1, true);
    else
      Image_file_info::write_file(pathname, 0, 0, false);
  }
  catch (const exult_exception& e) {
    EStudio::Alert(e.what());
  }
  ExultStudio *studio = ExultStudio::get_instance();
  studio->setup_file_list();  // Rescan list of shape files.
  }

/*
 *  Get value of a toggle button (false if not found).
 */

bool ExultStudio::get_toggle
  (
  char *name
  )
  {
  GtkWidget *btn = glade_xml_get_widget(app_xml, name);
  return btn ? gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(btn)) : -1;
  }

/*
 *  Find and set a toggle/checkbox button.
 */

void ExultStudio::set_toggle
  (
  char *name,
  bool val
  )
  {
  GtkWidget *btn = glade_xml_get_widget(app_xml, name);
  if (btn)
    gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(btn), val);
  }

/*
 *  Get an 8-bit set of flags from a group of toggles.
 */

unsigned char ExultStudio::get_bit_toggles
  (
  char **names,     // Names for bit 0, 1, 2,...
  int num       // # of names/bits.
  )
  {
  unsigned char bits = 0;
  for (int i = 0; i < num; i++)
    bits |= (get_toggle(names[i]) ? 1 : 0) << i;
  return bits;
  }

/*
 *  Set a group of toggles based on a sequential (0, 1, 2...) set of bit
 *  flags.
 */

void ExultStudio::set_bit_toggles
  (
  char **names,     // Names for bit 0, 1, 2,...
  int num,      // # of names/bits.
  unsigned char bits
  )
  {
  for (int i = 0; i < num; i++)
    set_toggle(names[i], (bits&(1<<i)) != 0);
  }

/*
 *  Get value of option-menu button (-1 if unsuccessful).
 */

int ExultStudio::get_optmenu
  (
  char *name
  )
  {
  GtkWidget *btn = glade_xml_get_widget(app_xml, name);
  if (!btn)
    return -1;
  GtkWidget *menu = gtk_option_menu_get_menu(GTK_OPTION_MENU(btn));
  GtkWidget *active = gtk_menu_get_active(GTK_MENU(menu));
  return g_list_index(GTK_MENU_SHELL(menu)->children, active);
  }

/*
 *  Find and set an option-menu button.
 */

void ExultStudio::set_optmenu
  (
  char *name,
  int val
  )
  {
  GtkWidget *btn = glade_xml_get_widget(app_xml, name);
  if (btn)
    gtk_option_menu_set_history(GTK_OPTION_MENU(btn), val);
  }

/*
 *  Get value of spin button (-1 if unsuccessful).
 */

int ExultStudio::get_spin
  (
  char *name
  )
  {
  GtkWidget *btn = glade_xml_get_widget(app_xml, name);
  return btn ? gtk_spin_button_get_value_as_int(
            GTK_SPIN_BUTTON(btn)) : -1;
  }

/*
 *  Find and set a spin button.
 */

void ExultStudio::set_spin
  (
  char *name,
  int val,
  bool sensitive
  )
  {
  GtkWidget *btn = glade_xml_get_widget(app_xml, name);
  if (btn)
    {
    gtk_spin_button_set_value(GTK_SPIN_BUTTON(btn), val);
    gtk_widget_set_sensitive(btn, sensitive);
    }
  }

/*
 *  Find and set a spin button, along with its range.
 */

void ExultStudio::set_spin
  (
  char *name,
  int val,
  int low, int high   // Range.
  )
  {
  GtkWidget *btn = glade_xml_get_widget(app_xml, name);
  if (btn)
    {
    gtk_spin_button_set_adjustment(GTK_SPIN_BUTTON(btn),
      GTK_ADJUSTMENT(
      gtk_adjustment_new (0, low, high, 1, 10, 10)));
    gtk_spin_button_set_value(GTK_SPIN_BUTTON(btn), val);
    }
  }

/*
 *  Get number from a text field.
 *
 *  Output: Number, or -1 if not found.
 */

int ExultStudio::get_num_entry
  (
  char *name
  )
  {
  GtkWidget *field = glade_xml_get_widget(app_xml, name);
  if (!field)
    return -1;
  const gchar *txt = gtk_entry_get_text(GTK_ENTRY(field));
  if (!txt)
    return -1;
  while (*txt == ' ')
    txt++;      // Skip space.
  if (txt[0] == '0' && txt[1] == 'x')
    return (int) strtoul(txt + 2, 0, 16); // Hex.
  else
    return atoi(txt);
  }

/*
 *  Get text from a text field.
 *
 *  Output: ->text, or null if not found.
 */

const gchar *ExultStudio::get_text_entry
  (
  char *name
  )
  {
  GtkWidget *field = glade_xml_get_widget(app_xml, name);
  if (!field)
    return 0;
  return gtk_entry_get_text(GTK_ENTRY(field));
  }

/*
 *  Find and set a text field to a number.
 */

void ExultStudio::set_entry
  (
  char *name,
  int val,
  bool hex,
  bool sensitive
  )
  {
  GtkWidget *field = glade_xml_get_widget(app_xml, name);
  if (field)
    {
    char *txt = hex ? g_strdup_printf("0x%x", val)
        : g_strdup_printf("%d", val);
    gtk_entry_set_text(GTK_ENTRY(field), txt);
    g_free(txt);
    gtk_widget_set_sensitive(field, sensitive);
    }
  }

/*
 *  Set text field.
 */

void ExultStudio::set_entry
  (
  char *name,
  const char *val,
  bool sensitive
  )
  {
  GtkWidget *field = glade_xml_get_widget(app_xml, name);
  if (field)
    {
    gtk_entry_set_text(GTK_ENTRY(field), val);
    gtk_widget_set_sensitive(field, sensitive);
    }
  }

/*
 *  Set statusbar.
 *  Output: Msg. ID, or 0.
 */

guint ExultStudio::set_statusbar
  (
  char *name,
  int context,
  char *msg
  )
  {
  GtkWidget *sbar = glade_xml_get_widget(app_xml, name);
  if (sbar)
    return gtk_statusbar_push(GTK_STATUSBAR(sbar), context, msg);
  else
    return 0;
  }

/*
 *  Pop last message that was set.
 */

void ExultStudio::remove_statusbar
  (
  char *name,
  int context,
  guint msgid
  )
  {
  if (msgid == 0)
    return;
  GtkWidget *sbar = glade_xml_get_widget(app_xml, name);
  if (sbar)
    return gtk_statusbar_remove(GTK_STATUSBAR(sbar),context,msgid);
  }

/*
 *  Set a button's text.
 */

void ExultStudio::set_button
  (
  char *name,
  const char *text
  )
  {
  GtkWidget *btn = glade_xml_get_widget(app_xml, name);
  GtkLabel *label = GTK_LABEL(GTK_BIN(btn)->child);
  gtk_label_set_text(label, text);
  }

/*
 *  Show/hide a widget.
 */

void ExultStudio::set_visible
  (
  char *name,
  bool vis
  )
  {
  GtkWidget *widg = glade_xml_get_widget(app_xml, name);
  if (widg)
    {
    if (vis)
      gtk_widget_show(widg);
    else
      gtk_widget_hide(widg);
    }
  }

/*
 *  Enable/disable a widget.
 */

void ExultStudio::set_sensitive
  (
  char *name,
  bool tf
  )
  {
  GtkWidget *widg = glade_xml_get_widget(app_xml, name);
  if (widg)
    gtk_widget_set_sensitive(widg, tf);
  }

/*
 *  Handle 'prompt' dialogs:
 */
static int prompt_choice = 0;   // Gets prompt choice.

C_EXPORT void
on_prompt3_yes_clicked      (GtkToggleButton *button,
           gpointer   user_data)
{
  prompt_choice = 0;
}
C_EXPORT void
on_prompt3_no_clicked     (GtkToggleButton *button,
           gpointer   user_data)
{
  prompt_choice = 1;
}
C_EXPORT void
on_prompt3_cancel_clicked   (GtkToggleButton *button,
           gpointer   user_data)
{
  prompt_choice = 2;
}


/*
 *  Prompt for one of two/three answers.
 *
 *  Output: 0 for 1st choice, 1 for 2nd, 2 for 3rd.
 */

int ExultStudio::prompt
  (
  const char *msg,    // Question to ask.
  const char *choice0,    // 1st choice.
  const char *choice1,    // 2nd choice, or NULL.
  const char *choice2   // 3rd choice, or NULL.
  )
  {
  static GdkPixmap *logo_pixmap = NULL;
  static GdkBitmap *logo_mask = NULL;
  if (!logo_pixmap)   // First time?
    {
    logo_pixmap = gdk_pixmap_create_from_xpm_d(app->window, 
        &logo_mask, NULL, logo_xpm);
    GtkWidget *pix = gtk_pixmap_new(logo_pixmap, logo_mask);
    gtk_widget_show(pix);
    GtkWidget *hbox = glade_xml_get_widget(app_xml, 
              "prompt3_hbox");
    gtk_box_pack_start(GTK_BOX(hbox), pix, FALSE, FALSE, 12);
          // Make logo show to left.
    gtk_box_reorder_child(GTK_BOX(hbox), pix, 0);
    }
  GtkWidget *dlg = glade_xml_get_widget(app_xml, "prompt3_dialog");
  gtk_label_set_text(
    GTK_LABEL(glade_xml_get_widget(app_xml, "prompt3_label")),
                msg);
  set_button("prompt3_yes", choice0);
  if (choice1)
    {
    set_button("prompt3_no", choice1);
    set_visible("prompt3_no", true);
    }
  else
    set_visible("prompt3_no", false);
  if (choice2)      // 3rd choice?  Show btn if so.
    {
    set_button("prompt3_cancel", choice2);
    set_visible("prompt3_cancel", true);
    }
  else
    set_visible("prompt3_cancel", false);
  prompt_choice = -1;
  gtk_window_set_modal(GTK_WINDOW(dlg), true);
  gtk_widget_show(dlg);   // Should be modal.
  while (prompt_choice == -1) // Spin.
    gtk_main_iteration(); // (Blocks).
  gtk_widget_hide(dlg);
  assert(prompt_choice >= 0 && prompt_choice <= 2);
  return prompt_choice;
  }

namespace EStudio {

/*
 *  Same as ExultStudio::prompt, but as a routine.
 */
int Prompt
  (
  const char *msg,    // Question to ask.
  const char *choice0,    // 1st choice.
  const char *choice1,    // 2nd choice, or NULL.
  const char *choice2   // 3rd choice, or NULL.
  )
  {
  return ExultStudio::get_instance()->prompt(msg, choice0, choice1,
              choice2);
  }

/*
 *  Just print a message (usually an error).
 */
void Alert
  (
  const char *msg,    // May be in printf format.
  ...
  )
  {
  std::va_list args;
  va_start(args, msg);
  char *fullmsg = g_strdup_vprintf(msg, args);
  Prompt(fullmsg, "Okay");
  g_free(fullmsg);
  }

/*
 *  Add a menu item to a menu.
 *
 *  Output: Menu item.
 */

GtkWidget *Add_menu_item
  (
  GtkWidget *menu,    // Menu to add to.
  const char *label,    // What to put.  NULL for separator.
  GtkSignalFunc func,   // Handle menu choice.
  gpointer func_data    // Data passed to func().
  )
  {
  GtkWidget *mitem = label ? gtk_menu_item_new_with_label(label) :
        gtk_menu_item_new();
  gtk_widget_show(mitem);
  gtk_menu_append(GTK_MENU(menu), mitem);
  if (!label)     // Want separator?
    gtk_widget_set_sensitive(mitem, FALSE);
  if (func)     // Function?
    gtk_signal_connect(GTK_OBJECT(mitem), "activate",
        GTK_SIGNAL_FUNC(func), func_data);
  return mitem;
  }

/*
 *  Create an arrow button.
 */

GtkWidget *Create_arrow_button
  (
  GtkArrowType dir,   // Direction.
  GtkSignalFunc clicked,    // Call this when clicked.
  gpointer func_data    // Passed to 'clicked'.
  )
  {
  GtkWidget *btn = gtk_button_new();
  gtk_widget_show(btn);
  GTK_WIDGET_SET_FLAGS(btn, GTK_CAN_DEFAULT);
  GtkWidget *arrow = gtk_arrow_new(dir, GTK_SHADOW_OUT);
  gtk_widget_show(arrow);
  gtk_container_add(GTK_CONTAINER(btn), arrow);
  gtk_signal_connect(GTK_OBJECT(btn), "clicked", clicked, func_data);
  return btn;
  }

} // namespace EStudio

/*
 *  'Preferences' window events.
 */

C_EXPORT void
on_prefs_cancel_clicked     (GtkButton *button,
           gpointer   user_data)
{
  gtk_widget_hide(gtk_widget_get_toplevel(GTK_WIDGET(button)));
}
C_EXPORT void
on_prefs_apply_clicked      (GtkButton *button,
           gpointer   user_data)
{
  ExultStudio::get_instance()->save_preferences();
}
C_EXPORT void
on_prefs_okay_clicked     (GtkButton *button,
           gpointer   user_data)
{
  ExultStudio::get_instance()->save_preferences();
  gtk_widget_hide(gtk_widget_get_toplevel(GTK_WIDGET(button)));
}

/*
 *  'Okay' was hit in the color selector.
 */

void ExultStudio::background_color_okay
  (
  GtkWidget *dlg,
  gpointer data
  )
  {
  GtkColorSelectionDialog *colorsel = GTK_COLOR_SELECTION_DIALOG(dlg);
  gdouble rgb[3];
  gtk_color_selection_get_color(
      GTK_COLOR_SELECTION(colorsel->colorsel), rgb);
  unsigned char r = (unsigned char) (rgb[0]*256),
          g = (unsigned char) (rgb[1]*256),
          b = (unsigned char) (rgb[2]*256);
  ExultStudio *studio = ExultStudio::get_instance();
  studio->background_color = (r<<16) + (g<<8) + b;
          // Show new color.
  GtkWidget *backgrnd = glade_xml_get_widget(studio->app_xml, 
              "prefs_background");
  gtk_object_set_user_data(GTK_OBJECT(backgrnd), 
          (gpointer) studio->background_color);
  GdkRectangle area = {0, 0, backgrnd->allocation.width, 
          backgrnd->allocation.height};
  gtk_widget_draw(backgrnd, &area);
  gtk_widget_destroy(dlg);
  }

C_EXPORT void
on_prefs_background_choose_clicked  (GtkButton *button,
           gpointer   user_data)
{
  GtkColorSelectionDialog *colorsel = GTK_COLOR_SELECTION_DIALOG(
    gtk_color_selection_dialog_new("Background color"));
  gtk_window_set_modal(GTK_WINDOW(colorsel), true);
          // Set mouse click handler.
  gtk_signal_connect_object(GTK_OBJECT(colorsel->ok_button), "clicked",
    GTK_SIGNAL_FUNC(ExultStudio::background_color_okay), 
            GTK_OBJECT(colorsel));
  gtk_signal_connect_object(GTK_OBJECT(colorsel->cancel_button), 
    "clicked", GTK_SIGNAL_FUNC(gtk_widget_destroy),
            GTK_OBJECT(colorsel));
          // Set delete handler.
  gtk_signal_connect(GTK_OBJECT(colorsel), "delete_event",
        GTK_SIGNAL_FUNC(gtk_false), 0L);
          // Get color.
  guint32 c = ExultStudio::get_instance()->get_background_color();
  gdouble rgb[3];
  rgb[0] = ((double) ((c>>16)&0xff))/256;
  rgb[1] = ((double) ((c>>8)&0xff))/256;
  rgb[2] = ((double) ((c>>0)&0xff))/256;
  gtk_color_selection_set_color(GTK_COLOR_SELECTION(colorsel->colorsel),
                rgb);
  gtk_widget_show(GTK_WIDGET(colorsel));
}
          // Background color area exposed.
C_EXPORT gboolean on_prefs_background_expose_event
  (
  GtkWidget *widget,    // The draw area.
  GdkEventExpose *event,
  gpointer data
  )
  {
  guint32 color = (guint32) gtk_object_get_user_data(GTK_OBJECT(widget));
  GdkGC *gc = (GdkGC *) 
      gtk_object_get_data(GTK_OBJECT(widget), "color_gc");
  if (!gc)
    {
    gc = gdk_gc_new(widget->window);
    gtk_object_set_data(GTK_OBJECT(widget), "color_gc", gc);
    }
  gdk_rgb_gc_set_foreground(gc, color);
  gdk_draw_rectangle(widget->window, gc, TRUE, event->area.x, 
      event->area.y, event->area.width, event->area.height);
  return (TRUE);
  }

          // X at top of window.
C_EXPORT gboolean on_prefs_window_delete_event
  (
  GtkWidget *widget,
  GdkEvent *event,
  gpointer user_data
  )
  {
  gtk_widget_hide(widget);
  return TRUE;
  }

/*
 *  Open preferences window.
 */

void ExultStudio::open_preferences
  (
  )
  {
  set_entry("prefs_image_editor", image_editor ? image_editor : "");
  set_entry("prefs_default_game", default_game ? default_game : "");
  GtkWidget *backgrnd = glade_xml_get_widget(app_xml, 
              "prefs_background");
  gtk_object_set_user_data(GTK_OBJECT(backgrnd), 
            (gpointer) background_color);
  GtkWidget *win = glade_xml_get_widget(app_xml, "prefs_window");
  gtk_widget_show(win);
  }

/*
 *  Save preferences.
 */

void ExultStudio::save_preferences
  (
  )
  {
  const char *text = get_text_entry("prefs_image_editor");
  g_free(image_editor);
  image_editor = g_strdup(text);
  config->set("config/estudio/image_editor", image_editor, true);
  text = get_text_entry("prefs_default_game");
  g_free(default_game);
  default_game = g_strdup(text);
  config->set("config/estudio/default_game", default_game, true);
  GtkWidget *backgrnd = glade_xml_get_widget(app_xml, 
              "prefs_background");
  background_color = (guint32) gtk_object_get_user_data(
            GTK_OBJECT(backgrnd));
  config->set("config/estudio/background_color", background_color, true);
          // Set background color.
  palbuf[3*255] = (background_color>>18)&0x3f;
  palbuf[3*255 + 1] = (background_color>>10)&0x3f;
  palbuf[3*255 + 2] = (background_color>>2)&0x3f;
  if (browser)      // Repaint browser.
    browser->set_background_color(background_color);
  }


/*
 *  Main routine.
 */
void ExultStudio::run()
{
  gtk_main();
}

/*
 *  This is called every few seconds to try to reconnect to Exult.
 */

static gint Reconnect
  (
  gpointer data     // ->ExultStudio.
  )
  {
  ExultStudio *studio = (ExultStudio *) data;
  if (studio->connect_to_server())
    return 0;   // Cancel timer.  We succeeded.
  else
    return 1;
  }

/*
 *  Send message to server.
 *
 *  Output: false if error sending (reported).
 */

bool ExultStudio::send_to_server
  (
  Exult_server::Msg_type id,
  unsigned char *data, 
  int datalen
  )
  {
  if (Send_data(server_socket, id, data, datalen) == -1)
    {
    cerr << "Error sending to server" << endl;
    return false;
    }
  return true;
  }

/*
 *  Input from server is available.
 */

#ifndef WIN32
static void Read_from_server
  (
  gpointer data,      // ->ExultStudio.
  gint socket,
  GdkInputCondition condition
  )
  {
  ExultStudio *studio = (ExultStudio *) data;
  studio->read_from_server();
  }
#else
static gint Read_from_server
  (
  gpointer data     // ->ExultStudio.
  )
  {
  ExultStudio *studio = (ExultStudio *) data;
  studio->read_from_server();
  return TRUE;
  }
#endif

gint Do_Drop_Callback(gpointer data);

void ExultStudio::read_from_server
  (
  )
  {
#ifdef WIN32
  // Nothing
  int len = Exult_server::peek_pipe();

  //Do_Drop_Callback(&len);

  if (len == -1)  {
    cout << "Disconnected from server" << endl;
    gtk_timeout_remove(server_input_tag);
    Exult_server::disconnect_from_server();
    server_input_tag = -1;
    server_socket = -1;
        // Try again every 4 secs.
    gtk_timeout_add(4000, Reconnect, this);

    return;
  }
  if (len < 1) return;
#endif
  unsigned char data[Exult_server::maxlength];
  Exult_server::Msg_type id;
  int datalen = Exult_server::Receive_data(server_socket, id, data,
              sizeof(data));
  if (datalen < 0)
    {
    cout << "Error reading from server" << endl;
    if (server_socket == -1)// Socket closed?
      {
#ifndef WIN32
      gdk_input_remove(server_input_tag);
#else
      gtk_timeout_remove(server_input_tag);
      Exult_server::disconnect_from_server();
#endif
      server_input_tag = -1;
          // Try again every 4 secs.
      gtk_timeout_add(4000, Reconnect, this);
      }
    return;
    }
  cout << "Read " << datalen << " bytes from server" << endl;
  cout << "ID = " << (int) id << endl;
  switch (id)
    {
  case Exult_server::obj:
    open_obj_window(data, datalen);
    break;
  case Exult_server::egg:
    open_egg_window(data, datalen);
    break;
  case Exult_server::npc:
    open_npc_window(data, datalen);
    break;
  case Exult_server::user_responded:
  case Exult_server::cancel:
  case Exult_server::locate_terrain:
  case Exult_server::swap_terrain:
  case Exult_server::insert_terrain:
  case Exult_server::delete_terrain:
  case Exult_server::locate_shape:
  case Exult_server::game_pos:
    if (waiting_for_server) // Send msg. to callback.
      {
      waiting_for_server(id, data, datalen, waiting_client);
      waiting_for_server = 0;
      waiting_client = 0;
      }
    else if (browser)
      browser->server_response((int) id, data, datalen);
    break;
  case Exult_server::info:
    info_received(data, datalen);
    break;
  case Exult_server::view_pos:
    if (locwin)
      locwin->view_changed(data, datalen);
    break;
  case Exult_server::combo_pick:
    open_combo_window();  // Open if necessary.
    if (combowin)
      combowin->add(data, datalen);
    break;
  case Exult_server::unused_shapes:
    show_unused_shapes(data, datalen);
    break;
  case Exult_server::select_status:
    set_edit_menu(data[0] != 0, data[1] != 0);
    break;
  case Exult_server::usecode_debugging:
    std::cerr << "Warning: got a usecode debugging message! (ignored)"
          << std::endl;
    break;
  }
  }

/*
 *  Try to connect to the Exult game.
 *
 *  Output: True if succeeded.
 */
bool ExultStudio::connect_to_server
  (
  )
  {
  if (!static_path)
    return false;   // No place to go.
#ifndef WIN32
  if (server_socket >= 0)   // Close existing socket.
    {
    close(server_socket);
    gdk_input_remove(server_input_tag);
    }
  server_socket = server_input_tag = -1;
  struct sockaddr_un addr;
  addr.sun_family = AF_UNIX;

  char *home = getenv("HOME");
  addr.sun_path[0] = 0;
  if (home)     // Use $HOME/.exult/exultserver
    {     //   if possible.
    strcpy(addr.sun_path, home);
    strcat(addr.sun_path, "/.exult/exultserver");
    if (!U7exists(addr.sun_path))
      addr.sun_path[0] = 0;
    }
  if (!addr.sun_path[0])    // Default to game/gamedat.
    {
          strcpy(addr.sun_path, static_path);
          char *pstatic = strrchr(addr.sun_path, '/');
          if (pstatic && !pstatic[1])     // End of path?
                  {
                  pstatic[0] = 0;
                  pstatic = strrchr(addr.sun_path, '/');
                  }
          if (!pstatic)
                  {
                  cout << "Can't find gamedat for socket" << endl;
                  return false;
                  }
          strcpy(pstatic + 1, "gamedat/exultserver");
    }
  server_socket = socket(PF_LOCAL, SOCK_STREAM, 0);
  if (server_socket < 0)
    {
    perror("Failed to open map-editor socket");
    return false;
    }
          // Set to be non-blocking.
//  fcntl(server_socket, F_SETFL, 
//        fcntl(server_socket, F_GETFL) | O_NONBLOCK);
  cout << "Trying to connect to server at '" << addr.sun_path << "'"
              << endl;
  if (connect(server_socket, (struct sockaddr *) &addr, 
          sizeof(addr.sun_family) + strlen(addr.sun_path)) == -1)
    {
    perror("Socket connect");
    close(server_socket);
    server_socket = -1;
    return false;
    }
  server_input_tag = gdk_input_add(server_socket,
      GDK_INPUT_READ, Read_from_server, this);
#else
    // Close existing socket.
  if (server_socket != -1) Exult_server::disconnect_from_server();
  if (server_input_tag != -1) gtk_timeout_remove(server_input_tag);
  server_socket = server_input_tag = -1;

  if (Exult_server::try_connect_to_server(static_path) > 0)
    server_input_tag = gtk_timeout_add(50, Read_from_server, this);
  else
    return false;
#endif
  cout << "Connected to server" << endl;
  send_to_server(Exult_server::info); // Request version, etc.
  set_edit_menu(false, false);  // For now, init. edit menu.
  return true;
  }
/*
 *  'Info' message received.
 */

void ExultStudio::info_received
  (
  unsigned char *data,    // Message from Exult.
  int len
  )
  {
  int vers, edlift, hdlift, edmode;
  bool editing, grid, mod;
  Game_info_in(data, len, vers, edlift, hdlift, 
          editing, grid, mod, edmode);
  if (vers != Exult_server::version)
    {     // Wrong version of Exult.
    EStudio::Alert("Expected ExultServer version %d, but got %d",
        Exult_server::version, vers);
#ifndef WIN32
    close(server_socket);
    gdk_input_remove(server_input_tag);
#else
    Exult_server::disconnect_from_server();
    gtk_timeout_remove(server_input_tag);
#endif
    server_socket = server_input_tag = -1;
    return;
    }
          // Set controls to what Exult thinks.
  set_spin("edit_lift_spin", edlift);
  set_spin("hide_lift_spin", hdlift);
  set_toggle("play_button", !editing);
  set_toggle("tile_grid_button", grid);
  if (edmode >= 0 && edmode < sizeof(mode_names)/sizeof(mode_names[0]))
    {
    GtkWidget *mitem = glade_xml_get_widget(app_xml, 
              mode_names[edmode]);

    gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(mitem),
                  TRUE);
    }
  }

/*
 *  Set edit menu entries depending on whether there's a selection or
 *  clipboard available.
 */

void ExultStudio::set_edit_menu
  (
  bool sel,     // Selection available.
  bool clip     // Clipboard isn't empty.
  )
  {
  set_sensitive("cut1", sel);
  set_sensitive("copy1", sel);
  set_sensitive("paste1", clip);
  set_sensitive("properties1", sel);
  set_sensitive("basic_properties1", sel);
  }

---