static GimpValueArray *
palette_set_columns_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
const GimpValueArray *args,
GError **error)
{
gboolean success = TRUE;
const gchar *name;
gint32 columns;
name = g_value_get_string (gimp_value_array_index (args, 0));
columns = g_value_get_int (gimp_value_array_index (args, 1));
if (success)
{
GimpPalette *palette = gimp_pdb_get_palette (gimp, name, TRUE, error);
if (palette)
gimp_palette_set_columns (palette, columns);
else
success = FALSE;
}
return gimp_procedure_get_return_values (procedure, success,
error ? *error : NULL);
}
static GValueArray *
palette_set_columns_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
const GValueArray *args)
{
gboolean success = TRUE;
const gchar *name;
gint32 columns;
name = g_value_get_string (&args->values[0]);
columns = g_value_get_int (&args->values[1]);
if (success)
{
GimpPalette *palette = (GimpPalette *)
gimp_container_get_child_by_name (gimp->palette_factory->container, name);
if (palette && GIMP_DATA (palette)->writable)
gimp_palette_set_columns (palette, columns);
else
success = FALSE;
}
return gimp_procedure_get_return_values (procedure, success);
}
static void
palette_import_columns_changed (GtkAdjustment *adj,
ImportDialog *dialog)
{
if (dialog->palette)
gimp_palette_set_columns (dialog->palette,
ROUND (gtk_adjustment_get_value (adj)));
}
static void
palette_editor_columns_changed (GtkAdjustment *adj,
GimpPaletteEditor *editor)
{
if (GIMP_DATA_EDITOR (editor)->data)
{
GimpPalette *palette = GIMP_PALETTE (GIMP_DATA_EDITOR (editor)->data);
gimp_palette_set_columns (palette,
ROUND (gtk_adjustment_get_value (adj)));
}
}
static void
palette_import_make_palette (ImportDialog *dialog)
{
GimpPalette *palette = NULL;
const gchar *palette_name;
gint n_colors;
gint n_columns;
gint threshold;
palette_name = gtk_entry_get_text (GTK_ENTRY (dialog->entry));
if (! palette_name || ! strlen (palette_name))
palette_name = _("Untitled");
n_colors = ROUND (gtk_adjustment_get_value (dialog->num_colors));
n_columns = ROUND (gtk_adjustment_get_value (dialog->columns));
threshold = ROUND (gtk_adjustment_get_value (dialog->threshold));
switch (dialog->import_type)
{
case GRADIENT_IMPORT:
{
GimpGradient *gradient;
gradient = gimp_context_get_gradient (dialog->context);
palette = gimp_palette_import_from_gradient (gradient,
dialog->context,
FALSE,
palette_name,
n_colors);
}
break;
case IMAGE_IMPORT:
{
GimpImage *image = gimp_context_get_image (dialog->context);
gboolean sample_merged;
gboolean selection_only;
sample_merged =
gtk_toggle_button_get_active
(GTK_TOGGLE_BUTTON (dialog->sample_merged_toggle));
selection_only =
gtk_toggle_button_get_active
(GTK_TOGGLE_BUTTON (dialog->selection_only_toggle));
if (gimp_image_get_base_type (image) == GIMP_INDEXED)
{
palette = gimp_palette_import_from_indexed_image (image,
dialog->context,
palette_name);
}
else if (sample_merged)
{
palette = gimp_palette_import_from_image (image,
dialog->context,
palette_name,
n_colors,
threshold,
selection_only);
}
else
{
GimpDrawable *drawable;
drawable = GIMP_DRAWABLE (gimp_image_get_active_layer (image));
palette = gimp_palette_import_from_drawable (drawable,
dialog->context,
palette_name,
n_colors,
threshold,
selection_only);
}
}
break;
case FILE_IMPORT:
{
GFile *file;
GError *error = NULL;
file = gtk_file_chooser_get_file (GTK_FILE_CHOOSER (dialog->file_chooser));
palette = gimp_palette_import_from_file (dialog->context,
file,
palette_name, &error);
g_object_unref (file);
if (! palette)
{
gimp_message_literal (dialog->context->gimp,
G_OBJECT (dialog->dialog), GIMP_MESSAGE_ERROR,
error->message);
g_error_free (error);
}
}
break;
}
if (palette)
{
if (dialog->palette)
g_object_unref (dialog->palette);
gimp_palette_set_columns (palette, n_columns);
gimp_view_set_viewable (GIMP_VIEW (dialog->preview),
GIMP_VIEWABLE (palette));
dialog->palette = palette;
}
gtk_widget_set_visible (dialog->no_colors_label,
dialog->palette &&
gimp_palette_get_n_colors (dialog->palette) > 0);
}
GList *
gimp_palette_load (GimpContext *context,
GFile *file,
GInputStream *input,
GError **error)
{
GimpPalette *palette = NULL;
GimpPaletteEntry *entry;
GDataInputStream *data_input;
gchar *str;
gsize str_len;
gchar *tok;
gint r, g, b;
gint linenum;
g_return_val_if_fail (G_IS_FILE (file), NULL);
g_return_val_if_fail (G_IS_INPUT_STREAM (input), NULL);
g_return_val_if_fail (error == NULL || *error == NULL, NULL);
data_input = g_data_input_stream_new (input);
r = g = b = 0;
linenum = 1;
str_len = 1024;
str = gimp_data_input_stream_read_line_always (data_input, &str_len,
NULL, error);
if (! str)
goto failed;
if (! g_str_has_prefix (str, "GIMP Palette"))
{
g_set_error (error, GIMP_DATA_ERROR, GIMP_DATA_ERROR_READ,
_("Missing magic header."));
g_free (str);
goto failed;
}
g_free (str);
palette = g_object_new (GIMP_TYPE_PALETTE,
"mime-type", "application/x-gimp-palette",
NULL);
linenum++;
str_len = 1024;
str = gimp_data_input_stream_read_line_always (data_input, &str_len,
NULL, error);
if (! str)
goto failed;
if (g_str_has_prefix (str, "Name: "))
{
gchar *utf8;
utf8 = gimp_any_to_utf8 (g_strstrip (str + strlen ("Name: ")), -1,
_("Invalid UTF-8 string in palette file '%s'"),
gimp_file_get_utf8_name (file));
gimp_object_take_name (GIMP_OBJECT (palette), utf8);
g_free (str);
linenum++;
str_len = 1024;
str = gimp_data_input_stream_read_line_always (data_input, &str_len,
NULL, error);
if (! str)
goto failed;
if (g_str_has_prefix (str, "Columns: "))
{
gint columns;
if (! gimp_ascii_strtoi (g_strstrip (str + strlen ("Columns: ")),
NULL, 10, &columns))
{
g_set_error (error, GIMP_DATA_ERROR, GIMP_DATA_ERROR_READ,
_("Invalid column count."));
g_free (str);
goto failed;
}
if (columns < 0 || columns > 256)
{
g_message (_("Reading palette file '%s': "
"Invalid number of columns in line %d. "
"Using default value."),
gimp_file_get_utf8_name (file), linenum);
columns = 0;
}
gimp_palette_set_columns (palette, columns);
g_free (str);
linenum++;
str_len = 1024;
str = gimp_data_input_stream_read_line_always (data_input, &str_len,
NULL, error);
if (! str)
goto failed;
}
}
else /* old palette format */
{
gimp_object_take_name (GIMP_OBJECT (palette),
g_path_get_basename (gimp_file_get_utf8_name (file)));
}
while (str)
{
GError *my_error = NULL;
if (str[0] != '#' && str[0] != '\0')
{
tok = strtok (str, " \t");
if (tok)
r = atoi (tok);
else
g_message (_("Reading palette file '%s': "
"Missing RED component in line %d."),
gimp_file_get_utf8_name (file), linenum);
tok = strtok (NULL, " \t");
if (tok)
g = atoi (tok);
else
g_message (_("Reading palette file '%s': "
"Missing GREEN component in line %d."),
gimp_file_get_utf8_name (file), linenum);
tok = strtok (NULL, " \t");
if (tok)
b = atoi (tok);
else
g_message (_("Reading palette file '%s': "
"Missing BLUE component in line %d."),
gimp_file_get_utf8_name (file), linenum);
/* optional name */
tok = strtok (NULL, "\n");
if (r < 0 || r > 255 ||
g < 0 || g > 255 ||
b < 0 || b > 255)
g_message (_("Reading palette file '%s': "
"RGB value out of range in line %d."),
gimp_file_get_utf8_name (file), linenum);
/* don't call gimp_palette_add_entry here, it's rather inefficient */
entry = g_slice_new0 (GimpPaletteEntry);
gimp_rgba_set_uchar (&entry->color,
(guchar) r,
(guchar) g,
(guchar) b,
255);
entry->name = g_strdup (tok ? tok : _("Untitled"));
entry->position = gimp_palette_get_n_colors (palette);
palette->colors = g_list_prepend (palette->colors, entry);
palette->n_colors++;
}
g_free (str);
linenum++;
str_len = 1024;
str = g_data_input_stream_read_line (data_input, &str_len,
NULL, &my_error);
if (! str && my_error)
{
g_message (_("Reading palette file '%s': "
"Read %d colors from truncated file: %s"),
gimp_file_get_utf8_name (file),
g_list_length (palette->colors),
my_error->message);
g_clear_error (&my_error);
}
}
palette->colors = g_list_reverse (palette->colors);
g_object_unref (data_input);
return g_list_prepend (NULL, palette);
failed:
g_object_unref (data_input);
if (palette)
g_object_unref (palette);
g_prefix_error (error, _("In line %d of palette file: "), linenum);
return NULL;
}
