gimp/app/palette.c

/* The GIMP -- an image manipulation program
 * Copyright (C) 1995 Spencer Kimball and Peter Mattis
 *
 * 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.
 */
#include "config.h"

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#ifdef HAVE_UNISTD_H
#include <unistd.h>
#endif
#ifdef HAVE_DIRENT_H
#include <sys/types.h>
#include <dirent.h>
#endif
#include <sys/stat.h>
#include <sys/types.h>
#include "appenv.h"
#include "buildmenu.h"
#include "colormaps.h"
#include "color_area.h"
#include "color_notebook.h"
#include "datafiles.h"
#include "devices.h"
#include "errors.h"
#include "gimpdnd.h"
#include "gimprc.h"
#include "gimpui.h"
#include "gradient_header.h"
#include "gradient.h"
#include "palette.h"
#include "palette_entries.h"
#include "session.h"
#include "palette_select.h"
#include "dialog_handler.h"

#include "libgimp/gimpintl.h"

#include "pixmaps/zoom_in.xpm"
#include "pixmaps/zoom_out.xpm"

#define ENTRY_WIDTH  12
#define ENTRY_HEIGHT 10
#define SPACING       1
#define COLUMNS      16
#define ROWS         11

#define PREVIEW_WIDTH ((ENTRY_WIDTH * COLUMNS) + (SPACING * (COLUMNS + 1)))
#define PREVIEW_HEIGHT ((ENTRY_HEIGHT * ROWS) + (SPACING * (ROWS + 1)))

#define PALETTE_EVENT_MASK GDK_EXPOSURE_MASK | GDK_BUTTON_PRESS_MASK | GDK_ENTER_NOTIFY_MASK

/* New palette code... */

#define IMPORT_PREVIEW_WIDTH 80
#define IMPORT_PREVIEW_HEIGHT 80
#define MAX_IMAGE_COLORS (10000*2)

typedef enum
{
  GRAD_IMPORT = 0,
  IMAGE_IMPORT = 1,
} ImportType;

typedef struct _ImportDialog ImportDialog;

struct _ImportDialog
{
  GtkWidget     *dialog;
  GtkWidget     *preview;
  GtkWidget     *entry;
  GtkWidget     *select_area;
  GtkWidget     *select;
  GtkWidget     *image_list;
  GtkWidget     *image_menu_item_image;
  GtkWidget     *image_menu_item_gradient;
  GtkWidget     *optionmenu1_menu;
  GtkWidget     *type_option;
  GtkWidget     *threshold_scale;
  GtkWidget     *threshold_text;
  GtkAdjustment *threshold;
  GtkAdjustment *sample;
  ImportType    import_type;
  GimpImage     *gimage;
};

typedef struct _PaletteDialog PaletteDialog;

struct _PaletteDialog
{
  GtkWidget *shell;
  GtkWidget *color_area;
  GtkWidget *scrolled_window;
  GtkWidget *color_name;
  GtkWidget *clist;
  GtkWidget *popup_menu;
  GtkWidget *popup_small_menu;
  ColorNotebookP color_notebook;
  gboolean color_notebook_active;
  PaletteEntriesP entries;
  PaletteEntryP color;
  GdkGC *gc;
  guint entry_sig_id;
  gfloat zoom_factor;  /* range from 0.1 to 4.0 */
  gfloat xzoom_factor;  
  guint last_width;
  gint columns;
  gint freeze_update;
  gint columns_valid;
};

/*  This one is called from palette_select.c  */
void  palette_clist_init(GtkWidget *clist, GtkWidget *shell, GdkGC *gc);

/*  Local function prototypes  */
static void  palette_entries_free (PaletteEntriesP);
static void  palette_entries_load (char *);
static void  palette_entry_free   (PaletteEntryP);
static void  palette_entries_save (PaletteEntriesP, char *);

PaletteDialog * create_palette_dialog (gboolean vert);

static void     palette_drag_color (GtkWidget *,
				    guchar *, guchar *, guchar *, gpointer);
static void     palette_drop_color (GtkWidget *,
				    guchar, guchar, guchar, gpointer);
static void     palette_draw_entries (PaletteDialog *palette, gint row_start,
				      gint column_highlight);
static void     redraw_palette       (PaletteDialog *palette);

static GSList * palette_entries_insert_list (GSList *list,
					     PaletteEntriesP entries, gint pos);
static void     palette_draw_small_preview  (GdkGC *gc, PaletteEntriesP p_entry);
static void     palette_scroll_clist_to_current (PaletteDialog *palette);
static void     palette_update_small_preview    (PaletteDialog *palette);
static void     palette_scroll_top_left         (PaletteDialog *palette);

static ImportDialog * palette_import_dialog (PaletteDialog *palette);
static void  palette_import_dialog_callback (GtkWidget *, gpointer);
static void  import_palette_create_from_image (GImage *gimage,
					       guchar *pname,
					       PaletteDialog *palette);

static void  palette_merge_dialog_callback (GtkWidget *, gpointer);


GSList                 *palette_entries_list = NULL;
static PaletteEntriesP  default_palette_entries = NULL;
static gint             num_palette_entries = 0;
static guchar           foreground[3] = { 0, 0, 0 };
static guchar           background[3] = { 255, 255, 255 };
static ImportDialog    *import_dialog = NULL;

PaletteDialog          *top_level_edit_palette = NULL;
PaletteDialog          *top_level_palette = NULL;

/*  dnd stuff  */
static GtkTargetEntry color_palette_target_table[] =
{
  GIMP_TARGET_COLOR
};
static guint n_color_palette_targets = (sizeof (color_palette_target_table) /
					sizeof (color_palette_target_table[0]));

static void
palette_entries_free (PaletteEntriesP entries)
{
  PaletteEntryP entry;
  GSList * list;

  list = entries->colors;
  while (list)
    {
      entry = (PaletteEntryP) list->data;
      palette_entry_free (entry);
      list = list->next;
    }

  g_free (entries->name);
  if (entries->filename)
    g_free (entries->filename);
  g_free (entries);
}

static void
palette_entries_delete (gchar *filename)
{
  if (filename)
    unlink (filename);
}

void
palettes_init (gint no_data)
{
  palette_init_palettes (no_data);
}

void
palette_free_palettes (void)
{
  GSList *list;
  PaletteEntriesP entries;

  list = palette_entries_list;

  while (list)
    {
      entries = (PaletteEntriesP) list->data;

      /*  If the palette has been changed, save it, if possible  */
      if (entries->changed)
	/*  save the palette  */
	palette_entries_save (entries, entries->filename);

      palette_entries_free (entries);
      list = g_slist_next (list);
    }
  g_slist_free (palette_entries_list);

  num_palette_entries = 0;
  palette_entries_list = NULL;
}


void
palettes_free ()
{
  palette_free_palettes ();
}

void
palette_get_foreground (guchar *r,
			guchar *g,
			guchar *b)
{
  *r = foreground[0];
  *g = foreground[1];
  *b = foreground[2];
}

void
palette_get_background (guchar *r,
			guchar *g,
			guchar *b)
{
  *r = background[0];
  *g = background[1];
  *b = background[2];
}

void
palette_set_foreground (gint r,
			gint g,
			gint b)
{
  guchar rr, gg, bb;

  /*  Foreground  */
  foreground[0] = r;
  foreground[1] = g;
  foreground[2] = b;

  palette_get_foreground (&rr, &gg, &bb);
  if (no_interface == FALSE)
    {
      foreground_pixel = get_color (rr, gg, bb);
      color_area_update ();
      device_status_update (current_device);
    }
}

void
palette_set_background (gint r,
			gint g,
			gint b)
{
  guchar rr, gg, bb;

  /*  Background  */
  background[0] = r;
  background[1] = g;
  background[2] = b;

  palette_get_background (&rr, &gg, &bb);
  if (no_interface == FALSE)
    {
      background_pixel = get_color (rr, gg, bb);
      color_area_update ();
    }
}

void
palette_set_default_colors (void)
{
  palette_set_foreground (0, 0, 0);
  palette_set_background (255, 255, 255);
}


void 
palette_swap_colors (void)
{
  guchar fg_r, fg_g, fg_b;
  guchar bg_r, bg_g, bg_b;
  
  palette_get_foreground (&fg_r, &fg_g, &fg_b);
  palette_get_background (&bg_r, &bg_g, &bg_b);
  
  palette_set_foreground (bg_r, bg_g, bg_b);
  palette_set_background (fg_r, fg_g, fg_b);
}

void
palette_init_palettes (gint no_data)
{
  if (!no_data)
    datafiles_read_directories (palette_path, palette_entries_load, 0);

}

static void
palette_select2_set_text_all (PaletteEntriesP entries)
{
  gint pos = 0;
  gchar *num_buf;
  GSList *plist;
  PaletteDialog *pp; 
  PaletteEntriesP p_entries = NULL;
  gchar * num_copy;

  plist = palette_entries_list;
  
  while (plist)
    {
      p_entries = (PaletteEntriesP) plist->data;
      plist = g_slist_next (plist);
      
      if (p_entries == entries)
	    break;
      pos++;
    }

  if(p_entries == NULL)
    return; /* This is actually and error */

  num_buf = g_strdup_printf ("%d", p_entries->n_colors);;

  num_copy = g_strdup (num_buf);

  pp = top_level_palette;
  gtk_clist_set_text (GTK_CLIST (pp->clist), pos, 1, num_copy);
  redraw_palette (pp);
}

static void
palette_select2_refresh_all ()
{
  PaletteDialog *pp; 

  if(!top_level_palette)
    return;

  pp = top_level_palette;
  gtk_clist_freeze (GTK_CLIST(pp->clist));
  gtk_clist_clear (GTK_CLIST(pp->clist));
  palette_clist_init (pp->clist, pp->shell, pp->gc);
  gtk_clist_thaw (GTK_CLIST (pp->clist));
  pp->entries = palette_entries_list->data;
  redraw_palette (pp);
  palette_scroll_clist_to_current (pp);
}

static void
palette_select2_clist_insert_all (PaletteEntriesP p_entries)
{
  PaletteEntriesP chk_entries;
  PaletteDialog *pp; 
  GSList *plist;
  gint pos = 0;

  plist = palette_entries_list;
  
  while (plist)
    {
      chk_entries = (PaletteEntriesP) plist->data;
      plist = g_slist_next (plist);
      
      /*  to make sure we get something!  */
      if (chk_entries == NULL)
	{
	  return;
	}
      if (strcmp (p_entries->name, chk_entries->name) == 0)
	break;
      pos++;
    }

  pp = top_level_palette;
  gtk_clist_freeze (GTK_CLIST (pp->clist));
  palette_insert_clist (pp->clist, pp->shell, pp->gc, p_entries, pos);
  gtk_clist_thaw (GTK_CLIST (pp->clist));

/*   if(gradient_select_dialog) */
/*     { */
/*       gtk_clist_set_text(GTK_CLIST(gradient_select_dialog->clist),n,1,grad->name);   */
/*     } */
}

static void
palette_save_palettes ()
{
  GSList *list;
  PaletteEntriesP entries;

  list = palette_entries_list;

  while (list)
    {
      entries = (PaletteEntriesP) list->data;

      /*  If the palette has been changed, save it, if possible  */
      if (entries->changed)
	/*  save the palette  */
	palette_entries_save (entries, entries->filename);

      list = g_slist_next (list);
    }
}

static void
palette_save_palettes_callback (GtkWidget *widget,
				gpointer   data)
{
  palette_save_palettes ();
}

static void
palette_entry_free (PaletteEntryP entry)
{
  if (entry->name)
    g_free (entry->name);

  g_free (entry);
}

void
palette_free ()
{
  if (top_level_edit_palette) 
    { 
      if(import_dialog)
	{
	  gtk_widget_destroy (import_dialog->dialog);
	  g_free (import_dialog);
	  import_dialog = NULL;
	}

      gdk_gc_destroy (top_level_edit_palette->gc); 
      
      if (top_level_edit_palette->color_notebook) 
	color_notebook_free (top_level_edit_palette->color_notebook); 
      
      g_free (top_level_edit_palette); 
      
      top_level_edit_palette = NULL; 
    }

  if (top_level_palette)
    {
      gdk_gc_destroy (top_level_palette->gc); 
      session_get_window_info (top_level_palette->shell, &palette_session_info);  
      top_level_palette = NULL;
    }
}

static void
palette_entries_save (PaletteEntriesP  palette,
		      gchar           *filename)
{
  FILE * fp;
  GSList * list;
  PaletteEntryP entry;

  if (! filename)
    return;

  /*  Open the requested file  */
  if (! (fp = fopen (filename, "w")))
    {
      g_message (_("can't save palette \"%s\"\n"), filename);
      return;
    }

  fprintf (fp, "GIMP Palette\n");
  fprintf (fp, "# %s -- GIMP Palette file\n", palette->name);

  list = palette->colors;
  while (list)
    {
      entry = (PaletteEntryP) list->data;
      fprintf (fp, "%d %d %d\t%s\n", entry->color[0], entry->color[1],
	       entry->color[2], entry->name);
      list = g_slist_next (list);
    }

  /*  Clean up  */
  fclose (fp);
}

static PaletteEntryP
palette_add_entry (PaletteEntriesP  entries,
		   gchar           *name,
		   gint             r,
		   gint             g,
		   gint             b)
{
  PaletteEntryP entry;

  if (entries)
    {
      entry = g_new (_PaletteEntry, 1);

      entry->color[0] = r;
      entry->color[1] = g;
      entry->color[2] = b;
      if (name)
	entry->name = g_strdup (name);
      else
	entry->name = g_strdup (_("Untitled"));
      entry->position = entries->n_colors;

      entries->colors = g_slist_append (entries->colors, entry);
      entries->n_colors += 1;

      entries->changed = 1;
      
      return entry;
    }

  return NULL;
}

static void
palette_change_color (gint r,
		      gint g,
		      gint b,
		      gint state)
{
  if (top_level_edit_palette && top_level_edit_palette->entries) 
    { 
      switch (state) 
 	{ 
 	case COLOR_NEW: 
 	  top_level_edit_palette->color =
	    palette_add_entry (top_level_edit_palette->entries,
			       _("Untitled"), r, g, b); 
	  
	  palette_update_small_preview (top_level_edit_palette);
	  redraw_palette (top_level_edit_palette);
 	  break; 
	  
 	case COLOR_UPDATE_NEW: 
 	  top_level_edit_palette->color->color[0] = r; 
 	  top_level_edit_palette->color->color[1] = g; 
 	  top_level_edit_palette->color->color[2] = b; 
	  palette_update_small_preview (top_level_edit_palette);
	  redraw_palette (top_level_edit_palette);
 	  break; 
	  
 	default: 
 	  break; 
 	} 
    } 
  
  if (active_color == FOREGROUND)
    palette_set_foreground (r, g, b);
  else if (active_color == BACKGROUND)
    palette_set_background (r, g, b);
}

void
palette_set_active_color (gint r,
			  gint g,
			  gint b,
			  gint state)
{
  palette_change_color (r, g, b, state);
}

static void
palette_entries_load (gchar *filename)
{
  PaletteEntriesP entries;
  PaletteEntriesP p_entries = NULL;
  gchar   str[512];
  gchar  *tok;
  FILE   *fp;
  gint    r, g, b;
  gint    linenum;
  GSList *list;
  gint    pos = 0;

  r = g = b = 0;

  entries = g_new (_PaletteEntries, 1);

  entries->filename = g_strdup (filename);
  entries->name = g_strdup (g_basename (filename));
  entries->colors = NULL;
  entries->n_colors = 0;
  entries->pixmap = NULL;

  /*  Open the requested file  */
  if (!(fp = fopen (filename, "r")))
    {
      palette_entries_free (entries);
      g_warning ("failed to open palette file %s: can't happen?", filename);
      return;
    }

  linenum = 0;

  fread (str, 13, 1, fp);
  str[13] = '\0';
  linenum++;
  if (strcmp (str, "GIMP Palette\n"))
    {
      /* bad magic, but maybe it has \r\n at the end of lines? */
      if (!strcmp (str, "GIMP Palette\r"))
	g_message (_("Loading palette %s:\n"
		     "Corrupt palette:\n"
		     "missing magic header\n"
		     "Does this file need converting from DOS?"), filename);
      else
	g_message (_("Loading palette %s:\n"
		     "Corrupt palette: missing magic header"), filename);
      fclose (fp);
      palette_entries_free (entries);
      return;
    }

  while (!feof (fp))
    {
      if (!fgets (str, 512, fp))
      {
	if (feof (fp))
	  break;
	g_message (_("Loading palette %s (line %d):\nRead error"),
		   filename, linenum);
	fclose (fp);
	palette_entries_free (entries);
	return;
      }

      linenum++;

      if (str[0] != '#')
	{
	  tok = strtok (str, " \t");
	  if (tok)
	    r = atoi (tok);
	  else
	    g_message (_("Loading palette %s (line %d):\n"
			 "Missing RED component"), filename, linenum);
	    /* maybe we should just abort? */

	  tok = strtok (NULL, " \t");
	  if (tok)
	    g = atoi (tok);
	  else
	    g_message (_("Loading palette %s (line %d):\n"
			 "Missing GREEN component"), filename, linenum);
	  
	  tok = strtok (NULL, " \t");
	  if (tok)
	    b = atoi (tok);
	  else
	    g_message (_("Loading palette %s (line %d):\n"
			 "Missing BLUE component"), filename, linenum);

	  /* optional name */
	  tok = strtok (NULL, "\n");

	  if (r < 0 || r > 255 ||
	      g < 0 || g > 255 ||
	      b < 0 || b > 255)
	    g_message (_("Loading palette %s (line %d):\n"
			 "RGB value out of range"), filename, linenum);

	  palette_add_entry (entries, tok, r, g, b);
	}
    }

  /*  Clean up  */

  fclose (fp);
  entries->changed = 0;

  list = palette_entries_list;

  while (list)
    {
      p_entries = (PaletteEntriesP) list->data;
      list = g_slist_next (list);
      
      /*  to make sure we get something!  */
      if (p_entries == NULL)
	{
	  p_entries = default_palette_entries;
	}
      if (strcmp (p_entries->name, entries->name) > 0)
	break;
      pos++;
    }
  
  palette_entries_list = palette_entries_insert_list (palette_entries_list, entries, pos);

  /* Check if the current palette is the default one */
  if (strcmp (default_palette, g_basename (filename)) == 0)
    default_palette_entries = entries;
}

static PaletteDialog *
new_top_palette (gboolean vert)
{
  PaletteDialog *p;

  p = create_palette_dialog (vert);
  palette_clist_init (p->clist, p->shell, p->gc);

  return p;
}

void 
palette_select_palette_init (void)
{
  /* Load them if they are not already loaded */
  if(top_level_edit_palette == NULL)
    {
      top_level_edit_palette = new_top_palette (FALSE);
    }
}

void 
palette_create (void)
{
  if (top_level_palette == NULL)
    {
      top_level_palette = new_top_palette (TRUE);
      /* top_level_palette = palette_new_selection(_("Palette"),NULL); */
      session_set_window_geometry (top_level_palette->shell,
				   &palette_session_info, TRUE);
      /* register this one only */
      dialog_register (top_level_palette->shell);

      gtk_widget_show (top_level_palette->shell);
      palette_scroll_clist_to_current (top_level_palette);
    }
  else
    {
      if (!GTK_WIDGET_VISIBLE (top_level_palette->shell))
	{
	  gtk_widget_show (top_level_palette->shell);
	}
      else
	{
	  gdk_window_raise (top_level_palette->shell->window);
	}
    }
}

void 
palette_create_edit (PaletteEntriesP entries)
{
  PaletteDialog *p;

  if (top_level_edit_palette == NULL)
    {
      p = new_top_palette (FALSE);

      gtk_widget_show(p->shell);
      
      palette_draw_entries(p,-1,-1);
      
      top_level_edit_palette = p;
    }
  else
    {
      if (!GTK_WIDGET_VISIBLE (top_level_edit_palette->shell))
	{
	  gtk_widget_show (top_level_edit_palette->shell);
	  palette_draw_entries (top_level_edit_palette, -1, -1);
	}
      else
	{
	  gdk_window_raise (top_level_edit_palette->shell->window);
	}
    }

  if(entries != NULL)
    {
      top_level_edit_palette->entries = entries;
      gtk_clist_unselect_all (GTK_CLIST (top_level_edit_palette->clist));
      palette_scroll_clist_to_current (top_level_edit_palette);
    }
}

static GSList *
palette_entries_insert_list (GSList          *list,
			     PaletteEntriesP  entries,
			     gint             pos)
{
  GSList *ret_list;

  /*  add it to the list  */
  num_palette_entries++;
  ret_list = g_slist_insert (list, (void *) entries, pos);

  return ret_list;
}

static void
palette_update_small_preview (PaletteDialog *palette)
{
  GSList *list;
  gint pos = 0;
  PaletteEntriesP p_entries = NULL;
  gchar *num_buf;

  list = palette_entries_list;
  
  pos = 0;
  
  while (list)
    {
      p_entries = (PaletteEntriesP) list->data;
      list = g_slist_next (list);
      
      /*  to make sure we get something!  */
      if (p_entries == NULL)
	{
	  p_entries = default_palette_entries;
	}
      if (p_entries == palette->entries)
	break;
      pos++;
    }
  
  num_buf = g_strdup_printf ("%d", p_entries->n_colors);
  palette_draw_small_preview (palette->gc, p_entries);
  gtk_clist_set_text (GTK_CLIST (palette->clist), pos, 1, num_buf);
}

static void
palette_delete_entry (GtkWidget *widget,
		      gpointer   data)
{
  PaletteEntryP entry;
  GSList *tmp_link;
  PaletteDialog *palette;
  gint pos = 0;

  palette = data;
  if (palette && palette->entries && palette->color)
    {
      entry = palette->color;
      palette->entries->colors = g_slist_remove (palette->entries->colors, entry);
      palette->entries->n_colors--;
      palette->entries->changed = 1;

      pos = entry->position;
      palette_entry_free (entry);

      tmp_link = g_slist_nth (palette->entries->colors, pos);

      if (tmp_link)
	{
	  palette->color = tmp_link->data;

	  while (tmp_link)
	    {
	      entry = tmp_link->data;
	      tmp_link = tmp_link->next;
	      entry->position = pos++;
	    }
	}
      else
	{
	  tmp_link = g_slist_nth (palette->entries->colors, pos - 1);
	  if (tmp_link)
	    palette->color = tmp_link->data;
	}

      if (palette->entries->n_colors == 0)
	palette->color = palette_add_entry (palette->entries, _("Black"), 0, 0, 0);
      palette_update_small_preview (palette);
      palette_select_set_text_all (palette->entries);
      palette_select2_set_text_all (palette->entries);
      redraw_palette (palette);
    }
}

static void
palette_new_callback (GtkWidget *widget,
		      gpointer   data)
{
  PaletteDialog *palette;
  char *num_buf;
  GSList *list;
  gint pos = 0;
  PaletteEntriesP p_entries = NULL;

  palette = data;
  if (palette && palette->entries)
    {
      if (active_color == FOREGROUND)
	palette->color =
	  palette_add_entry (palette->entries, _("Untitled"),
			     foreground[0], foreground[1], foreground[2]);
      else if (active_color == BACKGROUND)
	palette->color =
	  palette_add_entry (palette->entries, _("Untitled"),
			     background[0], background[1], background[2]);

      redraw_palette (palette);

      list = palette_entries_list;
      
      while (list)
	{
	  p_entries = (PaletteEntriesP) list->data;
	  list = g_slist_next (list);
	  
	  /*  to make sure we get something!  */
	  if (p_entries == NULL)
	    {
	      p_entries = default_palette_entries;
	    }
	  if (p_entries == palette->entries)
	    break;
	  pos++;
	}

      num_buf = g_strdup_printf ("%d", p_entries->n_colors);;
      palette_draw_small_preview (palette->gc, p_entries);
      gtk_clist_set_text (GTK_CLIST (palette->clist), pos, 1, num_buf);
      palette_select_set_text_all (palette->entries);
      palette_select2_set_text_all (palette->entries);
    }
}

static PaletteEntriesP
palette_create_entries (gpointer  data,
			gpointer  call_data)
{
  gchar *home;
  gchar *palette_name;
  gchar *local_path;
  gchar *first_token;
  gchar *token;
  gchar *path;
  PaletteEntriesP entries = NULL;
  PaletteDialog *palette;
  GSList *list;
  gint pos = 0;
  PaletteEntriesP p_entries = NULL;

  palette = data;

  palette_name = (char *) call_data;
  if (palette && palette_name)
    {
      entries = g_new (_PaletteEntries, 1);
      if (palette_path)
	{
	  /*  Get the first path specified in the palette path list  */
	  home = g_get_home_dir ();
	  local_path = g_strdup (palette_path);
	  first_token = local_path;
	  token = xstrsep (&first_token, G_SEARCHPATH_SEPARATOR_S);

	  if (token)
	    {
	      if (*token == '~')
		{
		  if (home)
		    path = g_strdup_printf ("%s%s", home, token + 1);
		  else
		    /* Just ignore the ~ if no HOME ??? */
		    path = g_strdup (token + 1);
		}
	      else
		{
		  path = g_strdup(token);
		}

	      entries->filename = g_strdup_printf ("%s" G_DIR_SEPARATOR_S "%s",
						   path, palette_name);

	      g_free (path);
	    }

	  g_free (local_path);
	}
      else
	entries->filename = NULL;

      entries->name = palette_name;  /*  don't need to copy because this memory is ours  */
      entries->colors = NULL;
      entries->n_colors = 0;
      entries->changed = 1;
      entries->pixmap = NULL;

      /* Add into the clist */

      list = palette_entries_list;
      
      while (list)
	{
	  p_entries = (PaletteEntriesP) list->data;
	  list = g_slist_next (list);
	  
	  /*  to make sure we get something!  */
	  if (p_entries == NULL)
	    {
	      p_entries = default_palette_entries;
	    }
	  if (strcmp(p_entries->name, entries->name) > 0)
	    break;
	  pos++;
	}

      palette_entries_list =
	palette_entries_insert_list (palette_entries_list, entries, pos);
      palette_insert_clist (palette->clist, palette->shell, palette->gc,
			    entries,pos);

      palette->entries = entries;

      palette_save_palettes ();
    }

  return entries;
}

static void
palette_add_entries_callback (GtkWidget *widget,
			      gpointer   data,
			      gpointer   call_data)
{
  PaletteEntriesP entries;

  entries = palette_create_entries (data, call_data);
  /* Update other selectors on screen */
  palette_select_clist_insert_all (entries);
  palette_select2_clist_insert_all (entries);
  palette_scroll_clist_to_current ((PaletteDialog *) data);
}

static void
palette_new_entries_callback (GtkWidget *widget,
			      gpointer   data)
{
  GtkWidget *qbox;

  qbox = gimp_query_string_box (_("New Palette"),
				gimp_standard_help_func,
				"dialogs/palette_editor/new_palette.html",
				_("Enter a name for new palette"),
				NULL,
				NULL, NULL,
				palette_add_entries_callback, data);
  gtk_widget_show (qbox);
}

static void
redraw_zoom (PaletteDialog *palette)
{
  if (palette->zoom_factor > 4.0)
    {
      palette->zoom_factor = 4.0;
    }
  else if (palette->zoom_factor < 0.1)
    {
      palette->zoom_factor = 0.1;
    }
  
  palette->columns = COLUMNS;
  palette->columns_valid = FALSE;
  redraw_palette (palette); 

  palette_scroll_top_left (palette);
}

static void
palette_zoomin (GtkWidget *widget,
		gpointer   data)
{
  PaletteDialog *palette = data;

  palette->zoom_factor += 0.1;
  redraw_zoom (palette);
}

static void
palette_zoomout (GtkWidget *widget,
		 gpointer   data)
{
  PaletteDialog *palette = data;

  palette->zoom_factor -= 0.1;
  redraw_zoom (palette);
}

static void 
palette_refresh (PaletteDialog *palette)
{
  if (palette)
    {
      if (default_palette_entries == palette->entries)
	default_palette_entries = NULL;
      palette->entries = NULL;

      /*  If a color selection dialog is up, hide it  */
      if (palette->color_notebook_active)
	{
	  palette->color_notebook_active = FALSE;
	  color_notebook_hide (palette->color_notebook);
	}
      palette_free_palettes ();   /*  free palettes, don't save any modified versions  */
      palette_init_palettes (FALSE);   /*  reload palettes  */

      gtk_clist_freeze (GTK_CLIST (palette->clist));
      gtk_clist_clear (GTK_CLIST (palette->clist));
      palette_clist_init (palette->clist, palette->shell, palette->gc);
      gtk_clist_thaw (GTK_CLIST (palette->clist));

      if (palette->entries == NULL)
	palette->entries = default_palette_entries;

      if(palette->entries == NULL && palette_entries_list)
	palette->entries = palette_entries_list->data;
      
      redraw_palette (palette);

      palette_scroll_clist_to_current (palette);

      palette_select_refresh_all ();
      palette_select2_refresh_all ();
    }
  else
    {
      palette_free_palettes (); 
      palette_init_palettes (FALSE);
    }
}

static void
palette_refresh_callback (GtkWidget *widget,
			  gpointer   data)
{
  palette_refresh (data);
}

/*****/
static void 
palette_draw_small_preview(GdkGC           *gc,
			   PaletteEntriesP  p_entry)
{
  guchar rgb_buf[SM_PREVIEW_WIDTH * SM_PREVIEW_HEIGHT * 3];
  GSList *tmp_link;
  gint index;
  PaletteEntryP entry;

  /*fill_clist_prev(p_entry,rgb_buf,48,16,0.0,1.0);*/
  memset (rgb_buf, 0x0, sizeof (rgb_buf));
  
  gdk_draw_rgb_image (p_entry->pixmap,
		      gc,
		      0,
		      0,
		      SM_PREVIEW_WIDTH,
		      SM_PREVIEW_HEIGHT,
		      GDK_RGB_DITHER_NORMAL,
		      rgb_buf,
		      SM_PREVIEW_WIDTH*3);
  
  tmp_link = p_entry->colors;
  index = 0;

  while (tmp_link)
    {
      guchar cell[3*3*3];
      gint loop;

      entry = tmp_link->data;
      tmp_link = tmp_link->next;
      
      for (loop = 0; loop < 27 ; loop+=3)
	{
	  cell[0+loop] = entry->color[0];
	  cell[1+loop] = entry->color[1];
	  cell[2+loop] = entry->color[2];
	}

      gdk_draw_rgb_image (p_entry->pixmap,
			  gc,
			  1+(index%((SM_PREVIEW_WIDTH-2)/3))*3,
			  1+(index/((SM_PREVIEW_WIDTH-2)/3))*3,
			  3,
			  3,
			  GDK_RGB_DITHER_NORMAL,
			  cell,
			  3);

      index++;
      if(index >= (((SM_PREVIEW_WIDTH-2)*(SM_PREVIEW_HEIGHT-2))/9))
	break;
    }
}


static void
palette_select_callback (gint                r,
			 gint                g,
			 gint                b,
			 ColorNotebookState  state,
			 void               *data)
{
  PaletteDialog *palette;
  guchar  *color;
  GSList  *list;
  gint pos = 0;
  PaletteEntriesP p_entries = NULL;
  
  palette = data;

  if (palette && palette->entries)
    {
      switch (state)
	{
	case COLOR_NOTEBOOK_UPDATE:
	  break;
	case COLOR_NOTEBOOK_OK:
	  if (palette->color)
	    {
	      color = palette->color->color;

	      color[0] = r;
	      color[1] = g;
	      color[2] = b;

	      /*  Update either foreground or background colors  */
	      if (active_color == FOREGROUND)
		palette_set_foreground (r, g, b);
	      else if (active_color == BACKGROUND)
		palette_set_background (r, g, b);
	  
	      palette_draw_entries (palette,
				    palette->color->position/(palette->columns),
				    palette->color->position%(palette->columns));
	      palette_draw_small_preview (palette->gc,palette->entries);

	      /* Add into the clist */
	      list = palette_entries_list;

	      while (list)
		{
		  p_entries = (PaletteEntriesP) list->data;
		  list = g_slist_next (list);

		  /*  to make sure we get something!  */
		  if (p_entries == NULL)
		    {
		      p_entries = default_palette_entries;
		    }
		  if (p_entries == palette->entries)
		    break;
		  pos++;
		}

	      gtk_clist_set_text (GTK_CLIST (palette->clist),
				  pos, 2, p_entries->name);
	      palette_select_set_text_all (palette->entries);
	      palette_select2_set_text_all (palette->entries);
	    }
	  /* Fallthrough */
	case COLOR_NOTEBOOK_CANCEL:
	  color_notebook_hide (palette->color_notebook);
	  palette->color_notebook_active = FALSE;
	}
    }
}

static void 
palette_scroll_clist_to_current (PaletteDialog *palette)
{
  GSList *list;
  gint pos = 0;
  PaletteEntriesP p_entries;

  if (palette && palette->entries)
    {
      list = palette_entries_list;
      
      while (list)
	{
	  p_entries = (PaletteEntriesP) list->data;
	  list = g_slist_next (list);
	  
	  if (p_entries == palette->entries)
	    break;
	  pos++;
	}

      gtk_clist_unselect_all (GTK_CLIST (palette->clist));
      gtk_clist_select_row (GTK_CLIST (palette->clist), pos, -1);
      gtk_clist_moveto (GTK_CLIST (palette->clist), pos, 0, 0.0, 0.0); 
    }
}

static void
palette_delete_entries_callback (GtkWidget *widget,
				 gpointer   data)
{
  PaletteDialog *palette;
  PaletteEntriesP entries;

  palette = data;
  if (palette && palette->entries)
    {
      entries = palette->entries;
      if (entries && entries->filename)
	palette_entries_delete (entries->filename);

      palette_entries_list = g_slist_remove (palette_entries_list, entries);

      palette_refresh (palette);
    }
}

static void
palette_close_callback (GtkWidget *widget,
			gpointer   data)
{
  PaletteDialog *palette;

  palette = data;
  if (palette)
    {
      if (palette->color_notebook_active)
	{
	  palette->color_notebook_active = FALSE;
	  color_notebook_hide (palette->color_notebook);
	}

      if(import_dialog)
	{
	  gtk_widget_destroy (import_dialog->dialog);
	  g_free (import_dialog);
	  import_dialog = NULL;
	}
      
      if (GTK_WIDGET_VISIBLE (palette->shell))
	gtk_widget_hide (palette->shell);
    }
}

static void
color_name_entry_changed (GtkWidget *widget,
			  gpointer   data)
{
  PaletteDialog *palette;

  palette = data;
  if (palette->color->name)
    g_free (palette->color->name);
  palette->entries->changed = 1;
  palette->color->name = 
    g_strdup (gtk_entry_get_text (GTK_ENTRY (palette->color_name)));
}


static void
palette_edit_callback (GtkWidget *widget,
		       gpointer   data)
{
  PaletteDialog *palette;
  guchar *color;

  palette = data;
  if (palette && palette->entries && palette->color)
    {
      color = palette->color->color;

      if (!palette->color_notebook)
	{
	  palette->color_notebook =
	    color_notebook_new (color[0], color[1], color[2],
				palette_select_callback, palette,
				FALSE);
	  palette->color_notebook_active = TRUE;
	}
      else
	{
	  if (!palette->color_notebook_active)
	    {
	      color_notebook_show (palette->color_notebook);
	      palette->color_notebook_active = TRUE;
	    }

	  color_notebook_set_color (palette->color_notebook,
				    color[0], color[1], color[2], 1);
	}
    }
}


static void
palette_popup_menu (PaletteDialog *palette)
{
  GtkWidget *menu;
  GtkWidget *menu_items;

  menu = gtk_menu_new ();
  menu_items = gtk_menu_item_new_with_label (_("Edit"));
  gtk_menu_append (GTK_MENU (menu), menu_items);

  gtk_signal_connect (GTK_OBJECT (menu_items), "activate", 
		      GTK_SIGNAL_FUNC (palette_edit_callback),
		      (gpointer) palette);
  gtk_widget_show (menu_items);

  menu_items = gtk_menu_item_new_with_label (_("New"));
  gtk_menu_append (GTK_MENU (menu), menu_items);
  gtk_signal_connect (GTK_OBJECT (menu_items), "activate", 
		      GTK_SIGNAL_FUNC (palette_new_callback),
		      (gpointer) palette);
  gtk_widget_show (menu_items);

  menu_items = gtk_menu_item_new_with_label (_("Delete"));
  gtk_signal_connect (GTK_OBJECT(menu_items), "activate", 
		      GTK_SIGNAL_FUNC (palette_delete_entry),
		      (gpointer) palette);
  gtk_menu_append (GTK_MENU (menu), menu_items);
  gtk_widget_show (menu_items);

  /* Do something interesting when the menuitem is selected */ 
  /*   gtk_signal_connect_object(GTK_OBJECT(menu_items), "activate", */
  /* 			    GTK_SIGNAL_FUNC(menuitem_response), (gpointer) g_strdup(buf)); */

  palette->popup_menu = menu;

  palette->popup_small_menu = menu = gtk_menu_new ();
  menu_items = gtk_menu_item_new_with_label (_("New"));
  gtk_menu_append (GTK_MENU (menu), menu_items);
  gtk_signal_connect (GTK_OBJECT (menu_items), "activate", 
		      GTK_SIGNAL_FUNC (palette_new_callback),
		      (gpointer) palette);
  gtk_widget_show (menu_items);
}

static gint
palette_color_area_events (GtkWidget     *widget,
			   GdkEvent      *event,
			   PaletteDialog *palette)
{
  GdkEventButton *bevent;
  GSList *tmp_link;
  int r, g, b;
  int entry_width;
  int entry_height;
  int row, col;
  int pos;

  switch (event->type)
    {
    case GDK_EXPOSE:
      redraw_palette(palette);
      break;
    case GDK_BUTTON_PRESS:
      bevent = (GdkEventButton *) event;
      entry_width = (ENTRY_WIDTH*palette->xzoom_factor)+SPACING;
      entry_height = (ENTRY_HEIGHT*palette->zoom_factor)+SPACING;
      col = (bevent->x - 1) / entry_width;
      row = (bevent->y - 1) / entry_height;
      pos = row * palette->columns + col;
      
      if ((bevent->button == 1 || bevent->button == 3) && palette->entries)
	{
	  tmp_link = g_slist_nth (palette->entries->colors, pos);
	  if (tmp_link)
	    {
	      if(palette->color)
		{
		  palette->freeze_update = TRUE;
 		  palette_draw_entries (palette, -1, -1);
		  palette->freeze_update = FALSE;
		}
	      palette->color = tmp_link->data;

	      /*  Update either foreground or background colors  */
	      r = palette->color->color[0];
	      g = palette->color->color[1];
	      b = palette->color->color[2];
	      if (active_color == FOREGROUND)
		{
		  if (bevent->state & GDK_CONTROL_MASK)
		    palette_set_background (r, g, b);
		  else
		    palette_set_foreground (r, g, b);
		}
	      else if (active_color == BACKGROUND)
		{
		  if (bevent->state & GDK_CONTROL_MASK)
		    palette_set_foreground (r, g, b);
		  else
		    palette_set_background (r, g, b);
		}

	      palette_draw_entries (palette, row, col);
	      /*  Update the active color name  */
	      gtk_entry_set_text (GTK_ENTRY (palette->color_name),
				  palette->color->name);
	      gtk_widget_set_sensitive (palette->color_name, TRUE);
	     /*  palette_update_current_entry (palette); */
	      if (bevent->button == 3)
		{
		  /* Popup the edit menu */
		  gtk_menu_popup (GTK_MENU (palette->popup_menu), NULL, NULL, 
				  NULL, NULL, 3,
				  ((GdkEventButton *)event)->time);
		}
	    }
	  else
	    {
	      if(bevent->button == 3)
		{
		  /* Popup the small new menu */
		  gtk_menu_popup (GTK_MENU (palette->popup_small_menu),
				  NULL, NULL, 
				  NULL, NULL, 3,
				  ((GdkEventButton *)event)->time);
		}
	    }
	}
      break;

    default:
      break;
    }

  return FALSE;
}

void 
palette_insert_clist (GtkWidget       *clist, 
		      GtkWidget       *shell,
		      GdkGC           *gc,
		      PaletteEntriesP  p_entries,
		      gint             pos)
{
  gchar *string[3];

  string[0] = NULL;
  string[1] = g_strdup_printf ("%d", p_entries->n_colors);
  string[2] = p_entries->name;

  gtk_clist_insert (GTK_CLIST (clist), pos, string);

  g_free (string[1]);
  
  if (p_entries->pixmap == NULL)
    p_entries->pixmap = gdk_pixmap_new (shell->window,
					SM_PREVIEW_WIDTH, 
					SM_PREVIEW_HEIGHT, 
					gtk_widget_get_visual (shell)->depth);
  
  palette_draw_small_preview (gc, p_entries);
  gtk_clist_set_pixmap (GTK_CLIST (clist), pos, 0, p_entries->pixmap, NULL);
  gtk_clist_set_row_data (GTK_CLIST (clist), pos, (gpointer) p_entries);
}  

void
palette_clist_init (GtkWidget *clist, 
		    GtkWidget *shell,
		    GdkGC     *gc)
{
  GSList *list;
  PaletteEntriesP p_entries = NULL;
  gint pos = 0;

  list = palette_entries_list;

  while (list)
    {
      p_entries = (PaletteEntriesP) list->data;
      list = g_slist_next (list);

      /*  to make sure we get something!  */
      if (p_entries == NULL)
	{
	  p_entries = default_palette_entries;
	}

      palette_insert_clist (clist, shell, gc, p_entries, pos);
      pos++;
    }
}

static int
palette_draw_color_row (guchar        **colors,
			gint            ncolors,
			gint            y,
			gint            column_highlight,
			guchar         *buffer,
			PaletteDialog  *palette)
{
  guchar *p;
  guchar bcolor;
  gint width, height;
  gint entry_width;
  gint entry_height;
  gint vsize;
  gint vspacing;
  gint i, j;
  GtkWidget *preview;

  if (!palette)
    return -1;

  preview = palette->color_area;

  bcolor = 0;

  width = preview->requisition.width;
  height = preview->requisition.height;
  entry_width = (ENTRY_WIDTH * palette->xzoom_factor);
  entry_height = (ENTRY_HEIGHT * palette->zoom_factor);

  if ((y >= 0) && ((y + SPACING) < height))
    vspacing = SPACING;
  else if (y < 0)
    vspacing = SPACING + y;
  else
    vspacing = height - y;

  if (vspacing > 0)
    {
      if (y < 0)
	y += SPACING - vspacing;

      for (i = SPACING - vspacing; i < SPACING; i++, y++)
	{
	  p = buffer;
	  for (j = 0; j < width; j++)
	    {
	      *p++ = bcolor;
	      *p++ = bcolor;
	      *p++ = bcolor;
	    }
	  
	  if (column_highlight >= 0)
	    {
	      guchar *ph = &buffer[3*column_highlight*(entry_width+SPACING)];
	      for (j = 0 ; j <= entry_width + SPACING; j++)
		{
		  *ph++ = ~bcolor;
		  *ph++ = ~bcolor;
		  *ph++ = ~bcolor;
		}
 	      gtk_preview_draw_row (GTK_PREVIEW (preview), buffer, 0,
				    y + entry_height + 1, width); 
	    }

	  gtk_preview_draw_row (GTK_PREVIEW (preview), buffer, 0, y, width);
	}

      if (y > SPACING)
	y += SPACING - vspacing;
    }
  else
    y += SPACING;

  vsize = (y >= 0) ? (entry_height) : (entry_height + y);

  if ((y >= 0) && ((y + entry_height) < height))
    vsize = entry_height;
  else if (y < 0)
    vsize = entry_height + y;
  else
    vsize = height - y;

  if (vsize > 0)
    {
      p = buffer;
      for (i = 0; i < ncolors; i++)
	{
	  for (j = 0; j < SPACING; j++)
	    {
	      *p++ = bcolor;
	      *p++ = bcolor;
	      *p++ = bcolor;
	    }

	  for (j = 0; j < entry_width; j++)
	    {
	      *p++ = colors[i][0];
	      *p++ = colors[i][1];
	      *p++ = colors[i][2];
	    }
	}

      for (i = 0; i < (palette->columns - ncolors); i++)
	{
	  for (j = 0; j < (SPACING + entry_width); j++)
	    {
	      *p++ = 0;
	      *p++ = 0;
	      *p++ = 0;
	    }
	}

      for (j = 0; j < SPACING; j++)
	{
	  if (ncolors == column_highlight)
	    {
	      *p++ = ~bcolor;
	      *p++ = ~bcolor;
	      *p++ = ~bcolor;
	    }
	  else
	    {
	      *p++ = bcolor;
	      *p++ = bcolor;
	      *p++ = bcolor;
	    }
	}

      if (y < 0)
	y += entry_height - vsize;
      for (i = 0; i < vsize; i++, y++)
	{
	  if (column_highlight >= 0)
	    {
	      guchar *ph = &buffer[3*column_highlight*(entry_width+SPACING)];
	      *ph++ = ~bcolor;
	      *ph++ = ~bcolor;
	      *ph++ = ~bcolor;
	      ph += 3*(entry_width);
	      *ph++ = ~bcolor;
	      *ph++ = ~bcolor;
	      *ph++ = ~bcolor;
	    }
	  gtk_preview_draw_row (GTK_PREVIEW (preview), buffer, 0, y, width);
	}
      if (y > entry_height)
	y += entry_height - vsize;
    }
  else
    y += entry_height;

  return y;
}

static void
palette_draw_entries (PaletteDialog *palette,
		      gint           row_start,
		      gint           column_highlight)
{
  PaletteEntryP entry;
  guchar *buffer;
  guchar **colors;
  GSList *tmp_link;
  gint width, height;
  gint entry_width;
  gint entry_height;
  gint index, y;

  if (palette && palette->entries)
    {
      width = palette->color_area->requisition.width;
      height = palette->color_area->requisition.height;

      entry_width = (ENTRY_WIDTH * palette->xzoom_factor);
      entry_height = (ENTRY_HEIGHT * palette->zoom_factor);

      colors = g_malloc (sizeof (guchar *) * palette->columns * 3);
      buffer = g_malloc (width * 3);

      if(row_start < 0)
	{
	  y = 0;
	  tmp_link = palette->entries->colors;
	  column_highlight = -1;
	}
      else
	{
	  y = (entry_height+SPACING)*row_start;
	  tmp_link = g_slist_nth (palette->entries->colors, row_start*palette->columns);
	}
      index = 0;

      while (tmp_link)
	{
	  entry = tmp_link->data;
	  tmp_link = tmp_link->next;

	  colors[index] = entry->color;
	  index++;

	  if (index == palette->columns)
	    {
	      index = 0;
	      y = palette_draw_color_row (colors, palette->columns, y, column_highlight, buffer, palette);
	      if (y >= height || row_start >= 0)
		{
		  /* This row only */
		  gtk_widget_draw (palette->color_area, NULL);
		  g_free (buffer);
		  g_free (colors);
		  return;
		}
	    }
	}

      while (y < height)
	{
	  y = palette_draw_color_row (colors, index, y, column_highlight, buffer, palette);
	  index = 0;
          if(row_start >= 0)
	    break;
	}

      g_free (buffer);
      g_free (colors);

      if(palette->freeze_update == FALSE)
	gtk_widget_draw (palette->color_area, NULL);
    }
}

static void
palette_scroll_top_left (PaletteDialog *palette)
{
  GtkAdjustment *hadj; 
  GtkAdjustment *vadj; 

  /* scroll viewport to top left */
  if(palette && palette->scrolled_window)
    {
      hadj = gtk_scrolled_window_get_hadjustment (GTK_SCROLLED_WINDOW (palette->scrolled_window));
      vadj = gtk_scrolled_window_get_vadjustment (GTK_SCROLLED_WINDOW (palette->scrolled_window));
      
      if(hadj)
	gtk_adjustment_set_value (hadj, 0.0);
      if(vadj)
	gtk_adjustment_set_value (vadj, 0.0);
    }
}

static void
redraw_palette (PaletteDialog *palette)
{
  GtkWidget *parent;
  gint vsize;
  gint nrows;
  gint n_entries;
  gint new_pre_width;
  gint entry_width;
  guint width;
  gint ncols;
  gfloat new_xzoom;

  width  = palette->color_area->parent->parent->allocation.width;
  new_xzoom = (gfloat)((gfloat)width/(gfloat)COLUMNS - SPACING)/(gfloat)ENTRY_WIDTH;

  if((palette->columns_valid) && palette->last_width == width)
    return;

  palette->last_width = width;
  palette->columns_valid = TRUE;
  palette->xzoom_factor = new_xzoom;

  n_entries = palette->entries->n_colors;
  nrows = n_entries / palette->columns;
  if (n_entries % palette->columns)
    nrows += 1;

  vsize = nrows* (SPACING + (gint)(ENTRY_HEIGHT*palette->zoom_factor)) + SPACING;

  parent = palette->color_area->parent;
  gtk_widget_ref (palette->color_area);
  gtk_container_remove (GTK_CONTAINER (parent), palette->color_area);

  new_pre_width = (gint) (ENTRY_WIDTH * palette->xzoom_factor);
  new_pre_width = (new_pre_width + SPACING) * palette->columns + SPACING;

  gtk_preview_size (GTK_PREVIEW (palette->color_area),
		    new_pre_width, /*PREVIEW_WIDTH,*/
		    vsize);

  gtk_container_add (GTK_CONTAINER (parent), palette->color_area);
  gtk_widget_unref (palette->color_area);

  palette_draw_entries (palette, -1, -1);
}

static void
palette_list_item_update (GtkWidget      *widget, 
			  gint            row,
			  gint            column,
			  GdkEventButton *event,
			  gpointer        data)
{
  PaletteDialog *palette;
  PaletteEntriesP p_entries;

  palette = (PaletteDialog *) data;

  if (palette->color_notebook_active)
    {
      palette->color_notebook_active = FALSE;
      color_notebook_hide (palette->color_notebook);
    }

  if (palette->color_notebook)
    color_notebook_free (palette->color_notebook);
  palette->color_notebook = NULL;

  p_entries = 
    (PaletteEntriesP) gtk_clist_get_row_data (GTK_CLIST (palette->clist), row);

  palette->entries = p_entries;
  palette->columns_valid = FALSE;

  redraw_palette (palette);

  palette_scroll_top_left (palette);

  /* Stop errors in case no colors are selected */ 
  gtk_signal_handler_block (GTK_OBJECT (palette->color_name),
			    palette->entry_sig_id);
  gtk_entry_set_text (GTK_ENTRY (palette->color_name), _("Undefined")); 
  gtk_widget_set_sensitive (palette->color_name, FALSE);
  gtk_signal_handler_unblock (GTK_OBJECT (palette->color_name),
			      palette->entry_sig_id);
}

static void
palette_edit_palette_callback (GtkWidget *widget,
			       gpointer   data)
{
  PaletteEntriesP p_entries = NULL;
  PaletteDialog *palette;
  GList *sel_list;

  palette = (PaletteDialog *) data;
  sel_list = GTK_CLIST (palette->clist)->selection;

  if (sel_list)
    {
      while (sel_list)
	{
	  gint row;

	  row = GPOINTER_TO_INT (sel_list->data);

	  p_entries = 
	    (PaletteEntriesP)gtk_clist_get_row_data (GTK_CLIST (palette->clist), row);

	  palette_create_edit (p_entries);

	  /* One only */
	  return;
	}
    }
}

PaletteDialog *
create_palette_dialog (gint vert)
{
  PaletteDialog *palette;
  GtkWidget *hbox;
  GtkWidget *hbox2;
  GtkWidget *vbox;
  GtkWidget *scrolledwindow;
  GtkWidget *palette_region;
  GtkWidget *entry;
  GtkWidget *alignment;
  GtkWidget *palette_list;
  GtkWidget *frame;
  GtkWidget *button;
  GtkWidget *pixmapwid;
  GdkPixmap *pixmap;
  GdkBitmap *mask;
  GtkStyle  *style;

  palette = g_new (PaletteDialog, 1);

  palette->entries = default_palette_entries;
  palette->color = NULL;
  palette->color_notebook = NULL;
  palette->color_notebook_active = FALSE;
  palette->zoom_factor = 1.0;
  palette->xzoom_factor = 1.0;
  palette->last_width = 0;
  palette->columns = COLUMNS;
  palette->columns_valid = TRUE;
  palette->freeze_update = FALSE;

  if (!vert)
    {
      palette->shell =
	gimp_dialog_new (_("Color Palette Edit"), "color_palette_edit",
			 gimp_standard_help_func,
			 "dialogs/palette_editor/palette_editor.html",
			 GTK_WIN_POS_NONE,
			 FALSE, TRUE, FALSE,

			 _("Save"), palette_save_palettes_callback,
			 palette, NULL, FALSE, FALSE,
			 _("Refresh"), palette_refresh_callback,
			 palette, NULL, FALSE, FALSE,
			 _("Close"), palette_close_callback,
			 palette, NULL, TRUE, TRUE,

			 NULL);
      gtk_widget_set_usize (palette->shell, 615, 200);
    }
  else
    {
      palette->shell =
	gimp_dialog_new (_("Color Palette"), "color_palette",
			 gimp_standard_help_func,
			 "dialogs/palette_selection.html",
			 GTK_WIN_POS_NONE,
			 FALSE, TRUE, FALSE,

			 _("Edit"), palette_edit_palette_callback,
			 palette, NULL, FALSE, FALSE,
			 _("Close"), palette_close_callback,
			 palette, NULL, TRUE, TRUE,

			 NULL);
      gtk_widget_set_usize (palette->shell, 230, 300);
    }

  /*  The main container widget  */
  if (vert)
    {
      hbox = gtk_notebook_new ();
      gtk_container_set_border_width (GTK_CONTAINER (hbox), 1);
    }
  else
    {
      hbox = gtk_hbox_new (FALSE, 4);
      gtk_container_set_border_width (GTK_CONTAINER (hbox), 4);
    }
  gtk_container_add (GTK_CONTAINER (GTK_DIALOG (palette->shell)->vbox), hbox);
  gtk_widget_show (hbox);

  vbox = gtk_vbox_new (FALSE, 2);
  if (!vert)
    {
      gtk_box_pack_start (GTK_BOX (hbox), vbox, TRUE, TRUE, 0);
    }
  gtk_widget_show (vbox);

  alignment = gtk_alignment_new (0.5, 0.5, 0.0, 0.0); 
  gtk_widget_show (alignment); 

  palette->scrolled_window =
    scrolledwindow = gtk_scrolled_window_new (NULL, NULL);
  gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwindow),
				  GTK_POLICY_AUTOMATIC, 
				  GTK_POLICY_ALWAYS);
  gtk_box_pack_start (GTK_BOX (vbox), scrolledwindow, TRUE, TRUE, 0);
  gtk_widget_show (scrolledwindow);

  palette->color_area = palette_region = gtk_preview_new (GTK_PREVIEW_COLOR);
  gtk_preview_set_dither (GTK_PREVIEW (palette->color_area),
			  GDK_RGB_DITHER_MAX);
  gtk_preview_size (GTK_PREVIEW (palette_region), PREVIEW_WIDTH, PREVIEW_HEIGHT);
  
  gtk_widget_set_events (palette_region, PALETTE_EVENT_MASK);
  gtk_signal_connect (GTK_OBJECT (palette->color_area), "event",
		      (GtkSignalFunc) palette_color_area_events,
		      palette);

  gtk_container_add (GTK_CONTAINER (alignment), palette_region);
  gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (scrolledwindow),
					 alignment);
  gtk_widget_show (palette_region);

  /*  dnd stuff  */
  gtk_drag_source_set (palette_region,
                       GDK_BUTTON1_MASK | GDK_BUTTON3_MASK,
                       color_palette_target_table, n_color_palette_targets,
                       GDK_ACTION_COPY | GDK_ACTION_MOVE);
  gimp_dnd_color_source_set (palette_region, palette_drag_color, palette);

  gtk_drag_dest_set (alignment,
                     GTK_DEST_DEFAULT_HIGHLIGHT |
                     GTK_DEST_DEFAULT_MOTION |
                     GTK_DEST_DEFAULT_DROP,
                     color_palette_target_table, n_color_palette_targets,
                     GDK_ACTION_COPY);
  gimp_dnd_color_dest_set (alignment, palette_drop_color, palette);

  /*  The color name entry  */
  hbox2 = gtk_hbox_new (FALSE, 2);
  gtk_box_pack_start (GTK_BOX (vbox), hbox2, FALSE, FALSE, 0);
  gtk_widget_show(hbox2);

  entry = palette->color_name = gtk_entry_new ();
  gtk_widget_show (entry);
  gtk_box_pack_start (GTK_BOX (hbox2), entry, TRUE, TRUE, 0);
  gtk_entry_set_text (GTK_ENTRY (entry), _("Undefined"));
  palette->entry_sig_id =
    gtk_signal_connect (GTK_OBJECT (entry), "changed",
			GTK_SIGNAL_FUNC (color_name_entry_changed),
			palette);

  /*  + and - buttons  */
  gtk_widget_realize (palette->shell);
  style = gtk_widget_get_style (palette->shell);

  button = gtk_button_new ();
  GTK_WIDGET_UNSET_FLAGS (button, GTK_RECEIVES_DEFAULT);
  gtk_signal_connect (GTK_OBJECT (button), "clicked",
		      GTK_SIGNAL_FUNC (palette_zoomin), (gpointer) palette);
  gtk_box_pack_start (GTK_BOX (hbox2), button, FALSE, FALSE, 0);

  pixmap = gdk_pixmap_create_from_xpm_d (palette->shell->window, &mask,
					 &style->bg[GTK_STATE_NORMAL], 
					 zoom_in_xpm);
  pixmapwid = gtk_pixmap_new (pixmap, mask);
  gtk_container_add (GTK_CONTAINER (button), pixmapwid);
  gtk_widget_show (pixmapwid);
  gtk_widget_show (button);

  button = gtk_button_new ();
  GTK_WIDGET_UNSET_FLAGS (button, GTK_RECEIVES_DEFAULT);
  gtk_signal_connect (GTK_OBJECT (button), "clicked",
		      GTK_SIGNAL_FUNC (palette_zoomout), (gpointer) palette);
  gtk_box_pack_start (GTK_BOX (hbox2), button, FALSE, FALSE, 0);

  pixmap = gdk_pixmap_create_from_xpm_d (palette->shell->window, &mask,
					 &style->bg[GTK_STATE_NORMAL], 
					 zoom_out_xpm);
  pixmapwid = gtk_pixmap_new (pixmap, mask);
  gtk_container_add (GTK_CONTAINER (button), pixmapwid);
  gtk_widget_show (pixmapwid);
  gtk_widget_show (button);
  
  /*  clist preview of palettes  */
  scrolledwindow = gtk_scrolled_window_new (NULL, NULL);
  palette->clist = palette_list = gtk_clist_new (3);
  gtk_clist_set_row_height (GTK_CLIST (palette_list), SM_PREVIEW_HEIGHT + 2);
  gtk_signal_connect (GTK_OBJECT (palette->clist), "select_row",
		      GTK_SIGNAL_FUNC (palette_list_item_update),
		      (gpointer) palette);
  if (vert)
    {
      gtk_widget_set_usize (palette_list, 203, 90);

      gtk_notebook_append_page (GTK_NOTEBOOK (hbox), vbox,
				gtk_label_new (_("Palette")));
      gtk_notebook_append_page (GTK_NOTEBOOK (hbox), scrolledwindow,
				gtk_label_new (_("Select")));
      gtk_widget_show (palette_list);
    }
  else
    {
      gtk_container_add (GTK_CONTAINER (hbox), scrolledwindow);
      gtk_widget_set_usize (palette_list, 203, -1);
      gtk_widget_show (palette_list);
    }

  gtk_clist_set_column_title (GTK_CLIST (palette_list), 0, _("Palette"));
  gtk_clist_set_column_title (GTK_CLIST (palette_list), 1, _("Ncols"));
  gtk_clist_set_column_title (GTK_CLIST (palette_list), 2, _("Name"));
  gtk_clist_column_titles_show (GTK_CLIST (palette_list));

  gtk_container_add (GTK_CONTAINER (scrolledwindow), palette->clist);

  gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwindow),
				  GTK_POLICY_AUTOMATIC,
				  GTK_POLICY_ALWAYS);
  
  if (!vert)
    gtk_clist_set_selection_mode (GTK_CLIST (palette_list),
				  GTK_SELECTION_EXTENDED);

  gtk_widget_show (scrolledwindow);

  gtk_clist_set_column_width (GTK_CLIST (palette_list), 0, SM_PREVIEW_WIDTH+2);
  gtk_clist_column_titles_show (GTK_CLIST (palette_list));

  if (!vert) 
    {
      frame = gtk_frame_new (_("Palette Ops"));
      gtk_box_pack_end (GTK_BOX (hbox), frame, FALSE, FALSE, 0);
      gtk_widget_show (frame); 

      vbox = gtk_vbox_new (FALSE, 2);
      gtk_container_set_border_width (GTK_CONTAINER (vbox), 4);
      gtk_container_add (GTK_CONTAINER (frame), vbox);
      gtk_widget_show (vbox);
      
      button = gtk_button_new_with_label (_("New"));
      GTK_WIDGET_UNSET_FLAGS (button, GTK_RECEIVES_DEFAULT);
      gtk_misc_set_padding (GTK_MISC (GTK_BIN (button)->child), 2, 0);
      gtk_signal_connect (GTK_OBJECT (button), "clicked",
			  (GtkSignalFunc) palette_new_entries_callback,
			  (gpointer) palette);
      gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
      gtk_widget_show (button);

      button = gtk_button_new_with_label (_("Delete"));
      GTK_WIDGET_UNSET_FLAGS (button, GTK_RECEIVES_DEFAULT);
      gtk_misc_set_padding (GTK_MISC (GTK_BIN (button)->child), 2, 0);
      gtk_signal_connect (GTK_OBJECT (button), "clicked",
			  (GtkSignalFunc) palette_delete_entries_callback,
			  (gpointer) palette);
      gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
      gtk_widget_show (button);
      
      button = gtk_button_new_with_label (_("Import"));
      GTK_WIDGET_UNSET_FLAGS (button, GTK_RECEIVES_DEFAULT);
      gtk_misc_set_padding (GTK_MISC (GTK_BIN (button)->child), 2, 0);
      gtk_signal_connect (GTK_OBJECT (button), "clicked",
			  (GtkSignalFunc) palette_import_dialog_callback,
			  (gpointer) palette);
      gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
      gtk_widget_show (button);

      button = gtk_button_new_with_label (_("Merge"));
      GTK_WIDGET_UNSET_FLAGS (button, GTK_RECEIVES_DEFAULT);
      gtk_misc_set_padding (GTK_MISC (GTK_BIN (button)->child), 2, 0);
      gtk_signal_connect (GTK_OBJECT (button), "clicked",
			  (GtkSignalFunc) palette_merge_dialog_callback,
			  (gpointer) palette);
      gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
      gtk_widget_show (button);
    }

  palette->gc = gdk_gc_new (palette->shell->window);

  palette_popup_menu (palette);

  return palette;
}

static void
palette_drag_color (GtkWidget *widget,
		    guchar    *r,
		    guchar    *g,
		    guchar    *b,
		    gpointer   data)
{
  PaletteDialog *palette;

  palette = (PaletteDialog *) data;

  if (palette && palette->entries && palette->color)
    {
      *r = (guchar) palette->color->color[0];
      *g = (guchar) palette->color->color[1];
      *b = (guchar) palette->color->color[2];
    }
}

static void
palette_drop_color (GtkWidget *widget,
		    guchar      r,
		    guchar      g,
		    guchar      b,
		    gpointer    data)
{
  PaletteDialog *palette;
  gchar  *name;
  gchar  *num_buf;
  GSList *list;
  gint    pos = 0;
  PaletteEntriesP p_entries = NULL;

  palette = (PaletteDialog *) data;

  if (palette && palette->entries)
    {
      name = g_strdup_printf ("#%02x%02x%02x", r, g, b);

      palette->color =
	palette_add_entry (palette->entries, name, r, g, b);

      g_free (name);

      palette->columns_valid = FALSE;
      redraw_palette (palette);

      list = palette_entries_list;
      
      while (list)
	{
	  p_entries = (PaletteEntriesP) list->data;
	  list = g_slist_next (list);
	  
	  /*  to make sure we get something!  */
	  if (p_entries == NULL)
	    {
	      p_entries = default_palette_entries;
	    }
	  if (p_entries == palette->entries)
	    break;
	  pos++;
	}

      num_buf = g_strdup_printf ("%d", p_entries->n_colors);;
      palette_draw_small_preview (palette->gc, p_entries);
      gtk_clist_set_text (GTK_CLIST (palette->clist), pos, 1, num_buf);
      palette_select_set_text_all (palette->entries);
      palette_select2_set_text_all (palette->entries);
    }
}

static void
import_dialog_select_grad_callback (GtkWidget *widget,
				    gpointer   data)
{
  /* Popup grad edit box .... */
  grad_create_gradient_editor ();
}

static void
import_dialog_close_callback (GtkWidget *widget,
			      gpointer   data)
{
  gtk_widget_destroy (import_dialog->dialog);
  g_free (import_dialog);
  import_dialog = NULL;
}

static void
import_palette_create_from_grad (gchar         *name,
				 PaletteDialog *palette)
{
  PaletteEntriesP entries;

  if(curr_gradient)
    {
      /* Add names to entry */
      double  dx, cur_x;
      double  r, g, b, a;
      extern void grad_get_color_at(double, double *, double *, double *, double *);
      gint sample_sz;
      gint loop;

      entries = palette_create_entries (palette, name);
      sample_sz = (gint)import_dialog->sample->value;  

      dx    = 1.0/ (sample_sz - 1);
      cur_x = 0;
      
      for (loop = 0 ; loop < sample_sz; loop++)
	{
	  grad_get_color_at(cur_x, &r, &g, &b, &a);
	  r = r * 255.0;
	  g = g * 255.0;
	  b = b * 255.0;
	  cur_x += dx;
	  palette_add_entry (palette->entries, _("Untitled"),
			     (gint) r, (gint) g, (gint) b);
	}
      palette_update_small_preview (palette);
      redraw_palette (palette);
      /* Update other selectors on screen */
      palette_select_clist_insert_all (entries);
      palette_select2_clist_insert_all (entries);
      palette_scroll_clist_to_current (palette);
    }
}

static void
import_dialog_import_callback (GtkWidget *widget,
			       gpointer   data)
{
  PaletteDialog *palette;

  palette = data;
  if (import_dialog)
    {
      guchar *pname;
      pname = gtk_entry_get_text (GTK_ENTRY (import_dialog->entry));
      if (!pname || strlen (pname) == 0)
	pname = g_strdup ("tmp");
      else
	pname = g_strdup (pname);
      switch (import_dialog->import_type)
	{
	case GRAD_IMPORT:
	  import_palette_create_from_grad (pname, palette);
	  break;
	case IMAGE_IMPORT:
	  import_palette_create_from_image (import_dialog->gimage,
					    pname, palette);
	  break;
	default:
	  break;
	}
      import_dialog_close_callback (NULL, NULL);
    }
}

static void
palette_merge_entries_callback (GtkWidget *widget,
				gpointer   data,
				gpointer   call_data)
{
  PaletteDialog *palette;
  PaletteEntriesP p_entries;
  PaletteEntriesP new_entries;
  GList *sel_list;

  new_entries = palette_create_entries (data, call_data);

  palette = (PaletteDialog *) data;

  sel_list = GTK_CLIST (palette->clist)->selection;

  if (sel_list)
    {
      while (sel_list)
	{
	  gint row;
	  GSList *cols;

	  row = GPOINTER_TO_INT (sel_list->data);
	  p_entries = 
	    (PaletteEntriesP)gtk_clist_get_row_data (GTK_CLIST (palette->clist), row);

	  /* Go through each palette and merge the colors */
	  cols = p_entries->colors;
	  while (cols)
	    {
	      PaletteEntryP entry = cols->data;
	      palette_add_entry (new_entries,
				 g_strdup (entry->name),
				 entry->color[0],
				 entry->color[1],
				 entry->color[2]);
	      cols = cols->next;
	    }
	  sel_list = sel_list->next;
	}
    }

  palette_update_small_preview (palette);
  redraw_palette (palette);
  gtk_clist_unselect_all (GTK_CLIST (palette->clist));
  /* Update other selectors on screen */
  palette_select_clist_insert_all (new_entries);
  palette_select2_clist_insert_all (new_entries);
  palette_scroll_clist_to_current (palette);
}

static void
palette_merge_dialog_callback (GtkWidget *widget,
			       gpointer   data)
{
  GtkWidget *qbox;

  qbox = gimp_query_string_box (_("Merge Palette"),
				gimp_standard_help_func,
				"dialogs/palette_editor/merge_palette.html",
				_("Enter a name for merged palette"),
				NULL,
				NULL, NULL,
				palette_merge_entries_callback,
				data);
  gtk_widget_show (qbox);
}

static void
palette_import_dialog_callback (GtkWidget *widget,
				gpointer   data)
{
  if (!import_dialog)
    {
      import_dialog = palette_import_dialog ((PaletteDialog *) data);
      gtk_widget_show (import_dialog->dialog);
    }
  else
    {
      gdk_window_raise (import_dialog->dialog->window);
    }
}

static void
palette_import_fill_grad_preview (GtkWidget  *preview,
				  gradient_t *gradient)
{
  guchar buffer[3*IMPORT_PREVIEW_WIDTH];
  gint loop;
  guchar *p = buffer;
  gdouble  dx, cur_x;
  gdouble  r, g, b, a;
  extern void grad_get_color_at(double, double *, double *, double *, double *);
  gradient_t *last_grad;

  dx    = 1.0/ (IMPORT_PREVIEW_WIDTH - 1);
  cur_x = 0;

  last_grad = curr_gradient;
  curr_gradient = gradient;
  for (loop = 0 ; loop < IMPORT_PREVIEW_WIDTH; loop++)
    {
      grad_get_color_at(cur_x, &r, &g, &b, &a);
      *p++ = r * 255.0;
      *p++ = g * 255.0;
      *p++ = b * 255.0;
      cur_x += dx;
    }
  curr_gradient = last_grad;

  for (loop = 0 ; loop < IMPORT_PREVIEW_HEIGHT; loop++)
    {
      gtk_preview_draw_row (GTK_PREVIEW (preview), buffer, 0, loop, IMPORT_PREVIEW_WIDTH);
    }
  gtk_widget_draw (preview, NULL);
}


void
import_palette_grad_update (gradient_t *grad)
{
  if (import_dialog && import_dialog->import_type == GRAD_IMPORT)
    {
      /* redraw gradient */
      palette_import_fill_grad_preview (import_dialog->preview, grad);
      gtk_entry_set_text (GTK_ENTRY (import_dialog->entry), grad->name);
    }
}

static void
import_grad_callback (GtkWidget *widget,
		      gpointer   data)
{
  if (import_dialog)
    {
      import_dialog->import_type = GRAD_IMPORT;
      if (import_dialog->image_list)
	{
	  gtk_widget_hide (import_dialog->image_list);
	  gtk_widget_destroy (import_dialog->image_list);
	  import_dialog->image_list = NULL;
	}
      gtk_widget_show (import_dialog->select);
      palette_import_fill_grad_preview (import_dialog->preview, curr_gradient);

      gtk_entry_set_text (GTK_ENTRY (import_dialog->entry), curr_gradient->name);
      gtk_widget_set_sensitive (import_dialog->threshold_scale, FALSE);
      gtk_widget_set_sensitive (import_dialog->threshold_text, FALSE);
    }
}

static void
gimlist_cb (gpointer im,
	    gpointer data)
{
  GSList** l;

  l = (GSList**) data;
  *l = g_slist_prepend (*l, im);
}

static void
import_image_update_image_preview (GimpImage *gimage)
{
  TempBuf * preview_buf;
  gchar *src, *buf;
  gint x,y,has_alpha;
  gint sel_width, sel_height;
  gint pwidth, pheight;

  import_dialog->gimage = gimage;

  /* Calculate preview size */

  sel_width = gimage->width;
  sel_height = gimage->height;

  if (sel_width > sel_height) {
    pwidth  = MIN(sel_width, IMPORT_PREVIEW_WIDTH);
    pheight = sel_height * pwidth / sel_width;
  } else {
    pheight = MIN(sel_height, IMPORT_PREVIEW_HEIGHT);
    pwidth  = sel_width * pheight / sel_height;
  }
  
  /* Min size is 2 */

  preview_buf = gimp_image_construct_composite_preview (gimage,
							MAX (pwidth, 2),
							MAX (pheight, 2));

  gtk_preview_size (GTK_PREVIEW (import_dialog->preview),
		    preview_buf->width,
		    preview_buf->height);

  buf = g_new (gchar,  IMPORT_PREVIEW_WIDTH * 3);
  src = (gchar *) temp_buf_data (preview_buf);
  has_alpha = (preview_buf->bytes == 2 || preview_buf->bytes == 4);
  for (y = 0; y <preview_buf->height ; y++)
    {
      if (preview_buf->bytes == (1+has_alpha))
	for (x = 0; x < preview_buf->width; x++)
	  {
	    buf[x*3+0] = src[x];
	    buf[x*3+1] = src[x];
	    buf[x*3+2] = src[x];
	  }
      else
	for (x = 0; x < preview_buf->width; x++)
	  {
	    gint stride = 3 + has_alpha;
	    buf[x*3+0] = src[x*stride+0];
	    buf[x*3+1] = src[x*stride+1];
	    buf[x*3+2] = src[x*stride+2];
	  }
      gtk_preview_draw_row (GTK_PREVIEW (import_dialog->preview),
			    (guchar *)buf, 0, y, preview_buf->width);
      src += preview_buf->width * preview_buf->bytes;
    }

  g_free (buf);
  temp_buf_free (preview_buf);

  gtk_widget_hide (import_dialog->preview);
  gtk_widget_draw (import_dialog->preview, NULL); 
  gtk_widget_show (import_dialog->preview);
}

static void
import_image_sel_callback (GtkWidget *widget,
			   gpointer   data)
{
  GimpImage *gimage;
  gchar *lab;

  gimage = GIMP_IMAGE (data);
  import_image_update_image_preview (gimage);

  lab = g_strdup_printf ("%s-%d",
			 g_basename (gimage_filename (import_dialog->gimage)),
			 pdb_image_to_id (import_dialog->gimage));

  gtk_entry_set_text (GTK_ENTRY (import_dialog->entry), lab);
}

static void
import_image_menu_add (GimpImage *gimage)
{
  GtkWidget *menuitem;
  gchar *lab = g_strdup_printf ("%s-%d",
				g_basename (gimage_filename (gimage)),
				pdb_image_to_id (gimage));
  menuitem = gtk_menu_item_new_with_label (lab);
  gtk_widget_show (menuitem);
  gtk_signal_connect (GTK_OBJECT (menuitem), "activate",
		      (GtkSignalFunc) import_image_sel_callback,
		      gimage);
  gtk_menu_append (GTK_MENU (import_dialog->optionmenu1_menu), menuitem);
}

/* Last Param gives us control over what goes in the menu on a delete oper */
static void
import_image_menu_activate (gint       redo,
			    GimpImage *del_image)
{
  GSList *list=NULL;
  gint num_images;
  GimpImage *last_img = NULL;
  GimpImage *first_img = NULL;
  gint act_num = -1;
  gint count = 0;
  gchar *lab;

  if (import_dialog)
    {
      if (import_dialog->import_type == IMAGE_IMPORT)
	{
	  if (!redo)
	    return;
	  else
	    {
	      if (import_dialog->image_list)
		{
		  last_img = import_dialog->gimage;
		  gtk_widget_hide (import_dialog->image_list);
		  gtk_widget_destroy (import_dialog->image_list);
		  import_dialog->image_list = NULL;
		}
	    }
	}
      import_dialog->import_type = IMAGE_IMPORT;

      /* Get list of images */
      gimage_foreach (gimlist_cb, &list);
      num_images = g_slist_length (list);
      
      if (num_images)
	{
	  gint i;
	  GtkWidget *optionmenu1;
	  GtkWidget *optionmenu1_menu;

	  import_dialog->image_list = optionmenu1 = gtk_option_menu_new ();
	  gtk_widget_set_usize (optionmenu1, IMPORT_PREVIEW_WIDTH, -1);
	  import_dialog->optionmenu1_menu = optionmenu1_menu = gtk_menu_new ();

	  for (i = 0; i < num_images; i++, list = g_slist_next (list))
	    {
	      if (GIMP_IMAGE (list->data) != del_image)
		{
		  if (first_img == NULL)
		    first_img = GIMP_IMAGE (list->data);
		  import_image_menu_add (GIMP_IMAGE (list->data));
		  if (last_img == GIMP_IMAGE (list->data))
		    act_num = count;
		  else
		    count++;
		}
	    }

	  gtk_option_menu_set_menu (GTK_OPTION_MENU (optionmenu1),
				    optionmenu1_menu);
	  gtk_widget_hide (import_dialog->select);
	  gtk_box_pack_start (GTK_BOX (import_dialog->select_area),
			      optionmenu1, FALSE, FALSE, 0);

	  if(last_img != NULL && last_img != del_image)
	      import_image_update_image_preview (last_img);
	  else if (first_img != NULL)
	      import_image_update_image_preview (first_img);

	  gtk_widget_show (optionmenu1);

	  /* reset to last one */
	  if(redo && act_num >= 0)
	    {
	      gchar *lab =
		g_strdup_printf ("%s-%d",
				 g_basename (gimage_filename (import_dialog->gimage)),
				 pdb_image_to_id (import_dialog->gimage));

	      gtk_option_menu_set_history (GTK_OPTION_MENU (optionmenu1), act_num);
	      gtk_entry_set_text (GTK_ENTRY (import_dialog->entry), lab);
	    }
	}
      g_slist_free (list);

      lab =
	g_strdup_printf ("%s-%d",
			 g_basename (gimage_filename (import_dialog->gimage)),
			 pdb_image_to_id (import_dialog->gimage));

      gtk_entry_set_text (GTK_ENTRY (import_dialog->entry), lab);
    }
}

static void
import_image_callback (GtkWidget *widget,
		       gpointer   data)
{
  import_image_menu_activate (FALSE, NULL);
  gtk_widget_set_sensitive (import_dialog->threshold_scale, TRUE);
  gtk_widget_set_sensitive (import_dialog->threshold_text, TRUE);
}

static gint
image_count ()
{
  GSList *list=NULL;
  gint num_images = 0;

  gimage_foreach (gimlist_cb, &list);
  num_images = g_slist_length (list);

  g_slist_free (list);

  return num_images;
}

static ImportDialog *
palette_import_dialog (PaletteDialog *palette)
{
  GtkWidget *dialog;
  GtkWidget *hbox;
  GtkWidget *frame;
  GtkWidget *vbox;
  GtkWidget *table;
  GtkWidget *label;
  GtkWidget *spinbutton;
  GtkWidget *button;
  GtkWidget *entry;
  GtkWidget *optionmenu;
  GtkWidget *optionmenu_menu;
  GtkWidget *menuitem;
  GtkWidget *image;
  GtkWidget *hscale;

  import_dialog = g_new (ImportDialog, 1);
  import_dialog->image_list = NULL;
  import_dialog->gimage = NULL;

  import_dialog->dialog = dialog =
    gimp_dialog_new (_("Import Palette"), "import_palette",
		     gimp_standard_help_func,
		     "dialogs/palette_editor/import_palette.html",
		     GTK_WIN_POS_NONE,
		     FALSE, TRUE, FALSE,

		     _("Import"), import_dialog_import_callback,
		     palette, NULL, FALSE, FALSE,
		     _("Close"), import_dialog_close_callback,
		     palette, NULL, TRUE, TRUE,

		     NULL);

  /*  The main hbox  */
  hbox = gtk_hbox_new (FALSE, 4);
  gtk_container_set_border_width (GTK_CONTAINER (hbox), 4);
  gtk_container_add (GTK_CONTAINER (GTK_DIALOG (dialog)->vbox), hbox);
  gtk_widget_show (hbox);

  /*  The "Import" frame  */
  frame = gtk_frame_new (_("Import"));
  gtk_box_pack_start (GTK_BOX (hbox), frame, TRUE, TRUE, 0);
  gtk_widget_show (frame);

  vbox = gtk_vbox_new (FALSE, 2);
  gtk_container_set_border_width (GTK_CONTAINER (vbox), 2);
  gtk_container_add (GTK_CONTAINER (frame), vbox);
  gtk_widget_show (vbox);

  table = gtk_table_new (4, 2, FALSE);
  gtk_table_set_col_spacing (GTK_TABLE (table), 0, 4);
  gtk_table_set_row_spacings (GTK_TABLE (table), 2);
  gtk_box_pack_start (GTK_BOX (vbox), table, FALSE, FALSE, 0);
  gtk_widget_show (table);

  /*  The source's name  */
  label = gtk_label_new (_("Name:"));
  gtk_misc_set_alignment (GTK_MISC (label), 1.0, 0.5);
  gtk_table_attach (GTK_TABLE (table), label, 0, 1, 0, 1,
                    GTK_EXPAND | GTK_FILL, GTK_EXPAND, 0, 0);
  gtk_widget_show (label);

  entry = import_dialog->entry = gtk_entry_new ();
  gtk_table_attach_defaults (GTK_TABLE (table), entry, 1, 2, 0, 1);
  gtk_entry_set_text (GTK_ENTRY (entry),
		      curr_gradient ? curr_gradient->name : _("new_import"));
  gtk_widget_show (entry);

  /*  The source type  */
  label = gtk_label_new (_("Source:"));
  gtk_misc_set_alignment (GTK_MISC (label), 1.0, 0.5);
  gtk_table_attach (GTK_TABLE (table), label, 0, 1, 1, 2,
                    GTK_EXPAND | GTK_FILL, GTK_EXPAND, 0, 0);
  gtk_widget_show (label);

  optionmenu = import_dialog->type_option = gtk_option_menu_new ();
  optionmenu_menu = gtk_menu_new ();
  gtk_table_attach_defaults (GTK_TABLE (table), optionmenu, 1, 2, 1, 2);
  menuitem = import_dialog->image_menu_item_gradient = 
    gtk_menu_item_new_with_label (_("Gradient"));
  gtk_signal_connect (GTK_OBJECT (menuitem), "activate",
		      (GtkSignalFunc) import_grad_callback,
		      NULL);
  gtk_menu_append (GTK_MENU (optionmenu_menu), menuitem);
  gtk_widget_show (menuitem);

  menuitem = import_dialog->image_menu_item_image =
    gtk_menu_item_new_with_label ("Image");
  gtk_signal_connect (GTK_OBJECT (menuitem), "activate",
		      (GtkSignalFunc) import_image_callback,
		      (gpointer) import_dialog);
  gtk_menu_append (GTK_MENU (optionmenu_menu), menuitem);
  gtk_widget_show (menuitem);

  gtk_option_menu_set_menu (GTK_OPTION_MENU (optionmenu), optionmenu_menu);
  gtk_widget_set_sensitive (menuitem, image_count() > 0);
  gtk_widget_show (optionmenu);

  /*  The sample size  */
  label = gtk_label_new (_("Sample Size:"));
  gtk_misc_set_alignment (GTK_MISC (label), 1.0, 0.5);
  gtk_table_attach (GTK_TABLE (table), label, 0, 1, 2, 3,
                    GTK_EXPAND | GTK_FILL, GTK_EXPAND, 0, 0);
  gtk_widget_show (label);

  import_dialog->sample =
    GTK_ADJUSTMENT(gtk_adjustment_new (256, 2, 10000, 1, 10, 10));
  spinbutton = gtk_spin_button_new (import_dialog->sample, 1, 0);
  gtk_table_attach_defaults (GTK_TABLE (table), spinbutton, 1, 2, 2, 3);
  gtk_widget_show (spinbutton);

  /*  The interval  */
  label = import_dialog->threshold_text = gtk_label_new (_("Interval:"));
  gtk_misc_set_alignment (GTK_MISC (label), 1.0, 1.0);
  gtk_table_attach (GTK_TABLE (table), label, 0, 1, 3, 4,
                    GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
  gtk_widget_set_sensitive(label, FALSE);
  gtk_widget_show (label);

  import_dialog->threshold = 
    GTK_ADJUSTMENT (gtk_adjustment_new (1, 1, 128, 1, 1, 1));
  hscale = import_dialog->threshold_scale = 
    gtk_hscale_new (import_dialog->threshold);
  gtk_scale_set_value_pos (GTK_SCALE (hscale), GTK_POS_TOP);
  gtk_scale_set_digits (GTK_SCALE (hscale), 0);
  gtk_table_attach_defaults (GTK_TABLE (table), hscale, 1, 2, 3, 4);
  gtk_widget_set_sensitive (hscale, FALSE);
  gtk_widget_show (hscale);

  /*  The preview frame  */
  frame = gtk_frame_new (_("Preview"));
  gtk_box_pack_start (GTK_BOX (hbox), frame, TRUE, TRUE, 0);
  gtk_widget_show (frame);

  vbox = import_dialog->select_area = gtk_vbox_new (FALSE, 2);
  gtk_container_set_border_width (GTK_CONTAINER (vbox), 2);
  gtk_container_add (GTK_CONTAINER (frame), vbox);
  gtk_widget_show (vbox);

  image = import_dialog->preview = gtk_preview_new (GTK_PREVIEW_COLOR);
  gtk_preview_set_dither (GTK_PREVIEW (image), GDK_RGB_DITHER_MAX);
  gtk_preview_size (GTK_PREVIEW (image),
		    IMPORT_PREVIEW_WIDTH, IMPORT_PREVIEW_HEIGHT);
  gtk_widget_set_usize (image, IMPORT_PREVIEW_WIDTH, IMPORT_PREVIEW_HEIGHT);
  gtk_box_pack_start (GTK_BOX (vbox), image, FALSE, FALSE, 0);
  gtk_widget_show (image);

  button = import_dialog->select = gtk_button_new_with_label (_("Select"));
  GTK_WIDGET_UNSET_FLAGS (button, GTK_RECEIVES_DEFAULT);
  gtk_signal_connect (GTK_OBJECT (button), "clicked", 
		      GTK_SIGNAL_FUNC (import_dialog_select_grad_callback),
		      (gpointer) image);
  gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
  gtk_widget_show (button);

  /*  Fill with the selected gradient  */
  palette_import_fill_grad_preview (image, curr_gradient);
  import_dialog->import_type = GRAD_IMPORT;
  return import_dialog;
}

/* Stuff to keep dialog uptodate */

void
palette_import_image_new (GimpImage * gimage)
{
  if (!import_dialog)
    return;

  if (!GTK_WIDGET_IS_SENSITIVE (import_dialog->image_menu_item_image))
    {
      gtk_widget_set_sensitive (import_dialog->image_menu_item_image, TRUE);
      return;
    }

  /* Now fill in the names if image menu shown */
  if (import_dialog->import_type == IMAGE_IMPORT)
    {
      import_image_menu_activate (TRUE, NULL);
    }
}

void
palette_import_image_destroyed (GimpImage* gimage)
{
  /* Now fill in the names if image menu shown */

  if (!import_dialog)
    return;

  if (image_count() <= 1)
    {
      /* Back to gradient type */
      gtk_option_menu_set_history (GTK_OPTION_MENU (import_dialog->type_option), 0);
      import_grad_callback (NULL, NULL);
      if (import_dialog->image_menu_item_image)
	gtk_widget_set_sensitive (import_dialog->image_menu_item_image, FALSE);
      return;
    }

  if (import_dialog->import_type == IMAGE_IMPORT)
    {
      import_image_menu_activate (TRUE, gimage);
    }
}

void
palette_import_image_renamed (GimpImage* gimage)
{
  /* Now fill in the names if image menu shown */
  if(import_dialog && import_dialog->import_type == IMAGE_IMPORT)
    {
      import_image_menu_activate (TRUE, NULL);
    }
}

typedef struct _ImgColors ImgColors;

struct _ImgColors
{
  guint count;
  guint r_adj;
  guint g_adj;
  guint b_adj;
  guchar r;
  guchar g;
  guchar b;
};

static gint count_color_entries = 0;

static void
create_storted_list (gpointer key,
		     gpointer value,
		     gpointer user_data)
{
  GSList    **sorted_list = (GSList**) user_data;
  ImgColors  *color_tab  = (ImgColors *) value;

  *sorted_list = g_slist_prepend (*sorted_list, color_tab);
}

static void 
create_image_palette (gpointer data,
		      gpointer user_data)
{
  PaletteDialog *palette = (PaletteDialog *) user_data;
  ImgColors *color_tab = (ImgColors *) data;
  gint sample_sz;
  gchar *lab;

  sample_sz = (gint) import_dialog->sample->value;  

  if (palette->entries->n_colors >= sample_sz)
    return;

  lab = g_strdup_printf ("%s (occurs %u)", _("Untitled"), color_tab->count);

  /* Adjust the colors to the mean of the the sample */
  palette_add_entry (palette->entries, lab, 
		     (gint)color_tab->r + (color_tab->r_adj/color_tab->count), 
		     (gint)color_tab->g + (color_tab->g_adj/color_tab->count), 
		     (gint)color_tab->b + (color_tab->b_adj/color_tab->count));
}

static gboolean
color_print_remove (gpointer key,
		    gpointer value,
		    gpointer user_data)
{
  g_free (value);

  return TRUE;
}

static gint 
sort_colors (gconstpointer a,
	     gconstpointer b)
{
  ImgColors *s1 = (ImgColors *) a;
  ImgColors *s2 = (ImgColors *) b;

  if(s1->count > s2->count)
    return -1;
  if(s1->count < s2->count)
    return 1;

  return 0;
}

static void
import_image_make_palette (GHashTable    *h_array,
			   guchar        *name,
			   PaletteDialog *palette)
{
  GSList * sorted_list = NULL;
  PaletteEntriesP entries;

  g_hash_table_foreach (h_array, create_storted_list, &sorted_list);
  sorted_list = g_slist_sort (sorted_list, sort_colors);

  entries = palette_create_entries (palette, name);
  g_slist_foreach (sorted_list, create_image_palette, palette);

  /* Free up used memory */
  /* Note the same structure is on both the hash list and the sorted
   * list. So only delete it once.
   */
  g_hash_table_freeze (h_array);
  g_hash_table_foreach_remove (h_array, color_print_remove, NULL);
  g_hash_table_thaw (h_array);
  g_hash_table_destroy (h_array);
  g_slist_free (sorted_list);

  /* Redraw with new palette */
  palette_update_small_preview (palette);
  redraw_palette (palette);
  /* Update other selectors on screen */
  palette_select_clist_insert_all (entries);
  palette_select2_clist_insert_all (entries);
  palette_scroll_clist_to_current (palette);
}

static GHashTable *
store_colors (GHashTable *h_array, 
	      guchar     *colors,
	      guchar     *colors_real, 
	      gint        sample_sz)
{
  gpointer found_color = NULL;
  ImgColors *new_color;
  guint key_colors = colors[0]*256*256+colors[1]*256+colors[2];

  if(h_array == NULL)
    {
      h_array = g_hash_table_new (g_direct_hash, g_direct_equal);
      count_color_entries = 0;
    }
  else
    {
      found_color = g_hash_table_lookup (h_array, (gpointer) key_colors);
    }

  if (found_color == NULL)
    {
      if (count_color_entries > MAX_IMAGE_COLORS)
	{
	  /* Don't add any more new ones */
	  return h_array;
	}

      count_color_entries++;

      new_color = g_new (ImgColors, 1);

      new_color->count = 1;
      new_color->r_adj = 0;
      new_color->g_adj = 0;
      new_color->b_adj = 0;
      new_color->r = colors[0];
      new_color->g = colors[1];
      new_color->b = colors[2];

      g_hash_table_insert (h_array, (gpointer) key_colors, new_color);
    }
  else
    {
      new_color = (ImgColors *) found_color;
      if(new_color->count < (G_MAXINT - 1))
	new_color->count++;
      
      /* Now do the adjustments ...*/
      new_color->r_adj += (colors_real[0] - colors[0]);
      new_color->g_adj += (colors_real[1] - colors[1]);
      new_color->b_adj += (colors_real[2] - colors[2]);

      /* Boundary conditions */
      if(new_color->r_adj > (G_MAXINT - 255))
	new_color->r_adj /= new_color->count;

      if(new_color->g_adj > (G_MAXINT - 255))
	new_color->g_adj /= new_color->count;

      if(new_color->b_adj > (G_MAXINT - 255))
	new_color->b_adj /= new_color->count;

    }

  return h_array;
}

static void
import_palette_create_from_image (GImage        *gimage,
				  guchar        *pname,
				  PaletteDialog *palette)
{
  PixelRegion imagePR;
  guchar *image_data;
  guchar *idata;
  guchar  rgb[MAX_CHANNELS];
  guchar  rgb_real[MAX_CHANNELS];
  gint has_alpha, indexed;
  gint width, height;
  gint bytes, alpha;
  gint i, j;
  void * pr;
  gint d_type;
  GHashTable *store_array = NULL;
  gint sample_sz;
  gint threshold = 1;

  sample_sz = (gint) import_dialog->sample->value;  

  if (gimage == NULL)
    return;

  /*  Get the image information  */
  bytes = gimage_composite_bytes (gimage);
  d_type = gimage_composite_type (gimage);
  has_alpha = (d_type == RGBA_GIMAGE ||
	       d_type == GRAYA_GIMAGE ||
	       d_type == INDEXEDA_GIMAGE);
  indexed = d_type == INDEXEDA_GIMAGE || d_type == INDEXED_GIMAGE;
  width = gimage->width;
  height = gimage->height;
  pixel_region_init (&imagePR, gimage_composite (gimage), 0, 0,
		     width, height, FALSE);

  alpha = bytes - 1;

  threshold = (gint) import_dialog->threshold->value;

  if(threshold < 1)
    threshold = 1;

  /*  iterate over the entire image  */
  for (pr = pixel_regions_register (1, &imagePR);
       pr != NULL;
       pr = pixel_regions_process (pr))
    {
      image_data = imagePR.data;

      for (i = 0; i < imagePR.h; i++)
	{
	  idata = image_data;

	  for (j = 0; j < imagePR.w; j++)
	    {
	      /*  Get the rgb values for the color  */
	      gimage_get_color (gimage, d_type, rgb, idata);
	      memcpy (rgb_real, rgb, MAX_CHANNELS); /* Structure copy */

	      rgb[0] = (rgb[0] / threshold) * threshold;
	      rgb[1] = (rgb[1] / threshold) * threshold;
	      rgb[2] = (rgb[2] / threshold) * threshold;

	      store_array =
		store_colors (store_array, rgb, rgb_real, sample_sz);

	      idata += bytes;
	    }

	  image_data += imagePR.rowstride;
	}
    }

  /* Make palette from the store_array */
  import_image_make_palette (store_array, pname, palette);
}