mirror of
https://gitlab.gnome.org/GNOME/gimp
synced 2024-10-21 20:12:30 +00:00
2f392e82b4
Wed Sep 29 21:56:52 BST 1999 Andy Thomas <alt@gimp.org> * app/colourmap_dialog.i.c * app/gdisplay_ops.c * app/palette.c 1) Index palette dialog now registered so it gets hidden/shown when the "TAB key" is pressed in the canvas window. 2) When the index palette is modified the changes are now shown immediately in all views. 3) DND now works in the index palette. 4) OK button when modifying a colour in the index palette dismisses the dialog correctly. 5) DND in the colour palette viewer does not crash when no colours are selected. 6) Corrected a problem with "New View". If your canvas is zoomed in and the image is offset in the display and a new view is requested the Canvas in the new view is corrupted. This bug is also in gimp 1.0.x
3279 lines
80 KiB
C
3279 lines
80 KiB
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_select.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;
|
|
ColorSelectP color_select;
|
|
int color_select_active;
|
|
PaletteEntriesP entries;
|
|
PaletteEntryP color;
|
|
GdkGC *gc;
|
|
guint entry_sig_id;
|
|
gfloat zoom_factor; /* range from 0.1 to 4.0 */
|
|
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_select)
|
|
color_select_free (top_level_edit_palette->color_select);
|
|
|
|
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/color_palette_edit_dialog.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;
|
|
|
|
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_select_active)
|
|
{
|
|
palette->color_select_active = 0;
|
|
color_select_hide (palette->color_select);
|
|
}
|
|
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,
|
|
ColorSelectState 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_SELECT_UPDATE:
|
|
break;
|
|
case COLOR_SELECT_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_SELECT_CANCEL:
|
|
color_select_hide (palette->color_select);
|
|
palette->color_select_active = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
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_select_active)
|
|
{
|
|
palette->color_select_active = 0;
|
|
color_select_hide (palette->color_select);
|
|
}
|
|
|
|
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_select)
|
|
{
|
|
palette->color_select =
|
|
color_select_new (color[0], color[1], color[2],
|
|
palette_select_callback, palette,
|
|
FALSE);
|
|
palette->color_select_active = 1;
|
|
}
|
|
else
|
|
{
|
|
if (!palette->color_select_active)
|
|
{
|
|
color_select_show (palette->color_select);
|
|
palette->color_select_active = 1;
|
|
}
|
|
|
|
color_select_set_color (palette->color_select,
|
|
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->zoom_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->zoom_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->zoom_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;
|
|
|
|
width = palette->color_area->parent->parent->allocation.width;
|
|
entry_width = (ENTRY_WIDTH*palette->zoom_factor)+SPACING;
|
|
ncols = width/entry_width;
|
|
|
|
if(ncols <= 0 ||
|
|
(palette->columns_valid && palette->columns == ncols))
|
|
return;
|
|
|
|
palette->columns_valid = TRUE;
|
|
palette->columns = ncols;
|
|
|
|
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->zoom_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_select_active)
|
|
{
|
|
palette->color_select_active = 0;
|
|
color_select_hide (palette->color_select);
|
|
}
|
|
|
|
if (palette->color_select)
|
|
color_select_free (palette->color_select);
|
|
palette->color_select = 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_select = NULL;
|
|
palette->color_select_active = 0;
|
|
palette->zoom_factor = 1.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/color_palette_edit_dialog.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/color_palette_dialog.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_AUTOMATIC);
|
|
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/color_palette_edit_dialog.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/import_palette_dialog.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);
|
|
}
|