mirror of
https://gitlab.gnome.org/GNOME/gimp
synced 2024-10-21 03:52:33 +00:00
2c0adc456a
Mon May 3 21:44:27 BST 1999 Austin Donnelly <austin@gimp.org> * app/palette.c: put up messages telling user about corrupted palette files as we load them. In particular, try and catch MSDOS format files such as those distributed from Visibone's website.
3196 lines
81 KiB
C
3196 lines
81 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 "actionarea.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 "general.h"
|
|
#include "gimprc.h"
|
|
#include "gradient_header.h"
|
|
#include "gradient.h"
|
|
#include "interface.h"
|
|
#include "palette.h"
|
|
#include "palette_entries.h"
|
|
#include "session.h"
|
|
#include "palette_select.h"
|
|
#include "dialog_handler.h"
|
|
|
|
#include "pixmaps/zoom_in.xpm"
|
|
#include "pixmaps/zoom_out.xpm"
|
|
|
|
#include "libgimp/gimpintl.h"
|
|
|
|
#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_COLOURS (10000*2)
|
|
|
|
typedef enum
|
|
{
|
|
GRAD_IMPORT = 0,
|
|
IMAGE_IMPORT = 1,
|
|
} ImportType;
|
|
|
|
|
|
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 _ImportDialog ImportDialog ,*ImportDialogP;
|
|
typedef struct _Palette _Palette, *PaletteP;
|
|
|
|
struct _Palette {
|
|
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;
|
|
};
|
|
|
|
|
|
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 *);
|
|
|
|
PaletteP create_palette_dialog (gint vert);
|
|
static void palette_draw_entries (PaletteP palette,gint row_start, gint column_highlight);
|
|
static void redraw_palette(PaletteP palette);
|
|
static GSList * palette_entries_insert_list (GSList *list,PaletteEntriesP entries,gint pos);
|
|
void palette_clist_init(GtkWidget *clist,
|
|
GtkWidget *shell,
|
|
GdkGC *gc);
|
|
static void palette_draw_small_preview(GdkGC *gc, PaletteEntriesP p_entry);
|
|
static void palette_scroll_clist_to_current(PaletteP palette);
|
|
static void palette_update_small_preview(PaletteP palette);
|
|
static void palette_scroll_top_left(PaletteP palette);
|
|
static ImportDialogP palette_import_dialog(PaletteP palette);
|
|
static void palette_import_dialog_callback (GtkWidget *w,gpointer client_data);
|
|
static void import_palette_create_from_image (GImage *gimage,guchar *pname,PaletteP palette);
|
|
static void palette_merge_dialog_callback (GtkWidget *w,gpointer client_data);
|
|
|
|
|
|
GSList *palette_entries_list = NULL;
|
|
static PaletteEntriesP default_palette_entries = NULL;
|
|
static int num_palette_entries = 0;
|
|
static unsigned char foreground[3] = { 0, 0, 0 };
|
|
static unsigned char background[3] = { 255, 255, 255 };
|
|
static ImportDialogP import_dialog = NULL;
|
|
|
|
PaletteP top_level_edit_palette = NULL;
|
|
PaletteP top_level_palette = NULL;
|
|
|
|
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 (char *filename)
|
|
{
|
|
if (filename)
|
|
unlink (filename);
|
|
}
|
|
|
|
void
|
|
palettes_init (int 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 (unsigned char *r,
|
|
unsigned char *g,
|
|
unsigned char *b)
|
|
{
|
|
*r = foreground[0];
|
|
*g = foreground[1];
|
|
*b = foreground[2];
|
|
}
|
|
|
|
void
|
|
palette_get_background (unsigned char *r,
|
|
unsigned char *g,
|
|
unsigned char *b)
|
|
{
|
|
*r = background[0];
|
|
*g = background[1];
|
|
*b = background[2];
|
|
}
|
|
|
|
void
|
|
palette_set_foreground (int r,
|
|
int g,
|
|
int b)
|
|
{
|
|
unsigned char rr, gg, bb;
|
|
|
|
/* Foreground */
|
|
foreground[0] = r;
|
|
foreground[1] = g;
|
|
foreground[2] = b;
|
|
|
|
palette_get_foreground (&rr, &gg, &bb);
|
|
if (no_interface == FALSE)
|
|
{
|
|
store_color (&foreground_pixel, rr, gg, bb);
|
|
color_area_update ();
|
|
device_status_update (current_device);
|
|
}
|
|
}
|
|
|
|
void
|
|
palette_set_background (int r,
|
|
int g,
|
|
int b)
|
|
{
|
|
unsigned char rr, gg, bb;
|
|
|
|
/* Background */
|
|
background[0] = r;
|
|
background[1] = g;
|
|
background[2] = b;
|
|
|
|
palette_get_background (&rr, &gg, &bb);
|
|
if (no_interface == FALSE)
|
|
{
|
|
store_color (&background_pixel, 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)
|
|
{
|
|
unsigned char fg_r, fg_g, fg_b;
|
|
unsigned char 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 (int 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;
|
|
char *num_buf;
|
|
GSList *plist;
|
|
PaletteP 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()
|
|
{
|
|
PaletteP 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;
|
|
PaletteP 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 *w,
|
|
gpointer client_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,
|
|
char *filename)
|
|
{
|
|
FILE * fp;
|
|
GSList * list;
|
|
PaletteEntryP entry;
|
|
|
|
if (! filename)
|
|
return;
|
|
|
|
/* Open the requested file */
|
|
if (! (fp = fopen (filename, "wb")))
|
|
{
|
|
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,
|
|
char *name,
|
|
int r,
|
|
int g,
|
|
int b)
|
|
{
|
|
PaletteEntryP entry;
|
|
|
|
if (entries)
|
|
{
|
|
entry = g_malloc (sizeof (_PaletteEntry));
|
|
|
|
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 (int r,
|
|
int g,
|
|
int b,
|
|
int 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 (int r,
|
|
int g,
|
|
int b,
|
|
int state)
|
|
{
|
|
palette_change_color (r, g, b, state);
|
|
}
|
|
|
|
static void
|
|
palette_entries_load (char *filename)
|
|
{
|
|
PaletteEntriesP entries;
|
|
char str[512];
|
|
char *tok;
|
|
FILE *fp;
|
|
int r, g, b;
|
|
int linenum;
|
|
GSList *list;
|
|
gint pos = 0;
|
|
PaletteEntriesP p_entries = NULL;
|
|
|
|
|
|
r = g = b = 0;
|
|
|
|
entries = (PaletteEntriesP) g_malloc (sizeof (_PaletteEntries));
|
|
|
|
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, "rb")))
|
|
{
|
|
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:\nCorrupt palette: missing magic header\nDoes this file need converting from DOS?"), filename);
|
|
else
|
|
g_message (_("Loading palette %s:\nCorrupt 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):\nMissing 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):\nMissing GREEN component"), filename, linenum);
|
|
}
|
|
|
|
tok = strtok (NULL, " \t");
|
|
if (tok) {
|
|
b = atoi (tok);
|
|
} else {
|
|
g_message (_("Loading palette %s (line %d):\nMissing 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):\nRGB value out of range"), filename, linenum);
|
|
|
|
palette_add_entry (entries, tok, r, g, b);
|
|
} /* if */
|
|
} /* while */
|
|
|
|
/* 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 PaletteP
|
|
new_top_palette(gint vert)
|
|
{
|
|
PaletteP 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)
|
|
{
|
|
PaletteP 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(PaletteP palette)
|
|
{
|
|
GSList *list;
|
|
gint pos = 0;
|
|
PaletteEntriesP p_entries = NULL;
|
|
char *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 *w,
|
|
gpointer client_data)
|
|
{
|
|
PaletteEntryP entry;
|
|
GSList *tmp_link;
|
|
PaletteP palette;
|
|
gint pos = 0;
|
|
|
|
palette = client_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 *w,
|
|
gpointer client_data)
|
|
{
|
|
PaletteP palette;
|
|
char *num_buf;
|
|
GSList *list;
|
|
gint pos = 0;
|
|
PaletteEntriesP p_entries = NULL;
|
|
|
|
palette = client_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 client_data,
|
|
gpointer call_data)
|
|
{
|
|
char *home;
|
|
char *palette_name;
|
|
char *local_path;
|
|
char *first_token;
|
|
char *token;
|
|
char *path;
|
|
PaletteEntriesP entries = NULL;
|
|
PaletteP palette;
|
|
GSList *list;
|
|
gint pos = 0;
|
|
PaletteEntriesP p_entries = NULL;
|
|
|
|
palette = client_data;
|
|
|
|
palette_name = (char *) call_data;
|
|
if (palette && palette_name)
|
|
{
|
|
entries = g_malloc (sizeof (_PaletteEntries));
|
|
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 *w,
|
|
gpointer client_data,
|
|
gpointer call_data)
|
|
{
|
|
PaletteEntriesP entries;
|
|
entries = palette_create_entries(client_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((PaletteP)client_data);
|
|
}
|
|
|
|
static void
|
|
palette_new_entries_callback (GtkWidget *w,
|
|
gpointer client_data)
|
|
{
|
|
query_string_box (_("New Palette"),
|
|
_("Enter a name for new palette"),
|
|
NULL,
|
|
NULL, NULL,
|
|
palette_add_entries_callback, client_data);
|
|
}
|
|
|
|
static void
|
|
redraw_zoom(PaletteP 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 *w,
|
|
gpointer client_data)
|
|
{
|
|
PaletteP palette = client_data;
|
|
palette->zoom_factor += 0.1;
|
|
redraw_zoom(palette);
|
|
}
|
|
|
|
static void
|
|
palette_zoomout (GtkWidget *w,
|
|
gpointer client_data)
|
|
{
|
|
PaletteP palette = client_data;
|
|
palette->zoom_factor -= 0.1;
|
|
redraw_zoom(palette);
|
|
}
|
|
|
|
static void
|
|
palette_refresh(PaletteP 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 *w,
|
|
gpointer client_data)
|
|
{
|
|
palette_refresh(client_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,SM_PREVIEW_WIDTH*SM_PREVIEW_HEIGHT*3);
|
|
|
|
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];
|
|
int 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 (int r,
|
|
int g,
|
|
int b,
|
|
ColorSelectState state,
|
|
void *client_data)
|
|
{
|
|
PaletteP palette;
|
|
unsigned char * color;
|
|
GSList *list;
|
|
gint pos = 0;
|
|
PaletteEntriesP p_entries = NULL;
|
|
|
|
palette = client_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(PaletteP 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 *w,
|
|
gpointer client_data)
|
|
{
|
|
PaletteP palette;
|
|
PaletteEntriesP entries;
|
|
|
|
palette = client_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 *w,
|
|
gpointer client_data)
|
|
{
|
|
PaletteP palette;
|
|
|
|
palette = client_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 gint
|
|
palette_dialog_delete_callback (GtkWidget *w,
|
|
GdkEvent *e,
|
|
gpointer client_data)
|
|
{
|
|
palette_close_callback (w, client_data);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
static void
|
|
color_name_entry_changed (GtkWidget *widget, gpointer pdata)
|
|
{
|
|
PaletteP palette;
|
|
|
|
palette = pdata;
|
|
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 client_data)
|
|
{
|
|
PaletteP palette;
|
|
unsigned char *color;
|
|
|
|
palette = client_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(PaletteP 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,
|
|
PaletteP palette)
|
|
{
|
|
GdkEventButton *bevent;
|
|
GSList *tmp_link;
|
|
int r, g, b;
|
|
int width, height;
|
|
int entry_width;
|
|
int entry_height;
|
|
int row, col;
|
|
int pos;
|
|
|
|
switch (event->type)
|
|
{
|
|
case GDK_BUTTON_PRESS:
|
|
bevent = (GdkEventButton *) event;
|
|
width = palette->color_area->requisition.width;
|
|
height = palette->color_area->requisition.height;
|
|
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)
|
|
palette_set_foreground (r, g, b);
|
|
else if (active_color == BACKGROUND)
|
|
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((void *)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 (unsigned char **colors,
|
|
gint ncolors,
|
|
gint y,
|
|
gint column_highlight,
|
|
unsigned char *buffer,
|
|
PaletteP palette)
|
|
{
|
|
unsigned char *p;
|
|
unsigned char bcolor;
|
|
int width, height;
|
|
int entry_width;
|
|
int entry_height;
|
|
int vsize;
|
|
int vspacing;
|
|
int 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 (PaletteP palette,gint row_start, gint column_highlight)
|
|
{
|
|
PaletteEntryP entry;
|
|
unsigned char *buffer;
|
|
unsigned char **colors;
|
|
GSList *tmp_link;
|
|
int width, height;
|
|
int entry_width;
|
|
int entry_height;
|
|
int 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(unsigned char *) * 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(PaletteP 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(PaletteP palette)
|
|
{
|
|
gint vsize;
|
|
gint nrows;
|
|
gint n_entries;
|
|
GtkWidget *parent;
|
|
gint new_pre_width;
|
|
|
|
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)
|
|
{
|
|
PaletteP palette;
|
|
PaletteEntriesP p_entries;
|
|
|
|
palette = (PaletteP)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;
|
|
|
|
redraw_palette(palette);
|
|
|
|
palette_scroll_top_left(palette);
|
|
|
|
/* Stop errors in case no colours 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 *w,
|
|
gpointer client_data)
|
|
{
|
|
PaletteEntriesP p_entries = NULL;
|
|
PaletteP palette = (PaletteP)client_data;
|
|
GList *sel_list;
|
|
|
|
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;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
PaletteP
|
|
create_palette_dialog (gint vert)
|
|
{
|
|
GtkWidget *palette_dialog;
|
|
GtkWidget *dialog_vbox3;
|
|
GtkWidget *hbox3;
|
|
GtkWidget *hbox4;
|
|
GtkWidget *hbox5;
|
|
GtkWidget *vbox4;
|
|
GtkWidget *palette_scrolledwindow;
|
|
GtkWidget *palette_region;
|
|
GtkWidget *color_name;
|
|
GtkWidget *alignment1;
|
|
GtkWidget *palette_list;
|
|
GtkWidget *frame1;
|
|
GtkWidget *vbuttonbox2;
|
|
GtkWidget *new_palette;
|
|
GtkWidget *delete_palette;
|
|
GtkWidget *save_palettes;
|
|
GtkWidget *import_palette;
|
|
GtkWidget *merge_palette;
|
|
GtkWidget *dialog_action_area3;
|
|
GtkWidget *alignment2;
|
|
GtkWidget *hbuttonbox3;
|
|
GtkWidget *close_button;
|
|
GtkWidget *refresh_button;
|
|
GtkWidget *clist_scrolledwindow;
|
|
PaletteP palette;
|
|
GdkColormap *colormap;
|
|
GtkWidget* button_plus;
|
|
GtkWidget* button_minus;
|
|
GtkWidget* pixmapwid;
|
|
GdkPixmap* pixmap;
|
|
GdkBitmap* mask;
|
|
GtkStyle* style;
|
|
|
|
palette = g_malloc (sizeof (_Palette));
|
|
|
|
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->freeze_update = FALSE;
|
|
|
|
palette->shell = palette_dialog = gtk_dialog_new ();
|
|
|
|
gtk_window_set_wmclass (GTK_WINDOW (palette->shell), "color_palette", "Gimp");
|
|
|
|
if(!vert)
|
|
{
|
|
gtk_widget_set_usize (palette_dialog, 615, 200);
|
|
}
|
|
else
|
|
{
|
|
gtk_widget_set_usize (palette_dialog, 230, 300);
|
|
}
|
|
|
|
if(!vert)
|
|
{
|
|
gtk_window_set_title (GTK_WINDOW (palette_dialog), _("Color Palette Edit"));
|
|
}
|
|
else
|
|
{
|
|
gtk_window_set_title (GTK_WINDOW (palette_dialog), _("Color Palette"));
|
|
}
|
|
|
|
gtk_window_set_policy (GTK_WINDOW (palette_dialog), TRUE, TRUE, FALSE);
|
|
|
|
dialog_vbox3 = GTK_DIALOG (palette_dialog)->vbox;
|
|
gtk_object_set_data (GTK_OBJECT (palette_dialog), "dialog_vbox3", dialog_vbox3);
|
|
gtk_widget_show (dialog_vbox3);
|
|
|
|
if(vert)
|
|
{
|
|
hbox3 = gtk_notebook_new();
|
|
gtk_widget_show (hbox3);
|
|
gtk_box_pack_start (GTK_BOX (dialog_vbox3), hbox3, TRUE, TRUE, 0);
|
|
}
|
|
else
|
|
{
|
|
hbox3 = gtk_hbox_new (FALSE, 0);
|
|
gtk_widget_show (hbox3);
|
|
gtk_box_pack_start (GTK_BOX (dialog_vbox3), hbox3, TRUE, TRUE, 0);
|
|
}
|
|
|
|
vbox4 = gtk_vbox_new (FALSE, 0);
|
|
gtk_object_set_data (GTK_OBJECT (palette_dialog), "vbox4", vbox4);
|
|
gtk_widget_show (vbox4);
|
|
if(!vert)
|
|
{
|
|
gtk_box_pack_start (GTK_BOX (hbox3), vbox4, TRUE, TRUE, 0);
|
|
}
|
|
|
|
alignment1 = gtk_alignment_new (0.5, 0.5, 0.0, 0.0);
|
|
gtk_object_set_data (GTK_OBJECT (palette_dialog), "alignment1", alignment1);
|
|
gtk_widget_show (alignment1);
|
|
|
|
palette->scrolled_window =
|
|
palette_scrolledwindow = gtk_scrolled_window_new (NULL, NULL);
|
|
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (palette_scrolledwindow),
|
|
GTK_POLICY_AUTOMATIC,
|
|
GTK_POLICY_AUTOMATIC);
|
|
|
|
gtk_object_set_data (GTK_OBJECT (palette_dialog), "palette_scrolledwindow", palette_scrolledwindow);
|
|
gtk_widget_show (palette_scrolledwindow);
|
|
gtk_box_pack_start (GTK_BOX (vbox4), palette_scrolledwindow, TRUE, TRUE, 0);
|
|
|
|
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_widget_show (palette_region);
|
|
gtk_container_add (GTK_CONTAINER (alignment1), palette_region);
|
|
gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (palette_scrolledwindow), alignment1);
|
|
|
|
hbox4 = gtk_hbox_new (FALSE, 0);
|
|
gtk_box_pack_start (GTK_BOX (vbox4), hbox4, FALSE, FALSE, 0);
|
|
gtk_widget_show(hbox4);
|
|
|
|
palette->color_name = color_name = gtk_entry_new ();
|
|
gtk_widget_show (color_name);
|
|
gtk_box_pack_start (GTK_BOX (hbox4), color_name, TRUE, TRUE, 0);
|
|
gtk_entry_set_text (GTK_ENTRY (color_name), _("Undefined"));
|
|
palette->entry_sig_id = gtk_signal_connect (GTK_OBJECT (color_name), "changed",
|
|
GTK_SIGNAL_FUNC (color_name_entry_changed),
|
|
palette);
|
|
|
|
/* + and - buttons */
|
|
style = gtk_widget_get_style(palette_dialog);
|
|
gtk_widget_realize(palette_dialog);
|
|
|
|
button_plus = gtk_button_new ();
|
|
GTK_WIDGET_UNSET_FLAGS (button_plus, GTK_RECEIVES_DEFAULT);
|
|
gtk_signal_connect (GTK_OBJECT (button_plus), "clicked",
|
|
GTK_SIGNAL_FUNC (palette_zoomin), (gpointer) palette);
|
|
gtk_box_pack_start (GTK_BOX (hbox4), button_plus, FALSE, FALSE, 0);
|
|
|
|
button_minus = gtk_button_new ();
|
|
GTK_WIDGET_UNSET_FLAGS (button_minus, GTK_RECEIVES_DEFAULT);
|
|
gtk_signal_connect (GTK_OBJECT (button_minus), "clicked",
|
|
GTK_SIGNAL_FUNC (palette_zoomout), (gpointer) palette);
|
|
gtk_box_pack_start (GTK_BOX (hbox4), button_minus, FALSE, FALSE, 0);
|
|
|
|
pixmap = gdk_pixmap_create_from_xpm_d(palette_dialog->window, &mask,
|
|
&style->bg[GTK_STATE_NORMAL],
|
|
zoom_in_xpm);
|
|
pixmapwid = gtk_pixmap_new(pixmap, mask);
|
|
gtk_container_add (GTK_CONTAINER (button_plus), pixmapwid);
|
|
gtk_widget_show (pixmapwid);
|
|
|
|
pixmap = gdk_pixmap_create_from_xpm_d(palette_dialog->window, &mask,
|
|
&style->bg[GTK_STATE_NORMAL],
|
|
zoom_out_xpm);
|
|
pixmapwid = gtk_pixmap_new(pixmap, mask);
|
|
gtk_container_add (GTK_CONTAINER (button_minus), pixmapwid);
|
|
gtk_widget_show (pixmapwid);
|
|
|
|
gtk_widget_show (button_plus);
|
|
gtk_widget_show (button_minus);
|
|
|
|
|
|
/* clist preview of palettes */
|
|
clist_scrolledwindow = gtk_scrolled_window_new (NULL, NULL);
|
|
palette->clist = palette_list = gtk_clist_new (3);
|
|
gtk_object_set_data (GTK_OBJECT (palette_dialog), "palette_list", palette_list);
|
|
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(hbox3),
|
|
vbox4,
|
|
gtk_label_new("Palette"));
|
|
gtk_notebook_append_page(GTK_NOTEBOOK(hbox3),
|
|
clist_scrolledwindow,
|
|
gtk_label_new("Select"));
|
|
gtk_widget_show (palette_list);
|
|
}
|
|
else
|
|
{
|
|
gtk_container_add (GTK_CONTAINER (hbox3), clist_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 (clist_scrolledwindow), GTK_WIDGET(palette->clist));
|
|
|
|
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (clist_scrolledwindow),
|
|
GTK_POLICY_AUTOMATIC,
|
|
GTK_POLICY_ALWAYS);
|
|
|
|
if(!vert)
|
|
{
|
|
gtk_clist_set_selection_mode(GTK_CLIST(palette_list),GTK_SELECTION_EXTENDED);
|
|
}
|
|
|
|
gtk_widget_show(clist_scrolledwindow);
|
|
|
|
gtk_container_border_width (GTK_CONTAINER (palette_list), 4);
|
|
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)
|
|
{
|
|
frame1 = gtk_frame_new (_("Palette Ops"));
|
|
gtk_object_set_data (GTK_OBJECT (palette_dialog), "frame1", frame1);
|
|
gtk_widget_show (frame1);
|
|
gtk_box_pack_end (GTK_BOX (hbox3), frame1, FALSE, FALSE, 7);
|
|
|
|
vbuttonbox2 = gtk_vbutton_box_new ();
|
|
gtk_object_set_data (GTK_OBJECT (palette_dialog), "vbuttonbox2", vbuttonbox2);
|
|
gtk_widget_show (vbuttonbox2);
|
|
gtk_container_add (GTK_CONTAINER (frame1), vbuttonbox2);
|
|
gtk_container_border_width (GTK_CONTAINER (vbuttonbox2), 6);
|
|
gtk_button_box_set_layout (GTK_BUTTON_BOX (vbuttonbox2), GTK_BUTTONBOX_SPREAD);
|
|
gtk_button_box_set_spacing (GTK_BUTTON_BOX (vbuttonbox2), 0);
|
|
gtk_button_box_set_child_size (GTK_BUTTON_BOX (vbuttonbox2), 44, 22);
|
|
gtk_button_box_set_child_ipadding (GTK_BUTTON_BOX (vbuttonbox2), 17, 0);
|
|
|
|
new_palette = gtk_button_new_with_label (_("New"));
|
|
GTK_WIDGET_UNSET_FLAGS (new_palette, GTK_RECEIVES_DEFAULT);
|
|
gtk_signal_connect (GTK_OBJECT (new_palette), "clicked",
|
|
(GtkSignalFunc) palette_new_entries_callback,
|
|
(gpointer) palette);
|
|
gtk_object_set_data (GTK_OBJECT (palette_dialog), "new_palette", new_palette);
|
|
gtk_widget_show (new_palette);
|
|
gtk_container_add (GTK_CONTAINER (vbuttonbox2), new_palette);
|
|
|
|
delete_palette = gtk_button_new_with_label (_("Delete"));
|
|
GTK_WIDGET_UNSET_FLAGS (delete_palette, GTK_RECEIVES_DEFAULT);
|
|
gtk_signal_connect (GTK_OBJECT (delete_palette), "clicked",
|
|
(GtkSignalFunc) palette_delete_entries_callback,
|
|
(gpointer) palette);
|
|
gtk_widget_show (delete_palette);
|
|
gtk_container_add (GTK_CONTAINER (vbuttonbox2), delete_palette);
|
|
|
|
save_palettes = gtk_button_new_with_label (_("Save"));
|
|
GTK_WIDGET_UNSET_FLAGS (save_palettes, GTK_RECEIVES_DEFAULT);
|
|
gtk_signal_connect (GTK_OBJECT (save_palettes), "clicked",
|
|
(GtkSignalFunc) palette_save_palettes_callback,
|
|
(gpointer) NULL);
|
|
gtk_widget_show (save_palettes);
|
|
gtk_container_add (GTK_CONTAINER (vbuttonbox2), save_palettes);
|
|
|
|
import_palette = gtk_button_new_with_label (_("Import"));
|
|
GTK_WIDGET_UNSET_FLAGS (import_palette, GTK_RECEIVES_DEFAULT);
|
|
gtk_signal_connect (GTK_OBJECT (import_palette), "clicked",
|
|
(GtkSignalFunc) palette_import_dialog_callback,
|
|
(gpointer) palette);
|
|
gtk_widget_show (import_palette);
|
|
gtk_container_add (GTK_CONTAINER (vbuttonbox2), import_palette);
|
|
|
|
merge_palette = gtk_button_new_with_label (_("Merge"));
|
|
GTK_WIDGET_UNSET_FLAGS (merge_palette, GTK_RECEIVES_DEFAULT);
|
|
gtk_signal_connect (GTK_OBJECT (merge_palette), "clicked",
|
|
(GtkSignalFunc) palette_merge_dialog_callback,
|
|
(gpointer) palette);
|
|
gtk_widget_show (merge_palette);
|
|
gtk_container_add (GTK_CONTAINER (vbuttonbox2), merge_palette);
|
|
}
|
|
dialog_action_area3 = GTK_DIALOG (palette_dialog)->action_area;
|
|
gtk_object_set_data (GTK_OBJECT (palette_dialog), "dialog_action_area3", dialog_action_area3);
|
|
gtk_widget_show (dialog_action_area3);
|
|
gtk_container_border_width (GTK_CONTAINER (dialog_action_area3), 2);
|
|
|
|
alignment2 = gtk_alignment_new (0.5, 0.5, 1, 1);
|
|
gtk_object_set_data (GTK_OBJECT (palette_dialog), "alignment2", alignment2);
|
|
gtk_widget_show (alignment2);
|
|
gtk_box_pack_start (GTK_BOX (dialog_action_area3), alignment2, TRUE, TRUE, 0);
|
|
|
|
hbox5 = gtk_hbox_new (FALSE, 0);
|
|
gtk_container_add (GTK_CONTAINER (alignment2), hbox5);
|
|
gtk_widget_show (hbox5);
|
|
|
|
hbuttonbox3 = gtk_hbutton_box_new ();
|
|
gtk_object_set_data (GTK_OBJECT (palette_dialog), "hbuttonbox3", hbuttonbox3);
|
|
gtk_widget_show (hbuttonbox3);
|
|
gtk_box_pack_end (GTK_BOX(hbox5), hbuttonbox3, FALSE, FALSE, 0);
|
|
gtk_button_box_set_spacing (GTK_BUTTON_BOX (hbuttonbox3), 4);
|
|
|
|
gtk_signal_connect (GTK_OBJECT (palette->shell), "delete_event",
|
|
GTK_SIGNAL_FUNC (palette_dialog_delete_callback),
|
|
palette);
|
|
|
|
close_button = gtk_button_new_with_label (_("Close"));
|
|
GTK_WIDGET_SET_FLAGS (close_button, GTK_CAN_DEFAULT);
|
|
gtk_window_set_default (GTK_WINDOW (palette->shell), close_button);
|
|
gtk_signal_connect(GTK_OBJECT(close_button), "clicked",
|
|
GTK_SIGNAL_FUNC(palette_close_callback), (gpointer)palette);
|
|
|
|
if(!vert)
|
|
{
|
|
refresh_button = gtk_button_new_with_label (_("Refresh"));
|
|
gtk_signal_connect(GTK_OBJECT(refresh_button), "clicked",
|
|
GTK_SIGNAL_FUNC(palette_refresh_callback), (gpointer)palette);
|
|
}
|
|
else
|
|
{
|
|
refresh_button = gtk_button_new_with_label (_("Edit"));
|
|
gtk_signal_connect(GTK_OBJECT(refresh_button), "clicked",
|
|
GTK_SIGNAL_FUNC(palette_edit_palette_callback), (gpointer)palette);
|
|
}
|
|
|
|
GTK_WIDGET_SET_FLAGS (refresh_button, GTK_CAN_DEFAULT);
|
|
gtk_container_add (GTK_CONTAINER (hbuttonbox3), refresh_button);
|
|
gtk_widget_show (refresh_button);
|
|
gtk_container_add (GTK_CONTAINER (hbuttonbox3), close_button);
|
|
gtk_widget_show (close_button);
|
|
|
|
gtk_widget_realize(palette->shell);
|
|
palette->gc = gdk_gc_new(palette->shell->window);
|
|
|
|
colormap = gtk_widget_get_colormap(palette->clist);
|
|
|
|
palette_popup_menu(palette);
|
|
|
|
return palette;
|
|
}
|
|
|
|
static void
|
|
import_dialog_select_grad_callback (GtkWidget *w,
|
|
gpointer client_data)
|
|
{
|
|
/* Popup grad edit box .... */
|
|
grad_create_gradient_editor();
|
|
}
|
|
|
|
static void
|
|
import_dialog_close_callback (GtkWidget *w,
|
|
gpointer client_data)
|
|
{
|
|
gtk_widget_destroy(import_dialog->dialog);
|
|
g_free(import_dialog);
|
|
import_dialog = NULL;
|
|
}
|
|
|
|
static void
|
|
import_palette_create_from_grad(gchar *name,PaletteP 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 *w,
|
|
gpointer client_data)
|
|
{
|
|
PaletteP palette;
|
|
palette = client_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 gint
|
|
import_dialog_delete_callback (GtkWidget *w,
|
|
GdkEvent *e,
|
|
gpointer client_data)
|
|
{
|
|
import_dialog_close_callback(w,client_data);
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
static void
|
|
palette_merge_entries_callback (GtkWidget *w,
|
|
gpointer client_data,
|
|
gpointer call_data)
|
|
{
|
|
PaletteP palette;
|
|
PaletteEntriesP p_entries;
|
|
PaletteEntriesP new_entries;
|
|
GList *sel_list;
|
|
|
|
new_entries = palette_create_entries(client_data,call_data);
|
|
|
|
palette = (PaletteP)client_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 colours */
|
|
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 *w,
|
|
gpointer client_data)
|
|
{
|
|
query_string_box (_("Merge Palette"),
|
|
_("Enter a name for merged palette"),
|
|
NULL,
|
|
NULL, NULL,
|
|
palette_merge_entries_callback, client_data);
|
|
}
|
|
|
|
static void
|
|
palette_import_dialog_callback (GtkWidget *w,
|
|
gpointer client_data)
|
|
{
|
|
if(!import_dialog)
|
|
{
|
|
import_dialog = palette_import_dialog((PaletteP)client_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;
|
|
double dx, cur_x;
|
|
double 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=(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)
|
|
{
|
|
int 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_container_add(GTK_CONTAINER(import_dialog->select_area),optionmenu1);
|
|
|
|
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 ImportDialogP
|
|
palette_import_dialog(PaletteP palette)
|
|
{
|
|
GtkWidget *dialog1;
|
|
GtkWidget *dialog_vbox1;
|
|
GtkWidget *hbox2;
|
|
GtkWidget *import_frame;
|
|
GtkWidget *vbox2;
|
|
GtkWidget *table1;
|
|
GtkWidget *steps;
|
|
GtkWidget *import_name;
|
|
GtkWidget *import_type;
|
|
GtkWidget *spinbutton2;
|
|
GtkWidget *entry1;
|
|
GtkWidget *optionmenu1;
|
|
GtkWidget *optionmenu1_menu;
|
|
GtkWidget *menuitem;
|
|
GtkWidget *preview_frame;
|
|
GtkWidget *vbox1;
|
|
GtkWidget *image1;
|
|
GtkWidget *select;
|
|
GtkWidget *dialog_action_area1;
|
|
GtkWidget *hbox1;
|
|
GtkWidget *hscale1;
|
|
GtkWidget *import;
|
|
GtkWidget *close;
|
|
|
|
import_dialog = g_malloc(sizeof(struct _ImportDialog));
|
|
import_dialog->image_list = NULL;
|
|
import_dialog->gimage = NULL;
|
|
|
|
import_dialog->dialog = dialog1 = gtk_dialog_new ();
|
|
gtk_window_set_title (GTK_WINDOW (dialog1), _("Import Palette"));
|
|
gtk_window_set_policy (GTK_WINDOW (dialog1), TRUE, TRUE, FALSE);
|
|
|
|
dialog_vbox1 = GTK_DIALOG (dialog1)->vbox;
|
|
gtk_widget_show (dialog_vbox1);
|
|
|
|
hbox2 = gtk_hbox_new (FALSE, 0);
|
|
gtk_widget_show (hbox2);
|
|
gtk_box_pack_start (GTK_BOX (dialog_vbox1), hbox2, FALSE, FALSE, 0);
|
|
|
|
import_frame = gtk_frame_new (_("Import"));
|
|
gtk_widget_show (import_frame);
|
|
gtk_box_pack_start (GTK_BOX (hbox2), import_frame, TRUE, TRUE, 0);
|
|
|
|
vbox2 = gtk_vbox_new (FALSE, 0);
|
|
gtk_widget_show (vbox2);
|
|
gtk_container_add (GTK_CONTAINER (import_frame), vbox2);
|
|
|
|
table1 = gtk_table_new (4, 2, FALSE);
|
|
gtk_widget_show (table1);
|
|
gtk_box_pack_start (GTK_BOX (vbox2), table1, TRUE, TRUE, 0);
|
|
|
|
steps = gtk_label_new (_("Sample Size:"));
|
|
gtk_widget_show (steps);
|
|
gtk_table_attach (GTK_TABLE (table1), steps, 0, 1, 2, 3,
|
|
GTK_EXPAND | GTK_FILL, GTK_EXPAND, 0, 0);
|
|
gtk_label_set_justify (GTK_LABEL (steps), GTK_JUSTIFY_LEFT);
|
|
|
|
import_dialog->threshold_text =
|
|
steps = gtk_label_new (_("Interval:"));
|
|
gtk_widget_show (steps);
|
|
gtk_table_attach (GTK_TABLE (table1), steps, 0, 1, 3, 4,
|
|
GTK_EXPAND | GTK_FILL, GTK_EXPAND, 0, 0);
|
|
gtk_label_set_justify (GTK_LABEL (steps), GTK_JUSTIFY_LEFT);
|
|
gtk_widget_set_sensitive(steps,FALSE);
|
|
|
|
import_name = gtk_label_new (_("Name:"));
|
|
gtk_widget_show (import_name);
|
|
gtk_table_attach (GTK_TABLE (table1), import_name, 0, 1, 0, 1,
|
|
GTK_EXPAND | GTK_FILL, GTK_EXPAND, 0, 0);
|
|
gtk_label_set_justify (GTK_LABEL (import_name), GTK_JUSTIFY_LEFT);
|
|
|
|
import_type = gtk_label_new (_("Source:"));
|
|
gtk_widget_show (import_type);
|
|
gtk_table_attach (GTK_TABLE (table1), import_type, 0, 1, 1, 2,
|
|
GTK_EXPAND | GTK_FILL, GTK_EXPAND, 0, 0);
|
|
gtk_label_set_justify (GTK_LABEL (import_type), GTK_JUSTIFY_LEFT);
|
|
|
|
import_dialog->sample = GTK_ADJUSTMENT(gtk_adjustment_new (256, 2, 10000, 1, 10, 10));
|
|
spinbutton2 = gtk_spin_button_new (import_dialog->sample, 1, 0);
|
|
gtk_widget_show (spinbutton2);
|
|
gtk_table_attach (GTK_TABLE (table1), spinbutton2, 1, 2, 2, 3,
|
|
GTK_EXPAND | GTK_FILL, GTK_EXPAND, 0, 0);
|
|
|
|
import_dialog->threshold_scale =
|
|
hscale1 =
|
|
gtk_hscale_new (import_dialog->threshold =
|
|
GTK_ADJUSTMENT (gtk_adjustment_new (1, 1, 128, 1, 1, 1)));
|
|
gtk_scale_set_value_pos (GTK_SCALE (hscale1), GTK_POS_TOP);
|
|
gtk_scale_set_digits (GTK_SCALE (hscale1), 0);
|
|
gtk_widget_show (hscale1);
|
|
gtk_table_attach (GTK_TABLE (table1), hscale1, 1, 2, 3, 4,
|
|
GTK_EXPAND | GTK_FILL, GTK_EXPAND, 0, 0);
|
|
gtk_widget_set_sensitive(hscale1,FALSE);
|
|
|
|
import_dialog->entry = entry1 = gtk_entry_new ();
|
|
gtk_widget_show (entry1);
|
|
gtk_table_attach (GTK_TABLE (table1), entry1, 1, 2, 0, 1,
|
|
GTK_FILL, 0, 0, 0);
|
|
/* gtk_widget_set_usize (entry1, 100, -1); */
|
|
gtk_entry_set_text (GTK_ENTRY (entry1), (curr_gradient)?curr_gradient->name:_("new_import"));
|
|
|
|
import_dialog->type_option = optionmenu1 = gtk_option_menu_new ();
|
|
gtk_widget_show (optionmenu1);
|
|
gtk_table_attach (GTK_TABLE (table1), optionmenu1, 1, 2, 1, 2,
|
|
GTK_FILL, 0, 0, 0);
|
|
optionmenu1_menu = gtk_menu_new ();
|
|
import_dialog->image_menu_item_gradient =
|
|
menuitem = gtk_menu_item_new_with_label (_("Gradient"));
|
|
gtk_widget_show (menuitem);
|
|
gtk_signal_connect(GTK_OBJECT(menuitem), "activate",
|
|
(GtkSignalFunc) import_grad_callback,
|
|
NULL);
|
|
gtk_menu_append (GTK_MENU (optionmenu1_menu), menuitem);
|
|
import_dialog->image_menu_item_image = menuitem = gtk_menu_item_new_with_label ("Image");
|
|
gtk_widget_show (menuitem);
|
|
gtk_signal_connect(GTK_OBJECT(menuitem), "activate",
|
|
(GtkSignalFunc) import_image_callback,
|
|
(gpointer)import_dialog);
|
|
gtk_menu_append (GTK_MENU (optionmenu1_menu), menuitem);
|
|
|
|
gtk_option_menu_set_menu (GTK_OPTION_MENU (optionmenu1), optionmenu1_menu);
|
|
gtk_widget_set_sensitive(menuitem,image_count() > 0);
|
|
|
|
preview_frame = gtk_frame_new (_("Preview"));
|
|
gtk_widget_show (preview_frame);
|
|
gtk_box_pack_start (GTK_BOX (hbox2), preview_frame, TRUE, TRUE, 0);
|
|
|
|
import_dialog->select_area = vbox1 = gtk_vbox_new (FALSE, 0);
|
|
gtk_widget_show (vbox1);
|
|
gtk_container_add (GTK_CONTAINER (preview_frame), vbox1);
|
|
|
|
import_dialog->preview = image1 = gtk_preview_new (GTK_PREVIEW_COLOR);
|
|
gtk_preview_set_dither (GTK_PREVIEW (image1),
|
|
GDK_RGB_DITHER_MAX);
|
|
gtk_preview_size (GTK_PREVIEW (image1), IMPORT_PREVIEW_WIDTH, IMPORT_PREVIEW_HEIGHT);
|
|
gtk_widget_show (image1);
|
|
gtk_widget_set_usize (image1,IMPORT_PREVIEW_WIDTH, IMPORT_PREVIEW_HEIGHT);
|
|
gtk_box_pack_start (GTK_BOX (vbox1), image1, FALSE, FALSE, 0);
|
|
|
|
import_dialog->select = select = gtk_button_new_with_label (_("select"));
|
|
gtk_signal_connect(GTK_OBJECT(select), "clicked",
|
|
GTK_SIGNAL_FUNC(import_dialog_select_grad_callback),(gpointer)image1);
|
|
gtk_widget_show (select);
|
|
gtk_box_pack_start (GTK_BOX (vbox1), select, FALSE, FALSE, 0);
|
|
|
|
dialog_action_area1 = GTK_DIALOG (dialog1)->action_area;
|
|
gtk_container_border_width (GTK_CONTAINER (dialog_action_area1), 2);
|
|
gtk_widget_show (dialog_action_area1);
|
|
|
|
hbox1 = gtk_hbox_new (FALSE, 0);
|
|
gtk_widget_show (hbox1);
|
|
gtk_box_pack_start (GTK_BOX (dialog_action_area1), hbox1, TRUE, TRUE, 0);
|
|
|
|
import = gtk_button_new_with_label (_("import"));
|
|
gtk_widget_show (import);
|
|
gtk_signal_connect(GTK_OBJECT(import), "clicked",
|
|
GTK_SIGNAL_FUNC(import_dialog_import_callback),(gpointer)palette);
|
|
gtk_container_border_width (GTK_CONTAINER (import), 4);
|
|
gtk_box_pack_end (GTK_BOX (hbox1), import, FALSE, FALSE, 0);
|
|
|
|
close = gtk_button_new_with_label (_("close"));
|
|
gtk_signal_connect(GTK_OBJECT(close), "clicked",
|
|
GTK_SIGNAL_FUNC(import_dialog_close_callback),(gpointer)NULL);
|
|
gtk_widget_show (close);
|
|
gtk_box_pack_start (GTK_BOX (hbox1), close, FALSE, FALSE, 0);
|
|
GTK_WIDGET_SET_FLAGS (close, GTK_CAN_DEFAULT);
|
|
gtk_widget_grab_default (close);
|
|
|
|
gtk_signal_connect (GTK_OBJECT (dialog1), "delete_event",
|
|
GTK_SIGNAL_FUNC (import_dialog_delete_callback),
|
|
(gpointer)palette);
|
|
|
|
/* Fill with the selected gradient */
|
|
palette_import_fill_grad_preview(image1,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);
|
|
}
|
|
}
|
|
|
|
struct _img_colours {
|
|
guint count;
|
|
guint r_adj;
|
|
guint g_adj;
|
|
guint b_adj;
|
|
guchar r;
|
|
guchar g;
|
|
guchar b;
|
|
};
|
|
|
|
typedef struct _img_colours ImgColours, *ImgColoursP;
|
|
static int count_colour_entries = 0;
|
|
|
|
static void
|
|
create_storted_list(gpointer key,gpointer value,gpointer user_data)
|
|
{
|
|
GSList **sorted_list = (GSList**)user_data;
|
|
ImgColoursP colour_tab = (ImgColoursP)value;
|
|
|
|
*sorted_list = g_slist_prepend(*sorted_list,colour_tab);
|
|
}
|
|
|
|
static void
|
|
create_image_palette(gpointer data,gpointer user_data)
|
|
{
|
|
PaletteP palette = (PaletteP)user_data;
|
|
ImgColoursP colour_tab = (ImgColoursP)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"),colour_tab->count);
|
|
|
|
/* Adjust the colours to the mean of the the sample */
|
|
palette_add_entry (palette->entries, lab,
|
|
(gint)colour_tab->r + (colour_tab->r_adj/colour_tab->count),
|
|
(gint)colour_tab->g + (colour_tab->g_adj/colour_tab->count),
|
|
(gint)colour_tab->b + (colour_tab->b_adj/colour_tab->count));
|
|
}
|
|
|
|
static gboolean
|
|
colour_print_remove(gpointer key,gpointer value,gpointer user_data)
|
|
{
|
|
g_free(value);
|
|
return TRUE;
|
|
}
|
|
|
|
static gint
|
|
sort_colours (gconstpointer a,gconstpointer b)
|
|
{
|
|
ImgColoursP s1 = (ImgColoursP) a;
|
|
ImgColoursP s2 = (ImgColoursP) 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, PaletteP 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_colours);
|
|
|
|
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,colour_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_colours(GHashTable *h_array,
|
|
guchar * colours,
|
|
guchar * colours_real,
|
|
gint sample_sz)
|
|
{
|
|
gpointer found_colour = NULL;
|
|
ImgColoursP new_colour;
|
|
guint key_colours = colours[0]*256*256+colours[1]*256+colours[2];
|
|
|
|
if(h_array == NULL)
|
|
{
|
|
h_array = g_hash_table_new(g_direct_hash,g_direct_equal);
|
|
count_colour_entries = 0;
|
|
}
|
|
else
|
|
{
|
|
found_colour = g_hash_table_lookup(h_array,(gpointer)key_colours);
|
|
}
|
|
|
|
if(found_colour == NULL)
|
|
{
|
|
if(count_colour_entries > MAX_IMAGE_COLOURS)
|
|
{
|
|
/* Don't add any more new ones */
|
|
return h_array;
|
|
}
|
|
|
|
count_colour_entries++;
|
|
|
|
new_colour = g_new(ImgColours,1);
|
|
|
|
new_colour->count = 1;
|
|
new_colour->r_adj = 0;
|
|
new_colour->g_adj = 0;
|
|
new_colour->b_adj = 0;
|
|
new_colour->r = colours[0];
|
|
new_colour->g = colours[1];
|
|
new_colour->b = colours[2];
|
|
|
|
g_hash_table_insert(h_array,(gpointer)key_colours,new_colour);
|
|
}
|
|
else
|
|
{
|
|
new_colour = (ImgColoursP)found_colour;
|
|
if(new_colour->count < (G_MAXINT - 1))
|
|
new_colour->count++;
|
|
|
|
/* Now do the adjustments ...*/
|
|
new_colour->r_adj += (colours_real[0] - colours[0]);
|
|
new_colour->g_adj += (colours_real[1] - colours[1]);
|
|
new_colour->b_adj += (colours_real[2] - colours[2]);
|
|
|
|
/* Boundary conditions */
|
|
if(new_colour->r_adj > (G_MAXINT - 255))
|
|
new_colour->r_adj /= new_colour->count;
|
|
|
|
if(new_colour->g_adj > (G_MAXINT - 255))
|
|
new_colour->g_adj /= new_colour->count;
|
|
|
|
if(new_colour->b_adj > (G_MAXINT - 255))
|
|
new_colour->b_adj /= new_colour->count;
|
|
|
|
}
|
|
|
|
return h_array;
|
|
}
|
|
|
|
static void
|
|
import_palette_create_from_image (GImage *gimage,guchar *pname,PaletteP palette)
|
|
{
|
|
PixelRegion imagePR;
|
|
unsigned char *image_data;
|
|
unsigned char *idata;
|
|
guchar rgb[MAX_CHANNELS];
|
|
guchar rgb_real[MAX_CHANNELS];
|
|
int has_alpha, indexed;
|
|
int width, height;
|
|
int bytes, alpha;
|
|
int i, j;
|
|
void * pr;
|
|
int 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_colours(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);
|
|
}
|
|
|