paledit.cc

Go to the documentation of this file.

/*
Copyright (C) 2000 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 <gtk/gtk.h>
#ifdef XWIN
#include <gdk/gdkx.h>
#endif
#include <glib.h>
#include "paledit.h"
#include "u7drag.h"
#include "utils.h"
#include <iostream>
#include <iomanip>
#include <ctype.h>
#include <stdio.h>
#include "studio.h"
#include "shapefile.h"

using std::cout;
using std::endl;
using std::string;
using std::vector;
using std::ostream;
using std::ofstream;
using std::setw;
using std::ifstream;
using EStudio::Prompt;
using EStudio::Alert;

/*
 *  Write out a single palette to a buffer.
 */

static void Write_palette
  (
  unsigned char *buf,   // 3*256 bytes.
  GdkRgbCmap *pal     // Palette to write.
  )
  {
  for (int i = 0; i < 256; i++)
    {
    int r = (pal->colors[i]>>16)&255,
        g = (pal->colors[i]>>8)&255,
        b = pal->colors[i]&255;
    buf[3*i] = r/4;   // Range 0-63.
    buf[3*i + 1] = g/4;
    buf[3*i + 2] = b/4;
    }
  }

/*
 *  Blit onto screen.
 */

inline void Palette_edit::show
  (
  int x, int y, int w, int h  // Area to blit.
  )
  {
  int stride = draw->allocation.width;
  gdk_draw_indexed_image(draw->window, drawgc, x, y, w, h,
      GDK_RGB_DITHER_NORMAL,
      image + y*stride + x, 
      stride, palettes[cur_pal]);
  if (selected >= 0)    // Show selected.
          // Draw yellow box.
    gdk_draw_rectangle(draw->window, drawgc, FALSE, 
      selected_box.x, selected_box.y,
      selected_box.w, selected_box.h);
  }

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

void Palette_edit::select
  (
  int new_sel
  )
  {
  selected = new_sel;
          // Remove prev. selection msg.
  gtk_statusbar_pop(GTK_STATUSBAR(sbar), sbar_sel);
  char buf[150];      // Show new selection.
  g_snprintf(buf, sizeof(buf), "Color %d (0x%02x)", new_sel, new_sel);
  gtk_statusbar_push(GTK_STATUSBAR(sbar), sbar_sel, buf);
  }

/*
 *  Load/reload from file.
 */

void Palette_edit::load
  (
  )
  {
          // Free old.
  for (vector<GdkRgbCmap*>::iterator it = palettes.begin();
          it != palettes.end(); ++it)
    gdk_rgb_cmap_free(*it);
  int cnt = flex_info->size();
  palettes.resize(cnt);   // Set size of list.
  if (!cnt)     // No palettes?
    new_palette();    // Create 1 blank palette.
  else
    {
    for (int pnum = 0; pnum < cnt; pnum++)
      {
      size_t len;
      unsigned char *buf = (unsigned char *)
            flex_info->get(pnum, len);
      assert(len = 3*256);
      guint32 colors[256];
      for (int i = 0; i < 256; i++)
        colors[i] = (buf[3*i]<<16)*4 + 
          (buf[3*i+1]<<8)*4 + buf[3*i+2]*4;
      palettes[pnum] = gdk_rgb_cmap_new(colors, 256);
      }
    }
  }

/*
 *  Draw the palette.  This need only be called when it changes.
 */

void Palette_edit::render
  (
  )
  {
  int neww = draw->allocation.width, newh = draw->allocation.height;
          // Changed size?
  if (neww != width || newh != height)
    {
    delete image;
    width = neww;
    height = newh;
    image = new guchar[width*height];
    }
          // Figure cell size.
  int eachw = width/16, eachh = height/16;
          // Figure extra pixels.
  int extraw = width%16, extrah = height%16;
  int color = 0;      // Color index.
  int cury = 0;
  unsigned char *out = image;
  for (int y = 0; y < 16; y++, color += 16)
    {
    int curx = 0;
    int stopy = cury + eachh + (y < extrah);
    for ( ; cury < stopy; cury++)
      for (int x = 0, c = color; x < 16; x++, c++)
        {
        int cntx = eachw + (x < extraw);
        while (cntx--)
          *out++ = c;
        }
    }
  if (selected >= 0)    // Update selected box.
    {
    int selx = selected%16, sely = selected/16;
    selected_box.x = selx*eachw;
    selected_box.y = sely*eachh;
    selected_box.w = eachw;
    selected_box.h = eachh;
    if (selx < extraw)  // Watch for extra pixels.
      { selected_box.w++; selected_box.x += selx; }
    else
      selected_box.x += extraw;
    if (sely < extrah)
      { selected_box.h++; selected_box.y += sely; }
    else
      selected_box.y += extrah;
    select(selected);
    }
  }

/*
 *  Color box was closed.
 */

int Palette_edit::color_closed
  (
  GtkWidget *dlg,
  GdkEvent *event,
  gpointer data
  )
  {
  cout << "color_closed" << endl;
  Palette_edit *paled = (Palette_edit *) data;
  paled->colorsel = 0;
  return FALSE;
  }

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

void Palette_edit::color_cancel
  (
  GtkWidget *dlg,
  gpointer data
  )
  {
  Palette_edit *paled = (Palette_edit *) data;
  if (paled->colorsel)
    gtk_widget_destroy(GTK_WIDGET(paled->colorsel));
  paled->colorsel = 0;
  }

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

void Palette_edit::color_okay
  (
  GtkWidget *dlg,
  gpointer data
  )
  {
  Palette_edit *paled = (Palette_edit *) data;
  if (paled->colorsel)
    {
    gdouble rgb[3];
    gtk_color_selection_get_color(
      GTK_COLOR_SELECTION(paled->colorsel->colorsel), rgb);
    unsigned char r = (unsigned char) (rgb[0]*256),
            g = (unsigned char) (rgb[1]*256),
            b = (unsigned char) (rgb[2]*256);
    if (paled->selected >= 0)
      paled->palettes[paled->cur_pal]->colors[
              paled->selected] = 
              (r<<16) + (g<<8) + b;
    gtk_widget_destroy(GTK_WIDGET(paled->colorsel));
          // Send to flex file.
    paled->update_flex(paled->cur_pal);
    paled->render();
    paled->show();
    }
  paled->colorsel = 0;
  }

/*
 *  Handle double-click on a color by bringing up a color-selector.
 */

void Palette_edit::double_clicked
  (
  )
  {
  cout << "Double-clicked" << endl;
  if (selected < 0 || colorsel) // Only one at a time.
    return;     // Nothing selected.
  char buf[150];      // Show new selection.
  g_snprintf(buf, sizeof(buf), "Color %d (0x%02x)", selected, selected);
  colorsel = GTK_COLOR_SELECTION_DIALOG(
          gtk_color_selection_dialog_new(buf));
          // Set mouse click handler.
  gtk_signal_connect(GTK_OBJECT(colorsel->ok_button), "clicked",
        GTK_SIGNAL_FUNC(color_okay), this);
  gtk_signal_connect(GTK_OBJECT(colorsel->cancel_button), "clicked",
        GTK_SIGNAL_FUNC(color_cancel), this);
          // Set delete handler.
  gtk_signal_connect(GTK_OBJECT(colorsel), "delete_event",
        GTK_SIGNAL_FUNC(color_closed), this);
          // Get color.
  guint32 c = palettes[cur_pal]->colors[selected];
  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));
  }

/*
 *  Configure the viewing window.
 */

gint Palette_edit::configure
  (
  GtkWidget *widget,    // The view window.
  GdkEventConfigure *event,
  gpointer data     // ->Palette_edit
  )
  {
  Palette_edit *paled = (Palette_edit *) data;
  if (!paled->width)    // First time?
    {
    paled->drawgc = gdk_gc_new(widget->window);
          // Foreground = yellow.
    gdk_rgb_gc_set_foreground(paled->drawgc,
              (255<<16) + (255<<8));
    }
  paled->render();
  return (TRUE);
  }

/*
 *  Handle an expose event.
 */

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

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

gint Palette_edit::mouse_press
  (
  GtkWidget *widget,    // The view window.
  GdkEventButton *event,
  gpointer data     // ->Palette_edit.
  )
  {
  Palette_edit *paled = (Palette_edit *) data;

    if (event->button == 4 || event->button == 5) // mouse wheel
        return (TRUE);

  if (paled->colorsel)
    return (TRUE);    // Already editing a color.
  int old_selected = paled->selected;
  int width = paled->width, height = paled->height;
  int eventx = (int) event->x, eventy = (int) event->y;
          // Figure cell size.
  int eachw = width/16, eachh = height/16;
          // Figure extra pixels.
  int extraw = width%16, extrah = height%16;
  int extrax = extraw*(eachw + 1);// Total length of extra-sized boxes.
  int extray = extrah*(eachh + 1);
  int selx, sely;     // Gets box indices.
  if (eventx < extrax)
    selx = eventx/(eachw + 1);
  else
    selx = extraw + (eventx - extrax)/eachw;
  if (eventy < extray)
    sely = eventy/(eachh + 1);
  else
    sely = extrah + (eventy - extray)/eachh;
  paled->selected = sely*16 + selx;
  if (paled->selected == old_selected)
    {     // Same square.  Check for dbl-click.
    if (((GdkEvent *) event)->type == GDK_2BUTTON_PRESS)
      paled->double_clicked();
    }
  else
    {
    paled->render();
    paled->show();
    }
  if (event->button == 3)
    gtk_menu_popup(GTK_MENU(paled->create_popup()), 
        0, 0, 0, 0, event->button, event->time);
  return (TRUE);
  }

/*
 *  Someone wants the dragged shape.
 */

void Palette_edit::drag_data_get
  (
  GtkWidget *widget,    // The view window.
  GdkDragContext *context,
  GtkSelectionData *seldata,  // Fill this in.
  guint info,
  guint time,
  gpointer data     // ->Palette_edit.
  )
  {
  cout << "In DRAG_DATA_GET" << endl;
  Palette_edit *paled = (Palette_edit *) data;
#if 0
  if (paled->selected < 0 || info != U7_TARGET_SHAPEID)
    return;     // Not sure about this.
  guchar buf[30];
  int file = U7_SHAPE_SHAPES; // +++++For now.
  Shape_info& shinfo = paled->info[paled->selected];
  int len = Store_u7_shapeid(buf, file, shinfo.shapenum, 
              shinfo.framenum);
  cout << "Setting selection data (" << shinfo.shapenum <<
      '/' << shinfo.framenum << ')' << endl;
          // 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_SHAPEID_NAME, 0),
                                        8, buf, len);
#endif
  }

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

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

/*
 *  Beginning of a drag.
 */

gint Palette_edit::drag_begin
  (
  GtkWidget *widget,    // The view window.
  GdkDragContext *context,
  gpointer data     // ->Palette_edit.
  )
  {
  cout << "In DRAG_BEGIN" << endl;
  Palette_edit *paled = (Palette_edit *) data;
  // Maybe someday.
  return TRUE;
  }

/*
 *  Handle a change to the 'Palette #' spin button.
 */

void Palette_edit::palnum_changed
  (
  GtkAdjustment *adj,   // The adjustment.
  gpointer data     // ->Shape_chooser.
  )
  {
  Palette_edit *ed = (Palette_edit *) data;
  gint newnum = (gint) adj->value;
  ed->show_palette(newnum);
  ed->render();
  ed->show();
  ed->enable_controls();
  }

/*
 *  Callbacks for buttons:
 */
void
on_exportbtn_clicked                   (GtkButton       *button,
                                        gpointer         user_data)
{
  GtkFileSelection *fsel = Create_file_selection(
    "Export palette to text format", 
      (File_sel_okay_fun) Palette_edit::export_palette, 
              user_data);
  gtk_widget_show(GTK_WIDGET(fsel));
}

void
on_importbtn_clicked                   (GtkButton       *button,
                                        gpointer         user_data)
{
  GtkFileSelection *fsel = Create_file_selection(
    "Import palette from text format", 
      (File_sel_okay_fun) Palette_edit::import_palette, 
              user_data);
  gtk_widget_show(GTK_WIDGET(fsel));
}

void
on_insert_btn_clicked                  (GtkButton       *button,
                                        gpointer         user_data)
{
  Palette_edit *ed = (Palette_edit *) user_data;
  ed->add_palette();
}
void
on_remove_btn_clicked                  (GtkButton       *button,
                                        gpointer         user_data)
{
  Palette_edit *ed = (Palette_edit *) user_data;
  ed->remove_palette();
}
void
on_up_btn_clicked                      (GtkButton       *button,
                                        gpointer         user_data)
{
  Palette_edit *ed = (Palette_edit *) user_data;
  ed->move_palette(true);
}
void
on_down_btn_clicked                  (GtkButton       *button,
                                        gpointer         user_data)
{
  Palette_edit *ed = (Palette_edit *) user_data;
  ed->move_palette(false);
}

/*
 *  Create box with 'Palette #', 'Import', 'Move' controls.
 */

GtkWidget *Palette_edit::create_controls
  (
  )
  {
          // Create main box.
  GtkWidget *topframe = gtk_frame_new (NULL);
  gtk_widget_show(topframe);
  GtkWidget *vbox = gtk_vbox_new(FALSE, 0);
  gtk_widget_show(vbox);
  gtk_container_add (GTK_CONTAINER (topframe), vbox);

  GtkWidget *hbox0 = gtk_hbox_new(FALSE, 0);
  gtk_widget_show(hbox0);
  gtk_box_pack_start(GTK_BOX(vbox), hbox0, TRUE, TRUE, 2);
  /*
   *  The 'Edit' controls.
   */
  GtkWidget *frame = gtk_frame_new ("Edit");
  gtk_widget_show(frame);
  gtk_box_pack_start (GTK_BOX (hbox0), frame, FALSE, FALSE, 2);
  GtkWidget *hbuttonbox = gtk_hbutton_box_new ();
  gtk_widget_show (hbuttonbox);
  gtk_container_add (GTK_CONTAINER (frame), hbuttonbox);
  gtk_button_box_set_layout (GTK_BUTTON_BOX (hbuttonbox), 
              GTK_BUTTONBOX_START);
  gtk_button_box_set_spacing (GTK_BUTTON_BOX (hbuttonbox), 0);

  insert_btn = gtk_button_new_with_label ("New");
  gtk_widget_show (insert_btn);
  gtk_container_add (GTK_CONTAINER (hbuttonbox), insert_btn);
  GTK_WIDGET_SET_FLAGS (insert_btn, GTK_CAN_DEFAULT);

  remove_btn = gtk_button_new_with_label ("Remove");
  gtk_widget_show (remove_btn);
  gtk_container_add (GTK_CONTAINER (hbuttonbox), remove_btn);
  GTK_WIDGET_SET_FLAGS (remove_btn, GTK_CAN_DEFAULT);
  gtk_signal_connect (GTK_OBJECT (insert_btn), "clicked",
      GTK_SIGNAL_FUNC (on_insert_btn_clicked),
      this);
  gtk_signal_connect (GTK_OBJECT (remove_btn), "clicked",
      GTK_SIGNAL_FUNC (on_remove_btn_clicked),
      this);
  /*
   *  The 'Move' controls.
   */
  frame = gtk_frame_new ("Move");
  gtk_widget_show(frame);
  gtk_box_pack_start (GTK_BOX (hbox0), frame, FALSE, FALSE, 2);
  GtkWidget *bbox = gtk_hbox_new(TRUE, 0);
  gtk_widget_show(bbox);
  gtk_container_add(GTK_CONTAINER (frame), bbox);
  down_btn = gtk_button_new();
  gtk_widget_show (down_btn);
  gtk_box_pack_start (GTK_BOX (bbox), down_btn, FALSE, FALSE, 0);
  GTK_WIDGET_SET_FLAGS (down_btn, GTK_CAN_DEFAULT);
  GtkWidget *arrow = gtk_arrow_new(GTK_ARROW_DOWN, GTK_SHADOW_OUT);
  gtk_widget_show(arrow);
  gtk_container_add(GTK_CONTAINER(down_btn), arrow);

  up_btn = gtk_button_new();
  gtk_widget_show (up_btn);
  gtk_box_pack_start (GTK_BOX (bbox), up_btn, FALSE, FALSE, 0);
  GTK_WIDGET_SET_FLAGS (up_btn, GTK_CAN_DEFAULT);
  arrow = gtk_arrow_new(GTK_ARROW_UP, GTK_SHADOW_OUT);
  gtk_widget_show(arrow);
  gtk_container_add(GTK_CONTAINER(up_btn), arrow);
  gtk_signal_connect (GTK_OBJECT (down_btn), "clicked",
      GTK_SIGNAL_FUNC (on_down_btn_clicked),
      this);
  gtk_signal_connect (GTK_OBJECT (up_btn), "clicked",
      GTK_SIGNAL_FUNC (on_up_btn_clicked),
      this);
  /*
   *  The 'File' controls.
   */
  frame = gtk_frame_new ("File");
  gtk_widget_show(frame);
  gtk_box_pack_start (GTK_BOX (hbox0), frame, FALSE, FALSE, 2);
  hbuttonbox = gtk_hbutton_box_new ();
  gtk_widget_show (hbuttonbox);
  gtk_container_add (GTK_CONTAINER (frame), hbuttonbox);
  gtk_button_box_set_layout (GTK_BUTTON_BOX (hbuttonbox), 
              GTK_BUTTONBOX_START);
  gtk_button_box_set_spacing (GTK_BUTTON_BOX (hbuttonbox), 0);

  GtkWidget *importbtn = gtk_button_new_with_label ("Import");
  gtk_widget_show (importbtn);
  gtk_container_add (GTK_CONTAINER (hbuttonbox), importbtn);
  GTK_WIDGET_SET_FLAGS (importbtn, GTK_CAN_DEFAULT);

  GtkWidget *exportbtn = gtk_button_new_with_label ("Export");
  gtk_widget_show (exportbtn);
  gtk_container_add (GTK_CONTAINER (hbuttonbox), exportbtn);
  GTK_WIDGET_SET_FLAGS (exportbtn, GTK_CAN_DEFAULT);
  gtk_signal_connect (GTK_OBJECT (importbtn), "clicked",
      GTK_SIGNAL_FUNC (on_importbtn_clicked),
      this);
  gtk_signal_connect (GTK_OBJECT (exportbtn), "clicked",
      GTK_SIGNAL_FUNC (on_exportbtn_clicked),
      this);
  return topframe;
  }

/*
 *  Enable/disable controls after changes.
 */

void Palette_edit::enable_controls
  (
  )
  {
          // Can't delete last one.
  gtk_widget_set_sensitive(remove_btn, cur_pal >= 0 &&
          palettes.size() > 1);
  if (cur_pal == -1)    // No palette?
    {
    gtk_widget_set_sensitive(down_btn, false);
    gtk_widget_set_sensitive(up_btn, false);
    gtk_widget_set_sensitive(remove_btn, false);
    }
  else
    {
    gtk_widget_set_sensitive(down_btn,
          cur_pal < palettes.size() - 1);
    gtk_widget_set_sensitive(up_btn, cur_pal > 0);
    gtk_widget_set_sensitive(remove_btn, palettes.size() > 1);
    }
  }

/*
 *  Set up box.
 */

void Palette_edit::setup
  (
  )
  {
          // Put things in a vert. box.
  GtkWidget *vbox = gtk_vbox_new(FALSE, 0);
  gtk_widget_show(vbox);
  set_widget(vbox);
          // 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(vbox), frame, TRUE, TRUE, 0);
  draw = gtk_drawing_area_new();  // Create drawing area window.
//  gtk_drawing_area_size(GTK_DRAWING_AREA(draw), w, h);
          // Indicate the events we want.
  gtk_widget_set_events(draw, GDK_EXPOSURE_MASK | GDK_BUTTON_PRESS_MASK
    | GDK_POINTER_MOTION_HINT_MASK |
    GDK_BUTTON1_MOTION_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);
          // Set mouse click handler.
  gtk_signal_connect(GTK_OBJECT(draw), "button_press_event",
        GTK_SIGNAL_FUNC(mouse_press), this);
          // Mouse motion.
  gtk_signal_connect(GTK_OBJECT(draw), "drag_begin",
        GTK_SIGNAL_FUNC(drag_begin), this);
  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_widget_show(draw);
          // At bottom, a status bar.
  sbar = gtk_statusbar_new();
  sbar_sel = gtk_statusbar_get_context_id(GTK_STATUSBAR(sbar),
              "selection");
          // At the bottom, status bar & frame:
  GtkWidget *hbox1 = gtk_hbox_new(FALSE, 0);
  gtk_box_pack_start(GTK_BOX(vbox), hbox1, FALSE, FALSE, 0);
  gtk_widget_show(hbox1);
  gtk_box_pack_start(GTK_BOX(hbox1), sbar, TRUE, TRUE, 0);
          // Palette # to right of sbar.
  GtkWidget *label = gtk_label_new("Palette #:");
  gtk_box_pack_start(GTK_BOX(hbox1), label, FALSE, FALSE, 4);
  gtk_widget_show(label);
          // A spin button for palette#.
  palnum_adj = GTK_ADJUSTMENT(gtk_adjustment_new(0, 0, 
        palettes.size() - 1, 1,
        2, 2));
  pspin = gtk_spin_button_new(palnum_adj, 1, 0);
  gtk_signal_connect(GTK_OBJECT(palnum_adj), "value_changed",
          GTK_SIGNAL_FUNC(palnum_changed), this);
  gtk_box_pack_start(GTK_BOX(hbox1), pspin, FALSE, FALSE, 0);
  gtk_widget_show(pspin);

          // Add edit controls to bottom.
  gtk_box_pack_start(GTK_BOX(vbox), create_controls(), FALSE, FALSE, 0);
  gtk_widget_show(sbar);
  enable_controls();
  }

/*
 *  Create/add a new palette.
 */

void Palette_edit::new_palette
  (
  )
  {
  guint32 colors[256];    // R, G, B, then all black.
  memset(&colors[0], 0, sizeof(colors));
  colors[0] = 255<<16;
  colors[1] = 255<<8;
  colors[2] = 255;
  GdkRgbCmap *newpal = gdk_rgb_cmap_new(colors, 256);
  int index = palettes.size();  // Index of new palette.
  palettes.push_back(newpal);
  update_flex(index);   // Add to file.
  }

/*
 *  Update palette entry in flex file.
 */

void Palette_edit::update_flex
  (
  int pnum      // Palette # to send to file.
  )
  {
  unsigned char *buf = new unsigned char[3*256];
  Write_palette(buf, palettes[pnum]);
          // Update or append file data.
  flex_info->set(pnum, (char *) buf, 3*256);
  flex_info->set_modified();
  }

/*
 *  Create the list for a single palette.
 */

Palette_edit::Palette_edit
  (
  Flex_file_info *flinfo    // Flex-file info.
  ) : Object_browser(0, flinfo),
    flex_info(flinfo), image(0), width(0), height(0),
    colorsel(0), cur_pal(0)
  {
  load();       // Load from file.
  setup();
  }

/*
 *  Delete.
 */

Palette_edit::~Palette_edit
  (
  )
  {
  for (vector<GdkRgbCmap*>::iterator it = palettes.begin();
          it != palettes.end(); ++it)
    gdk_rgb_cmap_free(*it);
  gtk_widget_destroy(get_widget());
  delete image;
  }

/*
 *  Get i'th palette.
 */

void Palette_edit::show_palette
  (
  int palnum
  )
  {
  cur_pal = palnum;
  }

/*
 *  Unselect.
 */

void Palette_edit::unselect
  (
  bool need_render      // 1 to render and show.
  )
  {
  if (selected >= 0)
    {
    selected = -1;
    if (need_render)
      {
      render();
      show();
      }
    }
  }

/*
 *  Move a palette within the list.
 */

void Palette_edit::move_palette
  (
  bool up
  )
  {
  if (cur_pal < 0)
    return;
  GdkRgbCmap *tmp;
  if (up)
    {
    if (cur_pal > 0)
      {
      tmp = palettes[cur_pal - 1];
      palettes[cur_pal - 1] = palettes[cur_pal];
      palettes[cur_pal] = tmp;
      cur_pal--;
      flex_info->swap(cur_pal);// Update flex-file list.
      }
    }
  else
    {
    if (cur_pal < palettes.size() - 1)
      {
      tmp = palettes[cur_pal + 1];
      palettes[cur_pal + 1] = palettes[cur_pal];
      palettes[cur_pal] = tmp;
      flex_info->swap(cur_pal);// Update flex-file list.
      cur_pal++;
      }
    }
  flex_info->set_modified();
  gtk_spin_button_set_value(GTK_SPIN_BUTTON(pspin), cur_pal);
  }

/*
 *  Update upper bound of a range widget.
 */

void Update_range_upper
  (
  GtkAdjustment *adj,
  int new_upper
  )
  {
  adj->upper = new_upper;
  gtk_signal_emit_by_name(GTK_OBJECT(adj), "changed");
  }

/*
 *  Add a new palette at the end of the list.
 */

void Palette_edit::add_palette
  (
  )
  {
  new_palette();
  cur_pal = palettes.size() - 1;  // Set to display new palette.
  Update_range_upper(palnum_adj, palettes.size() - 1);
          // This will update the display:
  gtk_spin_button_set_value(GTK_SPIN_BUTTON(pspin), cur_pal);
  }

/*
 *  Remove the current palette.
 */

void Palette_edit::remove_palette
  (
  )
  {
          // Don't delete the last one.
  if (cur_pal < 0 || palettes.size() < 2)
    return;
  if (Prompt(
    "Do you really want to delete the palette you're viewing?",
              "Yes", "No") != 0)
    return;
  gdk_rgb_cmap_free(palettes[cur_pal]);
  palettes.erase(palettes.begin() + cur_pal);
  flex_info->remove(cur_pal);
  flex_info->set_modified();
  if (cur_pal >= palettes.size())
    cur_pal = palettes.size() - 1;
  Update_range_upper(palnum_adj, palettes.size() - 1);
          // This will update the display:
  gtk_spin_button_set_value(GTK_SPIN_BUTTON(pspin), cur_pal);
  render();     // Cur_pal may not have changed.
  show();
  }

/*
 *  Export current palette.
 */

void Palette_edit::export_palette
  (
  char *fname,
  gpointer user_data
  )
  {
  Palette_edit *ed = (Palette_edit *) user_data;
  if (U7exists(fname))
    {
    char *msg = g_strdup_printf(
      "'%s' already exists.  Overwrite?", fname);
    int answer = Prompt(msg, "Yes", "No");
    g_free(msg);
    if (answer != 0)
      return;
    }
          // Write out current palette.
  GdkRgbCmap *pal = ed->palettes[ed->cur_pal];
  ofstream out(fname);    // OKAY that it's a 'text' file.
  out << "Palette from ExultStudio" << endl;
  int i;        // Skip 0's at end.
  for (i = 255; i > 0; i--)
    if (pal->colors[i] != 0)
      break;
  int last_color = i;
  for (i = 0; i <= last_color; i++)
    {
    int r = (pal->colors[i]>>16)&255,
        g = (pal->colors[i]>>8)&255,
        b = pal->colors[i]&255;
    out << setw(3) << r << ' ' << setw(3) << g << ' ' <<
            setw(3) << b << endl;
    }
  out.close();
  }

/*
 *  Import current palette.
 */

void Palette_edit::import_palette
  (
  char *fname,
  gpointer user_data
  )
  {
  Palette_edit *ed = (Palette_edit *) user_data;
  char *msg = g_strdup_printf(
      "Overwrite current palette from '%s'?", fname);
  int answer = Prompt(msg, "Yes", "No");
  g_free(msg);
  if (answer != 0)
    return;
          // Read in current palette.
  GdkRgbCmap *pal = ed->palettes[ed->cur_pal];
  ifstream in(fname);   // OKAY that it's a 'text' file.
  char buf[256];
  in.getline(buf, sizeof(buf)); // Skip 1st line.
  if (!in.good())
    {
    Alert("Error reading '%s'", fname);
    return;
    }
  int i = 0;      // Color #.
  while (i < 256 && !in.eof())
    {
    in.getline(buf, sizeof(buf));
    char *ptr = &buf[0];
          // Skip spaces.
    while (ptr < buf + sizeof(buf) && *ptr && isspace(*ptr))
      ptr++;
    if (*ptr == '#')
      continue; // Comment.
    int r, g, b;
    if (sscanf(buf, "%d %d %d", &r, &g, &b) == 3)
      pal->colors[i++] = (r<<16) + (g<<8) + b;
    }
  in.close();
          // Add to file.
  ed->update_flex(ed->cur_pal);
  ed->render();
  ed->show();
  }

---