static void
extract_hsl (const guchar *src,
gint bpp,
gint numpix,
guchar **dst)
{
register const guchar *rgb_src = src;
register guchar *hue_dst = dst[0];
register guchar *sat_dst = dst[1];
register guchar *lum_dst = dst[2];
register gint count = numpix, offset = bpp;
while (count-- > 0)
{
GimpRGB rgb;
GimpHSL hsl;
gimp_rgb_set_uchar (&rgb, rgb_src[0], rgb_src[1], rgb_src[2]);
gimp_rgb_to_hsl (&rgb, &hsl);
*hue_dst++ = (guchar) (hsl.h * 255.999);
*sat_dst++ = (guchar) (hsl.s * 255.999);
*lum_dst++ = (guchar) (hsl.l * 255.999);
rgb_src += offset;
}
}
GtkTextTag *
gimp_text_buffer_name_to_tag (GimpTextBuffer *buffer,
const gchar *name,
const gchar *attribute,
const gchar *value)
{
g_return_val_if_fail (GIMP_IS_TEXT_BUFFER (buffer), NULL);
g_return_val_if_fail (name != NULL, NULL);
if (! strcmp (name, "b"))
{
return buffer->bold_tag;
}
else if (! strcmp (name, "i"))
{
return buffer->italic_tag;
}
else if (! strcmp (name, "u"))
{
return buffer->underline_tag;
}
else if (! strcmp (name, "s"))
{
return buffer->strikethrough_tag;
}
else if (! strcmp (name, "span") &&
attribute != NULL &&
value != NULL)
{
if (! strcmp (attribute, GIMP_TEXT_ATTR_NAME_SIZE))
{
return gimp_text_buffer_get_size_tag (buffer, atoi (value));
}
else if (! strcmp (attribute, GIMP_TEXT_ATTR_NAME_BASELINE))
{
return gimp_text_buffer_get_baseline_tag (buffer, atoi (value));
}
else if (! strcmp (attribute, GIMP_TEXT_ATTR_NAME_KERNING))
{
return gimp_text_buffer_get_kerning_tag (buffer, atoi (value));
}
else if (! strcmp (attribute, GIMP_TEXT_ATTR_NAME_FONT))
{
return gimp_text_buffer_get_font_tag (buffer, value);
}
else if (! strcmp (attribute, GIMP_TEXT_ATTR_NAME_COLOR))
{
GimpRGB color;
guint r, g, b;
sscanf (value, "#%02x%02x%02x", &r, &g, &b);
gimp_rgb_set_uchar (&color, r, g, b);
return gimp_text_buffer_get_color_tag (buffer, &color);
}
}
return NULL;
}
static void
extract_yellowk (const guchar *src,
gint bpp,
gint numpix,
guchar **dst)
{
register const guchar *rgb_src = src;
register guchar *yellow_dst = dst[0];
register gint count = numpix, offset = bpp-3;
GimpCMYK gcmyk;
gimp_cmyk_set (&gcmyk, 0,0,0,0);
while (count-- > 0)
{
GimpRGB grgb;
guchar r, g, b;
r = *rgb_src++;
g = *rgb_src++;
b = *rgb_src++;
gimp_rgb_set_uchar (&grgb, r,g,b);
gimp_rgb_to_cmyk (&grgb, 1.0, &gcmyk);
gimp_cmyk_get_uchar (&gcmyk, NULL, NULL, yellow_dst++, NULL);
rgb_src += offset;
}
}
static gboolean
preview_event_handler (GtkWidget *area,
GdkEvent *event,
GtkWidget *preview)
{
gint pos;
guchar *buf;
guint32 drawable_id;
GimpRGB color;
GdkEventButton *button_event = (GdkEventButton *)event;
buf = GIMP_PREVIEW_AREA (area)->buf;
drawable_id = GIMP_DRAWABLE_PREVIEW (preview)->drawable->drawable_id;
switch (event->type)
{
case GDK_BUTTON_PRESS:
if (button_event->button == 2)
{
pos = event->button.x * gimp_drawable_bpp (drawable_id) +
event->button.y * GIMP_PREVIEW_AREA (area)->rowstride;
gimp_rgb_set_uchar (&color, buf[pos], buf[pos + 1], buf[pos + 2]);
gimp_color_button_set_color (GIMP_COLOR_BUTTON (from_colorbutton),
&color);
}
break;
default:
break;
}
return FALSE;
}
static void
transform (guchar *r,
guchar *g,
guchar *b)
{
switch (wvals.colormodel)
{
case HSL_MODEL:
{
GimpHSL hsl;
GimpRGB rgb;
gimp_rgb_set_uchar (&rgb, *r, *g, *b);
gimp_rgb_to_hsl (&rgb, &hsl);
if (wvals.redmode)
hsl.h = 0.5 * (1.0 + sin (((2 * hsl.h - 1.0) * wvals.redfrequency +
wvals.redangle / 180.0) * G_PI));
if (wvals.greenmode)
hsl.s = 0.5 * (1.0 + sin (((2 * hsl.s - 1.0) * wvals.greenfrequency +
wvals.greenangle / 180.0) * G_PI));
if (wvals.bluemode)
hsl.l = 0.5 * (1.0 + sin (((2 * hsl.l - 1.0) * wvals.bluefrequency +
wvals.blueangle / 180.0) * G_PI));
gimp_hsl_to_rgb (&hsl, &rgb);
gimp_rgb_get_uchar (&rgb, r, g, b);
}
break;
case RGB_MODEL:
if (wvals.redmode)
*r = ROUND (127.5 * (1.0 +
sin (((*r / 127.5 - 1.0) * wvals.redfrequency +
wvals.redangle / 180.0) * G_PI)));
if (wvals.greenmode)
*g = ROUND (127.5 * (1.0 +
sin (((*g / 127.5 - 1.0) * wvals.greenfrequency +
wvals.greenangle / 180.0) * G_PI)));
if (wvals.bluemode)
*b = ROUND (127.5 * (1.0 +
sin (((*b / 127.5 - 1.0) * wvals.bluefrequency +
wvals.blueangle / 180.0) * G_PI)));
break;
}
}
static VALUE
rb_gimp_rgb_set_uchar (VALUE self,
VALUE r,
VALUE g,
VALUE b)
{
Get_TypedStruct(self, GimpRGB, color);
gimp_rgb_set_uchar(color,
(guchar)NUM2INT(r),
(guchar)NUM2INT(g),
(guchar)NUM2INT(b));
return rb_ary_new3(3, r, g, b);
}
/**
* gimp_rgb_set_gdk_color:
* @rgb: a #GimpRGB that is to be set
* @gdk_color: pointer to the source #GdkColor
*
* Initializes @rgb from a #GdkColor. This function does not touch
* the alpha value of @rgb.
**/
void
gimp_rgb_set_gdk_color (GimpRGB *rgb,
const GdkColor *gdk_color)
{
guchar r, g, b;
g_return_if_fail (rgb != NULL);
g_return_if_fail (gdk_color != NULL);
r = gdk_color->red >> 8;
g = gdk_color->green >> 8;
b = gdk_color->blue >> 8;
gimp_rgb_set_uchar (rgb, r, g, b);
}
/* main function */
static void
run (const gchar *name,
gint nparams,
const GimpParam *param,
gint *nreturn_vals,
GimpParam **return_vals)
{
static GimpParam values[1];
GimpRunMode runmode;
GimpPDBStatusType status = GIMP_PDB_SUCCESS;
GimpDrawable *drawable;
*nreturn_vals = 1;
*return_vals = values;
INIT_I18N ();
values[0].type = GIMP_PDB_STATUS;
values[0].data.d_status = status;
runmode = param[0].data.d_int32;
drawable = gimp_drawable_get (param[2].data.d_drawable);
switch (runmode)
{
case GIMP_RUN_INTERACTIVE:
/* retrieve stored arguments (if any) */
gimp_get_data (PLUG_IN_PROC, &xargs);
/* initialize using foreground color */
gimp_context_get_foreground (&xargs.from);
if (! exchange_dialog (drawable))
return;
break;
case GIMP_RUN_WITH_LAST_VALS:
gimp_get_data (PLUG_IN_PROC, &xargs);
/*
* instead of recalling the last-set values,
* run with the current foreground as 'from'
* color, making ALT-F somewhat more useful.
*/
gimp_context_get_foreground (&xargs.from);
break;
case GIMP_RUN_NONINTERACTIVE:
if (nparams != 12)
{
status = GIMP_PDB_EXECUTION_ERROR;
}
else
{
gimp_rgb_set_uchar (&xargs.from,
param[3].data.d_int8,
param[4].data.d_int8,
param[5].data.d_int8);
gimp_rgb_set_uchar (&xargs.to,
param[6].data.d_int8,
param[7].data.d_int8,
param[8].data.d_int8);
gimp_rgb_set_uchar (&xargs.threshold,
param[9].data.d_int8,
param[10].data.d_int8,
param[11].data.d_int8);
}
break;
default:
break;
}
if (status == GIMP_PDB_SUCCESS)
{
if (gimp_drawable_is_rgb (drawable->drawable_id))
{
gimp_progress_init (_("Color Exchange"));
gimp_tile_cache_ntiles (2 * (drawable->width /
gimp_tile_width () + 1));
exchange (drawable, NULL);
gimp_drawable_detach (drawable);
/* store our settings */
if (runmode == GIMP_RUN_INTERACTIVE)
gimp_set_data (PLUG_IN_PROC, &xargs, sizeof (myParams));
/* and flush */
if (runmode != GIMP_RUN_NONINTERACTIVE)
gimp_displays_flush ();
}
else
status = GIMP_PDB_EXECUTION_ERROR;
}
values[0].data.d_status = status;
}
bool loadPalette(Pentagram::Palette * pal, const ConvertShapeFormat * format)
{
GimpRGB color;
guchar palHack[2];
palHack[1] = 255;
bool newPal;
const gchar * palName;
for (int i = 0; i < 256; ++i)
{
palHack[0] = i;
pal->native[i] = *((uint16 * ) palHack);
}
if (format == &PentagramShapeFormat)
{
palName = "Pentagram";
}
else if (format == &U8SKFShapeFormat)
{
palName = "U8SKF";
}
else if (format == &U8ShapeFormat)
{
palName = "Ultima8";
}
else if (format == &U82DShapeFormat)
{
palName = "Ultima8";
}
else if (format == &CrusaderShapeFormat)
{
palName = "Crusader";
}
else if (format == &Crusader2DShapeFormat)
{
palName = "Crusader";
}
else
{
return false;
}
newPal = ! gimp_context_set_palette(palName);
if (newPal)
{
gint colors = 0;
if (gimp_palette_get_info(palName, &colors))
{
newPal = false;
if (colors != 256)
{
newPal = true;
if (!gimp_palette_delete(palName))
return false;
}
}
}
if (newPal)
{
if (g_ascii_strcasecmp(palName, gimp_palette_new(palName)))
return false;
if (!gimp_context_set_palette(palName))
return false;
IDataSource * ds = choosePalette();
if (ds)
{
gint j = 0;
ds->seek(4);
pal->load(*ds);
delete ds;
for (gint i = 0; i < 256; ++i)
{
gimp_rgb_set_uchar(&color,
pal->palette[i * 3],
pal->palette[i * 3 + 1],
pal->palette[i * 3 + 2]);
gimp_palette_add_entry(palName, "Untitled", &color, &j);
assert (j == i);
}
}
else
{
return false;
}
}
else
{
for (gint i = 0; i < 256; ++i)
{
gimp_palette_entry_get_color(palName, i, &color);
gimp_rgb_get_uchar(&color,
&(pal->palette[i * 3]),
&(pal->palette[i * 3 + 1]),
&(pal->palette[i * 3 + 2]));
}
}
return true;
}
static gboolean
remap_dialog (gint32 image_ID,
guchar *map)
{
GtkWidget *dialog;
GtkWidget *vbox;
GtkWidget *box;
GtkWidget *iconview;
GtkListStore *store;
GtkCellRenderer *renderer;
GtkTreeIter iter;
guchar *cmap;
gint ncols, i;
gboolean valid;
gimp_ui_init (PLUG_IN_BINARY, FALSE);
dialog = gimp_dialog_new (_("Rearrange Colormap"), PLUG_IN_ROLE,
NULL, 0,
gimp_standard_help_func, PLUG_IN_PROC_REMAP,
GIMP_STOCK_RESET, RESPONSE_RESET,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OK, GTK_RESPONSE_OK,
NULL);
gtk_dialog_set_alternative_button_order (GTK_DIALOG (dialog),
RESPONSE_RESET,
GTK_RESPONSE_OK,
GTK_RESPONSE_CANCEL,
-1);
gimp_window_set_transient (GTK_WINDOW (dialog));
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 12);
gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog))),
vbox, TRUE, TRUE, 0);
cmap = gimp_image_get_colormap (image_ID, &ncols);
g_return_val_if_fail ((ncols > 0) && (ncols <= 256), FALSE);
store = gtk_list_store_new (NUM_COLS,
G_TYPE_INT, G_TYPE_STRING, GIMP_TYPE_RGB,
G_TYPE_DOUBLE, G_TYPE_DOUBLE, G_TYPE_DOUBLE);
for (i = 0; i < ncols; i++)
{
GimpRGB rgb;
GimpHSV hsv;
gint index = map[i];
gchar *text = g_strdup_printf ("%d", index);
gimp_rgb_set_uchar (&rgb,
cmap[index * 3],
cmap[index * 3 + 1],
cmap[index * 3 + 2]);
gimp_rgb_to_hsv (&rgb, &hsv);
reverse_order[i] = ncols - i - 1;
gtk_list_store_append (store, &iter);
gtk_list_store_set (store, &iter,
COLOR_INDEX, index,
COLOR_INDEX_TEXT, text,
COLOR_RGB, &rgb,
COLOR_H, hsv.h,
COLOR_S, hsv.s,
COLOR_V, hsv.v,
-1);
g_free (text);
}
g_free (cmap);
remap_ui = remap_ui_manager_new (dialog, store);
iconview = gtk_icon_view_new_with_model (GTK_TREE_MODEL (store));
g_object_unref (store);
gtk_box_pack_start (GTK_BOX (vbox), iconview, TRUE, TRUE, 0);
gtk_icon_view_set_selection_mode (GTK_ICON_VIEW (iconview),
GTK_SELECTION_SINGLE);
gtk_icon_view_set_orientation (GTK_ICON_VIEW (iconview),
GTK_ORIENTATION_VERTICAL);
gtk_icon_view_set_columns (GTK_ICON_VIEW (iconview), 16);
gtk_icon_view_set_row_spacing (GTK_ICON_VIEW (iconview), 0);
gtk_icon_view_set_column_spacing (GTK_ICON_VIEW (iconview), 0);
gtk_icon_view_set_reorderable (GTK_ICON_VIEW (iconview), TRUE);
renderer = gimp_cell_renderer_color_new ();
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (iconview), renderer, TRUE);
gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (iconview), renderer,
"color", COLOR_RGB,
NULL);
g_object_set (renderer,
"width", 24,
NULL);
renderer = gtk_cell_renderer_text_new ();
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (iconview), renderer, TRUE);
gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (iconview), renderer,
"text", COLOR_INDEX_TEXT,
NULL);
g_object_set (renderer,
"size-points", 6.0,
"xalign", 0.5,
"ypad", 0,
NULL);
g_signal_connect (iconview, "popup-menu",
G_CALLBACK (remap_popup_menu),
NULL);
g_signal_connect (iconview, "button-press-event",
G_CALLBACK (remap_button_press),
NULL);
box = gimp_hint_box_new (_("Drag and drop colors to rearrange the colormap. "
"The numbers shown are the original indices. "
"Right-click for a menu with sort options."));
gtk_box_pack_start (GTK_BOX (vbox), box, FALSE, FALSE, 0);
gtk_widget_show (box);
g_signal_connect (dialog, "response",
G_CALLBACK (remap_response),
store);
gtk_widget_show_all (dialog);
gtk_main ();
i = 0;
for (valid = gtk_tree_model_get_iter_first (GTK_TREE_MODEL (store), &iter);
valid;
valid = gtk_tree_model_iter_next (GTK_TREE_MODEL (store), &iter))
{
gint index;
gtk_tree_model_get (GTK_TREE_MODEL (store), &iter,
COLOR_INDEX, &index,
-1);
map[i++] = index;
}
gtk_widget_destroy (dialog);
return remap_run;
}
