shapegroup.cc

Go to the documentation of this file.

/*
Copyright (C) 2002 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

#include <cassert>
#include <fstream>
#include <gdk/gdkkeysyms.h>
#include "shapegroup.h"
#include "Flex.h"
#include "utils.h"
#include "exceptions.h"
#include "studio.h"
#include "objbrowse.h"
#include "shapefile.h"

using std::vector;
using std::ios;
using std::string;
using std::cout;
using std::endl;
using EStudio::Alert;

/*
 *  Create an empty group.
 */

Shape_group::Shape_group
  (
  const char *nm,     // Name.  Copied.
  Shape_group_file *f
  ) : name(nm), file(f)
  {
  }

/*
 *  Remove i'th entry.
 */

void Shape_group::del
  (
  int i
  )
  { 
  assert(i >= 0 && i < size());
  std::vector<int>::erase(begin() + i); 
  file->modified = true;
  }

/*
 *  Swap two entries.
 */

void Shape_group::swap
  (
  int i       // Lower one.
  )
  {
  int x0 = (*this)[i];
  (*this)[i] = (*this)[i + 1];
  (*this)[i + 1] = x0;
  file->modified = true;
  }

/*
 *  Add a new entry if not already there.
 */

void Shape_group::add
  (
  int id
  )
  {
  for (vector<int>::const_iterator it = begin(); it != end(); ++it)
    if ((*it) == id)
      return;   // Already there.
  push_back(id);
  file->modified = true;
  }

/*
 *  Init. and read in (if it exists) a groups file.
 */

Shape_group_file::Shape_group_file
  (
  const char *nm      // Basename.
  ) : name(nm), modified(false)
  {
  Flex *flex = 0;
  std::string patchname = "<PATCH>/" + name;
  std::string staticname = "<STATIC>/" + name;
  if (U7exists(patchname))  // First try 'patch' directory.
    flex = new Flex(patchname);
  else if (U7exists(staticname))
    flex = new Flex(staticname);
  if (flex)     // Exists?
    {
    int cnt = flex->number_of_objects();
    for (int i = 0; i < cnt; i++)
      {   // Get each group.
      std::size_t len;
      char *buf = flex->retrieve(i, len);
      char *gname = buf;  // Starts with name.
      unsigned char *ptr = (unsigned char *)
            gname + strlen(gname) + 1;
      int sz = Read2(ptr);  // Get # entries.
      assert ((len - ((char *) ptr - buf))/2 == sz);
      Shape_group *grp = new Shape_group(gname, this);
      grp->reserve(sz);
      for (int j = 0; j < sz; j++)
        grp->push_back(Read2(ptr));
      groups.push_back(grp);
      delete buf;
      }
    delete flex;
    }
  }

/*
 *  Search for a group with a given name.
 *
 *  Output: Index if found, else -1.
 */

int Shape_group_file::find
  (
  const char *nm
  )
  {
  for (vector<Shape_group *>::const_iterator it = groups.begin();
            it != groups.end(); ++it)
    if ((*it)->name == nm)
      return (it - groups.begin());
  return -1;
  }

/*
 *  Clean up.
 */

Shape_group_file::~Shape_group_file
  (
  )
  {
  for (vector<Shape_group *>::iterator it = groups.begin();
            it != groups.end(); ++it)
    delete (*it);   // Delete each group.
  }

/*
 *  Remove and delete a group.
 */

void Shape_group_file::remove
  (
  int index,
  bool del      // True to delete the group.
  )
  {
  modified = true;
  assert(index >= 0 && index < groups.size());
  Shape_group *grp = groups[index];
  groups.erase(groups.begin() + index);
  if (del)
    delete grp;
  }

/*
 *  Write out to the 'patch' directory.
 */

void Shape_group_file::write
  (
  )
  {
  std::ofstream out;
  std::string patchname = "<PATCH>/" + name;
  U7open(out, patchname.c_str());
  int cnt = groups.size();  // # groups.
  Flex_writer gfile(out, "ExultStudio shape groups", cnt);
  int i;        // Write each group.
  for (i = 0; i < cnt; i++)
    {
    Shape_group *grp = groups[i];
    const char *nm = grp->get_name();
    int sz = grp->size();
          // Name, #entries, entries(2-bytes).
    long len = strlen(nm) + 1 + 2 + 2*sz;
    unsigned char *buf = new unsigned char[len];
    strcpy((char *) buf, nm);
    unsigned char *ptr = buf + strlen(nm) + 1;
    Write2(ptr, sz);  // # entries.
    for (vector<int>::iterator it = grp->begin();
            it != grp->end(); it++)
      Write2(ptr, *it);
    assert(ptr - buf == len);
          // Write out to file.
    out.write(reinterpret_cast<char *>(buf), len);
    delete buf;
    gfile.mark_section_done();
    }
  if (!gfile.close())
    Alert("Error writing '%s'", patchname.c_str());
  modified = false;
  }

/*
 *  Get the tree row # (assuming just a simple list) for a given tree-
 *  model position.
 */

static int Get_tree_row
  (
  GtkTreePath *path
  )
  {
  gchar *str = gtk_tree_path_to_string(path);
  int row = atoi(str);
  g_free(str);
  return row;
  }
static int Get_tree_row
  (
  GtkTreeModel *model,
  GtkTreeIter *iter   // Position we want.
  )
  {
  GtkTreePath *path = gtk_tree_model_get_path(model, iter);
  int row = Get_tree_row(path);
  gtk_tree_path_free(path);
  return row;
  }

/*
 *  Group buttons:
 */
C_EXPORT void
on_groups_add_clicked     (GtkToggleButton *button,
           gpointer   user_data)
{
  ExultStudio::get_instance()->add_group();
}

C_EXPORT void
on_groups_del_clicked     (GtkToggleButton *button,
           gpointer   user_data)
{
  ExultStudio::get_instance()->del_group();
}

C_EXPORT gboolean
on_groups_new_name_key_press    (GtkEntry *entry,
           GdkEventKey  *event,
           gpointer  user_data)
{
  if (event->keyval == GDK_Return)
    {
    ExultStudio::get_instance()->add_group();
    return TRUE;
    }
  return FALSE;     // Let parent handle it.
}

/*
 *  Groups list signals:
 */
C_EXPORT void
on_group_list_cursor_changed    (GtkTreeView  *tview)
{
  ExultStudio::get_instance()->setup_group_controls();
}

void
on_group_list_row_inserted    (GtkTreeModel *model,
           GtkTreePath *path,
           GtkTreeIter *iter,
           gpointer user_data)
{
  ExultStudio::get_instance()->groups_changed(model, path, iter);
}

void
on_group_list_row_changed   (GtkTreeModel *model,
           GtkTreePath *path,
           GtkTreeIter *iter,
           gpointer user_data)
{
  ExultStudio::get_instance()->groups_changed(model, path, iter, true);
}

void
on_group_list_row_deleted   (GtkTreeModel *model,
           GtkTreePath *path,
           gpointer user_data)
{
  ExultStudio::get_instance()->groups_changed(model, path, 0);
}

C_EXPORT void
on_group_list_row_activated   (GtkTreeView  *treeview,
           GtkTreePath  *path,
           GtkTreeViewColumn *column,
           gpointer  user_data)
{
  ExultStudio::get_instance()->open_group_window();
}

/* columns */
enum
{
  GRP_FILE_COLUMN = 0,
  GRP_GROUP_COLUMN,
  GRP_NUM_COLUMNS
};

/*
 *  Initialize the list of shape groups for the file being shown in the
 *  browser.
 */

void ExultStudio::setup_groups
  (
  )
  {
  Shape_group_file *groups = curfile->get_groups();
  if (!groups)      // No groups?
    {
    set_visible("groups_frame", FALSE);
    return;
    }
  GtkTreeView *tview = GTK_TREE_VIEW(
        glade_xml_get_widget(app_xml, "group_list"));
  GtkTreeModel *oldmod = gtk_tree_view_get_model(tview);
  GtkTreeStore *model;
  gulong addsig = 0, delsig = 0, chgsig = 0;
  if (!oldmod)      // Create model first time.
    {
      model = gtk_tree_store_new(GRP_NUM_COLUMNS, 
            G_TYPE_STRING, G_TYPE_POINTER);
    gtk_tree_view_set_model(tview, GTK_TREE_MODEL(model));
    g_object_unref(model);
          // Create column.
      GtkCellRenderer *renderer = gtk_cell_renderer_text_new();
    g_object_set (renderer, "xalign", 0.0, NULL);
    gint col_offset = gtk_tree_view_insert_column_with_attributes(
        tview,
        -1, "Names",
        renderer, "text",
        GRP_FILE_COLUMN, NULL);
    GtkTreeViewColumn *column = gtk_tree_view_get_column(tview, 
              col_offset - 1);
    gtk_tree_view_column_set_clickable(column, TRUE);
    addsig = g_signal_connect(G_OBJECT(model), "row-inserted",
      GTK_SIGNAL_FUNC(on_group_list_row_inserted), this);
          // Store signal id with model.
    g_object_set_data(G_OBJECT(model), "row-inserted",
              (gpointer) addsig);
    delsig = g_signal_connect(G_OBJECT(model), "row-deleted",
      GTK_SIGNAL_FUNC(on_group_list_row_deleted), this);
    g_object_set_data(G_OBJECT(model), "row-deleted",
              (gpointer) delsig);
    chgsig = g_signal_connect(G_OBJECT(model), "row-changed",
      GTK_SIGNAL_FUNC(on_group_list_row_changed), this);
    g_object_set_data(G_OBJECT(model), "row-changed",
              (gpointer) delsig);
    }
  else
    {
    model = GTK_TREE_STORE(oldmod);
    addsig = (gulong) g_object_get_data(G_OBJECT(model), 
              "row-inserted");
    delsig = (gulong) g_object_get_data(G_OBJECT(model), 
              "row-deleted");
    chgsig = (gulong) g_object_get_data(G_OBJECT(model), 
              "row-changed");
    }
          // Block this signal during creation.
  g_signal_handler_block(model, addsig);
  g_signal_handler_block(model, delsig);
  g_signal_handler_block(model, chgsig);
  gtk_tree_store_clear(model);
  set_visible("groups_frame", TRUE);
  gtk_tree_view_set_reorderable(tview, TRUE);
  int cnt = groups->size(); // Add groups from file.
  GtkTreeIter iter;
  for (int i = 0; i < cnt; i++)
    {
    Shape_group *grp = groups->get(i);
    gtk_tree_store_append(model, &iter, NULL);
    gtk_tree_store_set(model, &iter,
      GRP_FILE_COLUMN, grp->get_name(),
      GRP_GROUP_COLUMN, grp,
      -1);
    }
  gtk_tree_view_set_rules_hint(tview, TRUE);
  g_signal_handler_unblock(model, addsig);
  g_signal_handler_unblock(model, delsig);
  g_signal_handler_unblock(model, chgsig);
  setup_group_controls();   // Enable/disable the controls.
  }

/*
 *  Enable/disable the controls based on whether there's a selection.
 */

void ExultStudio::setup_group_controls
  (
  )
  {
  set_visible("groups_frame", true);
  GtkTreeView *tview = GTK_TREE_VIEW(
        glade_xml_get_widget(app_xml, "group_list"));
  GtkTreeSelection *list = gtk_tree_view_get_selection(tview);
  if (list)
    {
//    int row = (int) list->data;
//    set_sensitive("groups_open", true);
    set_sensitive("groups_del", true);
//    set_sensitive("groups_up_arrow", row > 0);
//    set_sensitive("groups_down_arrow", row < clist->rows);
    }
  else
    {
//    set_sensitive("groups_open", false);
    set_sensitive("groups_del", false);
//    set_sensitive("groups_up_arrow", false);
//    set_sensitive("groups_down_arrow", false);
    }
  }

/*
 *  Add/delete a new group.
 */

void ExultStudio::add_group
  (
  )
  {
  if (!curfile)
    return;
  GtkTreeView *tview = GTK_TREE_VIEW(
        glade_xml_get_widget(app_xml, "group_list"));
    GtkTreeStore *model = GTK_TREE_STORE(gtk_tree_view_get_model(tview));
  const char *nm = get_text_entry("groups_new_name");
  Shape_group_file *groups = curfile->get_groups();
          // Make sure name isn't already there.
  if (nm && *nm && groups->find(nm) < 0)
    {
    Shape_group *grp = new Shape_group(nm, groups);
    GtkTreeIter iter;
    gtk_tree_store_append(model, &iter, NULL);
    gtk_tree_store_set(model, &iter,
      GRP_FILE_COLUMN, nm,
      GRP_GROUP_COLUMN, grp,
      -1);
    }
  set_entry("groups_new_name", "");
  }

void ExultStudio::del_group
  (
  )
  {
  if (!curfile)
    return;
  GtkTreeView *tview = GTK_TREE_VIEW(
        glade_xml_get_widget(app_xml, "group_list"));
  GtkTreeSelection *list = gtk_tree_view_get_selection(tview);
  if (!list)
    return;
  GtkTreeModel *model;
  GtkTreeIter iter;
  if (!gtk_tree_selection_get_selected(list, &model, &iter))
    return;
  int row = Get_tree_row(model, &iter);
  Shape_group_file *groups = curfile->get_groups();
  Shape_group *grp = groups->get(row);
  string msg("Delete group '");
  msg += grp->get_name();
  msg += "'?";
  int choice = prompt(msg.c_str(), "Yes", "No");
  if (choice != 0)    // Yes?
    return;
  delete groups->get(row);  // Delete the group.
  gtk_tree_store_remove(GTK_TREE_STORE(model), &iter);
          // Close the group's windows.
  vector<GtkWindow*> toclose;
  vector<GtkWindow*>::const_iterator it;
  for (it = group_windows.begin(); it != group_windows.end(); ++it)
    {
    Object_browser *chooser = (Object_browser *) 
      gtk_object_get_data(GTK_OBJECT(*it), "browser");
    if (chooser->get_group() == grp)
          // A match?
      toclose.push_back(*it);
    }
  for (it = toclose.begin(); it != toclose.end(); ++it)
    close_group_window(GTK_WIDGET(*it));
  }

/*
 *  A group has been inserted or deleted from the list.
 */

void ExultStudio::groups_changed
  (
  GtkTreeModel *model,
  GtkTreePath *path,    // Position.
  GtkTreeIter *loc,   // Insert/change location, or 0.
  bool value      // True if value changed at loc.
  )
  {
  if (!curfile)
    return;
  Shape_group_file *groups = curfile->get_groups();
  int row = Get_tree_row(path);
  if (!loc)
    groups->remove(row, false);
  else
    {
    void *grpaddr = 0;
    gtk_tree_model_get(model, loc, GRP_GROUP_COLUMN, &grpaddr,
                -1);
    Shape_group *grp = (Shape_group *) grpaddr;
    if (value)    // Changed?
      groups->set(grp, row);
    else
      groups->insert(grp, row);
    }
  }

/*
 *  Events on 'group' window:
 */
/*
 *  Npc window's close button.
 */
C_EXPORT gboolean on_group_window_delete_event
  (
  GtkWidget *widget,
  GdkEvent *event,
  gpointer user_data
  )
  {
  ExultStudio::get_instance()->close_group_window(widget);
  return TRUE;
  }
C_EXPORT void
on_group_up_clicked     (GtkToggleButton *button,
           gpointer   user_data)
{
  Object_browser *chooser = (Object_browser *)gtk_object_get_data(
    GTK_OBJECT(gtk_widget_get_toplevel(GTK_WIDGET(button))), 
              "browser");
  Shape_group *grp = chooser->get_group();
  int i = chooser->get_selected();
  if (grp && i > 0)   // Moving item up.
    {
    grp->swap(i - 1);
    ExultStudio::get_instance()->update_group_windows(grp);
    }
}
C_EXPORT void
on_group_down_clicked     (GtkToggleButton *button,
           gpointer   user_data)
{
  Object_browser *chooser = (Object_browser *)gtk_object_get_data(
    GTK_OBJECT(gtk_widget_get_toplevel(GTK_WIDGET(button))), 
              "browser");
  Shape_group *grp = chooser->get_group();
  int i = chooser->get_selected();
  if (grp && i < grp->size() - 1) // Moving down.
    {
    grp->swap(i);
    ExultStudio::get_instance()->update_group_windows(grp);
    }
}
C_EXPORT void
on_group_shape_remove_clicked   (GtkToggleButton *button,
           gpointer   user_data)
{
  Object_browser *chooser = (Object_browser *)gtk_object_get_data(
    GTK_OBJECT(gtk_widget_get_toplevel(GTK_WIDGET(button))), 
              "browser");
  Shape_group *grp = chooser->get_group();
  int i = chooser->get_selected();
  if (grp && i >= 0)
    {
    grp->del(i);
    ExultStudio::get_instance()->update_group_windows(grp);
    }
}

/*
 *  Open a 'group' window for the currently selected group.
 */

void ExultStudio::open_group_window
  (
  )
  {
  GtkTreeView *tview = GTK_TREE_VIEW(
        glade_xml_get_widget(app_xml, "group_list"));
  GtkTreeSelection *list = gtk_tree_view_get_selection(tview);
  if (!list || !curfile || !vgafile || !palbuf)
    return;
  GtkTreeModel *model;
  GtkTreeIter iter;
  if (!gtk_tree_selection_get_selected(list, &model, &iter))
    return;
  int row = Get_tree_row(model, &iter);
  Shape_group_file *groups = curfile->get_groups();
  Shape_group *grp = groups->get(row);
  GladeXML *xml = glade_xml_new(glade_path, "group_window", NULL);
  glade_xml_signal_autoconnect(xml);
  GtkWidget *grpwin = glade_xml_get_widget(xml, "group_window");
  Object_browser *chooser = curfile->create_browser(vgafile,palbuf, grp);
          // Set xml as data on window.
  gtk_object_set_data(GTK_OBJECT(grpwin), "xml", xml);
  gtk_object_set_data(GTK_OBJECT(grpwin), "browser", chooser);
          // Set window title, name field.
  string title("Exult Group:  ");
  title += grp->get_name();
  gtk_window_set_title(GTK_WINDOW(grpwin), title.c_str());
  GtkWidget *field = glade_xml_get_widget(xml, "group_name");
  if (field)
    gtk_entry_set_text(GTK_ENTRY(field), grp->get_name());
          // Attach browser.
  GtkWidget *browser_box = glade_xml_get_widget(xml, "group_shapes" );
  gtk_widget_show(browser_box);
  gtk_box_pack_start(GTK_BOX(browser_box), chooser->get_widget(), 
                TRUE, TRUE, 0);
          // Auto-connect doesn't seem to work.
  gtk_signal_connect (GTK_OBJECT(grpwin), "delete_event",
                      GTK_SIGNAL_FUNC (on_group_window_delete_event),
                      this);
  group_windows.push_back(GTK_WINDOW(grpwin));
  gtk_widget_show(grpwin);
  }

/*
 *  Close a 'group' window.
 */

void ExultStudio::close_group_window
  (
  GtkWidget *grpwin
  )
  {
          // Remove from list.
  for (vector<GtkWindow*>::iterator it = group_windows.begin();
          it != group_windows.end(); ++it)
    {
    if (*it == GTK_WINDOW(grpwin))
      {
      group_windows.erase(it);
      break;
      }
    }
  GladeXML *xml = (GladeXML *) gtk_object_get_data(GTK_OBJECT(grpwin), 
              "xml");
  Object_browser *chooser = (Object_browser *) gtk_object_get_data(
      GTK_OBJECT(grpwin), "browser");
  delete chooser;
  gtk_widget_destroy(grpwin);
  g_object_unref(G_OBJECT(xml));
  }

/*
 *  Save all modified group files.
 */

void ExultStudio::save_groups
  (
  )
  {
  if (!files)
    return;
  int cnt = files->size();
  for (int i = 0; i < cnt; i++) // Check each file.
    {
    Shape_file_info *info = (*files)[i];
    Shape_group_file *gfile = info->get_groups();
    if (gfile && gfile->is_modified())
      gfile->write();
    }
  }

/*
 *  Return TRUE if any groups have been modified.
 */

bool ExultStudio::groups_modified
  (
  )
  {
  if (!files)
    return false;
  int cnt = files->size();
  for (int i = 0; i < cnt; i++) // Check each file.
    {
    Shape_file_info *info = (*files)[i];
    Shape_group_file *gfile = info->get_groups();
    if (gfile && gfile->is_modified())
      return true;
    }
  return false;
  }

/*
 *  Update all windows showing a given group.
 */

void ExultStudio::update_group_windows
  (
  Shape_group *grp    // Group, or 0 for all.
  )
  {
  for (vector<GtkWindow*>::const_iterator it = group_windows.begin();
          it != group_windows.end(); ++it)
    {
    Object_browser *chooser = (Object_browser *) 
      gtk_object_get_data(GTK_OBJECT(*it), "browser");
    if (!grp || chooser->get_group() == grp)
      {   // A match?
      chooser->render();
      chooser->show();
      }
    }
  }

---