static void
palettes_merge_callback (GtkWidget *widget,
const gchar *palette_name,
gpointer data)
{
/* FIXME: reimplement palettes_merge_callback() */
#if 0
GimpContainerEditor *editor;
GimpPalette *palette;
GimpPalette *new_palette;
GList *sel_list;
editor = (GimpContainerEditor *) data;
sel_list = GTK_LIST (GIMP_CONTAINER_LIST_VIEW (editor->view)->gtk_list)->selection;
if (! sel_list)
{
gimp_message_literal (gimp,
G_OBJECT (widget), GIMP_MESSAGE_WARNING,
"Can't merge palettes because "
"there are no palettes selected.");
return;
}
new_palette = GIMP_PALETTE (gimp_palette_new (palette_name, FALSE));
while (sel_list)
{
GimpListItem *list_item;
list_item = GIMP_LIST_ITEM (sel_list->data);
palette = (GimpPalette *) GIMP_VIEW (list_item->preview)->viewable;
if (palette)
{
GList *cols;
for (cols = gimp_palette_get_colors (palette);
cols;
cols = g_list_next (cols))
{
GimpPaletteEntry *entry = cols->data;
gimp_palette_add_entry (new_palette,
entry->name,
&entry->color);
}
}
sel_list = sel_list->next;
}
gimp_container_add (editor->view->container,
GIMP_OBJECT (new_palette));
#endif
}
static void
gimp_palette_view_invalidate (GimpPalette *palette,
GimpPaletteView *view)
{
view->dnd_entry = NULL;
if (view->selected &&
! g_list_find (gimp_palette_get_colors (palette), view->selected))
{
gimp_palette_view_select_entry (view, NULL);
}
}
static GimpValueArray *
palette_get_colors_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
const GimpValueArray *args,
GError **error)
{
gboolean success = TRUE;
GimpValueArray *return_vals;
const gchar *name;
gint32 num_colors = 0;
GimpRGB *colors = NULL;
name = g_value_get_string (gimp_value_array_index (args, 0));
if (success)
{
GimpPalette *palette = gimp_pdb_get_palette (gimp, name, FALSE, error);
if (palette)
{
GList *list = gimp_palette_get_colors (palette);
gint i;
num_colors = gimp_palette_get_n_colors (palette);
colors = g_new (GimpRGB, num_colors);
for (i = 0; i < num_colors; i++, list = g_list_next (list))
{
GimpPaletteEntry *entry = list->data;
colors[i] = entry->color;
}
}
else
success = FALSE;
}
return_vals = gimp_procedure_get_return_values (procedure, success,
error ? *error : NULL);
if (success)
{
g_value_set_int (gimp_value_array_index (return_vals, 1), num_colors);
gimp_value_take_colorarray (gimp_value_array_index (return_vals, 2), colors, num_colors);
}
return return_vals;
}
gboolean
gimp_palette_save (GimpData *data,
GOutputStream *output,
GError **error)
{
GimpPalette *palette = GIMP_PALETTE (data);
GString *string;
GList *list;
gsize bytes_written;
string = g_string_new ("GIMP Palette\n");
g_string_append_printf (string,
"Name: %s\n"
"Columns: %d\n"
"#\n",
gimp_object_get_name (palette),
CLAMP (gimp_palette_get_columns (palette), 0, 256));
for (list = gimp_palette_get_colors (palette);
list;
list = g_list_next (list))
{
GimpPaletteEntry *entry = list->data;
guchar r, g, b;
gimp_rgb_get_uchar (&entry->color, &r, &g, &b);
g_string_append_printf (string, "%3d %3d %3d\t%s\n",
r, g, b, entry->name);
}
if (! g_output_stream_write_all (output, string->str, string->len,
&bytes_written, NULL, error) ||
bytes_written != string->len)
{
g_string_free (string, TRUE);
return FALSE;
}
g_string_free (string, TRUE);
return TRUE;
}
gboolean
gimp_palette_save (GimpData *data,
GError **error)
{
GimpPalette *palette = GIMP_PALETTE (data);
GList *list;
FILE *file;
file = g_fopen (gimp_data_get_filename (data), "wb");
if (! file)
{
g_set_error (error, GIMP_DATA_ERROR, GIMP_DATA_ERROR_OPEN,
_("Could not open '%s' for writing: %s"),
gimp_filename_to_utf8 (gimp_data_get_filename (data)),
g_strerror (errno));
return FALSE;
}
fprintf (file, "GIMP Palette\n");
fprintf (file, "Name: %s\n", gimp_object_get_name (palette));
fprintf (file, "Columns: %d\n#\n", CLAMP (gimp_palette_get_columns (palette),
0, 256));
for (list = gimp_palette_get_colors (palette);
list;
list = g_list_next (list))
{
GimpPaletteEntry *entry = list->data;
guchar r, g, b;
gimp_rgb_get_uchar (&entry->color, &r, &g, &b);
fprintf (file, "%3d %3d %3d\t%s\n", r, g, b, entry->name);
}
fclose (file);
return TRUE;
}
static void
gimp_view_renderer_palette_render (GimpViewRenderer *renderer,
GtkWidget *widget)
{
GimpViewRendererPalette *renderpal = GIMP_VIEW_RENDERER_PALETTE (renderer);
GimpPalette *palette;
GimpColorTransform *transform;
guchar *row;
guchar *dest;
GList *list;
gdouble cell_width;
gint grid_width;
gint dest_stride;
gint y;
palette = GIMP_PALETTE (renderer->viewable);
if (gimp_palette_get_n_colors (palette) == 0)
return;
grid_width = renderpal->draw_grid ? 1 : 0;
if (renderpal->cell_size > 0)
{
gint n_columns = gimp_palette_get_columns (palette);
if (n_columns > 0)
cell_width = MAX ((gdouble) renderpal->cell_size,
(gdouble) (renderer->width - grid_width) /
(gdouble) n_columns);
else
cell_width = renderpal->cell_size;
}
else
{
gint n_columns = gimp_palette_get_columns (palette);
if (n_columns > 0)
cell_width = ((gdouble) (renderer->width - grid_width) /
(gdouble) n_columns);
else
cell_width = (gdouble) (renderer->width - grid_width) / 16.0;
}
cell_width = MAX (4.0, cell_width);
renderpal->cell_width = cell_width;
renderpal->columns = (gdouble) (renderer->width - grid_width) / cell_width;
renderpal->rows = gimp_palette_get_n_colors (palette) / renderpal->columns;
if (gimp_palette_get_n_colors (palette) % renderpal->columns)
renderpal->rows += 1;
renderpal->cell_height = MAX (4, ((renderer->height - grid_width) /
renderpal->rows));
if (! renderpal->draw_grid)
renderpal->cell_height = MIN (renderpal->cell_height,
renderpal->cell_width);
list = gimp_palette_get_colors (palette);
if (! renderer->surface)
renderer->surface = cairo_image_surface_create (CAIRO_FORMAT_RGB24,
renderer->width,
renderer->height);
cairo_surface_flush (renderer->surface);
row = g_new (guchar, renderer->width * 4);
dest = cairo_image_surface_get_data (renderer->surface);
dest_stride = cairo_image_surface_get_stride (renderer->surface);
transform = gimp_view_renderer_get_color_transform (renderer, widget,
babl_format ("cairo-RGB24"),
babl_format ("cairo-RGB24"));
for (y = 0; y < renderer->height; y++)
{
if ((y % renderpal->cell_height) == 0)
{
guchar r, g, b;
gint x;
gint n = 0;
guchar *d = row;
memset (row, renderpal->draw_grid ? 0 : 255, renderer->width * 4);
r = g = b = (renderpal->draw_grid ? 0 : 255);
for (x = 0; x < renderer->width; x++, d += 4)
{
if ((x % renderpal->cell_width) == 0)
{
if (list && n < renderpal->columns &&
renderer->width - x >= renderpal->cell_width)
{
GimpPaletteEntry *entry = list->data;
list = g_list_next (list);
n++;
gimp_rgb_get_uchar (&entry->color, &r, &g, &b);
}
else
{
r = g = b = (renderpal->draw_grid ? 0 : 255);
}
}
if (renderpal->draw_grid && (x % renderpal->cell_width) == 0)
{
GIMP_CAIRO_RGB24_SET_PIXEL (d, 0, 0, 0);
}
else
{
GIMP_CAIRO_RGB24_SET_PIXEL (d, r, g, b);
}
}
}
if (renderpal->draw_grid && (y % renderpal->cell_height) == 0)
{
memset (dest, 0, renderer->width * 4);
}
else
{
if (transform)
{
gimp_color_transform_process_pixels (transform,
babl_format ("cairo-RGB24"),
row,
babl_format ("cairo-RGB24"),
dest,
renderer->width);
}
else
{
memcpy (dest, row, renderer->width * 4);
}
}
dest += dest_stride;
}
g_free (row);
cairo_surface_mark_dirty (renderer->surface);
}
