combo.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 <gdk/gdkkeysyms.h>
#include "studio.h"
#include "combo.h"
#include "exult_constants.h"
#include "exceptions.h"
#include "shapevga.h"
#include "shapefile.h"
#include "ibuf8.h"
#include "objserial.h"
#include "shapegroup.h"
#include "Flex.h"
#include "u7drag.h"

using std::cout;
using std::cin;
using std::endl;

const int border = 2;     // Border at bottom, sides of each
          //   combo in browser.
const int maxtiles = 32;    // Max. width/height in tiles.

/*
 *  Open combo window (if not already open).
 */

C_EXPORT void on_new_combo1_activate
  (
  GtkMenuItem     *menuitem,
        gpointer         user_data
  )
  {
  ExultStudio *studio = ExultStudio::get_instance();
  studio->open_combo_window();
  }
void ExultStudio::open_combo_window
  (
  )
  {
  if (combowin && combowin->is_visible())
    return;     // Already open.
  if (!vgafile)
    {
    EStudio::Alert("'shapes.vga' file isn't present");
    return;
    }
  Shapes_vga_file *svga = (Shapes_vga_file *) vgafile->get_ifile();
  delete combowin;    // Delete old (svga may have changed).
  combowin = new Combo_editor(svga, palbuf);
  combowin->show(true);
          // Set edit-mode to pick.
  GtkWidget *mitem = glade_xml_get_widget(app_xml, "pick_for_combo1");
  gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(mitem), TRUE);
  }

/*
 *  Save combos.
 */

void ExultStudio::save_combos
  (
  )
  {
          // Get file info.
  Shape_file_info *combos = files->create("combos.flx");
  try {
    if (combos)
      combos->flush();
  } catch (const exult_exception& e) {
    EStudio::Alert(e.what());
  }
  }

/*
 *  Callbacks for "Combo" editor window.
 */
C_EXPORT gint on_combo_draw_expose_event
  (
  GtkWidget *widget,    // The view window.
  GdkEventExpose *event,
  gpointer data     // ->Shape_chooser.
  )
  {
  Combo_editor *combo = (Combo_editor *) gtk_object_get_user_data(
    GTK_OBJECT(gtk_widget_get_toplevel(GTK_WIDGET(widget))));
  combo->render(&event->area);
  return TRUE;
  }

C_EXPORT void
on_combo_remove_clicked                (GtkButton       *button,
                                        gpointer         user_data)
{
  Combo_editor *combo = (Combo_editor *) gtk_object_get_user_data(
    GTK_OBJECT(gtk_widget_get_toplevel(GTK_WIDGET(button))));
  combo->remove();
}

C_EXPORT void
on_combo_apply_clicked                 (GtkButton       *button,
                                        gpointer         user_data)
{
  Combo_editor *combo = (Combo_editor *) gtk_object_get_user_data(
    GTK_OBJECT(gtk_widget_get_toplevel(GTK_WIDGET(button))));
  combo->save();
}

C_EXPORT void
on_combo_ok_clicked                    (GtkButton       *button,
                                        gpointer         user_data)
{
  GtkWidget *win = gtk_widget_get_toplevel(GTK_WIDGET(button));
  Combo_editor *combo = (Combo_editor *) gtk_object_get_user_data(
              GTK_OBJECT(win));
  combo->save();
  gtk_widget_hide(win);
}

C_EXPORT void
on_combo_locx_changed     (GtkSpinButton *button,
           gpointer   user_data)
{
  Combo_editor *combo = (Combo_editor *) gtk_object_get_user_data(
    GTK_OBJECT(gtk_widget_get_toplevel(GTK_WIDGET(button))));
  combo->set_position();
}

C_EXPORT void
on_combo_locy_changed     (GtkSpinButton *button,
           gpointer   user_data)
{
  Combo_editor *combo = (Combo_editor *) gtk_object_get_user_data(
    GTK_OBJECT(gtk_widget_get_toplevel(GTK_WIDGET(button))));
  combo->set_position();
}

C_EXPORT void
on_combo_locz_changed     (GtkSpinButton *button,
           gpointer   user_data)
{
  Combo_editor *combo = (Combo_editor *) gtk_object_get_user_data(
    GTK_OBJECT(gtk_widget_get_toplevel(GTK_WIDGET(button))));
  combo->set_position();
}

C_EXPORT void
on_combo_order_changed      (GtkSpinButton *button,
           gpointer   user_data)
{
  Combo_editor *combo = (Combo_editor *) gtk_object_get_user_data(
    GTK_OBJECT(gtk_widget_get_toplevel(GTK_WIDGET(button))));
  combo->set_order();
}

/*
 *  Mouse events in draw area.
 */
C_EXPORT gint on_combo_draw_button_press_event
  (
  GtkWidget *widget,    // The view window.
  GdkEventButton *event,
  gpointer data     // ->Combo_chooser.
  )
  {
  Combo_editor *combo = (Combo_editor *) gtk_object_get_user_data(
    GTK_OBJECT(gtk_widget_get_toplevel(GTK_WIDGET(widget))));
  return combo->mouse_press(event);
  }

/*
 *  Which member makes the better 'hot-spot' in a combo, where 'better'
 *  means lower, then southmost, then eastmost.
 *
 *  Output: 0 if c0, 1 if c1
 */

int hot_spot_compare
  (
  Combo_member& c0,
  Combo_member& c1
  )
  {
  if (c0.tz < c1.tz)
    return 0;
  else if (c1.tz < c0.tz)
    return 1;
  else if (c0.ty > c1.ty)
    return 0;
  else if (c1.ty > c0.ty)
    return 1;
  else
    return c0.tx >= c1.tx ? 0 : 1;
  }

/*
 *  Get footprint of given member.
 */

Rectangle Combo::get_member_footprint
  (
  int i       // i'th member.
  )
  {
  Combo_member *m = members[i];
          // Get tile dims.
  Shape_info& info = shapes_file->get_info(m->shapenum);
  int xtiles = info.get_3d_xtiles(m->framenum),
      ytiles = info.get_3d_ytiles(m->framenum);
          // Get tile footprint.
  Rectangle box(m->tx - xtiles + 1, m->ty - ytiles + 1, 
              xtiles, ytiles);
  return box;
  }

/*
 *  Create empty combo.
 */

Combo::Combo
  (
  Shapes_vga_file *svga
  ) : shapes_file(svga),
      starttx(c_num_tiles), startty(c_num_tiles), hot_index(-1),
      tilefoot(0, 0, 0, 0)
  {
          // Read info. the first time.
  shapes_file->read_info(false, true);//+++++BG?
  }

/*
 *  Copy another.
 */

Combo::Combo
  (
  const Combo& c2
  ) : shapes_file(c2.shapes_file), starttx(c2.starttx),
      startty(c2.startty), 
      hot_index(c2.hot_index), name(c2.name), tilefoot(c2.tilefoot)
  {
  for (std::vector<Combo_member *>::const_iterator it = c2.members.begin();
          it != c2.members.end(); ++it)
    {
    Combo_member *m = *it;
    members.push_back(new Combo_member(m->tx, m->ty, m->tz, 
          m->shapenum, m->framenum));
    }
  }

/*
 *  Clean up.
 */

Combo::~Combo
  (
  )
  {
  for (std::vector<Combo_member *>::iterator it = members.begin();
          it != members.end(); ++it)
    delete *it;
  }

/*
 *  Add a new object.
 */

void Combo::add
  (
  int tx, int ty, int tz,   // Location rel. to top-left.
  int shnum, int frnum    // Shape.
  )
  {
          // Look for identical shape, pos.
  for (std::vector<Combo_member *>::iterator it = members.begin();
          it != members.end(); ++it)
    {
    Combo_member *m = *it;
    if (tx == m->tx && ty == m->ty && tz == m->tz &&
        shnum == m->shapenum && frnum == m->framenum)
      return;   // Don't add same one twice.
    }
          // Get tile dims.
  Shape_info& info = shapes_file->get_info(shnum);
  int xtiles = info.get_3d_xtiles(frnum),
      ytiles = info.get_3d_ytiles(frnum),
      ztiles = info.get_3d_height();
          // Get tile footprint.
  Rectangle box(tx - xtiles + 1, ty - ytiles + 1, xtiles, ytiles);
  if (!members.size())    // First one?
    tilefoot = box;   // Init. total footprint.
  else
    {     // Too far away?
    if (tilefoot.x + tilefoot.w - box.x > maxtiles ||
        box.x + box.w - tilefoot.x > maxtiles ||
        tilefoot.y + tilefoot.h - box.y > maxtiles ||
        box.y + box.h - tilefoot.y > maxtiles)
      {
      EStudio::Alert(
        "New object is too far (> 32) from others");
      return;
      }
          // Add to footprint.
    tilefoot = tilefoot.add(box);
    }
  Combo_member *memb = new Combo_member(tx, ty, tz, shnum, frnum);
  members.push_back(memb);
          // Figure visible top-left tile, with
          //   1 to spare.
  int vtx = tx - xtiles - 2 - (tz + ztiles + 1)/2, 
      vty = ty - ytiles - 2 - (tz + ztiles + 1)/2;
  if (vtx < starttx)    // Adjust our starting point.
    starttx = vtx;
  if (vty < startty)
    startty = vty;
  if (hot_index == -1 ||    // First one, or better than prev?
      hot_spot_compare(*memb, *members[hot_index]) == 0)
    hot_index = members.size() - 1;
  }

/*
 *  Remove i'th object.
 */

void Combo::remove
  (
  int i
  )
  {
  if (i < 0 || i >= members.size())
    return;
          // Get and remove i'th entry.
  std::vector<Combo_member *>::iterator it = members.begin() + i;
  Combo_member *m = *it;
  members.erase(it);
  delete m;
  hot_index = -1;     // Figure new hot-spot, footprint.
  tilefoot = Rectangle(0, 0, 0, 0);
  for (std::vector<Combo_member *>::iterator it = members.begin();
            it != members.end(); ++it)
    {
    Combo_member *m = *it;
    int index = it - members.begin();
    Rectangle box = get_member_footprint(index);
    if (hot_index == -1)  // First?
      {
      hot_index = 0;
      tilefoot = box;
      }
    else
      {
      if (hot_spot_compare(*m, *members[hot_index]) == 0)
        hot_index = index;
      tilefoot = tilefoot.add(box);
      }
    }
  }

/*
 *  Paint in a drawing area.
 */

void Combo::draw
  (
  Shape_draw *draw,
  int selected,     // Index of 'selected' item, or -1.
  int xoff, int yoff    // Offset within draw.
  )
  {
  int selx = -1000, sely = -1000;
  bool selfound = false;
  for (std::vector<Combo_member *>::iterator it = members.begin();
          it != members.end(); ++it)
    {
    Combo_member *m = *it;
          // Figure pixels up-left for lift.
    int lft = m->tz*(c_tilesize/2);
          // Figure relative tile.
    int mtx = m->tx - starttx,
        mty = m->ty - startty;
          // Hot spot:
    int x = mtx*c_tilesize - lft,
        y = mty*c_tilesize - lft;
    Shape_frame *shape = shapes_file->get_shape(m->shapenum,
                m->framenum);
    if (!shape)
      continue;
          // But draw_shape uses top-left.
    x -= shape->get_xleft();
    y -= shape->get_yabove();
    x += xoff; y += yoff; // Add offset within area.
    draw->draw_shape(shape, x, y);
    if (it - members.begin() == selected)
      {
      selx = x; // Save coords for selected.
      sely = y;
      selfound = true;
      }
    }
  if (selfound)     // Now put border around selected.
    {
    Combo_member *m = members[selected];
          // FOR NOW, use color #1 ++++++++
    draw->draw_shape_outline(m->shapenum, m->framenum,
            selx, sely, 1);
    }
  }

/*
 *  Find last member in list that contains a mouse point.
 *
 *  Output: Index of member found, or -1 if none.
 */

int Combo::find
  (
  int mx, int my      // Mouse position in draw area.
  )
  {
  int cnt = members.size();
  for (int i = cnt - 1; i >= 0; i--)
    {
    Combo_member *m = members[i];
          // Figure pixels up-left for lift.
    int lft = m->tz*(c_tilesize/2);
          // Figure relative tile.
    int mtx = m->tx - starttx,
        mty = m->ty - startty;
    int x = mtx*c_tilesize - lft,
        y = mty*c_tilesize - lft;
    Shape_frame *frame = shapes_file->get_shape(
            m->shapenum, m->framenum);
    if (frame && frame->has_point(mx - x, my - y))
      return i;
    }
  return -1;
  }

/*
 *  Write out.
 *
 *  Output: Allocated buffer containing result.
 */

unsigned char *Combo::write
  (
  int& datalen      // Actual length of data in buf. is
          //   returned here.
  )
  {
  int namelen = name.length();  // Name length.
          // Room for our data + members.
  unsigned char *buf = new unsigned char[namelen + 1 + 
            7*4 + members.size()*(5*4)];
  unsigned char *ptr = buf;
  Serial_out out(ptr);
  out << name;
  out << hot_index << starttx << startty;
  out << (short) members.size();  // # members to follow.
  for (std::vector<Combo_member *>::const_iterator it = members.begin();
          it != members.end(); ++it)
    {
    Combo_member *m = *it;
    out << m->tx << m->ty << m->tz << m->shapenum <<
            m->framenum;
    }
  datalen = ptr - buf;    // Return actual length.
  return buf;
  }

/*
 *  Read in.
 *
 *  Output: ->past actual data read.
 */

unsigned char *Combo::read
  (
  unsigned char *buf,
  int bufsize
  )
  {
  unsigned char *ptr = buf;
  Serial_in in(ptr);
  in << name;
  in << hot_index << starttx << startty;
  short cnt;
  in << cnt;      // # members to follow.
  for (int i = 0; i < cnt; i++)
    {
    short tx, ty, tz, shapenum, framenum;
    in << tx << ty << tz << shapenum << framenum;
    Combo_member *memb = new Combo_member(tx, ty, tz, 
            shapenum, framenum);
    members.push_back(memb);
    Rectangle box = get_member_footprint(i);
    if (i == 0)   // Figure footprint.
      tilefoot = box;
    else
      tilefoot = tilefoot.add(box);
    }
  return ptr;
  }

/*
 *  Set to edit an existing combo.
 */

void Combo_editor::set_combo
  (
  Combo *newcombo,    // We'll own this.
  int findex      // File index.
  )
  {
  delete combo;
  combo = newcombo;
  file_index = findex;
  selected = -1;
  ExultStudio::get_instance()->set_entry(
      "combo_name", combo->name.c_str(), true);
  set_controls();     // No selection now.
  render();
  }

/*
 *  Create combo editor.
 */

Combo_editor::Combo_editor
  (
  Shapes_vga_file *svga,    // File containing shapes.
  unsigned char *palbuf   // Palette for drawing shapes.
  ) : Shape_draw(svga, palbuf, glade_xml_get_widget(
    ExultStudio::get_instance()->get_xml(), "combo_draw")),
      selected(-1), setting_controls(false), file_index(-1)
  {
  static bool first = true;
  combo = new Combo(svga);
  GladeXML *app_xml = ExultStudio::get_instance()->get_xml();
  win = glade_xml_get_widget(app_xml, "combo_win");
  gtk_object_set_user_data(GTK_OBJECT(win), this);
  if (first)      // Indicate the events we want.
    {
    gtk_widget_set_events(draw, GDK_EXPOSURE_MASK | 
      GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK |
        GDK_BUTTON1_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK);
    first = false;
    }
  set_controls();
  }

/*
 *  Clean up.
 */

Combo_editor::~Combo_editor
  (
  )
  {
  delete combo;
  }

/*
 *  Show/hide.
 */

void Combo_editor::show
  (
  bool tf
  )
  {
  if (tf)
    gtk_widget_show(win);
  else
    gtk_widget_hide(win);
  }

/*
 *  Display.
 */

void Combo_editor::render
  (
  GdkRectangle *area    // 0 for whole draw area.
  )
  {
  Shape_draw::configure();  // Setup the first time.
          // Get dims.
  int draww = draw->allocation.width,
      drawh = draw->allocation.height;
  GdkRectangle all;
  if (!area)
    {
    all.x = all.y = 0;
    all.width = draww;
    all.height = drawh;
    area = &all;
    }
  gdk_gc_set_clip_rectangle(drawgc, area);
  iwin->fill8(255);   // Fill with background color.
  combo->draw(this, selected);  // Draw shapes.
  Shape_draw::show(area->x, area->y, area->width, area->height);
  }

/*
 *  Set controls according to what's selected.
 */

void Combo_editor::set_controls
  (
  )
  {
  setting_controls = true;  // Avoid updating.
  ExultStudio *studio = ExultStudio::get_instance();
  Combo_member *m = combo->get(selected);
  if (!m)       // None selected?
    {
    studio->set_spin("combo_locx", 0, false);
    studio->set_spin("combo_locy", 0, false);
    studio->set_spin("combo_locz", 0, false);
    studio->set_spin("combo_order", 0, false);
    studio->set_sensitive("combo_remove", false);
    }
  else
    {
    int draww = draw->allocation.width,
        drawh = draw->allocation.height;
    studio->set_sensitive("combo_locx", true);
    studio->set_spin("combo_locx", m->tx - combo->starttx,
              0, draww/c_tilesize);
    studio->set_sensitive("combo_locy", true);
    studio->set_spin("combo_locy", m->ty - combo->startty,
              0, drawh/c_tilesize);
    studio->set_sensitive("combo_locz", true);
    studio->set_spin("combo_locz", m->tz, 0, 15);
    studio->set_sensitive("combo_order", true);
    studio->set_spin("combo_order", selected, 0,
            combo->members.size() - 1);
    studio->set_sensitive("combo_remove", true);
    }
  setting_controls = false;
  }

/*
 *  Handle a mouse-press event.
 */

gint Combo_editor::mouse_press
  (
  GdkEventButton *event
  )
  {
  if (event->button != 1)
    return FALSE;   // Handling left-click.
          // Get mouse position, draw dims.
  int mx = (int) event->x, my = (int) event->y;
  selected = combo->find(mx, my); // Find it (or -1 if not found).
  set_controls();
  render();
  return TRUE;
  }

/*
 *  Move the selected item within the order.
 */

void Combo_editor::set_order
  (
  )
  {
  if (setting_controls || selected < 0)
    return;
  ExultStudio *studio = ExultStudio::get_instance();
  int newi = studio->get_spin("combo_order");
  if (selected == newi)
    return;     // Already correct.
  int dir = newi > selected ? 1 : -1;
  while (newi != selected)
    {
    Combo_member *tmp = combo->members[selected + dir];
    combo->members[selected + dir] = combo->members[selected];
    combo->members[selected] = tmp;
    selected += dir;
    }
  render();
  }

/*
 *  Move the selected item to the desired position in the spin buttons.
 */

void Combo_editor::set_position
  (
  )
  {
  Combo_member *m = combo->get(selected);
  if (!m || setting_controls)
    return;
  ExultStudio *studio = ExultStudio::get_instance();
  m->tx = combo->starttx + studio->get_spin("combo_locx");
  m->ty = combo->startty + studio->get_spin("combo_locy");
  m->tz = studio->get_spin("combo_locz");
  render();
  }

/*
 *  Get # shapes we can display.
 */

int Combo_chooser::get_count
  (
  )
  {
  return group ? group->size() : combos.size();
  }

/*
 *  Add an object/shape picked from Exult.
 */

void Combo_editor::add
  (
  unsigned char *data,    // Serialized object.
  int datalen
  )
  {
  unsigned long addr;
  int tx, ty, tz;
  int shape, frame, quality;
  std::string name;
  if (!Object_in(data, datalen, addr, tx, ty, tz, shape, frame,
    quality, name))
    {
    cout << "Error decoding object" << endl;
    return;
    }
  combo->add(tx, ty, tz, shape, frame);
  render();
  }

/*
 *  Remove selected.
 */

void Combo_editor::remove
  (
  )
  {
  if (selected >= 0)
    {
    combo->remove(selected);
    selected = -1;
    set_controls();
    render();
    }
  }

/*
 *  Save combo.
 */

void Combo_editor::save
  (
  )
  {
  ExultStudio *studio = ExultStudio::get_instance();
          // Get name from field.
  combo->name = studio->get_text_entry("combo_name");
  Flex_file_info *flex_info = dynamic_cast<Flex_file_info *>
        (studio->get_files()->create("combos.flx"));
  if (!flex_info)
    {
    EStudio::Alert("Can't open 'combos.flx'");
    return;
    }
  flex_info->set_modified();
  int len;      // Serialize.
  unsigned char *newbuf = combo->write(len);
          // Update or append file data.
  flex_info->set(file_index == -1 ? flex_info->size() : file_index, 
          (char *) newbuf, len);
  Combo_chooser *browser = dynamic_cast<Combo_chooser *>(
            studio->get_browser());
  if (browser)      // Browser open?
    file_index = browser->add(new Combo(*combo), file_index);
  }

/*
 *  Blit onto screen.
 */

void Combo_chooser::show
  (
  int x, int y, int w, int h  // Area to blit.
  )
  {
  Shape_draw::show(draw->window, x, y, w, h);
  if (selected >= 0)    // Show selected.
    {
    Rectangle b = info[selected].box;
          // Draw yellow box.
    gdk_draw_rectangle(draw->window, drawgc, FALSE, 
              b.x, b.y, b.w, b.h);
    }
  }

/*
 *  Select an entry.  This should be called after rendering
 *  the combo.
 */

void Combo_chooser::select
  (
  int new_sel
  )
  {
  if (new_sel < 0 || new_sel >= info_cnt)
    return;     // Bad value.
  selected = new_sel;
  enable_controls();
  int num = info[selected].num;
  Combo *combo = combos[num];
          // Remove prev. selection msg.
//  gtk_statusbar_pop(GTK_STATUSBAR(sbar), sbar_sel);
  char buf[150];      // Show new selection.
  g_snprintf(buf, sizeof(buf), "Combo %d", num);
  if (combo && !combo->name.empty())
    {
    int len = strlen(buf);
    g_snprintf(buf + len, sizeof(buf) - len, 
        ":  '%s'", combo->name.c_str());
    }
  gtk_statusbar_push(GTK_STATUSBAR(sbar), sbar_sel, buf);
  }

/*
 *  Unselect.
 */

void Combo_chooser::unselect
  (
  bool need_render      // 1 to render and show.
  )
  {
  if (selected >= 0)
    {
    selected = -1;
    if (need_render)
      {
      render();
      show();
      }
    if (sel_changed)  // Tell client.
      (*sel_changed)();
    }
  enable_controls();    // Enable/disable controls.
  char buf[150];      // Show new selection.
  if (info_cnt > 0)
    {
//    gtk_statusbar_pop(GTK_STATUSBAR(sbar), sbar_sel);
    g_snprintf(buf, sizeof(buf), "Combos %d to %d",
      info[0].num, info[info_cnt - 1].num);
    gtk_statusbar_push(GTK_STATUSBAR(sbar), sbar_sel, buf);
    }
  else
    {
//    gtk_statusbar_pop(GTK_STATUSBAR(sbar), sbar_sel);
    gtk_statusbar_push(GTK_STATUSBAR(sbar), sbar_sel,
              "No combos");
    }
  }

/*
 *  Load/reload from file.
 */

void Combo_chooser::load
  (
  )
  {
  int cnt = combos.size();
  for (int i = 0; i < cnt; i++) // Delete all the combos.
    delete combos[i];
  int num_combos = flex_info->size();
          // We need 'shapes.vga'.
  Shape_file_info *svga_info = 
        ExultStudio::get_instance()->get_vgafile();
  Shapes_vga_file *svga = svga_info ?
      (Shapes_vga_file *) svga_info->get_ifile() : 0;
  combos.resize(num_combos);  // Set size of list.
  if (!svga)
    num_combos = 0;
          // Read them all in.
  for (int i = 0; i < num_combos; i++)
    {
    size_t len;
    unsigned char *buf = (unsigned char *) flex_info->get(i, len);
    Combo *combo = new Combo(svga);
    combo->read(buf, len);
    combos[i] = combo;  // Store in list.
    }
  }

/*
 *  Render as many combos as fit in the combo chooser window.
 */

void Combo_chooser::render
  (
  )
  {
          // Look for selected frame.
  int selcombo = -1, new_selected = -1;
  if (selected >= 0)    // Save selection info.
    selcombo = info[selected].num;
          // Remove "selected" message.
  //gtk_statusbar_pop(GTK_STATUSBAR(sbar), sbar_sel);
  delete [] info;     // Delete old info. list.
          // Get drawing area dimensions.
  gint winw = draw->allocation.width, winh = draw->allocation.height;
          // Provide more than enough room.
  info = new Combo_info[256];
  info_cnt = 0;     // Count them.
          // Clear window first.
  iwin->fill8(255);   // Background color.
  int index = index0;
          // We'll always show 128x128.
  const int combow = 128, comboh = 128;
  int total_cnt = get_count();
  int y = border;
          // Show bottom if at least 1/2 vis.
  while (index < total_cnt && y + comboh/2 + border <= winh)
    {
    int x = border;
    int cliph = y + comboh <= winh ? comboh : (winh - y);
    while (index < total_cnt && x + combow + border <= winw)
      {
      iwin->set_clip(x, y, combow, cliph);
      int combonum = group ? (*group)[index] : index;
      combos[combonum]->draw(this, -1, x, y);
      iwin->clear_clip();
          // Store info. about where drawn.
      info[info_cnt].set(combonum, x, y, combow, comboh);
      if (combonum == selcombo)
            // Found the selected combo.
        new_selected = info_cnt;
      info_cnt++;
      index++;    // Next combo.
      x += combow + border;
      }
    y += comboh + border;
    }
  if (new_selected == -1)
    unselect(false);
  else
    select(new_selected);
  }

/*
 *  Scroll to a new combo.
 */

void Combo_chooser::scroll
  (
  int newindex      // Abs. index of leftmost to show.
  )
  {
  int total = combos.size();
  if (index0 < newindex)  // Going forwards?
    index0 = newindex < total ? newindex : total;
  else if (index0 > newindex) // Backwards?
    index0 = newindex >= 0 ? newindex : 0;
  render();
  show();
  }

/*
 *  Scroll up/down by one row.
 */

void Combo_chooser::scroll
  (
  bool upwards
  )
  {
  GtkAdjustment *adj = gtk_range_get_adjustment(GTK_RANGE(vscroll));
  float delta = adj->step_increment;
  if (upwards)
    delta = -delta;
  adj->value += delta;
  gtk_signal_emit_by_name(GTK_OBJECT(adj), "changed");
  scroll((gint) adj->value);
  }

/*
 *  Someone wants the dragged combo.
 */

void Combo_chooser::drag_data_get
  (
  GtkWidget *widget,    // The view window.
  GdkDragContext *context,
  GtkSelectionData *seldata,  // Fill this in.
  guint info,
  guint time,
  gpointer data     // ->Shape_chooser.
  )
  {
  cout << "In DRAG_DATA_GET" << endl;
  Combo_chooser *chooser = (Combo_chooser *) data;
  if (chooser->selected < 0 || info != U7_TARGET_COMBOID)
    return;     // Not sure about this.
          // Get combo #.
  int num = chooser->info[chooser->selected].num;
  Combo *combo = chooser->combos[num];
          // Get enough memory.
  int cnt = combo->members.size();
  int buflen = 5*4 + cnt*5*4;
cout << "Buflen = " << buflen << endl;
  guchar *buf = new unsigned char[buflen];
  guchar *ptr = buf;
  U7_combo_data *ents = new U7_combo_data[cnt];
          // Get 'hot-spot' member.
  Combo_member *hot = combo->members[combo->hot_index];
  for (int i = 0; i < cnt; i++)
    {
    Combo_member *m = combo->members[i];
    ents[i].tx = m->tx - hot->tx;
    ents[i].ty = m->ty - hot->ty;
    ents[i].tz = m->tz - hot->tz;
    ents[i].shape = m->shapenum;
    ents[i].frame = m->framenum;
    }
  Rectangle foot = combo->tilefoot;
  int len = Store_u7_comboid(buf, foot.w, foot.h,
      foot.x + foot.w - 1 - hot->tx,
      foot.y + foot.h - 1 - hot->ty, cnt, ents);
  assert(len <= buflen);
#ifdef WIN32
  windragdata *wdata = (windragdata *)seldata;
  wdata->assign(info, len, buf);
#else
          // Make us owner of xdndselection.
  gtk_selection_owner_set(widget, gdk_atom_intern("XdndSelection", 0),
                time);
          // Set data.
  gtk_selection_data_set(seldata,
      gdk_atom_intern(U7_TARGET_COMBOID_NAME, 0),
                                        8, buf, len);
#endif
  delete buf;
  delete [] ents;
  }

/*
 *  Another app. has claimed the selection.
 */

gint Combo_chooser::selection_clear
  (
  GtkWidget *widget,    // The view window.
  GdkEventSelection *event,
  gpointer data     // ->Combo_chooser.
  )
  {
//  Combo_chooser *chooser = (Combo_chooser *) data;
  cout << "SELECTION_CLEAR" << endl;
  return TRUE;
  }

/*
 *  Beginning of a drag.
 */

gint Combo_chooser::drag_begin
  (
  GtkWidget *widget,    // The view window.
  GdkDragContext *context,
  gpointer data     // ->Combo_chooser.
  )
  {
  cout << "In DRAG_BEGIN" << endl;
  Combo_chooser *chooser = (Combo_chooser *) data;
  if (chooser->selected < 0)
    return FALSE;   // ++++Display a halt bitmap.
          // Get ->combo.
  int num = chooser->info[chooser->selected].num;
  Combo *combo = chooser->combos[num];
          // Show 'hot' member as icon.
  Combo_member *hot = combo->members[combo->hot_index];
  Shape_frame *shape = combo->shapes_file->get_shape(hot->shapenum,
              hot->framenum);
  if (shape)
    chooser->set_drag_icon(context, shape);
  return TRUE;
  }

/*
 *  Handle a scrollbar event.
 */

void Combo_chooser::scrolled
  (
  GtkAdjustment *adj,   // The adjustment.
  gpointer data     // ->Combo_chooser.
  )
  {
  Combo_chooser *chooser = (Combo_chooser *) data;
  gint newindex = (gint) adj->value;
  chooser->scroll(newindex);
  }

/*
 *  Callbacks for controls:
 */
/*
 *  Keystroke in draw-area.
 */
static gboolean
on_combo_key_press      (GtkEntry *entry,
           GdkEventKey  *event,
           gpointer  user_data)
{
  Combo_chooser *chooser = (Combo_chooser *) user_data;
  switch (event->keyval)
    {
  case GDK_Delete:
    chooser->remove();
    return TRUE;
    }
  return FALSE;     // Let parent handle it.
}

/*
 *  Enable/disable controls after selection changed.
 */

void Combo_chooser::enable_controls
  (
  )
  {
  if (selected == -1)   // No selection.
    {
    if (!group)
      {
      gtk_widget_set_sensitive(move_down, false);
      gtk_widget_set_sensitive(move_up, false);
      }
    return;
    }
  if (!group)
    {
    gtk_widget_set_sensitive(move_down, 
        info[selected].num < combos.size() - 1);
    gtk_widget_set_sensitive(move_up, 
          info[selected].num > 0);
    }
  }

static gint Mouse_release(GtkWidget *, GdkEventButton *, gpointer);

/*
 *  Create the list.
 */

Combo_chooser::Combo_chooser
  (
  Vga_file *i,      // Where they're kept.
  Flex_file_info *flinfo,   // Flex-file info.
  unsigned char *palbuf,    // Palette, 3*256 bytes (rgb triples).
  int w, int h,     // Dimensions.
  Shape_group *g      // Filter, or null.
  ) : Object_browser(g, flinfo), 
    Shape_draw(i, palbuf, gtk_drawing_area_new()),
    flex_info(flinfo), index0(0),
    info(0), info_cnt(0), sel_changed(0)
  {
  load();       // Init. from file data.
          // Put things in a vert. box.
  GtkWidget *vbox = gtk_vbox_new(FALSE, 0);
  set_widget(vbox); // This is our "widget"
  gtk_widget_show(vbox);
  
  GtkWidget *hbox = gtk_hbox_new(FALSE, 0);
  gtk_widget_show(hbox);
  gtk_box_pack_start(GTK_BOX(vbox), hbox, TRUE, TRUE, 0);
  
          // A frame looks nice.
  GtkWidget *frame = gtk_frame_new(NULL);
  gtk_frame_set_shadow_type(GTK_FRAME(frame), GTK_SHADOW_IN);
  gtk_widget_show(frame);
  gtk_box_pack_start(GTK_BOX(hbox), frame, TRUE, TRUE, 0);
          // NOTE:  draw is in Shape_draw.
          // Indicate the events we want.
  gtk_widget_set_events(draw, GDK_EXPOSURE_MASK | GDK_BUTTON_PRESS_MASK
    | GDK_BUTTON_RELEASE_MASK
    | GDK_POINTER_MOTION_HINT_MASK |
    GDK_BUTTON1_MOTION_MASK | GDK_KEY_PRESS_MASK);
          // Set "configure" handler.
  gtk_signal_connect(GTK_OBJECT(draw), "configure_event",
        GTK_SIGNAL_FUNC(configure), this);
          // Set "expose" handler.
  gtk_signal_connect(GTK_OBJECT(draw), "expose_event",
        GTK_SIGNAL_FUNC(expose), this);
          // Keystroke.
  gtk_signal_connect(GTK_OBJECT(draw), "key-press-event",
          GTK_SIGNAL_FUNC (on_combo_key_press),
          this);
  GTK_WIDGET_SET_FLAGS(draw, GTK_CAN_FOCUS);
          // Set mouse click handler.
  gtk_signal_connect(GTK_OBJECT(draw), "button_press_event",
        GTK_SIGNAL_FUNC(mouse_press), this);
  gtk_signal_connect(GTK_OBJECT(draw), "button_release_event",
        GTK_SIGNAL_FUNC(Mouse_release), this);
          // Mouse motion.
  gtk_signal_connect(GTK_OBJECT(draw), "drag_begin",
        GTK_SIGNAL_FUNC(drag_begin), this);
#ifdef WIN32
// required to override GTK+ Drag and Drop
  gtk_signal_connect(GTK_OBJECT(draw), "motion_notify_event",
        GTK_SIGNAL_FUNC(win32_drag_motion), this);
#else
  gtk_signal_connect(GTK_OBJECT(draw), "motion_notify_event",
        GTK_SIGNAL_FUNC(drag_motion), this);
#endif
  gtk_signal_connect (GTK_OBJECT(draw), "drag_data_get",
        GTK_SIGNAL_FUNC(drag_data_get), this);
  gtk_signal_connect (GTK_OBJECT(draw), "selection_clear_event",
        GTK_SIGNAL_FUNC(selection_clear), this);
  gtk_container_add (GTK_CONTAINER (frame), draw);
  gtk_drawing_area_size(GTK_DRAWING_AREA(draw), w, h);
  gtk_widget_show(draw);
          // Want a scrollbar for the combos.
  GtkObject *combo_adj = gtk_adjustment_new(0, 0, 
        combos.size(), 1, 
        4, 1.0);
  vscroll = gtk_vscrollbar_new(GTK_ADJUSTMENT(combo_adj));
          // Update window when it stops.
  gtk_range_set_update_policy(GTK_RANGE(vscroll),
          GTK_UPDATE_DELAYED);
  gtk_box_pack_start(GTK_BOX(hbox), vscroll, FALSE, TRUE, 0);
          // Set scrollbar handler.
  gtk_signal_connect(GTK_OBJECT(combo_adj), "value_changed",
          GTK_SIGNAL_FUNC(scrolled), this);
  gtk_widget_show(vscroll);
          // At the bottom, status bar:
  GtkWidget *hbox1 = gtk_hbox_new(FALSE, 0);
  gtk_box_pack_start(GTK_BOX(vbox), hbox1, FALSE, FALSE, 0);
  gtk_widget_show(hbox1);
          // At left, a status bar.
  sbar = gtk_statusbar_new();
  sbar_sel = gtk_statusbar_get_context_id(GTK_STATUSBAR(sbar),
              "selection");
  gtk_box_pack_start(GTK_BOX(hbox1), sbar, TRUE, TRUE, 0);
  gtk_widget_show(sbar);
          // Add controls to bottom.
  gtk_box_pack_start(GTK_BOX(vbox), 
    create_controls(find_controls|move_controls), FALSE, FALSE, 0);
  }

/*
 *  Delete.
 */

Combo_chooser::~Combo_chooser
  (
  )
  {
  gtk_widget_destroy(get_widget());
  delete [] info;
  int i;
  int cnt = combos.size();
  for (i = 0; i < cnt; i++) // Delete all the combos.
    delete combos[i];
  }

/*
 *  Add a new or updated combo.
 *
 *  Output: Index of entry.
 */

int Combo_chooser::add
  (
  Combo *newcombo,    // We'll own this.
  int index     // Index to replace, or -1 to add new.
  )
  {
  if (index == -1)
    {     // New.
    combos.push_back(newcombo);
    index = combos.size() - 1;  // Index of new entry.
    }
  else
    {
    assert(index >= 0 && index < combos.size());
    delete combos[index];
    combos[index] = newcombo;
    }
  GtkAdjustment *adj = 
      gtk_range_get_adjustment(GTK_RANGE(vscroll));
  adj->upper = combos.size();
  gtk_signal_emit_by_name(GTK_OBJECT(adj), "changed");
  render();
  show();
  return index;     // Return index.
  }

/*
 *  Remove selected entry.
 */

void Combo_chooser::remove
  (
  )
  {
  if (selected < 0)
    return;
  int tnum = info[selected].num;
  Combo_editor *combowin = ExultStudio::get_instance()->get_combowin();
  if (combowin && combowin->is_visible() && combowin->file_index == tnum)
    {
    EStudio::Alert("Can't remove the combo you're editing");
    return;
    }
  if (EStudio::Prompt("Okay to remove selected combo?", "Yes", "no")
                != 0)
    return;
  selected = -1;
  Combo *todel = combos[tnum];
  delete todel;     // Delete from our list.
  combos.erase(combos.begin() + tnum);
  flex_info->set_modified();
  flex_info->remove(tnum);  // Update flex-file list.
  GtkAdjustment *adj =    // Update scrollbar.
      gtk_range_get_adjustment(GTK_RANGE(vscroll));
  adj->upper = combos.size();
  gtk_signal_emit_by_name(GTK_OBJECT(adj), "changed");
  render();
  show();
  }

/*
 *  Bring up editor for selected combo.
 */

void Combo_chooser::edit
  (
  )
  {
  if (selected < 0)
    return;
  Combo_editor *combowin = ExultStudio::get_instance()->get_combowin();
  if (combowin && combowin->is_visible())
    {
    EStudio::Alert("You're already editing a combo");
    return;
    }
  int tnum = info[selected].num;
  ExultStudio *studio = ExultStudio::get_instance();
  studio->open_combo_window();  // Open it.
  Combo_editor *ed = studio->get_combowin();
  if (!ed || !ed->is_visible())
    return;     // Failed.  Shouldn't happen.
  ed->set_combo(new Combo(*(combos[tnum])), tnum);
  }

/*
 *  Configure the viewing window.
 */

gint Combo_chooser::configure
  (
  GtkWidget *widget,    // The draw area.
  GdkEventConfigure *event,
  gpointer data     // ->Combo_chooser
  )
  {
  Combo_chooser *chooser = (Combo_chooser *) data;
  chooser->Shape_draw::configure();
  chooser->render();
          // Set new scroll amounts.
  int w = event->width, h = event->height;
  int per_row = (w - border)/(128 + border);
  int num_rows = (h - border)/(128 + border);
  int page_size = per_row*num_rows;
  GtkAdjustment *adj = gtk_range_get_adjustment(GTK_RANGE(
            chooser->vscroll));
  adj->step_increment = per_row;
  adj->page_increment = page_size;
  adj->page_size = page_size;
  gtk_signal_emit_by_name(GTK_OBJECT(adj), "changed");
#if 0 /* ++++++Later */
  if (chooser->group)   // Filtering?
    chooser->enable_drop(); // Can drop combos here.
#endif
  return (TRUE);
  }

/*
 *  Handle an expose event.
 */

gint Combo_chooser::expose
  (
  GtkWidget *widget,    // The view window.
  GdkEventExpose *event,
  gpointer data     // ->Combo_chooser.
  )
  {
  Combo_chooser *chooser = (Combo_chooser *) data;
  chooser->show(event->area.x, event->area.y, event->area.width,
              event->area.height);
  return (TRUE);
  }

#ifdef WIN32

/*
 *  Dragging in win32.
 */
static bool win32_button = false;

gint Combo_chooser::win32_drag_motion
  (
  GtkWidget *widget,    // The view window.
  GdkEventMotion *event,
  gpointer data     // ->Combo_chooser.
  )
  {
    if (win32_button)
    {
    win32_button = false;

    // prepare the dragged data
    windragdata wdata;

    // This call allows us to recycle the data transfer initialization code.
    //  It's clumsy, but far easier to maintain.
    drag_data_get(NULL, NULL, (GtkSelectionData *) &wdata,
      U7_TARGET_COMBOID, 0, data);

    POINT pnt;
    GetCursorPos(&pnt);

    LPDROPSOURCE idsrc = (LPDROPSOURCE) new Windropsource(0, 
      pnt.x, pnt.y);
    LPDATAOBJECT idobj = (LPDATAOBJECT) new Winstudioobj(wdata);
    DWORD dndout;

    HRESULT res = DoDragDrop(idobj, idsrc, DROPEFFECT_COPY, &dndout);
    if (FAILED(res)) {
      g_warning ("Oops! Something is wrong with OLE2 DnD..");
    }

    delete idsrc;
    idobj->Release(); // Not sure if we really need this. However, it doesn't hurt either.
    }

  return true;
  };

#else
gint Combo_chooser::drag_motion
  (
  GtkWidget *widget,    // The view window.
  GdkEventMotion *event,
  gpointer data     // ->Shape_chooser.
  )
  {
  Combo_chooser *chooser = (Combo_chooser *) data;
  if (!chooser->dragging && chooser->selected >= 0)
    chooser->start_drag(U7_TARGET_COMBOID_NAME, 
      U7_TARGET_COMBOID, (GdkEvent *) event);
  return true;
  }
#endif

/*
 *  Handle a mouse button press event.
 */

gint Combo_chooser::mouse_press
  (
  GtkWidget *widget,    // The view window.
  GdkEventButton *event,
  gpointer data     // ->Combo_chooser.
  )
  {
  gtk_widget_grab_focus(widget);  // Enables keystrokes.
  Combo_chooser *chooser = (Combo_chooser *) data;

    if (event->button == 4) {
        chooser->scroll(true);
        return(TRUE);
    } else if (event->button == 5) {
        chooser->scroll(false);
        return(TRUE);
    }



  int old_selected = chooser->selected;
  int i;        // Search through entries.
  for (i = 0; i < chooser->info_cnt; i++)
    if (chooser->info[i].box.has_point(
          (int) event->x, (int) event->y))
      {   // Found the box?
          // Indicate we can drag.
#ifdef WIN32
// Here, we have to override GTK+'s Drag and Drop, which is non-OLE and
// usually stucks outside the program window. I think it's because
// the dragged shape only receives mouse motion events when the new mouse pointer
// position is *still* inside the shape. So if you move the mouse too fast,
// we are stuck.
      win32_button = true;
#endif
      chooser->selected = i;
      chooser->render();
      chooser->show();
          // Tell client.
      if (chooser->sel_changed)
        (*chooser->sel_changed)();
      break;
      }
  if (i == chooser->info_cnt && event->button == 1)
    chooser->unselect(true);  // Nothing under mouse.
  else if (chooser->selected == old_selected && old_selected >= 0)
    {     // Same square.  Check for dbl-click.
    if (((GdkEvent *) event)->type == GDK_2BUTTON_PRESS)
      chooser->edit();
    }
  if (event->button == 3)
    gtk_menu_popup(GTK_MENU(chooser->create_popup()), 
        0, 0, 0, 0, event->button, event->time);
  return (TRUE);
  }

/*
 *  Handle a mouse button-release event in the combo chooser.
 */
static gint Mouse_release
  (
  GtkWidget *widget,    // The view window.
  GdkEventButton *event,
  gpointer data     // ->Shape_chooser.
  )
  {
  Combo_chooser *chooser = (Combo_chooser *) data;
  chooser->mouse_up();
  }

/*
 *  Move currently-selected combo up or down.
 */

void Combo_chooser::move
  (
  bool upwards
  )
  {
  if (selected < 0)
    return;     // Shouldn't happen.
  int tnum = info[selected].num;
  if ((tnum == 0 && upwards) || (tnum == combos.size() - 1 && !upwards))
    return;
  if (upwards)      // Going to swap tnum & tnum+1.
    tnum--;
  Combo *tmp = combos[tnum];
  combos[tnum] = combos[tnum + 1];
  combos[tnum + 1] = tmp;
  selected += upwards ? -1 : 1;
          // Update editor if open.
  Combo_editor *combowin = ExultStudio::get_instance()->get_combowin();
  if (combowin && combowin->is_visible())
    {
    if (combowin->file_index == tnum)
      combowin->file_index = tnum + 1;
    else if (combowin->file_index == tnum + 1)
      combowin->file_index = tnum;
    }
  flex_info->set_modified();
  flex_info->swap(tnum);    // Update flex-file list.
  render();
  show();
  }

/*
 *  Search for an entry.
 */

void Combo_chooser::search
  (
  const char *srch,   // What to search for.
  int dir       // 1 or -1.
  )
  {
  int total = get_count();
  if (!total)
    return;     // Empty.
  ExultStudio *studio = ExultStudio::get_instance();
          // Start with selection, or top.
  int start = selected >= 0 ? info[selected].num : 0;
  int i;
  start += dir;
  int stop = dir == -1 ? -1 : total;
  for (i = start; i != stop; i += dir)
    {
    int num = group ? (*group)[i] : i;
    const char *nm = combos[i]->name.c_str();
    if (nm && search_name(nm, srch))
      break;    // Found it.
    }
  if (i == stop)
    return;     // Not found.
  while (i < index0)    // Above current view?
    scroll(true);
  while (i >= index0 + info_cnt)  // Below?
    scroll(false);
  int newsel = i - index0;  // New selection.
  if (newsel >= 0 && newsel < info_cnt)
    select(newsel);
  show();
  }

---