procyberian/gimp
2
0
Fork 0
mirror of https://gitlab.gnome.org/GNOME/gimp.git synced 2025-07-03 17:33:25 +00:00
Code Issues 1 Projects 1 Releases Packages Wiki Activity Actions

app, libgimp*, plug-ins: int32 array arguments don't need a size argument anymore.

Browse source 
GimpArray (and therefore the int32 array typedef) contains its own size.
We don't need to store the array size in a preceding argument.

Also adding gimp_int32_array_get_values() and gimp_int32_array_set_values()
to edit an existing GimpArray.
This comes with the fact we should start making the GimpArray type more
explicit, because clearly by trying to hide this type so much, it was
too much looking like the int32 array param spec was expecting a C array
(as was visible in the file-ico plug-in where we were getting a C array,
which was a bug only made invisible by the fact we were not setting the
C array back in the config object in the end).

Last but not least, I finally implemented int32 array (de)serialization.

As a side fix, the "images" arg in file-pdf-export-multi procedure is
now a proper image array (not an int32 array), and of course the "count"
arg was removed.
This commit is contained in:
Jehan 2024-10-24 17:43:09 +02:00
parent 60eb27ab18
commit f2b9babfb4
13 changed files with 306 additions and 187 deletions
Download patch file Download diff file Expand all files Collapse all files

34
app/pdb/gimppdb.c
View file

@ -449,23 +449,23 @@ gimp_pdb_execute_procedure_by_name (GimpPDB *pdb,
GIMP_VALUE_HOLDS_FLOAT_ARRAY (value) || GIMP_VALUE_HOLDS_FLOAT_ARRAY (value) ||
GIMP_VALUE_HOLDS_CORE_OBJECT_ARRAY (value)) GIMP_VALUE_HOLDS_CORE_OBJECT_ARRAY (value))
{ {
/* Array arguments don't have their size information when they if (GIMP_VALUE_HOLDS_FLOAT_ARRAY (value))
* are set by core code, in C array form. {
* By convention, the previous argument has to be the array /* Array arguments don't have their size information when they
* size argument. * are set by core code, in C array form.
*/ * By convention, the previous argument has to be the array
g_return_val_if_fail (prev_value_type == G_TYPE_INT && prev_int_value >= 0, NULL); * size argument.
*/
if (GIMP_VALUE_HOLDS_INT32_ARRAY (value)) g_return_val_if_fail (prev_value_type == G_TYPE_INT && prev_int_value >= 0, NULL);
gimp_value_set_int32_array (value, gimp_value_set_float_array (value,
(const gint32 *) va_arg (va_args, gpointer), (const gdouble *) va_arg (va_args, gpointer),
prev_int_value); prev_int_value);
else if (GIMP_VALUE_HOLDS_FLOAT_ARRAY (value)) }
gimp_value_set_float_array (value, else if (GIMP_VALUE_HOLDS_CORE_OBJECT_ARRAY (value) ||
(const gdouble *) va_arg (va_args, gpointer), GIMP_VALUE_HOLDS_INT32_ARRAY (value))
prev_int_value); {
else if (GIMP_VALUE_HOLDS_CORE_OBJECT_ARRAY (value)) g_value_set_boxed (value, va_arg (va_args, gpointer));
g_value_set_boxed (value, va_arg (va_args, gpointer)); }
} }
else else
{ {

5
app/plug-in/gimpplugin-message.c
View file

@ -729,10 +729,7 @@ gimp_plug_in_handle_proc_install (GimpPlugIn *plug_in,
GPParamDef *param_def = &proc_install->params[i]; GPParamDef *param_def = &proc_install->params[i];
GPParamDef *prev_param_def = &proc_install->params[i - 1]; GPParamDef *prev_param_def = &proc_install->params[i - 1];
if ((! strcmp (param_def->type_name, "GimpParamInt32Array") || if (! strcmp (param_def->type_name, "GimpParamFloatArray") &&
! strcmp (param_def->type_name, "GimpParamIntFloatArray") ||
! strcmp (param_def->type_name, "GimpParamIntColorArray"))
&&
strcmp (prev_param_def->type_name, "GParamInt")) strcmp (prev_param_def->type_name, "GParamInt"))
{ {
gimp_message (plug_in->manager->gimp, NULL, GIMP_MESSAGE_ERROR, gimp_message (plug_in->manager->gimp, NULL, GIMP_MESSAGE_ERROR,

2
libgimpbase/gimpbase.def
View file

@ -85,6 +85,8 @@ EXPORTS
gimp_installation_directory gimp_installation_directory
gimp_installation_directory_file gimp_installation_directory_file
gimp_int32_array_get_type gimp_int32_array_get_type
gimp_int32_array_get_values
gimp_int32_array_set_values
gimp_interpolation_type_get_type gimp_interpolation_type_get_type
gimp_is_canonical_identifier gimp_is_canonical_identifier
gimp_join_style_get_type gimp_join_style_get_type

43
libgimpbase/gimpparamspecs.c
View file

@ -452,6 +452,49 @@ gimp_value_take_array (GValue *value,
typedef GimpArray GimpInt32Array; typedef GimpArray GimpInt32Array;
G_DEFINE_BOXED_TYPE (GimpInt32Array, gimp_int32_array, gimp_array_copy, gimp_array_free) G_DEFINE_BOXED_TYPE (GimpInt32Array, gimp_int32_array, gimp_array_copy, gimp_array_free)
/**
* gimp_int32_array_get_values:
* @array: the #GimpArray representing #int32 values.
* @length: the number of #int32 values in the returned array.
*
* Returns: (array length=length) (transfer none): a C-array of #gint32.
*/
const gint32 *
gimp_int32_array_get_values (GimpArray *array,
gsize *length)
{
g_return_val_if_fail (array->length % sizeof (gint32) == 0, NULL);
if (length)
*length = array->length / sizeof (gint32);
return (const gint32 *) array->data;
}
/**
* gimp_int32_array_set_values:
* @array: the array to modify.
* @values: (array length=length): the C-array.
* @length: the number of #int32 values in @data.
* @static_data: whether @data is a static rather than allocated array.
*/
void
gimp_int32_array_set_values (GimpArray *array,
const gint32 *values,
gsize length,
gboolean static_data)
{
g_return_if_fail ((values == NULL && length == 0) || (values != NULL && length > 0));
if (! array->static_data)
g_free (array->data);
array->length = length * sizeof (gint32);
array->data = static_data ? (guint8 *) values : g_memdup2 (values, array->length);
array->static_data = static_data;
}
/* /*
* GIMP_TYPE_PARAM_INT32_ARRAY * GIMP_TYPE_PARAM_INT32_ARRAY
*/ */

13
libgimpbase/gimpparamspecs.h
View file

@ -211,10 +211,17 @@ GParamSpec * gimp_param_spec_array (const gchar *name,
* GIMP_TYPE_INT32_ARRAY * GIMP_TYPE_INT32_ARRAY
*/ */
#define GIMP_TYPE_INT32_ARRAY (gimp_int32_array_get_type ()) #define GIMP_TYPE_INT32_ARRAY (gimp_int32_array_get_type ())
#define GIMP_VALUE_HOLDS_INT32_ARRAY(value) (G_TYPE_CHECK_VALUE_TYPE ((value), GIMP_TYPE_INT32_ARRAY)) #define GIMP_VALUE_HOLDS_INT32_ARRAY(value) (G_TYPE_CHECK_VALUE_TYPE ((value), GIMP_TYPE_INT32_ARRAY))
GType gimp_int32_array_get_type (void) G_GNUC_CONST; GType gimp_int32_array_get_type (void) G_GNUC_CONST;
const gint32 * gimp_int32_array_get_values (GimpArray *array,
gsize *length);
void gimp_int32_array_set_values (GimpArray *array,
const gint32 *values,
gsize length,
gboolean static_data);
/* /*

44
libgimpconfig/gimpconfig-deserialize.c
View file

@ -85,6 +85,8 @@ static GTokenType gimp_config_deserialize_value_array (GValue *value,
GimpConfig *config, GimpConfig *config,
GParamSpec *prop_spec, GParamSpec *prop_spec,
GScanner *scanner); GScanner *scanner);
static GTokenType gimp_config_deserialize_array (GValue *value,
GScanner *scanner);
static GTokenType gimp_config_deserialize_strv (GValue *value, static GTokenType gimp_config_deserialize_strv (GValue *value,
GScanner *scanner); GScanner *scanner);
static GimpUnit * gimp_config_get_unit_from_identifier (const gchar *identifier); static GimpUnit * gimp_config_get_unit_from_identifier (const gchar *identifier);
@ -382,6 +384,10 @@ gimp_config_deserialize_value (GValue *value,
{ {
return gimp_config_deserialize_strv (value, scanner); return gimp_config_deserialize_strv (value, scanner);
} }
else if (prop_spec->value_type == GIMP_TYPE_INT32_ARRAY)
{
return gimp_config_deserialize_array (value, scanner);
}
else if (prop_spec->value_type == GIMP_TYPE_UNIT) else if (prop_spec->value_type == GIMP_TYPE_UNIT)
{ {
return gimp_config_deserialize_unit (value, prop_spec, scanner); return gimp_config_deserialize_unit (value, prop_spec, scanner);
@ -926,6 +932,44 @@ gimp_config_deserialize_strv (GValue *value,
return result_token; return result_token;
} }
static GTokenType
gimp_config_deserialize_array (GValue *value,
GScanner *scanner)
{
gint32 *values;
gint n_values;
GTokenType result_token = G_TOKEN_RIGHT_PAREN;
if (! gimp_scanner_parse_int (scanner, &n_values))
return G_TOKEN_INT;
values = g_new0 (gint32, n_values);
for (gint i = 0; i < n_values; i++)
{
gint value;
if (! gimp_scanner_parse_int (scanner, &value))
{
result_token = G_TOKEN_INT;
break;
}
values[i] = value;
}
if (result_token == G_TOKEN_RIGHT_PAREN)
{
gimp_value_take_int32_array (value, values, n_values);
}
else
{
g_scanner_error (scanner, "Missing value.");
}
return result_token;
}
static GimpUnit * static GimpUnit *
gimp_config_get_unit_from_identifier (const gchar *identifier) gimp_config_get_unit_from_identifier (const gchar *identifier)
{ {

46
libgimpconfig/gimpconfig-serialize.c
View file

@ -48,8 +48,10 @@
**/ **/
static gboolean gimp_config_serialize_strv (const GValue *value, static gboolean gimp_config_serialize_strv (const GValue *value,
GString *str); GString *str);
static gboolean gimp_config_serialize_array (const GValue *value,
GString *str);
/** /**
@ -512,6 +514,11 @@ gimp_config_serialize_value (const GValue *value,
return gimp_config_serialize_strv (value, str); return gimp_config_serialize_strv (value, str);
} }
if (GIMP_VALUE_HOLDS_INT32_ARRAY (value))
{
return gimp_config_serialize_array (value, str);
}
if (G_VALUE_HOLDS_BOOLEAN (value)) if (G_VALUE_HOLDS_BOOLEAN (value))
{ {
gboolean bool; gboolean bool;
@ -729,3 +736,38 @@ gimp_config_serialize_strv (const GValue *value,
return TRUE; return TRUE;
} }
static gboolean
gimp_config_serialize_array (const GValue *value,
GString *str)
{
GimpArray *array;
g_return_val_if_fail (GIMP_VALUE_HOLDS_INT32_ARRAY (value), FALSE);
array = g_value_get_boxed (value);
if (array)
{
gint32 *values = (gint32 *) array->data;
gint length = array->length / sizeof (gint32);
/* Write length */
g_string_append_printf (str, "%d", length);
for (gint i = 0; i < length; i++)
{
gchar *istr;
istr = g_strdup_printf (" %d", values[i]);
g_string_append (str, istr);
g_free (istr);
}
}
else
{
g_string_append (str, "0");
}
return TRUE;
}

2
plug-ins/common/file-gih.c
View file

@ -483,7 +483,7 @@ gih_export (GimpProcedure *procedure,
static void static void
gih_remove_guides (GimpProcedureConfig *config, gih_remove_guides (GimpProcedureConfig *config,
GimpImage *image) GimpImage *image)
{ {
GimpArray *array; GimpArray *array;

36
plug-ins/common/file-pdf-export.c
View file

@ -431,18 +431,12 @@ pdf_create_procedure (GimpPlugIn *plug_in,
GIMP_RUN_INTERACTIVE, GIMP_RUN_INTERACTIVE,
G_PARAM_READWRITE); G_PARAM_READWRITE);
gimp_procedure_add_int_argument (procedure, "count", gimp_procedure_add_core_object_array_argument (procedure, "images",
_("Count"), "Images",
_("The number of images entered (This will be the " "Input image for each page (An image can "
"number of pages)."), "appear more than once)",
1, MAX_PAGE_COUNT, 1, GIMP_TYPE_IMAGE,
G_PARAM_READWRITE); G_PARAM_READWRITE);
gimp_procedure_add_int32_array_argument (procedure, "images",
"Images",
"Input image for each page (An image can "
"appear more than once)",
G_PARAM_READWRITE);
gimp_procedure_add_boolean_argument (procedure, "vectorize", gimp_procedure_add_boolean_argument (procedure, "vectorize",
_("Convert _bitmaps to vector graphics where possible"), _("Convert _bitmaps to vector graphics where possible"),
@ -528,7 +522,7 @@ pdf_export_multi (GimpProcedure *procedure,
GimpRunMode run_mode; GimpRunMode run_mode;
GimpExportOptions *options = NULL; GimpExportOptions *options = NULL;
gchar *uri; gchar *uri;
const gint32 *image_ids = NULL; GimpImage **images = NULL;
GimpImage *image = NULL; GimpImage *image = NULL;
GFile *file = NULL; GFile *file = NULL;
@ -537,8 +531,7 @@ pdf_export_multi (GimpProcedure *procedure,
g_object_get (config, g_object_get (config,
"run-mode", &run_mode, "run-mode", &run_mode,
"uri", &uri, "uri", &uri,
"count", &multi_page.image_count, "images", &images,
"images", &image_ids,
NULL); NULL);
options = g_object_new (GIMP_TYPE_EXPORT_OPTIONS, options = g_object_new (GIMP_TYPE_EXPORT_OPTIONS,
@ -559,11 +552,16 @@ pdf_export_multi (GimpProcedure *procedure,
if (file != NULL) if (file != NULL)
file_name = g_file_get_path (file); file_name = g_file_get_path (file);
if (image_ids) if (images)
for (gint i = 0; i < multi_page.image_count; i++) {
multi_page.images[i] = gimp_image_get_by_id (image_ids[i]); multi_page.image_count = gimp_core_object_array_get_length ((GObject **) images);
for (gint i = 0; i < multi_page.image_count; i++)
multi_page.images[i] = images[i];
}
else else
init_image_list_defaults (image); {
init_image_list_defaults (image);
}
validate_image_list (); validate_image_list ();

40
plug-ins/common/file-pdf-load.c
View file

@ -51,8 +51,8 @@ gimp_plugin_pdf_load_error_quark (void)
typedef struct typedef struct
{ {
gint n_pages; gsize n_pages;
gint *pages; gint *pages;
} PdfSelectedPages; } PdfSelectedPages;
@ -253,15 +253,9 @@ pdf_create_procedure (GimpPlugIn *plug_in,
GIMP_PAGE_SELECTOR_TARGET_LAYERS, GIMP_PAGE_SELECTOR_TARGET_LAYERS,
G_PARAM_READWRITE); G_PARAM_READWRITE);
gimp_procedure_add_int_argument (procedure, "n-pages",
_("N pages"),
_("Number of pages to load (0 for all)"),
0, G_MAXINT, 0,
G_PARAM_READWRITE);
/* FIXME: shouldn't the whole selector be considered as one argument /* FIXME: shouldn't the whole selector be considered as one argument
* containing properties "target", "n-pages" and "pages" as a single * containing properties "target" and "pages" as a single object?
* object? *
* Or actually should we store pages at all? While it makes sense to store * Or actually should we store pages at all? While it makes sense to store
* some settings generally, not sure that the list of page makes sense * some settings generally, not sure that the list of page makes sense
* from one PDF document loaded to another (different) one. * from one PDF document loaded to another (different) one.
@ -381,10 +375,14 @@ pdf_load (GimpProcedure *procedure,
if (test_page) if (test_page)
{ {
gint i; GimpArray *pages_array;
gint doc_n_pages; const gint32 *page_numbers;
gint i;
gint doc_n_pages;
g_object_get (config, "pages", &pages_array, NULL);
page_numbers = gimp_int32_array_get_values (pages_array, &pages.n_pages);
g_object_get (config, "n-pages", &pages.n_pages, NULL);
doc_n_pages = poppler_document_get_n_pages (doc); doc_n_pages = poppler_document_get_n_pages (doc);
/* The number of imported pages may be bigger than /* The number of imported pages may be bigger than
* the number of pages from the original document. * the number of pages from the original document.
@ -402,15 +400,11 @@ pdf_load (GimpProcedure *procedure,
} }
else else
{ {
const gint32 *p;
g_object_get (config, "pages", &p, NULL);
pages.pages = g_new (gint, pages.n_pages); pages.pages = g_new (gint, pages.n_pages);
for (i = 0; i < pages.n_pages; i++) for (i = 0; i < pages.n_pages; i++)
{ {
if (p[i] >= doc_n_pages) if (page_numbers[i] >= doc_n_pages)
{ {
status = GIMP_PDB_EXECUTION_ERROR; status = GIMP_PDB_EXECUTION_ERROR;
g_set_error (&error, GIMP_PLUGIN_PDF_LOAD_ERROR, 0, g_set_error (&error, GIMP_PLUGIN_PDF_LOAD_ERROR, 0,
@ -423,13 +417,13 @@ pdf_load (GimpProcedure *procedure,
"PDF document '%1$s' has %3$d pages. Page %2$d is out of range.", "PDF document '%1$s' has %3$d pages. Page %2$d is out of range.",
doc_n_pages), doc_n_pages),
gimp_file_get_utf8_name (file), gimp_file_get_utf8_name (file),
p[i], page_numbers[i],
doc_n_pages); doc_n_pages);
break; break;
} }
else else
{ {
pages.pages[i] = p[i]; pages.pages[i] = page_numbers[i];
} }
} }
} }
@ -1148,12 +1142,12 @@ load_dialog (PopplerDocument *doc,
target = gimp_page_selector_get_target (GIMP_PAGE_SELECTOR (selector)); target = gimp_page_selector_get_target (GIMP_PAGE_SELECTOR (selector));
g_object_set (config, g_object_set (config,
"target", target, "target", target,
NULL); NULL);
pages->pages = pages->pages =
gimp_page_selector_get_selected_pages (GIMP_PAGE_SELECTOR (selector), gimp_page_selector_get_selected_pages (GIMP_PAGE_SELECTOR (selector),
&pages->n_pages); (gint *) &pages->n_pages);
/* select all if none selected */ /* select all if none selected */
if (pages->n_pages == 0) if (pages->n_pages == 0)
@ -1162,7 +1156,7 @@ load_dialog (PopplerDocument *doc,
pages->pages = pages->pages =
gimp_page_selector_get_selected_pages (GIMP_PAGE_SELECTOR (selector), gimp_page_selector_get_selected_pages (GIMP_PAGE_SELECTOR (selector),
&pages->n_pages); (gint *) &pages->n_pages);
} }
/* cleanup */ /* cleanup */

96
plug-ins/file-ico/ico-export.c
View file

@ -75,9 +75,9 @@ static gboolean ico_save_init (GimpImage *image,
gint32 run_mode, gint32 run_mode,
IcoSaveInfo *info, IcoSaveInfo *info,
gint n_hot_spot_x, gint n_hot_spot_x,
gint32 *hot_spot_x, const gint32 *hot_spot_x,
gint n_hot_spot_y, gint n_hot_spot_y,
gint32 *hot_spot_y, const gint32 *hot_spot_y,
GError **error); GError **error);
static GimpPDBStatusType static GimpPDBStatusType
shared_save_image (GFile *file, shared_save_image (GFile *file,
@ -86,10 +86,12 @@ static GimpPDBStatusType
GimpProcedure *procedure, GimpProcedure *procedure,
GimpProcedureConfig *config, GimpProcedureConfig *config,
gint32 run_mode, gint32 run_mode,
gint *n_hot_spot_x, gsize *n_hot_spot_x,
gint32 **hot_spot_x, const gint32 *hot_spot_x,
gint *n_hot_spot_y, gint32 **new_hot_spot_x,
gint32 **hot_spot_y, gsize *n_hot_spot_y,
const gint32 *hot_spot_y,
gint32 **new_hot_spot_y,
gint32 file_offset, gint32 file_offset,
gint icon_index, gint icon_index,
GError **error, GError **error,
@ -179,14 +181,14 @@ ico_write_int8 (FILE *fp,
static gboolean static gboolean
ico_save_init (GimpImage *image, ico_save_init (GimpImage *image,
gint32 run_mode, gint32 run_mode,
IcoSaveInfo *info, IcoSaveInfo *info,
gint n_hot_spot_x, gint n_hot_spot_x,
gint32 *hot_spot_x, const gint32 *hot_spot_x,
gint n_hot_spot_y, gint n_hot_spot_y,
gint32 *hot_spot_y, const gint32 *hot_spot_y,
GError **error) GError **error)
{ {
GList *iter; GList *iter;
gint num_colors; gint num_colors;
@ -1200,7 +1202,7 @@ ico_export_image (GFile *file,
return shared_save_image (file, NULL, image, procedure, return shared_save_image (file, NULL, image, procedure,
config, run_mode, config, run_mode,
0, NULL, 0, NULL, 0, NULL, NULL, 0, NULL, NULL,
0, 0, error, &info); 0, 0, error, &info);
} }
@ -1210,10 +1212,12 @@ cur_export_image (GFile *file,
GimpProcedure *procedure, GimpProcedure *procedure,
GimpProcedureConfig *config, GimpProcedureConfig *config,
gint32 run_mode, gint32 run_mode,
gint *n_hot_spot_x, gsize *n_hot_spot_x,
gint32 **hot_spot_x, const gint32 *hot_spot_x,
gint *n_hot_spot_y, gint32 **new_hot_spot_x,
gint32 **hot_spot_y, gsize *n_hot_spot_y,
const gint32 *hot_spot_y,
gint32 **new_hot_spot_y,
GError **error) GError **error)
{ {
IcoSaveInfo info; IcoSaveInfo info;
@ -1225,8 +1229,8 @@ cur_export_image (GFile *file,
return shared_save_image (file, NULL, image, procedure, return shared_save_image (file, NULL, image, procedure,
config, run_mode, config, run_mode,
n_hot_spot_x, hot_spot_x, n_hot_spot_x, hot_spot_x, new_hot_spot_x,
n_hot_spot_y, hot_spot_y, n_hot_spot_y, hot_spot_y, new_hot_spot_y,
0, 0, error, &info); 0, 0, error, &info);
} }
@ -1237,10 +1241,12 @@ ani_export_image (GFile *file,
GimpProcedure *procedure, GimpProcedure *procedure,
GimpProcedureConfig *config, GimpProcedureConfig *config,
gint32 run_mode, gint32 run_mode,
gint *n_hot_spot_x, gsize *n_hot_spot_x,
gint32 **hot_spot_x, const gint32 *hot_spot_x,
gint *n_hot_spot_y, gint32 **new_hot_spot_x,
gint32 **hot_spot_y, gsize *n_hot_spot_y,
const gint32 *hot_spot_y,
gint32 **new_hot_spot_y,
AniFileHeader *header, AniFileHeader *header,
AniSaveInfo *ani_info, AniSaveInfo *ani_info,
GError **error) GError **error)
@ -1258,9 +1264,9 @@ ani_export_image (GFile *file,
IcoSaveInfo info; IcoSaveInfo info;
if (! ico_save_init (image, run_mode, &info, if (! ico_save_init (image, run_mode, &info,
*n_hot_spot_x, *hot_spot_x, *n_hot_spot_x, hot_spot_x,
*n_hot_spot_y, *hot_spot_y, *n_hot_spot_y, hot_spot_y,
error)) error))
{ {
return GIMP_PDB_EXECUTION_ERROR; return GIMP_PDB_EXECUTION_ERROR;
} }
@ -1439,8 +1445,8 @@ ani_export_image (GFile *file,
offset = ftell (fp); offset = ftell (fp);
status = shared_save_image (file, fp, image, procedure, status = shared_save_image (file, fp, image, procedure,
config, run_mode, config, run_mode,
n_hot_spot_x, hot_spot_x, n_hot_spot_x, hot_spot_x, new_hot_spot_x,
n_hot_spot_y, hot_spot_y, n_hot_spot_y, hot_spot_y, new_hot_spot_y,
offset, i, error, &info); offset, i, error, &info);
if (status != GIMP_PDB_SUCCESS) if (status != GIMP_PDB_SUCCESS)
@ -1515,10 +1521,12 @@ shared_save_image (GFile *file,
GimpProcedure *procedure, GimpProcedure *procedure,
GimpProcedureConfig *config, GimpProcedureConfig *config,
gint32 run_mode, gint32 run_mode,
gint *n_hot_spot_x, gsize *n_hot_spot_x,
gint32 **hot_spot_x, const gint32 *hot_spot_x,
gint *n_hot_spot_y, gint32 **new_hot_spot_x,
gint32 **hot_spot_y, gsize *n_hot_spot_y,
const gint32 *hot_spot_y,
gint32 **new_hot_spot_y,
gint32 file_offset, gint32 file_offset,
gint icon_index, gint icon_index,
GError **error, GError **error,
@ -1539,9 +1547,9 @@ shared_save_image (GFile *file,
if (! fp_ani && if (! fp_ani &&
! ico_save_init (image, run_mode, info, ! ico_save_init (image, run_mode, info,
n_hot_spot_x ? *n_hot_spot_x : 0, n_hot_spot_x ? *n_hot_spot_x : 0,
hot_spot_x ? *hot_spot_x : NULL, hot_spot_x,
n_hot_spot_y ? *n_hot_spot_y : 0, n_hot_spot_y ? *n_hot_spot_y : 0,
hot_spot_y ? *hot_spot_y : NULL, hot_spot_y,
error)) error))
{ {
return GIMP_PDB_EXECUTION_ERROR; return GIMP_PDB_EXECUTION_ERROR;
@ -1698,20 +1706,20 @@ shared_save_image (GFile *file,
if (! fp_ani) if (! fp_ani)
{ {
if (hot_spot_x) if (new_hot_spot_x)
{ {
*hot_spot_x = info->hot_spot_x; *new_hot_spot_x = info->hot_spot_x;
info->hot_spot_x = NULL; info->hot_spot_x = NULL;
*n_hot_spot_x = num_icons;
} }
if (hot_spot_y) if (new_hot_spot_y)
{ {
*hot_spot_y = info->hot_spot_y; *new_hot_spot_y = info->hot_spot_y;
info->hot_spot_y = NULL; info->hot_spot_y = NULL;
*n_hot_spot_y = num_icons;
} }
if (n_hot_spot_x)
*n_hot_spot_x = num_icons;
if (n_hot_spot_y)
*n_hot_spot_y = num_icons;
} }
/* If saving .ani file, don't clear until /* If saving .ani file, don't clear until

20
plug-ins/file-ico/ico-export.h
View file

@ -34,10 +34,12 @@ GimpPDBStatusType cur_export_image (GFile *file,
GimpProcedure *procedure, GimpProcedure *procedure,
GimpProcedureConfig *config, GimpProcedureConfig *config,
gint32 run_mode, gint32 run_mode,
gint *n_hot_spot_x, gsize *n_hot_spot_x,
gint32 **hot_spot_x, const gint32 *hot_spot_x,
gint *n_hot_spot_y, gint32 **new_hot_spot_x,
gint32 **hot_spot_y, gsize *n_hot_spot_y,
const gint32 *hot_spot_y,
gint32 **new_hot_spot_y,
GError **error); GError **error);
GimpPDBStatusType ani_export_image (GFile *file, GimpPDBStatusType ani_export_image (GFile *file,
@ -45,10 +47,12 @@ GimpPDBStatusType ani_export_image (GFile *file,
GimpProcedure *procedure, GimpProcedure *procedure,
GimpProcedureConfig *config, GimpProcedureConfig *config,
gint32 run_mode, gint32 run_mode,
gint *n_hot_spot_x, gsize *n_hot_spot_x,
gint32 **hot_spot_x, const gint32 *hot_spot_x,
gint *n_hot_spot_y, gint32 **new_hot_spot_x,
gint32 **hot_spot_y, gsize *n_hot_spot_y,
const gint32 *hot_spot_y,
gint32 **new_hot_spot_y,
AniFileHeader *header, AniFileHeader *header,
AniSaveInfo *ani_info, AniSaveInfo *ani_info,
GError **error); GError **error);

112
plug-ins/file-ico/ico.c
View file

@ -340,21 +340,10 @@ ico_create_procedure (GimpPlugIn *plug_in,
gimp_file_procedure_set_extensions (GIMP_FILE_PROCEDURE (procedure), gimp_file_procedure_set_extensions (GIMP_FILE_PROCEDURE (procedure),
"cur"); "cur");
gimp_procedure_add_int_argument (procedure, "n-hot-spot-x",
"Number of hot spot's X coordinates",
"Number of hot spot's X coordinates",
0, G_MAXINT, 0,
G_PARAM_READWRITE);
gimp_procedure_add_int32_array_argument (procedure, "hot-spot-x", gimp_procedure_add_int32_array_argument (procedure, "hot-spot-x",
"Hot spot X", "Hot spot X",
"X coordinates of hot spot (one per layer)", "X coordinates of hot spot (one per layer)",
G_PARAM_READWRITE); G_PARAM_READWRITE);
gimp_procedure_add_int_argument (procedure, "n-hot-spot-y",
"Number of hot spot's Y coordinates",
"Number of hot spot's Y coordinates",
0, G_MAXINT, 0,
G_PARAM_READWRITE);
gimp_procedure_add_int32_array_argument (procedure, "hot-spot-y", gimp_procedure_add_int32_array_argument (procedure, "hot-spot-y",
"Hot spot Y", "Hot spot Y",
"Y coordinates of hot spot (one per layer)", "Y coordinates of hot spot (one per layer)",
@ -408,21 +397,10 @@ ico_create_procedure (GimpPlugIn *plug_in,
0, G_MAXINT, 8, 0, G_MAXINT, 8,
G_PARAM_READWRITE); G_PARAM_READWRITE);
gimp_procedure_add_int_argument (procedure, "n-hot-spot-x",
"Number of hot spot's X coordinates",
"Number of hot spot's X coordinates",
0, G_MAXINT, 0,
G_PARAM_READWRITE);
gimp_procedure_add_int32_array_argument (procedure, "hot-spot-x", gimp_procedure_add_int32_array_argument (procedure, "hot-spot-x",
"Hot spot X", "Hot spot X",
"X coordinates of hot spot (one per layer)", "X coordinates of hot spot (one per layer)",
G_PARAM_READWRITE); G_PARAM_READWRITE);
gimp_procedure_add_int_argument (procedure, "n-hot-spot-y",
"Number of hot spot's Y coordinates",
"Number of hot spot's Y coordinates",
0, G_MAXINT, 0,
G_PARAM_READWRITE);
gimp_procedure_add_int32_array_argument (procedure, "hot-spot-y", gimp_procedure_add_int32_array_argument (procedure, "hot-spot-y",
"Hot spot Y", "Hot spot Y",
"Y coordinates of hot spot (one per layer)", "Y coordinates of hot spot (one per layer)",
@ -605,39 +583,40 @@ cur_export (GimpProcedure *procedure,
{ {
GimpPDBStatusType status; GimpPDBStatusType status;
GError *error = NULL; GError *error = NULL;
gint32 *hot_spot_x = NULL; GimpArray *x_array = NULL;
gint32 *hot_spot_y = NULL; GimpArray *y_array = NULL;
gint n_hot_spot_x = 0; const gint32 *hot_spot_x = NULL;
gint n_hot_spot_y = 0; const gint32 *hot_spot_y = NULL;
gint32 *new_hot_spot_x = NULL;
gint32 *new_hot_spot_y = NULL;
gsize n_hot_spot_x = 0;
gsize n_hot_spot_y = 0;
gegl_init (NULL, NULL); gegl_init (NULL, NULL);
g_object_get (config, g_object_get (config,
"n-hot-spot-x", &n_hot_spot_x, "hot-spot-x", &x_array,
"n-hot-spot-y", &n_hot_spot_y, "hot-spot-y", &y_array,
"hot-spot-x", &hot_spot_x,
"hot-spot-y", &hot_spot_y,
NULL); NULL);
hot_spot_x = gimp_int32_array_get_values (x_array, &n_hot_spot_x);
hot_spot_y = gimp_int32_array_get_values (y_array, &n_hot_spot_y);
status = cur_export_image (file, image, procedure, config, run_mode, status = cur_export_image (file, image, procedure, config, run_mode,
&n_hot_spot_x, &hot_spot_x, &n_hot_spot_x, hot_spot_x, &new_hot_spot_x,
&n_hot_spot_y, &hot_spot_y, &n_hot_spot_y, hot_spot_y, &new_hot_spot_y,
&error); &error);
if (status == GIMP_PDB_SUCCESS) if (status == GIMP_PDB_SUCCESS)
{ {
/* XXX: seems libgimpconfig is not able to serialize gimp_int32_array_set_values (x_array, new_hot_spot_x, n_hot_spot_x, FALSE);
* GimpInt32Array args yet anyway. Still leave this here for now, gimp_int32_array_set_values (y_array, new_hot_spot_y, n_hot_spot_y, FALSE);
* as reminder of missing feature when we see the warnings.
*/
g_object_set (config, g_object_set (config,
"n-hot-spot-x", n_hot_spot_x, "hot-spot-x", x_array,
"n-hot-spot-y", n_hot_spot_y, "hot-spot-y", y_array,
/*"hot-spot-x", hot_spot_x,*/
/*"hot-spot-y", hot_spot_y,*/
NULL); NULL);
g_free (hot_spot_x); g_free (new_hot_spot_x);
g_free (hot_spot_y); g_free (new_hot_spot_y);
} }
return gimp_procedure_new_return_values (procedure, status, error); return gimp_procedure_new_return_values (procedure, status, error);
@ -654,14 +633,18 @@ ani_export (GimpProcedure *procedure,
gpointer run_data) gpointer run_data)
{ {
GimpPDBStatusType status; GimpPDBStatusType status;
GError *error = NULL; GError *error = NULL;
gchar *inam = NULL; gchar *inam = NULL;
gchar *iart = NULL; gchar *iart = NULL;
gint jif_rate = 0; gint jif_rate = 0;
gint32 *hot_spot_x = NULL; GimpArray *x_array = NULL;
gint32 *hot_spot_y = NULL; GimpArray *y_array = NULL;
gint n_hot_spot_x = 0; const gint32 *hot_spot_x = NULL;
gint n_hot_spot_y = 0; const gint32 *hot_spot_y = NULL;
gint32 *new_hot_spot_x = NULL;
gint32 *new_hot_spot_y = NULL;
gsize n_hot_spot_x = 0;
gsize n_hot_spot_y = 0;
AniFileHeader header; AniFileHeader header;
AniSaveInfo ani_info; AniSaveInfo ani_info;
@ -671,10 +654,8 @@ ani_export (GimpProcedure *procedure,
"cursor-name", &inam, "cursor-name", &inam,
"author-name", &iart, "author-name", &iart,
"default-delay", &jif_rate, "default-delay", &jif_rate,
"n-hot-spot-x", &n_hot_spot_x, "hot-spot-x", &x_array,
"n-hot-spot-y", &n_hot_spot_y, "hot-spot-y", &y_array,
"hot-spot-x", &hot_spot_x,
"hot-spot-y", &hot_spot_y,
NULL); NULL);
/* Jiffies (1/60th of a second) used if rate chunk not present. */ /* Jiffies (1/60th of a second) used if rate chunk not present. */
@ -682,28 +663,27 @@ ani_export (GimpProcedure *procedure,
ani_info.inam = inam; ani_info.inam = inam;
ani_info.iart = iart; ani_info.iart = iart;
hot_spot_x = gimp_int32_array_get_values (x_array, &n_hot_spot_x);
hot_spot_y = gimp_int32_array_get_values (y_array, &n_hot_spot_y);
status = ani_export_image (file, image, procedure, config, run_mode, status = ani_export_image (file, image, procedure, config, run_mode,
&n_hot_spot_x, &hot_spot_x, &n_hot_spot_x, hot_spot_x, &new_hot_spot_x,
&n_hot_spot_y, &hot_spot_y, &n_hot_spot_y, hot_spot_y, &new_hot_spot_y,
&header, &ani_info, &error); &header, &ani_info, &error);
if (status == GIMP_PDB_SUCCESS) if (status == GIMP_PDB_SUCCESS)
{ {
/* XXX: seems libgimpconfig is not able to serialize gimp_int32_array_set_values (x_array, new_hot_spot_x, n_hot_spot_x, FALSE);
* GimpInt32Array args yet anyway. Still leave this here for now, gimp_int32_array_set_values (y_array, new_hot_spot_y, n_hot_spot_y, FALSE);
* as reminder of missing feature when we see the warnings.
*/
g_object_set (config, g_object_set (config,
"cursor-name", NULL, "cursor-name", NULL,
"author-name", NULL, "author-name", NULL,
"default-delay", header.jif_rate, "default-delay", header.jif_rate,
"n-hot-spot-x", n_hot_spot_x, "hot-spot-x", x_array,
"n-hot-spot-y", n_hot_spot_y, "hot-spot-y", y_array,
/*"hot-spot-x", hot_spot_x,*/
/*"hot-spot-y", hot_spot_y,*/
NULL); NULL);
g_free (hot_spot_x); g_free (new_hot_spot_x);
g_free (hot_spot_y); g_free (new_hot_spot_y);
g_free (inam); g_free (inam);
g_free (iart); g_free (iart);