diff --git a/app/file/file-save.c b/app/file/file-save.c index 64775d2934..881332d23b 100644 --- a/app/file/file-save.c +++ b/app/file/file-save.c @@ -70,6 +70,7 @@ file_save (Gimp *gimp, gboolean mounted = TRUE; GError *my_error = NULL; GList *drawables_list; + GimpExportOptions *options = NULL; g_return_val_if_fail (GIMP_IS_GIMP (gimp), GIMP_PDB_CALLING_ERROR); g_return_val_if_fail (GIMP_IS_IMAGE (image), GIMP_PDB_CALLING_ERROR); @@ -91,6 +92,9 @@ file_save (Gimp *gimp, gimp_image_saving (image); + /* TEMP - Remove later */ + options = gimp_export_options_new (); + drawables_list = gimp_image_get_selected_drawables (image); if (! drawables_list) @@ -190,9 +194,10 @@ file_save (Gimp *gimp, gimp_get_user_context (gimp), progress, error, gimp_object_get_name (file_proc), - GIMP_TYPE_RUN_MODE, run_mode, - GIMP_TYPE_IMAGE, image, - G_TYPE_FILE, file, + GIMP_TYPE_RUN_MODE, run_mode, + GIMP_TYPE_IMAGE, image, + G_TYPE_FILE, file, + GIMP_TYPE_EXPORT_OPTIONS, options, G_TYPE_NONE); status = g_value_get_enum (gimp_value_array_index (return_vals, 0)); diff --git a/app/pdb/file-cmds.c b/app/pdb/file-cmds.c index 30b10b85cd..140ec0728f 100644 --- a/app/pdb/file-cmds.c +++ b/app/pdb/file-cmds.c @@ -259,8 +259,10 @@ file_save_invoker (GimpProcedure *procedure, gimp_value_array_index (new_args, 1)); g_value_transform (gimp_value_array_index (args, 2), gimp_value_array_index (new_args, 2)); + g_value_transform (gimp_value_array_index (args, 3), + gimp_value_array_index (new_args, 3)); - for (i = 3; i < proc->num_args; i++) + for (i = 4; i < proc->num_args; i++) if (G_IS_PARAM_SPEC_STRING (proc->args[i])) g_value_set_static_string (gimp_value_array_index (new_args, i), ""); @@ -516,6 +518,12 @@ register_file_procs (GimpPDB *pdb) "The file to save the image in", G_TYPE_FILE, GIMP_PARAM_READWRITE)); + gimp_procedure_add_argument (procedure, + gimp_param_spec_export_options ("options", + "options", + "Export option settings", + 0, + GIMP_PARAM_READWRITE)); gimp_pdb_register_procedure (pdb, procedure); g_object_unref (procedure); diff --git a/app/plug-in/gimpplugin-proc.c b/app/plug-in/gimpplugin-proc.c index 5332568e57..7aa8055951 100644 --- a/app/plug-in/gimpplugin-proc.c +++ b/app/plug-in/gimpplugin-proc.c @@ -390,17 +390,17 @@ gimp_plug_in_set_file_proc_save_handler (GimpPlugIn *plug_in, procedure = GIMP_PROCEDURE (proc); - if ((procedure->num_args < 3) || - ! GIMP_IS_PARAM_SPEC_RUN_MODE (procedure->args[0]) || - ! GIMP_IS_PARAM_SPEC_IMAGE (procedure->args[1]) || - ! GIMP_IS_PARAM_SPEC_FILE (procedure->args[2])) + if ((procedure->num_args < 4) || + ! GIMP_IS_PARAM_SPEC_RUN_MODE (procedure->args[0]) || + ! GIMP_IS_PARAM_SPEC_IMAGE (procedure->args[1]) || + ! GIMP_IS_PARAM_SPEC_FILE (procedure->args[2])) { g_set_error (error, GIMP_PDB_ERROR, GIMP_PDB_ERROR_FAILED, "Plug-in \"%s\"\n(%s)\n" "attempted to register procedure \"%s\" " "as save handler which does not take the standard " "save procedure arguments:\n" - "(GimpRunMode, GimpImage, GFile)", + "(GimpRunMode, GimpImage, GFile, GimpExportOptions)", gimp_object_get_name (plug_in), gimp_file_get_utf8_name (plug_in->file), proc_name); diff --git a/app/plug-in/plug-in-rc.c b/app/plug-in/plug-in-rc.c index 4d5b855f56..e1cd6402a2 100644 --- a/app/plug-in/plug-in-rc.c +++ b/app/plug-in/plug-in-rc.c @@ -998,6 +998,15 @@ plug_in_proc_arg_deserialize (GScanner *scanner, goto error; } break; + + case GP_PARAM_DEF_TYPE_EXPORT_OPTIONS: + if (! gimp_scanner_parse_int (scanner, + ¶m_def.meta.m_export_options.capabilities)) + { + token = G_TOKEN_INT; + goto error; + } + break; } if (! gimp_scanner_parse_token (scanner, G_TOKEN_RIGHT_PAREN)) @@ -1059,6 +1068,9 @@ plug_in_proc_arg_deserialize (GScanner *scanner, case GP_PARAM_DEF_TYPE_ID_ARRAY: g_free (param_def.meta.m_id_array.type_name); break; + + case GP_PARAM_DEF_TYPE_EXPORT_OPTIONS: + break; } return token; @@ -1240,6 +1252,11 @@ plug_in_rc_write_proc_arg (GimpConfigWriter *writer, gimp_config_writer_string (writer, param_def.meta.m_id_array.type_name); break; + + case GP_PARAM_DEF_TYPE_EXPORT_OPTIONS: + gimp_config_writer_printf (writer, "%d", + param_def.meta.m_export_options.capabilities); + break; } gimp_config_writer_close (writer); diff --git a/libgimp/gimp.def b/libgimp/gimp.def index b779612ab7..9144ec5153 100644 --- a/libgimp/gimp.def +++ b/libgimp/gimp.def @@ -270,6 +270,7 @@ EXPORTS gimp_export_comment gimp_export_exif gimp_export_iptc + gimp_export_options_get_image gimp_export_procedure_get_support_comment gimp_export_procedure_get_support_exif gimp_export_procedure_get_support_iptc @@ -278,6 +279,7 @@ EXPORTS gimp_export_procedure_get_support_xmp gimp_export_procedure_get_type gimp_export_procedure_new + gimp_export_procedure_set_capabilities gimp_export_procedure_set_support_comment gimp_export_procedure_set_support_exif gimp_export_procedure_set_support_iptc diff --git a/libgimp/gimp.h b/libgimp/gimp.h index 6f9efcdeab..cfbda65bce 100644 --- a/libgimp/gimp.h +++ b/libgimp/gimp.h @@ -42,6 +42,7 @@ #include #include #include +#include #include #include #include diff --git a/libgimp/gimpexport.c b/libgimp/gimpexportoptions.c similarity index 85% rename from libgimp/gimpexport.c rename to libgimp/gimpexportoptions.c index 0855b4c5cc..de342a8785 100644 --- a/libgimp/gimpexport.c +++ b/libgimp/gimpexportoptions.c @@ -1,8 +1,8 @@ /* LIBGIMP - The GIMP Library * Copyright (C) 1995-1997 Peter Mattis and Spencer Kimball * - * gimpexport.c - * Copyright (C) 1999-2004 Sven Neumann + * gimpexportoptions.c + * Copyright (C) 2024 Alx Sa. * * This library is free software: you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public @@ -12,7 +12,7 @@ * This library 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 - * Library General Public License for more details. + * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with this library. If not, see @@ -21,40 +21,18 @@ #include "config.h" -#include - -#include - #include "gimp.h" -#include "gimpui.h" + +#include "gimpexportoptions.h" #include "libgimp-intl.h" -/** - * SECTION: gimpexport - * @title: gimpexport - * @short_description: Export an image before it is saved. - * - * This function should be called by all save_plugins unless they are - * able to save all image formats GIMP knows about. It takes care of - * asking the user if she wishes to export the image to a format the - * save_plugin can handle. It then performs the necessary conversions - * (e.g. Flatten) on a copy of the image so that the image can be - * saved without changing the original image. - * - * The capabilities of the save_plugin are specified by combining - * #GimpExportCapabilities using a bitwise OR. - * - * Make sure you have initialized GTK+ before you call this function - * as it will most probably have to open a dialog. - **/ - +/* export helper functions */ typedef void (* ExportFunc) (GimpImage *image, GList **drawables); - /* the export action structure */ typedef struct { @@ -548,47 +526,42 @@ export_action_perform (const ExportAction *action, export_action_get_func (action) (image, drawables); } - -/* dialog functions */ - /** - * gimp_export_image: + * gimp_export_options_get_image: + * @options: The #GimpExportOptions object. * @image: Pointer to the image. - * @capabilities: What can the image_format do? * * Takes an image to be saved together with a description - * of the capabilities of the image_format. If the type of - * image doesn't match the capabilities of the format - * a dialog is opened that informs the user that the image has - * to be exported and offers to do the necessary conversions. - * - * If the user chooses to export the image, a copy is created. + * of the capabilities of the image_format. A copy is created. * This copy is then converted, @image is changed to point to the * new image and the procedure returns GIMP_EXPORT_EXPORT. * The save_plugin has to take care of deleting the created image using * gimp_image_delete() once the image has been saved. * - * If the user chooses to Ignore the export problem, @image is not - * altered, GIMP_EXPORT_IGNORE is returned and the save_plugin - * should try to save the original image. - * * Returns: An enum of #GimpExportReturn describing the user_action. + * + * Since: 3.0 **/ GimpExportReturn -gimp_export_image (GimpImage **image, - GimpExportCapabilities capabilities) +gimp_export_options_get_image (GimpExportOptions *options, + GimpImage **image) { - GSList *actions = NULL; - GimpImageBaseType type; - GList *layers; - gint n_layers; - GList *iter; - gboolean added_flatten = FALSE; - gboolean has_layer_masks = FALSE; - gboolean background_has_alpha = TRUE; - GimpExportReturn retval = GIMP_EXPORT_IGNORE; + GSList *actions = NULL; + GimpImageBaseType type; + GList *layers; + gint n_layers; + GList *iter; + GimpExportCapabilities capabilities = 0; + gboolean added_flatten = FALSE; + gboolean has_layer_masks = FALSE; + gboolean background_has_alpha = TRUE; + GimpExportReturn retval = GIMP_EXPORT_IGNORE; g_return_val_if_fail (gimp_image_is_valid (*image), FALSE); + g_return_val_if_fail (options != NULL, FALSE); + + /* Get capabilities from ExportOptions */ + g_object_get (options, "capabilities", &capabilities, NULL); /* do some sanity checks */ if (capabilities & GIMP_EXPORT_NEEDS_ALPHA) @@ -891,71 +864,3 @@ gimp_export_image (GimpImage **image, return retval; } - -/** - * gimp_export_dialog_new: - * @format_name: The short name of the image_format (e.g. JPEG or PNG). - * @role: The dialog's @role which will be set with - * gtk_window_set_role(). - * @help_id: The GIMP help id. - * - * Creates a new export dialog. All file plug-ins should use this - * dialog to get a consistent look on the export dialogs. Use - * gimp_export_dialog_get_content_area() to get a vertical #GtkBox to be - * filled with export options. The export dialog is a wrapped - * #GimpDialog. - * - * The dialog response when the user clicks on the Export button is - * %GTK_RESPONSE_OK, and when the Cancel button is clicked it is - * %GTK_RESPONSE_CANCEL. - * - * Returns: (transfer full): The new export dialog. - * - * Since: 2.8 - **/ -GtkWidget * -gimp_export_dialog_new (const gchar *format_name, - const gchar *role, - const gchar *help_id) -{ - GtkWidget *dialog; - /* TRANSLATORS: the %s parameter is an image format name (ex: PNG). */ - gchar *title = g_strdup_printf (_("Export Image as %s"), format_name); - - dialog = gimp_dialog_new (title, role, - NULL, 0, - gimp_standard_help_func, help_id, - - _("_Cancel"), GTK_RESPONSE_CANCEL, - _("_Export"), GTK_RESPONSE_OK, - - NULL); - - gimp_dialog_set_alternative_button_order (GTK_DIALOG (dialog), - GTK_RESPONSE_OK, - GTK_RESPONSE_CANCEL, - -1); - - gimp_window_set_transient (GTK_WINDOW (dialog)); - - g_free (title); - - return dialog; -} - -/** - * gimp_export_dialog_get_content_area: - * @dialog: A dialog created with gimp_export_dialog_new() - * - * Returns the vertical #GtkBox of the passed export dialog to be filled with - * export options. - * - * Returns: (transfer none): The #GtkBox to fill with export options. - * - * Since: 2.8 - **/ -GtkWidget * -gimp_export_dialog_get_content_area (GtkWidget *dialog) -{ - return gtk_dialog_get_content_area (GTK_DIALOG (dialog)); -} diff --git a/libgimp/gimpexportoptions.h b/libgimp/gimpexportoptions.h new file mode 100644 index 0000000000..073e33fe2a --- /dev/null +++ b/libgimp/gimpexportoptions.h @@ -0,0 +1,55 @@ +/* LIBGIMP - The GIMP Library + * Copyright (C) 1995-2000 Peter Mattis and Spencer Kimball + * + * gimpexportoptions.h + * Copyright (C) 2024 Alx Sa. + * + * This library is free software: you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 3 of the License, or (at your option) any later version. + * + * This library 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library. If not, see + * . + */ + +#if !defined (__GIMP_H_INSIDE__) && !defined (GIMP_COMPILATION) +#error "Only can be included directly." +#endif + +#ifndef __LIBGIMP_GIMP_EXPORT_OPTIONS_H__ +#define __LIBGIMP_GIMP_EXPORT_OPTIONS_H__ + +G_BEGIN_DECLS + +/* For information look into the C source or the html documentation */ + + +/** + * GimpExportReturn: + * @GIMP_EXPORT_IGNORE: The image is unmodified but export shall continue anyway + * @GIMP_EXPORT_EXPORT: The chosen transforms were applied to the image + * + * Possible return values of gimp_export_image(). + **/ +typedef enum +{ + GIMP_EXPORT_IGNORE, + GIMP_EXPORT_EXPORT +} GimpExportReturn; + + +GimpExportReturn gimp_export_options_get_image (GimpExportOptions *options, + GimpImage **image); + + +G_END_DECLS + + +#endif /* __LIBGIMP_GIMP_EXPORT_OPTIONS_H__ */ diff --git a/libgimp/gimpexportprocedure.c b/libgimp/gimpexportprocedure.c index 25a0697d82..89d22602b2 100644 --- a/libgimp/gimpexportprocedure.c +++ b/libgimp/gimpexportprocedure.c @@ -46,6 +46,7 @@ enum { PROP_0, + PROP_CAPABILITIES, PROP_SUPPORTS_EXIF, PROP_SUPPORTS_IPTC, PROP_SUPPORTS_XMP, @@ -57,44 +58,52 @@ enum struct _GimpExportProcedure { - GimpFileProcedure parent_instance; + GimpFileProcedure parent_instance; - GimpRunExportFunc run_func; - gpointer run_data; - GDestroyNotify run_data_destroy; + GimpRunExportFunc run_func; + gpointer run_data; + GDestroyNotify run_data_destroy; - gboolean supports_exif; - gboolean supports_iptc; - gboolean supports_xmp; - gboolean supports_profile; - gboolean supports_thumbnail; - gboolean supports_comment; + GimpExportCapabilities capabilities; + GimpExportOptionsEditFunc create_func; + gpointer create_data; - gboolean export_metadata; + gboolean supports_exif; + gboolean supports_iptc; + gboolean supports_xmp; + gboolean supports_profile; + gboolean supports_thumbnail; + gboolean supports_comment; + + gboolean export_metadata; }; -static void gimp_export_procedure_constructed (GObject *object); -static void gimp_export_procedure_finalize (GObject *object); -static void gimp_export_procedure_set_property (GObject *object, - guint property_id, - const GValue *value, - GParamSpec *pspec); -static void gimp_export_procedure_get_property (GObject *object, - guint property_id, - GValue *value, - GParamSpec *pspec); +static void gimp_export_procedure_constructed (GObject *object); +static void gimp_export_procedure_finalize (GObject *object); +static void gimp_export_procedure_set_property (GObject *object, + guint property_id, + const GValue *value, + GParamSpec *pspec); +static void gimp_export_procedure_get_property (GObject *object, + guint property_id, + GValue *value, + GParamSpec *pspec); -static void gimp_export_procedure_install (GimpProcedure *procedure); +static void gimp_export_procedure_install (GimpProcedure *procedure); static GimpValueArray * - gimp_export_procedure_run (GimpProcedure *procedure, - const GimpValueArray *args); + gimp_export_procedure_run (GimpProcedure *procedure, + const GimpValueArray *args); static GimpProcedureConfig * - gimp_export_procedure_create_config (GimpProcedure *procedure, - GParamSpec **args, - gint n_args); + gimp_export_procedure_create_config (GimpProcedure *procedure, + GParamSpec **args, + gint n_args); -static void gimp_export_procedure_add_metadata (GimpExportProcedure *export_procedure); +static void gimp_export_procedure_add_metadata (GimpExportProcedure *export_procedure); + +static void gimp_export_procedure_update_options (GimpProcedureConfig *config, + GParamSpec *param, + gpointer data); G_DEFINE_TYPE (GimpExportProcedure, gimp_export_procedure, GIMP_TYPE_FILE_PROCEDURE) @@ -118,6 +127,20 @@ gimp_export_procedure_class_init (GimpExportProcedureClass *klass) procedure_class->run = gimp_export_procedure_run; procedure_class->create_config = gimp_export_procedure_create_config; + /** + * GimpExportProcedure:capabilities: + * + * What #GimpExportCapabilities are supported + * + * Since: 3.0.0 + */ + props[PROP_CAPABILITIES] = g_param_spec_int ("capabilities", + "Supported image capabilities", + NULL, + 0, G_MAXINT, 0, + G_PARAM_CONSTRUCT | + GIMP_PARAM_READWRITE); + /** * GimpExportProcedure:supports-exif: * @@ -204,6 +227,7 @@ static void gimp_export_procedure_init (GimpExportProcedure *procedure) { procedure->export_metadata = FALSE; + procedure->capabilities = 0; } static void @@ -223,6 +247,11 @@ gimp_export_procedure_constructed (GObject *object) "File", "The file to export to", GIMP_PARAM_READWRITE); + + _gimp_procedure_add_argument (procedure, + gimp_param_spec_export_options ("options", "Options", + "Export options", 0, + G_PARAM_READWRITE)); } static void @@ -246,6 +275,9 @@ gimp_export_procedure_set_property (GObject *object, switch (property_id) { + case PROP_CAPABILITIES: + procedure->capabilities = g_value_get_int (value); + break; case PROP_SUPPORTS_EXIF: procedure->supports_exif = g_value_get_boolean (value); break; @@ -281,6 +313,9 @@ gimp_export_procedure_get_property (GObject *object, switch (property_id) { + case PROP_CAPABILITIES: + g_value_set_int (value, procedure->capabilities); + break; case PROP_SUPPORTS_EXIF: g_value_set_boolean (value, procedure->supports_exif); break; @@ -334,7 +369,7 @@ gimp_export_procedure_install (GimpProcedure *procedure) priority); } -#define ARG_OFFSET 3 +#define ARG_OFFSET 4 static GimpValueArray * gimp_export_procedure_run (GimpProcedure *procedure, @@ -349,12 +384,15 @@ gimp_export_procedure_run (GimpProcedure *procedure, GimpImage *image; GFile *file; GimpMetadata *metadata; - gchar *mimetype = NULL; - GimpPDBStatusType status = GIMP_PDB_EXECUTION_ERROR; + GimpExportOptions *options = NULL; + gchar *mimetype = NULL; + GimpPDBStatusType status = GIMP_PDB_EXECUTION_ERROR; + gboolean free_options = FALSE; run_mode = GIMP_VALUES_GET_ENUM (args, 0); image = GIMP_VALUES_GET_IMAGE (args, 1); file = GIMP_VALUES_GET_FILE (args, 2); + options = g_value_get_object (gimp_value_array_index (args, 3)); remaining = gimp_value_array_new (gimp_value_array_length (args) - ARG_OFFSET); @@ -398,9 +436,33 @@ gimp_export_procedure_run (GimpProcedure *procedure, metadata = _gimp_procedure_config_begin_export (config, image, run_mode, remaining, mimetype); g_free (mimetype); + /* GimpExportOptions may be null if called non-interactively from a script, + * so we'll make sure it's initialized */ + if (options == NULL) + { + options = gimp_export_options_new (); + free_options = TRUE; + } + + if (export_proc->create_func != NULL) + { + export_proc->create_func (procedure, config, options, + export_proc->create_data); + + g_signal_connect_object (config, "notify", + G_CALLBACK (gimp_export_procedure_update_options), + options, 0); + } + else + { + g_object_set (options, + "capabilities", export_proc->capabilities, + NULL); + } + return_values = export_proc->run_func (procedure, run_mode, image, - file, metadata, config, - export_proc->run_data); + file, options, metadata, + config, export_proc->run_data); if (return_values != NULL && gimp_value_array_length (return_values) > 0 && @@ -418,6 +480,8 @@ gimp_export_procedure_run (GimpProcedure *procedure, g_printerr ("%s: ERROR: the GimpExportProcedureConfig object was refed " "by plug-in, it MUST NOT do that!\n", G_STRFUNC); + if (free_options) + g_object_unref (options); g_object_unref (config); gimp_value_array_unref (remaining); @@ -506,6 +570,22 @@ gimp_export_procedure_add_metadata (GimpExportProcedure *export_procedure) ran_once = TRUE; } +static void +gimp_export_procedure_update_options (GimpProcedureConfig *config, + GParamSpec *param, + gpointer data) +{ + GimpProcedure *procedure; + GimpExportProcedure *export_proc; + GimpExportOptions *options = GIMP_EXPORT_OPTIONS (data); + + procedure = gimp_procedure_config_get_procedure (config); + export_proc = GIMP_EXPORT_PROCEDURE (procedure); + + export_proc->create_func (procedure, config, options, + export_proc->create_data); +} + /* public functions */ @@ -529,7 +609,7 @@ gimp_export_procedure_add_metadata (GimpExportProcedure *export_procedure) * * It automatically adds the standard * - * (#GimpRunMode, #GimpImage, #GimpDrawable, #GFile) + * (#GimpRunMode, #GimpImage, #GFile, #GimpExportOptions) * * arguments of an export procedure. It is possible to add additional * arguments. @@ -578,6 +658,39 @@ gimp_export_procedure_new (GimpPlugIn *plug_in, return GIMP_PROCEDURE (procedure); } +/** + * gimp_export_procedure_set_capabilities: + * @procedure: a #GimpProcedure. + * @capabilities: a #GimpExportCapabilities enum + * @create_func: (nullable): callback function to update export options + * @create_data: (nullable): data for @create_func + * + * Sets default #GimpExportCapabilities for image export. + * + * Since: 3.0 + **/ +void +gimp_export_procedure_set_capabilities (GimpExportProcedure *procedure, + GimpExportCapabilities capabilities, + GimpExportOptionsEditFunc create_func, + gpointer create_data) +{ + g_return_if_fail (GIMP_IS_EXPORT_PROCEDURE (procedure)); + + /* Assign default image capabilities */ + g_object_set (procedure, + "capabilities", capabilities, + NULL); + + /* TODO: Do more with this when we have user-specified callbacks for + * image capabilities */ + if (create_func != NULL) + { + procedure->create_func = create_func; + procedure->create_data = create_data; + } +} + /** * gimp_export_procedure_set_support_exif: * @procedure: a #GimpProcedure. diff --git a/libgimp/gimpexportprocedure.h b/libgimp/gimpexportprocedure.h index a8f791cf0b..e52eceed6f 100644 --- a/libgimp/gimpexportprocedure.h +++ b/libgimp/gimpexportprocedure.h @@ -35,6 +35,7 @@ G_BEGIN_DECLS * @run_mode: the #GimpRunMode. * @image: the image to export. * @file: the #GFile to export to. + * @options: the #GimpExportOptions settings. * @metadata: metadata object prepared for the mimetype passed in * gimp_file_procedure_set_mime_types() if export_metadata * argument was set in gimp_export_procedure_new(). @@ -57,42 +58,66 @@ typedef GimpValueArray * (* GimpRunExportFunc) (GimpProcedure *procedure, GimpRunMode run_mode, GimpImage *image, GFile *file, + GimpExportOptions *options, GimpMetadata *metadata, GimpProcedureConfig *config, gpointer run_data); +/** + * GimpExportOptionsEditFunc: + * @procedure: the #GimpProcedure that runs. + * @config: the #GimpProcedureConfig. + * @options: the @GimpExportOptions object to update. + * @create_data: (closure): the create_data given. + * + * To be described. + * + * Since: 3.0 + **/ + +typedef void (* GimpExportOptionsEditFunc) (GimpProcedure *procedure, + GimpProcedureConfig *config, + GimpExportOptions *options, + gpointer create_data); + #define GIMP_TYPE_EXPORT_PROCEDURE (gimp_export_procedure_get_type ()) G_DECLARE_FINAL_TYPE (GimpExportProcedure, gimp_export_procedure, GIMP, EXPORT_PROCEDURE, GimpFileProcedure) -GimpProcedure * gimp_export_procedure_new (GimpPlugIn *plug_in, - const gchar *name, - GimpPDBProcType proc_type, - gboolean export_metadata, - GimpRunExportFunc run_func, - gpointer run_data, - GDestroyNotify run_data_destroy); +GimpProcedure * gimp_export_procedure_new (GimpPlugIn *plug_in, + const gchar *name, + GimpPDBProcType proc_type, + gboolean export_metadata, + GimpRunExportFunc run_func, + gpointer run_data, + GDestroyNotify run_data_destroy); -void gimp_export_procedure_set_support_exif (GimpExportProcedure *procedure, - gboolean supports); -void gimp_export_procedure_set_support_iptc (GimpExportProcedure *procedure, - gboolean supports); -void gimp_export_procedure_set_support_xmp (GimpExportProcedure *procedure, - gboolean supports); -void gimp_export_procedure_set_support_profile (GimpExportProcedure *procedure, - gboolean supports); -void gimp_export_procedure_set_support_thumbnail (GimpExportProcedure *procedure, - gboolean supports); -void gimp_export_procedure_set_support_comment (GimpExportProcedure *procedure, - gboolean supports); +void gimp_export_procedure_set_capabilities (GimpExportProcedure *procedure, + GimpExportCapabilities capabilities, + GimpExportOptionsEditFunc create_func, + gpointer create_data); -gboolean gimp_export_procedure_get_support_exif (GimpExportProcedure *procedure); -gboolean gimp_export_procedure_get_support_iptc (GimpExportProcedure *procedure); -gboolean gimp_export_procedure_get_support_xmp (GimpExportProcedure *procedure); -gboolean gimp_export_procedure_get_support_profile (GimpExportProcedure *procedure); -gboolean gimp_export_procedure_get_support_thumbnail (GimpExportProcedure *procedure); -gboolean gimp_export_procedure_get_support_comment (GimpExportProcedure *procedure); + +void gimp_export_procedure_set_support_exif (GimpExportProcedure *procedure, + gboolean supports); +void gimp_export_procedure_set_support_iptc (GimpExportProcedure *procedure, + gboolean supports); +void gimp_export_procedure_set_support_xmp (GimpExportProcedure *procedure, + gboolean supports); +void gimp_export_procedure_set_support_profile (GimpExportProcedure *procedure, + gboolean supports); +void gimp_export_procedure_set_support_thumbnail (GimpExportProcedure *procedure, + gboolean supports); +void gimp_export_procedure_set_support_comment (GimpExportProcedure *procedure, + gboolean supports); + +gboolean gimp_export_procedure_get_support_exif (GimpExportProcedure *procedure); +gboolean gimp_export_procedure_get_support_iptc (GimpExportProcedure *procedure); +gboolean gimp_export_procedure_get_support_xmp (GimpExportProcedure *procedure); +gboolean gimp_export_procedure_get_support_profile (GimpExportProcedure *procedure); +gboolean gimp_export_procedure_get_support_thumbnail (GimpExportProcedure *procedure); +gboolean gimp_export_procedure_get_support_comment (GimpExportProcedure *procedure); G_END_DECLS diff --git a/libgimp/gimpfile_pdb.c b/libgimp/gimpfile_pdb.c index e314560ac8..68bbf8e719 100644 --- a/libgimp/gimpfile_pdb.c +++ b/libgimp/gimpfile_pdb.c @@ -179,6 +179,7 @@ gimp_file_load_layers (GimpRunMode run_mode, * @run_mode: The run mode. * @image: Input image. * @file: The file to save the image in. + * @options: Export option settings. * * Saves a file by extension. * @@ -188,9 +189,10 @@ gimp_file_load_layers (GimpRunMode run_mode, * Returns: TRUE on success. **/ gboolean -gimp_file_save (GimpRunMode run_mode, - GimpImage *image, - GFile *file) +gimp_file_save (GimpRunMode run_mode, + GimpImage *image, + GFile *file, + GimpExportOptions *options) { GimpValueArray *args; GimpValueArray *return_vals; @@ -200,6 +202,7 @@ gimp_file_save (GimpRunMode run_mode, GIMP_TYPE_RUN_MODE, run_mode, GIMP_TYPE_IMAGE, image, G_TYPE_FILE, file, + GIMP_TYPE_EXPORT_OPTIONS, options, G_TYPE_NONE); return_vals = _gimp_pdb_run_procedure_array (gimp_get_pdb (), diff --git a/libgimp/gimpfile_pdb.h b/libgimp/gimpfile_pdb.h index 30352d593f..47a26078f5 100644 --- a/libgimp/gimpfile_pdb.h +++ b/libgimp/gimpfile_pdb.h @@ -32,20 +32,21 @@ G_BEGIN_DECLS /* For information look into the C source or the html documentation */ -GimpImage* gimp_file_load (GimpRunMode run_mode, - GFile *file); -GimpLayer* gimp_file_load_layer (GimpRunMode run_mode, - GimpImage *image, - GFile *file); -GimpLayer** gimp_file_load_layers (GimpRunMode run_mode, - GimpImage *image, - GFile *file, - gint *num_layers); -gboolean gimp_file_save (GimpRunMode run_mode, - GimpImage *image, - GFile *file); -gboolean gimp_file_save_thumbnail (GimpImage *image, - GFile *file); +GimpImage* gimp_file_load (GimpRunMode run_mode, + GFile *file); +GimpLayer* gimp_file_load_layer (GimpRunMode run_mode, + GimpImage *image, + GFile *file); +GimpLayer** gimp_file_load_layers (GimpRunMode run_mode, + GimpImage *image, + GFile *file, + gint *num_layers); +gboolean gimp_file_save (GimpRunMode run_mode, + GimpImage *image, + GFile *file, + GimpExportOptions *options); +gboolean gimp_file_save_thumbnail (GimpImage *image, + GFile *file); G_END_DECLS diff --git a/libgimp/gimpgpparams-body.c b/libgimp/gimpgpparams-body.c index 0b200ee09e..d2115348c7 100644 --- a/libgimp/gimpgpparams-body.c +++ b/libgimp/gimpgpparams-body.c @@ -293,6 +293,14 @@ _gimp_gp_param_def_to_param_spec (const GPParamDef *param_def) return gimp_param_spec_object_array (name, nick, blurb, g_type_from_name (param_def->meta.m_id_array.type_name), flags); + + case GP_PARAM_DEF_TYPE_EXPORT_OPTIONS: + if (! strcmp (param_def->type_name, "GimpParamExportOptions")) + { + return gimp_param_spec_export_options (name, nick, blurb, + param_def->meta.m_export_options.capabilities, + flags); + } break; } @@ -498,6 +506,14 @@ _gimp_param_spec_to_gp_param_def (GParamSpec *pspec, param_def->meta.m_id_array.type_name = (gchar *) g_type_name (GIMP_PARAM_SPEC_OBJECT_ARRAY (pspec)->object_type); } + else if (pspec_type == GIMP_TYPE_PARAM_EXPORT_OPTIONS) + { + GimpParamSpecExportOptions *eospec = GIMP_PARAM_SPEC_EXPORT_OPTIONS (pspec); + + param_def->param_def_type = GP_PARAM_DEF_TYPE_EXPORT_OPTIONS; + + param_def->meta.m_export_options.capabilities = eospec->capabilities; + } else if (pspec_type == G_TYPE_PARAM_OBJECT && value_type != G_TYPE_FILE && value_type != GEGL_TYPE_COLOR) @@ -924,6 +940,18 @@ gimp_gp_param_to_value (gpointer gimp, { g_value_set_object (value, get_unit_by_id (gimp, param->data.d_int)); } + else if (g_type_is_a (G_VALUE_TYPE (value), GIMP_TYPE_EXPORT_OPTIONS)) + { + GimpExportOptions *options = gimp_export_options_new (); + + g_object_set (options, + "capabilities", param->data.d_export_options.capabilities, + NULL); + + g_value_set_object (value, options); + + g_object_unref (options); + } else if (G_VALUE_HOLDS_PARAM (value)) { GParamSpec *pspec = @@ -1359,6 +1387,20 @@ gimp_value_to_gp_param (const GValue *value, param->data.d_int = unit ? gimp_unit_get_id (unit) : -1; } + else if (g_type_is_a (G_VALUE_TYPE (value), GIMP_TYPE_EXPORT_OPTIONS)) + { + GimpExportOptions *options = g_value_get_object (value); + gint capabilities = 0; + + param->param_type = GP_PARAM_TYPE_INT; + + if (options) + g_object_get (options, + "capabilities", &capabilities, + NULL); + + param->data.d_export_options.capabilities = capabilities; + } else if (G_VALUE_HOLDS_PARAM (value)) { param->param_type = GP_PARAM_TYPE_PARAM_DEF; @@ -1460,6 +1502,9 @@ _gimp_gp_params_free (GPParam *params, } break; + case GP_PARAM_TYPE_EXPORT_OPTIONS: + break; + case GP_PARAM_TYPE_PARAM_DEF: break; } diff --git a/libgimp/gimpui.def b/libgimp/gimpui.def index 059ac0c527..73b4e6876d 100644 --- a/libgimp/gimpui.def +++ b/libgimp/gimpui.def @@ -15,9 +15,6 @@ EXPORTS gimp_drawable_preview_get_drawable gimp_drawable_preview_get_type gimp_drawable_preview_new_from_drawable - gimp_export_dialog_get_content_area - gimp_export_dialog_new - gimp_export_image gimp_export_procedure_dialog_add_metadata gimp_export_procedure_dialog_get_type gimp_export_procedure_dialog_new diff --git a/libgimp/gimpui.h b/libgimp/gimpui.h index 423dbfe40d..86c3ae641a 100644 --- a/libgimp/gimpui.h +++ b/libgimp/gimpui.h @@ -33,7 +33,6 @@ #include #include #include -#include #include #include #include diff --git a/libgimp/meson.build b/libgimp/meson.build index 882a10cb25..7122ca677d 100644 --- a/libgimp/meson.build +++ b/libgimp/meson.build @@ -179,6 +179,7 @@ libgimp_sources_introspectable = [ 'gimpchannel.c', 'gimpdisplay.c', 'gimpdrawable.c', + 'gimpexportoptions.c', 'gimpfileprocedure.c', 'gimpfont.c', 'gimpgimprc.c', @@ -239,6 +240,7 @@ libgimp_headers_introspectable = [ 'gimpchannel.h', 'gimpdisplay.h', 'gimpdrawable.h', + 'gimpexportoptions.h', 'gimpfileprocedure.h', 'gimpfont.h', 'gimpgimprc.h', @@ -281,7 +283,6 @@ libgimpui_sources_introspectable = [ 'gimpbrushchooser.c', 'gimpdrawablechooser.c', 'gimpdrawablepreview.c', - 'gimpexport.c', 'gimpfontchooser.c', 'gimpgradientchooser.c', 'gimpimagecombobox.c', @@ -318,7 +319,6 @@ libgimpui_headers_introspectable = [ 'gimpbrushchooser.h', 'gimpdrawablechooser.h', 'gimpdrawablepreview.h', - 'gimpexport.h', 'gimpfontchooser.h', 'gimpgradientchooser.h', 'gimpimagecombobox.h', diff --git a/libgimpbase/gimpbase.def b/libgimpbase/gimpbase.def index 15c4279419..57713e91b9 100644 --- a/libgimpbase/gimpbase.def +++ b/libgimpbase/gimpbase.def @@ -55,6 +55,8 @@ EXPORTS gimp_enum_value_get_help gimp_env_init gimp_escape_uline + gimp_export_options_get_type + gimp_export_options_new gimp_file_get_utf8_name gimp_file_has_extension gimp_file_show_in_file_manager @@ -124,6 +126,7 @@ EXPORTS gimp_paint_application_mode_get_type gimp_param_array_get_type gimp_param_choice_get_type + gimp_param_export_options_get_type gimp_param_float_array_get_type gimp_param_int32_array_get_type gimp_param_memsize_get_type @@ -131,6 +134,7 @@ EXPORTS gimp_param_parasite_get_type gimp_param_spec_array gimp_param_spec_choice + gimp_param_spec_export_options gimp_param_spec_float_array gimp_param_spec_int32_array gimp_param_spec_memsize diff --git a/libgimpbase/gimpbase.h b/libgimpbase/gimpbase.h index 4cabf43c35..07267cb285 100644 --- a/libgimpbase/gimpbase.h +++ b/libgimpbase/gimpbase.h @@ -29,6 +29,7 @@ #include #include #include +#include #include #include #include diff --git a/libgimpbase/gimpbasetypes.h b/libgimpbase/gimpbasetypes.h index 7e9077f238..be1612147f 100644 --- a/libgimpbase/gimpbasetypes.h +++ b/libgimpbase/gimpbasetypes.h @@ -44,14 +44,15 @@ G_BEGIN_DECLS #endif -typedef struct _GimpChoice GimpChoice; -typedef struct _GimpParasite GimpParasite; -typedef struct _GimpEnumDesc GimpEnumDesc; -typedef struct _GimpFlagsDesc GimpFlagsDesc; -typedef struct _GimpUnit GimpUnit; -typedef struct _GimpValueArray GimpValueArray; +typedef struct _GimpChoice GimpChoice; +typedef struct _GimpParasite GimpParasite; +typedef struct _GimpEnumDesc GimpEnumDesc; +typedef struct _GimpExportOptions GimpExportOptions; +typedef struct _GimpFlagsDesc GimpFlagsDesc; +typedef struct _GimpUnit GimpUnit; +typedef struct _GimpValueArray GimpValueArray; -typedef struct _GimpMetadata GimpMetadata; +typedef struct _GimpMetadata GimpMetadata; /** diff --git a/libgimpbase/gimpexportoptions.c b/libgimpbase/gimpexportoptions.c new file mode 100644 index 0000000000..b1352170f7 --- /dev/null +++ b/libgimpbase/gimpexportoptions.c @@ -0,0 +1,149 @@ +/* GIMP - The GNU Image Manipulation Program + * Copyright (C) 1995 Spencer Kimball and Peter Mattis + * + * gimpexportoptions.h + * Copyright (C) 2024 Alx Sa. + * + * 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 3 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, see . + */ + +#include "config.h" + +#include + +#include "gimpbasetypes.h" + +#include "gimpexportoptions.h" + +enum +{ + PROP_0, + PROP_CAPABILITIES, + N_PROPS +}; + +struct _GimpExportOptions +{ + GObject parent_instance; + + GimpExportCapabilities capabilities; +}; + + +static void gimp_export_options_finalize (GObject *object); +static void gimp_export_options_set_property (GObject *object, + guint property_id, + const GValue *value, + GParamSpec *pspec); +static void gimp_export_options_get_property (GObject *object, + guint property_id, + GValue *value, + GParamSpec *pspec); + + +G_DEFINE_TYPE (GimpExportOptions, gimp_export_options, G_TYPE_OBJECT) + +#define parent_class gimp_export_options_parent_class + +static GParamSpec *props[N_PROPS] = { NULL, }; + +static void +gimp_export_options_class_init (GimpExportOptionsClass *klass) +{ + GObjectClass *object_class = G_OBJECT_CLASS (klass); + + object_class->finalize = gimp_export_options_finalize; + object_class->get_property = gimp_export_options_get_property; + object_class->set_property = gimp_export_options_set_property; + + /** + * GimpExportProcedure:capabilities: + * + * What #GimpExportCapabilities are supported + * + * Since: 3.0.0 + */ + props[PROP_CAPABILITIES] = g_param_spec_int ("capabilities", + "Supported image capabilities", + NULL, + 0, G_MAXINT, 0, + G_PARAM_CONSTRUCT | + G_PARAM_READWRITE); + + g_object_class_install_properties (object_class, N_PROPS, props); +} + +static void +gimp_export_options_init (GimpExportOptions *options) +{ + options->capabilities = 0; +} + +static void +gimp_export_options_finalize (GObject *object) +{ + G_OBJECT_CLASS (parent_class)->finalize (object); +} + +static void +gimp_export_options_set_property (GObject *object, + guint property_id, + const GValue *value, + GParamSpec *pspec) +{ + GimpExportOptions *options = GIMP_EXPORT_OPTIONS (object); + + switch (property_id) + { + case PROP_CAPABILITIES: + options->capabilities = g_value_get_int (value); + break; + + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); + break; + } +} + +static void +gimp_export_options_get_property (GObject *object, + guint property_id, + GValue *value, + GParamSpec *pspec) +{ + GimpExportOptions *options = GIMP_EXPORT_OPTIONS (object); + + switch (property_id) + { + case PROP_CAPABILITIES: + g_value_set_int (value, options->capabilities); + break; + + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); + break; + } +} + +/* public functions */ + +GimpExportOptions * +gimp_export_options_new (void) +{ + GimpExportOptions *options; + + options = g_object_new (GIMP_TYPE_EXPORT_OPTIONS, NULL); + + return options; +} diff --git a/libgimp/gimpexport.h b/libgimpbase/gimpexportoptions.h similarity index 50% rename from libgimp/gimpexport.h rename to libgimpbase/gimpexportoptions.h index 7e7156dfdc..771c46d784 100644 --- a/libgimp/gimpexport.h +++ b/libgimpbase/gimpexportoptions.h @@ -1,36 +1,41 @@ -/* LIBGIMP - The GIMP Library - * Copyright (C) 1995-1999 Peter Mattis and Spencer Kimball +/* GIMP - The GNU Image Manipulation Program + * Copyright (C) 1995 Spencer Kimball and Peter Mattis * - * gimpexport.h - * Copyright (C) 1999-2000 Sven Neumann + * gimpexportoptions.h + * Copyright (C) 2024 Alx Sa. * - * This library is free software: you can redistribute it and/or - * modify it under the terms of the GNU Lesser General Public - * License as published by the Free Software Foundation; either - * version 3 of the License, or (at your option) any later version. + * 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 3 of the License, or + * (at your option) any later version. * - * This library is distributed in the hope that it will be useful, + * 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 - * Lesser General Public License for more details. + * 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 Lesser General Public - * License along with this library. If not, see - * . + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . */ -#if !defined (__GIMP_UI_H_INSIDE__) && !defined (GIMP_COMPILATION) -#error "Only can be included directly." +#if !defined (__GIMP_BASE_H_INSIDE__) && !defined (GIMP_BASE_COMPILATION) +#error "Only can be included directly." #endif -#ifndef __GIMP_EXPORT_H__ -#define __GIMP_EXPORT_H__ + +#ifndef __GIMP_EXPORT_OPTIONS_H__ +#define __GIMP_EXPORT_OPTIONS_H__ G_BEGIN_DECLS + /* For information look into the C source or the html documentation */ +#define GIMP_TYPE_EXPORT_OPTIONS (gimp_export_options_get_type ()) +G_DECLARE_FINAL_TYPE (GimpExportOptions, gimp_export_options, GIMP, EXPORT_OPTIONS, GObject) + + /** * GimpExportCapabilities: * @GIMP_EXPORT_CAN_HANDLE_RGB: Handles RGB images @@ -63,29 +68,9 @@ typedef enum } GimpExportCapabilities; -/** - * GimpExportReturn: - * @GIMP_EXPORT_IGNORE: The image is unmodified but export shall continue anyway - * @GIMP_EXPORT_EXPORT: The chosen transforms were applied to the image - * - * Possible return values of gimp_export_image(). - **/ -typedef enum -{ - GIMP_EXPORT_IGNORE, - GIMP_EXPORT_EXPORT -} GimpExportReturn; - - -GtkWidget * gimp_export_dialog_new (const gchar *format_name, - const gchar *role, - const gchar *help_id); -GtkWidget * gimp_export_dialog_get_content_area (GtkWidget *dialog); - -GimpExportReturn gimp_export_image (GimpImage **image, - GimpExportCapabilities capabilities); +GimpExportOptions * gimp_export_options_new (void); G_END_DECLS -#endif /* __GIMP_EXPORT_H__ */ +#endif /* __GIMP_EXPORT_OPTIONS_H__ */ diff --git a/libgimpbase/gimpparamspecs.c b/libgimpbase/gimpparamspecs.c index c1c964894d..1715bd8d91 100644 --- a/libgimpbase/gimpparamspecs.c +++ b/libgimpbase/gimpparamspecs.c @@ -1210,3 +1210,85 @@ gimp_value_take_object_array (GValue *value, g_value_take_boxed (value, array); } + +/* + * GIMP_TYPE_PARAM_EXPORT_OPTIONS + */ + +static void gimp_param_export_options_class_init (GParamSpecClass *klass); +static void gimp_param_export_options_init (GParamSpec *pspec); + +GType +gimp_param_export_options_get_type (void) +{ + static GType type = 0; + + if (! type) + { + const GTypeInfo info = + { + sizeof (GParamSpecClass), + NULL, NULL, + (GClassInitFunc) gimp_param_export_options_class_init, + NULL, NULL, + sizeof (GimpParamSpecExportOptions), + 0, + (GInstanceInitFunc) gimp_param_export_options_init + }; + + type = g_type_register_static (G_TYPE_PARAM_BOXED, + "GimpParamExportOptions", &info, 0); + } + + return type; +} + +static void +gimp_param_export_options_class_init (GParamSpecClass *klass) +{ + klass->value_type = GIMP_TYPE_EXPORT_OPTIONS; +} + +static void +gimp_param_export_options_init (GParamSpec *pspec) +{ + GimpParamSpecExportOptions *options = GIMP_PARAM_SPEC_EXPORT_OPTIONS (pspec); + + options->capabilities = 0; +} + +/** + * gimp_param_spec_export_options: + * @name: Canonical name of the property specified. + * @nick: Nick name of the property specified. + * @blurb: Description of the property specified. + * @capabilities: Int representing the image export capabilities + * @flags: Flags for the property specified. + * + * Creates a new #GimpParamSpecExportOptions specifying a + * #G_TYPE_INT property. + * + * See g_param_spec_internal() for details on property names. + * + * Returns: (transfer full): The newly created #GimpParamSpecExportOptions. + * + * Since: 3.0 + **/ +GParamSpec * +gimp_param_spec_export_options (const gchar *name, + const gchar *nick, + const gchar *blurb, + gint capabilities, + GParamFlags flags) +{ + GimpParamSpecExportOptions *options_spec; + + options_spec = g_param_spec_internal (GIMP_TYPE_PARAM_EXPORT_OPTIONS, + name, nick, blurb, flags); + + g_return_val_if_fail (options_spec, NULL); + + options_spec->capabilities = capabilities; + + return G_PARAM_SPEC (options_spec); +} diff --git a/libgimpbase/gimpparamspecs.h b/libgimpbase/gimpparamspecs.h index d82322b821..da6a357563 100644 --- a/libgimpbase/gimpparamspecs.h +++ b/libgimpbase/gimpparamspecs.h @@ -369,6 +369,31 @@ void gimp_value_take_object_array (GValue *value, gsize length); +/* + * GIMP_TYPE_PARAM_EXPORT_OPTIONS + */ + +#define GIMP_TYPE_PARAM_EXPORT_OPTIONS (gimp_param_export_options_get_type ()) +#define GIMP_PARAM_SPEC_EXPORT_OPTIONS(pspec) (G_TYPE_CHECK_INSTANCE_CAST ((pspec), GIMP_TYPE_PARAM_EXPORT_OPTIONS, GimpParamSpecExportOptions)) +#define GIMP_IS_PARAM_SPEC_EXPORT_OPTIONS(pspec) (G_TYPE_CHECK_INSTANCE_TYPE ((pspec), GIMP_TYPE_PARAM_EXPORT_OPTIONS)) + +typedef struct _GimpParamSpecExportOptions GimpParamSpecExportOptions; + +struct _GimpParamSpecExportOptions +{ + GParamSpecBoxed parent_instance; + + gint capabilities; +}; + +GType gimp_param_export_options_get_type (void) G_GNUC_CONST; + +GParamSpec * gimp_param_spec_export_options (const gchar *name, + const gchar *nick, + const gchar *blurb, + gint capabilities, + GParamFlags flags); + G_END_DECLS #endif /* __GIMP_PARAM_SPECS_H__ */ diff --git a/libgimpbase/gimpprotocol.c b/libgimpbase/gimpprotocol.c index e77631e03e..0a3543610b 100644 --- a/libgimpbase/gimpprotocol.c +++ b/libgimpbase/gimpprotocol.c @@ -1278,6 +1278,13 @@ _gp_param_def_read (GIOChannel *channel, user_data)) return FALSE; break; + + case GP_PARAM_DEF_TYPE_EXPORT_OPTIONS: + if (! _gimp_wire_read_int32 (channel, + (guint32 *) ¶m_def->meta.m_export_options.capabilities, 1, + user_data)) + return FALSE; + break; } return TRUE; @@ -1328,6 +1335,9 @@ _gp_param_def_destroy (GPParamDef *param_def) case GP_PARAM_DEF_TYPE_ID_ARRAY: g_free (param_def->meta.m_id_array.type_name); break; + + case GP_PARAM_DEF_TYPE_EXPORT_OPTIONS: + break; } } @@ -1604,6 +1614,13 @@ _gp_param_def_write (GIOChannel *channel, user_data)) return FALSE; break; + + case GP_PARAM_DEF_TYPE_EXPORT_OPTIONS: + if (! _gimp_wire_write_int32 (channel, + (guint32 *) ¶m_def->meta.m_export_options.capabilities, 1, + user_data)) + return FALSE; + break; } return TRUE; @@ -2058,6 +2075,13 @@ _gp_params_read (GIOChannel *channel, (*params)[i].data.d_parasite.data = NULL; break; + case GP_PARAM_TYPE_EXPORT_OPTIONS: + if (! _gimp_wire_read_int32 (channel, + (guint32 *) &(*params)[i].data.d_export_options.capabilities, 1, + user_data)) + goto cleanup; + break; + case GP_PARAM_TYPE_PARAM_DEF: if (! _gp_param_def_read (channel, &(*params)[i].data.d_param_def, @@ -2261,6 +2285,13 @@ _gp_params_write (GIOChannel *channel, } break; + case GP_PARAM_TYPE_EXPORT_OPTIONS: + if (! _gimp_wire_write_int32 (channel, + (const guint32 *) ¶ms[i].data.d_export_options.capabilities, 1, + user_data)) + return; + break; + case GP_PARAM_TYPE_PARAM_DEF: if (! _gp_param_def_write (channel, ¶ms[i].data.d_param_def, @@ -2330,6 +2361,9 @@ _gp_params_destroy (GPParam *params, g_free (params[i].data.d_parasite.data); break; + case GP_PARAM_TYPE_EXPORT_OPTIONS: + break; + case GP_PARAM_TYPE_PARAM_DEF: _gp_param_def_destroy (¶ms[i].data.d_param_def); break; diff --git a/libgimpbase/gimpprotocol.h b/libgimpbase/gimpprotocol.h index 4d6d712926..29ceb6e6c0 100644 --- a/libgimpbase/gimpprotocol.h +++ b/libgimpbase/gimpprotocol.h @@ -58,7 +58,8 @@ typedef enum GP_PARAM_DEF_TYPE_STRING, GP_PARAM_DEF_TYPE_GEGL_COLOR, GP_PARAM_DEF_TYPE_ID, - GP_PARAM_DEF_TYPE_ID_ARRAY + GP_PARAM_DEF_TYPE_ID_ARRAY, + GP_PARAM_DEF_TYPE_EXPORT_OPTIONS } GPParamDefType; typedef enum @@ -74,35 +75,38 @@ typedef enum GP_PARAM_TYPE_PARASITE, GP_PARAM_TYPE_ARRAY, GP_PARAM_TYPE_ID_ARRAY, + GP_PARAM_TYPE_EXPORT_OPTIONS, GP_PARAM_TYPE_PARAM_DEF } GPParamType; -typedef struct _GPConfig GPConfig; -typedef struct _GPTileReq GPTileReq; -typedef struct _GPTileAck GPTileAck; -typedef struct _GPTileData GPTileData; -typedef struct _GPParamDef GPParamDef; -typedef struct _GPParamDefInt GPParamDefInt; -typedef struct _GPParamDefUnit GPParamDefUnit; -typedef struct _GPParamDefEnum GPParamDefEnum; -typedef struct _GPParamDefBoolean GPParamDefBoolean; -typedef struct _GPParamDefFloat GPParamDefFloat; -typedef struct _GPParamDefString GPParamDefString; -typedef struct _GPParamDefChoice GPParamDefChoice; -typedef struct _GPParamStrv GPParamStrv; -typedef struct _GPParamDefGeglColor GPParamDefGeglColor; -typedef struct _GPParamDefID GPParamDefID; -typedef struct _GPParamDefIDArray GPParamDefIDArray; -typedef struct _GPParam GPParam; -typedef struct _GPParamArray GPParamArray; -typedef struct _GPParamIDArray GPParamIDArray; -typedef struct _GPParamColor GPParamColor; -typedef struct _GPParamColorArray GPParamColorArray; -typedef struct _GPProcRun GPProcRun; -typedef struct _GPProcReturn GPProcReturn; -typedef struct _GPProcInstall GPProcInstall; -typedef struct _GPProcUninstall GPProcUninstall; +typedef struct _GPConfig GPConfig; +typedef struct _GPTileReq GPTileReq; +typedef struct _GPTileAck GPTileAck; +typedef struct _GPTileData GPTileData; +typedef struct _GPParamDef GPParamDef; +typedef struct _GPParamDefInt GPParamDefInt; +typedef struct _GPParamDefUnit GPParamDefUnit; +typedef struct _GPParamDefEnum GPParamDefEnum; +typedef struct _GPParamDefBoolean GPParamDefBoolean; +typedef struct _GPParamDefFloat GPParamDefFloat; +typedef struct _GPParamDefString GPParamDefString; +typedef struct _GPParamDefChoice GPParamDefChoice; +typedef struct _GPParamStrv GPParamStrv; +typedef struct _GPParamDefGeglColor GPParamDefGeglColor; +typedef struct _GPParamDefID GPParamDefID; +typedef struct _GPParamDefIDArray GPParamDefIDArray; +typedef struct _GPParamDefExportOptions GPParamDefExportOptions; +typedef struct _GPParam GPParam; +typedef struct _GPParamArray GPParamArray; +typedef struct _GPParamIDArray GPParamIDArray; +typedef struct _GPParamColor GPParamColor; +typedef struct _GPParamColorArray GPParamColorArray; +typedef struct _GPParamExportOptions GPParamExportOptions; +typedef struct _GPProcRun GPProcRun; +typedef struct _GPProcReturn GPProcReturn; +typedef struct _GPProcInstall GPProcInstall; +typedef struct _GPProcUninstall GPProcUninstall; struct _GPConfig @@ -223,6 +227,11 @@ struct _GPParamDefChoice gchar *default_val; }; +struct _GPParamDefExportOptions +{ + gint capabilities; +}; + struct _GPParamDef { GPParamDefType param_def_type; @@ -235,16 +244,17 @@ struct _GPParamDef union { - GPParamDefInt m_int; - GPParamDefUnit m_unit; - GPParamDefEnum m_enum; - GPParamDefBoolean m_boolean; - GPParamDefFloat m_float; - GPParamDefString m_string; - GPParamDefGeglColor m_gegl_color; - GPParamDefID m_id; - GPParamDefIDArray m_id_array; - GPParamDefChoice m_choice; + GPParamDefInt m_int; + GPParamDefUnit m_unit; + GPParamDefEnum m_enum; + GPParamDefBoolean m_boolean; + GPParamDefFloat m_float; + GPParamDefString m_string; + GPParamDefGeglColor m_gegl_color; + GPParamDefID m_id; + GPParamDefIDArray m_id_array; + GPParamDefChoice m_choice; + GPParamDefExportOptions m_export_options; } meta; }; @@ -278,6 +288,11 @@ struct _GPParamColorArray GPParamColor *colors; }; +struct _GPParamExportOptions +{ + gint capabilities; +}; + struct _GPParam { GPParamType param_type; @@ -285,18 +300,19 @@ struct _GPParam union { - gint32 d_int; - gdouble d_float; - gchar *d_string; - gchar **d_strv; - GBytes *d_bytes; - GPParamColor d_gegl_color; - GPParamColorArray d_color_array; - GimpRGB d_color; - GimpParasite d_parasite; - GPParamArray d_array; - GPParamIDArray d_id_array; - GPParamDef d_param_def; + gint32 d_int; + gdouble d_float; + gchar *d_string; + gchar **d_strv; + GBytes *d_bytes; + GPParamColor d_gegl_color; + GPParamColorArray d_color_array; + GimpRGB d_color; + GimpParasite d_parasite; + GPParamArray d_array; + GPParamIDArray d_id_array; + GPParamExportOptions d_export_options; + GPParamDef d_param_def; } data; }; diff --git a/libgimpbase/meson.build b/libgimpbase/meson.build index a2c27016b1..60e9f104e7 100644 --- a/libgimpbase/meson.build +++ b/libgimpbase/meson.build @@ -54,6 +54,7 @@ libgimpbase_sources_introspectable = files( 'gimpchoice.c', 'gimpcpuaccel.c', 'gimpenv.c', + 'gimpexportoptions.c', 'gimpmemsize.c', 'gimpmetadata.c', 'gimpparamspecs.c', @@ -87,6 +88,7 @@ libgimpbase_headers_introspectable = files( 'gimpchoice.h', 'gimpcpuaccel.h', 'gimpenv.h', + 'gimpexportoptions.h', 'gimplimits.h', 'gimpmemsize.h', 'gimpmetadata.h', diff --git a/libgimpconfig/gimpconfig-params.c b/libgimpconfig/gimpconfig-params.c index df72c10468..9db5e13693 100644 --- a/libgimpconfig/gimpconfig-params.c +++ b/libgimpconfig/gimpconfig-params.c @@ -323,6 +323,14 @@ gimp_config_param_spec_duplicate (GParamSpec *pspec) spec->object_type, flags); } + else if (GIMP_IS_PARAM_SPEC_EXPORT_OPTIONS (pspec)) + { + GimpParamSpecExportOptions *spec = GIMP_PARAM_SPEC_EXPORT_OPTIONS (pspec); + + copy = gimp_param_spec_export_options (name, nick, blurb, + spec->capabilities, + flags); + } else if (G_IS_PARAM_SPEC_OBJECT (pspec)) { GType value_type = G_PARAM_SPEC_VALUE_TYPE (pspec); diff --git a/pdb/app.pl b/pdb/app.pl index a7d582e5ec..ec556ffda6 100644 --- a/pdb/app.pl +++ b/pdb/app.pl @@ -433,6 +433,15 @@ g_param_spec_uint ("$name", "$blurb", 1, G_MAXUINT32, 1, $flags) +CODE + } + elsif ($pdbtype eq 'export_options') { + $pspec = < 'image', type => 'image', desc => 'Input image' }, { name => 'file', type => 'file', - desc => 'The file to save the image in' } + desc => 'The file to save the image in' }, + { name => 'options', type => 'export_options', + desc => 'Export option settings' } ); %invoke = ( @@ -272,8 +274,10 @@ HELP gimp_value_array_index (new_args, 1)); g_value_transform (gimp_value_array_index (args, 2), gimp_value_array_index (new_args, 2)); + g_value_transform (gimp_value_array_index (args, 3), + gimp_value_array_index (new_args, 3)); - for (i = 3; i < proc->num_args; i++) + for (i = 4; i < proc->num_args; i++) if (G_IS_PARAM_SPEC_STRING (proc->args[i])) g_value_set_static_string (gimp_value_array_index (new_args, i), ""); diff --git a/pdb/pdb.pl b/pdb/pdb.pl index 9151b7c49a..a296a7936e 100644 --- a/pdb/pdb.pl +++ b/pdb/pdb.pl @@ -482,6 +482,18 @@ package Gimp::CodeGen::pdb; set_value_func => 'g_value_set_uint ($value, $var)', take_value_func => 'g_value_set_uint ($value, $var)' }, + export_options => { name => 'EXPORT_OPTIONS', + gtype => 'GIMP_TYPE_EXPORT_OPTIONS', + type => 'GimpExportOptions *', + const_type => 'GimpExportOptions *', + init_value => 'NULL', + out_annotate => '(transfer none)', + get_value_func => '$var = g_value_get_object ($value)', + dup_value_func => '$var = g_value_dup_object (gimp_value_array_index ($value))', + set_value_func => 'g_value_set_object ($value, $var)', + take_value_func => 'g_value_set_object ($value, $var)', + headers => [ qw("libgimpbase/gimpbase.h") ] }, + unit => { name => 'UNIT', gtype => 'GIMP_TYPE_UNIT', type => 'GimpUnit *', diff --git a/plug-ins/common/file-aa.c b/plug-ins/common/file-aa.c index ef072dce90..540e2c5a6c 100644 --- a/plug-ins/common/file-aa.c +++ b/plug-ins/common/file-aa.c @@ -68,6 +68,7 @@ static GimpValueArray * ascii_export (GimpProcedure *procedure, GimpRunMode run_mode, GimpImage *image, GFile *file, + GimpExportOptions *options, GimpMetadata *metadata, GimpProcedureConfig *config, gpointer run_data); @@ -148,6 +149,13 @@ ascii_create_procedure (GimpPlugIn *plug_in, gimp_file_procedure_set_extensions (GIMP_FILE_PROCEDURE (procedure), "txt,ansi,text"); + gimp_export_procedure_set_capabilities (GIMP_EXPORT_PROCEDURE (procedure), + GIMP_EXPORT_CAN_HANDLE_RGB | + GIMP_EXPORT_CAN_HANDLE_GRAY | + GIMP_EXPORT_CAN_HANDLE_INDEXED | + GIMP_EXPORT_CAN_HANDLE_ALPHA, + NULL, NULL); + for (i = 0; aa_formats[i]; i++); gimp_procedure_add_int_argument (procedure, "file-type", @@ -165,6 +173,7 @@ ascii_export (GimpProcedure *procedure, GimpRunMode run_mode, GimpImage *image, GFile *file, + GimpExportOptions *options, GimpMetadata *metadata, GimpProcedureConfig *config, gpointer run_data) @@ -184,11 +193,7 @@ ascii_export (GimpProcedure *procedure, status = GIMP_PDB_CANCEL; } - export = gimp_export_image (&image, - GIMP_EXPORT_CAN_HANDLE_RGB | - GIMP_EXPORT_CAN_HANDLE_GRAY | - GIMP_EXPORT_CAN_HANDLE_INDEXED | - GIMP_EXPORT_CAN_HANDLE_ALPHA); + export = gimp_export_options_get_image (options, &image); drawables = gimp_image_list_layers (image); if (status == GIMP_PDB_SUCCESS) diff --git a/plug-ins/common/file-cel.c b/plug-ins/common/file-cel.c index 93ae4a0210..62fdebf104 100644 --- a/plug-ins/common/file-cel.c +++ b/plug-ins/common/file-cel.c @@ -71,6 +71,7 @@ static GimpValueArray * cel_export (GimpProcedure *procedure, GimpRunMode run_mode, GimpImage *image, GFile *file, + GimpExportOptions *options, GimpMetadata *metadata, GimpProcedureConfig *config, gpointer run_data); @@ -183,6 +184,12 @@ cel_create_procedure (GimpPlugIn *plug_in, gimp_file_procedure_set_extensions (GIMP_FILE_PROCEDURE (procedure), "cel"); + gimp_export_procedure_set_capabilities (GIMP_EXPORT_PROCEDURE (procedure), + GIMP_EXPORT_CAN_HANDLE_RGB | + GIMP_EXPORT_CAN_HANDLE_ALPHA | + GIMP_EXPORT_CAN_HANDLE_INDEXED, + NULL, NULL); + gimp_procedure_add_file_argument (procedure, "palette-file", _("_Palette file"), _("File to save palette to"), @@ -276,6 +283,7 @@ cel_export (GimpProcedure *procedure, GimpRunMode run_mode, GimpImage *image, GFile *file, + GimpExportOptions *options, GimpMetadata *metadata, GimpProcedureConfig *config, gpointer run_data) @@ -287,10 +295,7 @@ cel_export (GimpProcedure *procedure, gegl_init (NULL, NULL); - export = gimp_export_image (&image, - GIMP_EXPORT_CAN_HANDLE_RGB | - GIMP_EXPORT_CAN_HANDLE_ALPHA | - GIMP_EXPORT_CAN_HANDLE_INDEXED); + export = gimp_export_options_get_image (options, &image); drawables = gimp_image_list_layers (image); diff --git a/plug-ins/common/file-compressor.c b/plug-ins/common/file-compressor.c index 128818f048..677976ccf7 100644 --- a/plug-ins/common/file-compressor.c +++ b/plug-ins/common/file-compressor.c @@ -157,6 +157,7 @@ static GimpValueArray * compressor_export (GimpProcedure *proc GimpRunMode run_mode, GimpImage *image, GFile *file, + GimpExportOptions *options, GimpMetadata *metadata, GimpProcedureConfig *config, gpointer run_data); @@ -176,6 +177,7 @@ static GimpImage * load_image (const CompressorEntry *comp static GimpPDBStatusType export_image (const CompressorEntry *compressor, GFile *file, GimpImage *image, + GimpExportOptions *options, gint n_drawables, GList *drawables, gint32 run_mode, @@ -401,9 +403,10 @@ compressor_export (GimpProcedure *procedure, GimpRunMode run_mode, GimpImage *image, GFile *file, + GimpExportOptions *options, GimpMetadata *metadata, GimpProcedureConfig *config, - gpointer run_data) + gpointer run_data) { const CompressorEntry *compressor = run_data; GimpPDBStatusType status; @@ -417,8 +420,8 @@ compressor_export (GimpProcedure *procedure, gimp_plug_in_set_pdb_error_handler (gimp_procedure_get_plug_in (procedure), GIMP_PDB_ERROR_HANDLER_PLUGIN); - status = export_image (compressor, file, image, n_drawables, drawables, - run_mode, &error); + status = export_image (compressor, file, image, options, n_drawables, + drawables, run_mode, &error); g_list_free (drawables); return gimp_procedure_new_return_values (procedure, status, error); @@ -428,6 +431,7 @@ static GimpPDBStatusType export_image (const CompressorEntry *compressor, GFile *file, GimpImage *image, + GimpExportOptions *options, gint n_drawables, GList *drawables, gint32 run_mode, @@ -448,7 +452,7 @@ export_image (const CompressorEntry *compressor, tmp_file = gimp_temp_file (ext + 1); - if (! (gimp_file_save (run_mode, image, tmp_file) && + if (! (gimp_file_save (run_mode, image, tmp_file, options) && valid_file (tmp_file))) { g_file_delete (tmp_file, NULL, NULL); diff --git a/plug-ins/common/file-csource.c b/plug-ins/common/file-csource.c index 9a4280fba2..39c7b1b208 100644 --- a/plug-ins/common/file-csource.c +++ b/plug-ins/common/file-csource.c @@ -63,6 +63,7 @@ static GimpValueArray * csource_export (GimpProcedure *procedur GimpRunMode run_mode, GimpImage *image, GFile *file, + GimpExportOptions *options, GimpMetadata *metadata, GimpProcedureConfig *config, gpointer run_data); @@ -139,6 +140,11 @@ csource_create_procedure (GimpPlugIn *plug_in, gimp_file_procedure_set_extensions (GIMP_FILE_PROCEDURE (procedure), "c"); + gimp_export_procedure_set_capabilities (GIMP_EXPORT_PROCEDURE (procedure), + GIMP_EXPORT_CAN_HANDLE_RGB | + GIMP_EXPORT_CAN_HANDLE_ALPHA, + NULL, NULL); + gimp_procedure_add_string_aux_argument (procedure, "prefixed-name", _("_Prefixed name"), _("Prefixed name"), @@ -205,6 +211,7 @@ csource_export (GimpProcedure *procedure, GimpRunMode run_mode, GimpImage *image, GFile *file, + GimpExportOptions *options, GimpMetadata *metadata, GimpProcedureConfig *config, gpointer run_data) @@ -225,9 +232,7 @@ csource_export (GimpProcedure *procedure, gimp_ui_init (PLUG_IN_BINARY); - export = gimp_export_image (&image, - GIMP_EXPORT_CAN_HANDLE_RGB | - GIMP_EXPORT_CAN_HANDLE_ALPHA); + export = gimp_export_options_get_image (options, &image); drawables = gimp_image_list_layers (image); g_object_set (config, diff --git a/plug-ins/common/file-dicom.c b/plug-ins/common/file-dicom.c index 329354fc64..d1fb85b2fb 100644 --- a/plug-ins/common/file-dicom.c +++ b/plug-ins/common/file-dicom.c @@ -96,6 +96,7 @@ static GimpValueArray * dicom_export (GimpProcedure *procedure GimpRunMode run_mode, GimpImage *image, GFile *file, + GimpExportOptions *options, GimpMetadata *metadata, GimpProcedureConfig *config, gpointer run_data); @@ -174,13 +175,13 @@ dicom_create_procedure (GimpPlugIn *plug_in, gimp_procedure_set_menu_label (procedure, _("DICOM image")); gimp_procedure_set_documentation (procedure, - "Loads files of the dicom file format", - "Load a file in the DICOM standard " - "format. The standard is defined at " - "http://medical.nema.org/. The plug-in " - "currently only supports reading " - "images with uncompressed pixel " - "sections.", + _("Loads files of the dicom file format"), + _("Load a file in the DICOM standard " + "format. The standard is defined at " + "http://medical.nema.org/. The plug-in " + "currently only supports reading " + "images with uncompressed pixel " + "sections."), name); gimp_procedure_set_attribution (procedure, "Dov Grobgeld", @@ -207,16 +208,16 @@ dicom_create_procedure (GimpPlugIn *plug_in, "Medicine image")); gimp_procedure_set_documentation (procedure, - "Save file in the DICOM file format", - "Save an image in the medical " - "standard DICOM image formats. " - "The standard is defined at " - "http://medical.nema.org/. The file " - "format is defined in section 10 of " - "the standard. The files are saved " - "uncompressed and the compulsory DICOM " - "tags are filled with default dummy " - "values.", + _("Save file in the DICOM file format"), + _("Save an image in the medical " + "standard DICOM image formats. " + "The standard is defined at " + "http://medical.nema.org/. The file " + "format is defined in section 10 of " + "the standard. The files are saved " + "uncompressed and the compulsory DICOM " + "tags are filled with default dummy " + "values."), name); gimp_procedure_set_attribution (procedure, "Dov Grobgeld", @@ -227,6 +228,11 @@ dicom_create_procedure (GimpPlugIn *plug_in, "image/x-dcm"); gimp_file_procedure_set_extensions (GIMP_FILE_PROCEDURE (procedure), "dcm,dicom"); + + gimp_export_procedure_set_capabilities (GIMP_EXPORT_PROCEDURE (procedure), + GIMP_EXPORT_CAN_HANDLE_RGB | + GIMP_EXPORT_CAN_HANDLE_GRAY, + NULL, NULL); } return procedure; @@ -268,6 +274,7 @@ dicom_export (GimpProcedure *procedure, GimpRunMode run_mode, GimpImage *image, GFile *file, + GimpExportOptions *options, GimpMetadata *metadata, GimpProcedureConfig *config, gpointer run_data) @@ -279,9 +286,7 @@ dicom_export (GimpProcedure *procedure, gegl_init (NULL, NULL); - export = gimp_export_image (&image, - GIMP_EXPORT_CAN_HANDLE_RGB | - GIMP_EXPORT_CAN_HANDLE_GRAY); + export = gimp_export_options_get_image (options, &image); drawables = gimp_image_list_layers (image); diff --git a/plug-ins/common/file-farbfeld.c b/plug-ins/common/file-farbfeld.c index 98102a8176..757a547b9c 100644 --- a/plug-ins/common/file-farbfeld.c +++ b/plug-ins/common/file-farbfeld.c @@ -74,6 +74,7 @@ static GimpValueArray * farbfeld_export (GimpProcedure *proced GimpRunMode run_mode, GimpImage *image, GFile *file, + GimpExportOptions *options, GimpMetadata *metadata, GimpProcedureConfig *config, gpointer run_data); @@ -174,6 +175,13 @@ farbfeld_create_procedure (GimpPlugIn *plug_in, gimp_file_procedure_set_extensions (GIMP_FILE_PROCEDURE (procedure), "ff"); + + gimp_export_procedure_set_capabilities (GIMP_EXPORT_PROCEDURE (procedure), + GIMP_EXPORT_CAN_HANDLE_RGB | + GIMP_EXPORT_CAN_HANDLE_GRAY | + GIMP_EXPORT_CAN_HANDLE_INDEXED | + GIMP_EXPORT_CAN_HANDLE_ALPHA, + NULL, NULL); } return procedure; @@ -215,6 +223,7 @@ farbfeld_export (GimpProcedure *procedure, GimpRunMode run_mode, GimpImage *image, GFile *file, + GimpExportOptions *options, GimpMetadata *metadata, GimpProcedureConfig *config, gpointer run_data) @@ -226,11 +235,7 @@ farbfeld_export (GimpProcedure *procedure, gegl_init (NULL, NULL); - export = gimp_export_image (&image, - GIMP_EXPORT_CAN_HANDLE_RGB | - GIMP_EXPORT_CAN_HANDLE_GRAY | - GIMP_EXPORT_CAN_HANDLE_INDEXED | - GIMP_EXPORT_CAN_HANDLE_ALPHA); + export = gimp_export_options_get_image (options, &image); drawables = gimp_image_list_layers (image); if (! export_image (file, image, drawables->data, &error)) diff --git a/plug-ins/common/file-gbr.c b/plug-ins/common/file-gbr.c index fb636387f1..bde85c508e 100644 --- a/plug-ins/common/file-gbr.c +++ b/plug-ins/common/file-gbr.c @@ -71,6 +71,7 @@ static GimpValueArray * gbr_export (GimpProcedure *procedure, GimpRunMode run_mode, GimpImage *image, GFile *file, + GimpExportOptions *options, GimpMetadata *metadata, GimpProcedureConfig *config, gpointer run_data); @@ -146,6 +147,13 @@ gbr_create_procedure (GimpPlugIn *plug_in, gimp_file_procedure_set_handles_remote (GIMP_FILE_PROCEDURE (procedure), TRUE); + gimp_export_procedure_set_capabilities (GIMP_EXPORT_PROCEDURE (procedure), + GIMP_EXPORT_CAN_HANDLE_GRAY | + GIMP_EXPORT_CAN_HANDLE_RGB | + GIMP_EXPORT_CAN_HANDLE_INDEXED | + GIMP_EXPORT_CAN_HANDLE_ALPHA, + NULL, NULL); + gimp_procedure_add_int_argument (procedure, "spacing", _("Sp_acing"), _("Spacing of the brush"), @@ -167,6 +175,7 @@ gbr_export (GimpProcedure *procedure, GimpRunMode run_mode, GimpImage *image, GFile *file, + GimpExportOptions *options, GimpMetadata *metadata, GimpProcedureConfig *config, gpointer run_data) @@ -207,11 +216,7 @@ gbr_export (GimpProcedure *procedure, status = GIMP_PDB_CANCEL; } - export = gimp_export_image (&image, - GIMP_EXPORT_CAN_HANDLE_GRAY | - GIMP_EXPORT_CAN_HANDLE_RGB | - GIMP_EXPORT_CAN_HANDLE_INDEXED | - GIMP_EXPORT_CAN_HANDLE_ALPHA); + export = gimp_export_options_get_image (options, &image); drawables = gimp_image_list_layers (image); n_drawables = g_list_length (drawables); diff --git a/plug-ins/common/file-gegl.c b/plug-ins/common/file-gegl.c index 2ba7a39204..3669596dc5 100644 --- a/plug-ins/common/file-gegl.c +++ b/plug-ins/common/file-gegl.c @@ -89,6 +89,7 @@ static GimpValueArray * goat_export (GimpProcedure *procedure, GimpRunMode run_mode, GimpImage *image, GFile *file, + GimpExportOptions *options, GimpMetadata *metadata, GimpProcedureConfig *config, gpointer run_data); @@ -231,6 +232,13 @@ goat_create_procedure (GimpPlugIn *plug_in, format->mime_type); gimp_file_procedure_set_extensions (GIMP_FILE_PROCEDURE (procedure), format->extensions); + + gimp_export_procedure_set_capabilities (GIMP_EXPORT_PROCEDURE (procedure), + GIMP_EXPORT_CAN_HANDLE_RGB | + GIMP_EXPORT_CAN_HANDLE_GRAY | + GIMP_EXPORT_CAN_HANDLE_INDEXED | + GIMP_EXPORT_CAN_HANDLE_ALPHA, + NULL, NULL); } } @@ -274,6 +282,7 @@ goat_export (GimpProcedure *procedure, GimpRunMode run_mode, GimpImage *image, GFile *file, + GimpExportOptions *options, GimpMetadata *metadata, GimpProcedureConfig *config, gpointer run_data) @@ -286,11 +295,7 @@ goat_export (GimpProcedure *procedure, gegl_init (NULL, NULL); - export = gimp_export_image (&image, - GIMP_EXPORT_CAN_HANDLE_RGB | - GIMP_EXPORT_CAN_HANDLE_GRAY | - GIMP_EXPORT_CAN_HANDLE_INDEXED | - GIMP_EXPORT_CAN_HANDLE_ALPHA); + export = gimp_export_options_get_image (options, &image); drawables = gimp_image_list_layers (image); if (! export_image (file, format->export_op, image, drawables->data, diff --git a/plug-ins/common/file-gif-export.c b/plug-ins/common/file-gif-export.c index 8c404a95b7..22c2687c30 100644 --- a/plug-ins/common/file-gif-export.c +++ b/plug-ins/common/file-gif-export.c @@ -79,6 +79,7 @@ static GimpValueArray * gif_export (GimpProcedure *procedure, GimpRunMode run_mode, GimpImage *image, GFile *file, + GimpExportOptions *options, GimpMetadata *metadata, GimpProcedureConfig *config, gpointer run_data); @@ -90,6 +91,11 @@ static gboolean export_image (GFile *file, GObject *config, GError **error); +static void export_edit_options (GimpProcedure *procedure, + GimpProcedureConfig *config, + GimpExportOptions *options, + gpointer create_data); + static GimpPDBStatusType sanity_check (GFile *file, GimpImage **image, GimpRunMode run_mode, @@ -179,6 +185,12 @@ gif_create_procedure (GimpPlugIn *plug_in, gimp_file_procedure_set_extensions (GIMP_FILE_PROCEDURE (procedure), "gif"); + gimp_export_procedure_set_capabilities (GIMP_EXPORT_PROCEDURE (procedure), + GIMP_EXPORT_CAN_HANDLE_INDEXED | + GIMP_EXPORT_CAN_HANDLE_GRAY | + GIMP_EXPORT_CAN_HANDLE_ALPHA, + export_edit_options, NULL); + gimp_procedure_add_boolean_argument (procedure, "interlace", _("_Interlace"), _("Try to export as interlaced"), @@ -257,6 +269,7 @@ gif_export (GimpProcedure *procedure, GimpRunMode run_mode, GimpImage *image, GFile *file, + GimpExportOptions *options, GimpMetadata *metadata, GimpProcedureConfig *config, gpointer run_data) @@ -330,33 +343,8 @@ gif_export (GimpProcedure *procedure, if (status == GIMP_PDB_SUCCESS) { GList *drawables; - GimpExportCapabilities capabilities; - capabilities = (GIMP_EXPORT_CAN_HANDLE_INDEXED | - GIMP_EXPORT_CAN_HANDLE_GRAY | - GIMP_EXPORT_CAN_HANDLE_ALPHA); - - /* Create an exportable image based on the export options */ - switch (run_mode) - { - case GIMP_RUN_INTERACTIVE: - case GIMP_RUN_WITH_LAST_VALS: - { - gboolean as_animation; - - g_object_get (config, - "as-animation", &as_animation, - NULL); - - if (as_animation) - capabilities |= GIMP_EXPORT_CAN_HANDLE_LAYERS; - break; - } - - default: - break; - } - export = gimp_export_image (&image, capabilities); + export = gimp_export_options_get_image (options, &image); drawables = gimp_image_list_layers (image); if (! export_image (file, image, drawables->data, orig_image, @@ -1182,6 +1170,31 @@ export_image (GFile *file, return TRUE; } +static void +export_edit_options (GimpProcedure *procedure, + GimpProcedureConfig *config, + GimpExportOptions *options, + gpointer create_data) +{ + GimpExportCapabilities capabilities; + gboolean as_animation; + + g_object_get (G_OBJECT (config), + "as-animation", &as_animation, + NULL); + + capabilities = (GIMP_EXPORT_CAN_HANDLE_INDEXED | + GIMP_EXPORT_CAN_HANDLE_GRAY | + GIMP_EXPORT_CAN_HANDLE_ALPHA); + + if (as_animation) + capabilities |= GIMP_EXPORT_CAN_HANDLE_LAYERS; + + g_object_set (G_OBJECT (options), + "capabilities", capabilities, + NULL); +} + static gboolean bad_bounds_dialog (void) { diff --git a/plug-ins/common/file-gih.c b/plug-ins/common/file-gih.c index 1bc813a2da..1bf527ad45 100644 --- a/plug-ins/common/file-gih.c +++ b/plug-ins/common/file-gih.c @@ -86,6 +86,7 @@ static GimpValueArray * gih_export (GimpProcedure *procedure, GimpRunMode run_mode, GimpImage *image, GFile *file, + GimpExportOptions *options, GimpMetadata *metadata, GimpProcedureConfig *config, gpointer run_data); @@ -180,6 +181,13 @@ gih_create_procedure (GimpPlugIn *plug_in, gimp_file_procedure_set_handles_remote (GIMP_FILE_PROCEDURE (procedure), TRUE); + gimp_export_procedure_set_capabilities (GIMP_EXPORT_PROCEDURE (procedure), + GIMP_EXPORT_CAN_HANDLE_RGB | + GIMP_EXPORT_CAN_HANDLE_GRAY | + GIMP_EXPORT_CAN_HANDLE_ALPHA | + GIMP_EXPORT_CAN_HANDLE_LAYERS, + NULL, NULL); + gimp_procedure_add_int_argument (procedure, "spacing", _("Spacing (_percent)"), _("Spacing of the brush"), @@ -247,6 +255,7 @@ gih_export (GimpProcedure *procedure, GimpRunMode run_mode, GimpImage *image, GFile *file, + GimpExportOptions *options, GimpMetadata *metadata, GimpProcedureConfig *config, gpointer run_data) @@ -378,11 +387,7 @@ gih_export (GimpProcedure *procedure, } } - export = gimp_export_image (&image, - GIMP_EXPORT_CAN_HANDLE_RGB | - GIMP_EXPORT_CAN_HANDLE_GRAY | - GIMP_EXPORT_CAN_HANDLE_ALPHA | - GIMP_EXPORT_CAN_HANDLE_LAYERS); + export = gimp_export_options_get_image (options, &image); layers = gimp_image_list_layers (image); n_drawables = g_list_length (layers); diff --git a/plug-ins/common/file-header.c b/plug-ins/common/file-header.c index 7a06d0a087..85002b7603 100644 --- a/plug-ins/common/file-header.c +++ b/plug-ins/common/file-header.c @@ -57,6 +57,7 @@ static GimpValueArray * header_export (GimpProcedure *procedure GimpRunMode run_mode, GimpImage *image, GFile *file, + GimpExportOptions *options, GimpMetadata *metadata, GimpProcedureConfig *config, gpointer run_data); @@ -116,8 +117,8 @@ header_create_procedure (GimpPlugIn *plug_in, gimp_procedure_set_menu_label (procedure, _("C source code header")); gimp_procedure_set_documentation (procedure, - "saves files as C unsigned character " - "array", + _("Saves files as C unsigned character " + "array"), "FIXME: write help", name); gimp_procedure_set_attribution (procedure, @@ -131,6 +132,11 @@ header_create_procedure (GimpPlugIn *plug_in, "image/x-chdr"); gimp_file_procedure_set_extensions (GIMP_FILE_PROCEDURE (procedure), "h"); + + gimp_export_procedure_set_capabilities (GIMP_EXPORT_PROCEDURE (procedure), + GIMP_EXPORT_CAN_HANDLE_RGB | + GIMP_EXPORT_CAN_HANDLE_INDEXED, + NULL, NULL); } return procedure; @@ -141,6 +147,7 @@ header_export (GimpProcedure *procedure, GimpRunMode run_mode, GimpImage *image, GFile *file, + GimpExportOptions *options, GimpMetadata *metadata, GimpProcedureConfig *config, gpointer run_data) @@ -152,9 +159,7 @@ header_export (GimpProcedure *procedure, gegl_init (NULL, NULL); - export = gimp_export_image (&image, - GIMP_EXPORT_CAN_HANDLE_RGB | - GIMP_EXPORT_CAN_HANDLE_INDEXED); + export = gimp_export_options_get_image (options, &image); drawables = gimp_image_list_layers (image); if (! export_image (file, image, drawables->data, diff --git a/plug-ins/common/file-heif.c b/plug-ins/common/file-heif.c index 4f5945e902..7717ca7d2b 100644 --- a/plug-ins/common/file-heif.c +++ b/plug-ins/common/file-heif.c @@ -85,6 +85,7 @@ static GimpValueArray * heif_export (GimpProcedure *pro GimpRunMode run_mode, GimpImage *image, GFile *file, + GimpExportOptions *options, GimpMetadata *metadata, GimpProcedureConfig *config, gpointer run_data); @@ -93,6 +94,7 @@ static GimpValueArray * heif_av1_export (GimpProcedure *pro GimpRunMode run_mode, GimpImage *image, GFile *file, + GimpExportOptions *options, GimpMetadata *metadata, GimpProcedureConfig *config, gpointer run_data); @@ -251,6 +253,11 @@ heif_create_procedure (GimpPlugIn *plug_in, gimp_file_procedure_set_extensions (GIMP_FILE_PROCEDURE (procedure), "heif,heic"); + gimp_export_procedure_set_capabilities (GIMP_EXPORT_PROCEDURE (procedure), + GIMP_EXPORT_CAN_HANDLE_RGB | + GIMP_EXPORT_CAN_HANDLE_ALPHA, + NULL, NULL); + gimp_procedure_add_int_argument (procedure, "quality", _("_Quality"), _("Quality factor (0 = worst, 100 = best)"), @@ -359,6 +366,11 @@ heif_create_procedure (GimpPlugIn *plug_in, gimp_file_procedure_set_extensions (GIMP_FILE_PROCEDURE (procedure), "avif"); + gimp_export_procedure_set_capabilities (GIMP_EXPORT_PROCEDURE (procedure), + GIMP_EXPORT_CAN_HANDLE_RGB | + GIMP_EXPORT_CAN_HANDLE_ALPHA, + NULL, NULL); + gimp_file_procedure_set_priority (GIMP_FILE_PROCEDURE (procedure), 100); gimp_procedure_add_int_argument (procedure, "quality", @@ -486,6 +498,7 @@ heif_export (GimpProcedure *procedure, GimpRunMode run_mode, GimpImage *image, GFile *file, + GimpExportOptions *options, GimpMetadata *metadata_unused, GimpProcedureConfig *config, gpointer run_data) @@ -506,9 +519,7 @@ heif_export (GimpProcedure *procedure, status = GIMP_PDB_CANCEL; } - export = gimp_export_image (&image, - GIMP_EXPORT_CAN_HANDLE_RGB | - GIMP_EXPORT_CAN_HANDLE_ALPHA); + export = gimp_export_options_get_image (options, &image); drawables = gimp_image_list_layers (image); if (status == GIMP_PDB_SUCCESS) @@ -548,6 +559,7 @@ heif_av1_export (GimpProcedure *procedure, GimpRunMode run_mode, GimpImage *image, GFile *file, + GimpExportOptions *options, GimpMetadata *metadata_unused, GimpProcedureConfig *config, gpointer run_data) @@ -569,9 +581,7 @@ heif_av1_export (GimpProcedure *procedure, status = GIMP_PDB_CANCEL; } - export = gimp_export_image (&image, - GIMP_EXPORT_CAN_HANDLE_RGB | - GIMP_EXPORT_CAN_HANDLE_ALPHA); + export = gimp_export_options_get_image (options, &image); drawables = gimp_image_list_layers (image); if (status == GIMP_PDB_SUCCESS) diff --git a/plug-ins/common/file-html-table.c b/plug-ins/common/file-html-table.c index 5f63001a69..4d5cacd206 100644 --- a/plug-ins/common/file-html-table.c +++ b/plug-ins/common/file-html-table.c @@ -88,6 +88,7 @@ static GimpValueArray * html_export (GimpProcedure *procedure, GimpRunMode run_mode, GimpImage *image, GFile *file, + GimpExportOptions *options, GimpMetadata *metadata, GimpProcedureConfig *config, gpointer run_data); @@ -257,6 +258,7 @@ html_export (GimpProcedure *procedure, GimpRunMode run_mode, GimpImage *image, GFile *file, + GimpExportOptions *options, GimpMetadata *metadata, GimpProcedureConfig *config, gpointer run_data) diff --git a/plug-ins/common/file-jpegxl.c b/plug-ins/common/file-jpegxl.c index e70eab2174..22822b9b0c 100644 --- a/plug-ins/common/file-jpegxl.c +++ b/plug-ins/common/file-jpegxl.c @@ -70,6 +70,7 @@ static GimpValueArray *jpegxl_export (GimpProcedure *procedur GimpRunMode run_mode, GimpImage *image, GFile *file, + GimpExportOptions *options, GimpMetadata *metadata, GimpProcedureConfig *config, gpointer run_data); @@ -182,6 +183,12 @@ jpegxl_create_procedure (GimpPlugIn *plug_in, gimp_file_procedure_set_extensions (GIMP_FILE_PROCEDURE (procedure), "jxl"); + gimp_export_procedure_set_capabilities (GIMP_EXPORT_PROCEDURE (procedure), + GIMP_EXPORT_CAN_HANDLE_RGB | + GIMP_EXPORT_CAN_HANDLE_GRAY | + GIMP_EXPORT_CAN_HANDLE_ALPHA, + NULL, NULL); + gimp_procedure_add_boolean_argument (procedure, "lossless", _("L_ossless"), _("Use lossless compression"), @@ -2115,6 +2122,7 @@ jpegxl_export (GimpProcedure *procedure, GimpRunMode run_mode, GimpImage *image, GFile *file, + GimpExportOptions *options, GimpMetadata *metadata, GimpProcedureConfig *config, gpointer run_data) @@ -2136,10 +2144,7 @@ jpegxl_export (GimpProcedure *procedure, } } - export = gimp_export_image (&image, - GIMP_EXPORT_CAN_HANDLE_RGB | - GIMP_EXPORT_CAN_HANDLE_GRAY | - GIMP_EXPORT_CAN_HANDLE_ALPHA); + export = gimp_export_options_get_image (options, &image); drawables = gimp_image_list_layers (image); if (status == GIMP_PDB_SUCCESS) diff --git a/plug-ins/common/file-mng.c b/plug-ins/common/file-mng.c index ac358e2d7d..99e64e6e5f 100644 --- a/plug-ins/common/file-mng.c +++ b/plug-ins/common/file-mng.c @@ -161,6 +161,7 @@ static GimpValueArray * mng_export (GimpProcedure *procedur GimpRunMode run_mode, GimpImage *image, GFile *file, + GimpExportOptions *options, GimpMetadata *metadata, GimpProcedureConfig *config, gpointer run_data); @@ -272,6 +273,14 @@ mng_create_procedure (GimpPlugIn *plug_in, gimp_file_procedure_set_extensions (GIMP_FILE_PROCEDURE (procedure), "mng"); + gimp_export_procedure_set_capabilities (GIMP_EXPORT_PROCEDURE (procedure), + GIMP_EXPORT_CAN_HANDLE_RGB | + GIMP_EXPORT_CAN_HANDLE_GRAY | + GIMP_EXPORT_CAN_HANDLE_INDEXED | + GIMP_EXPORT_CAN_HANDLE_ALPHA | + GIMP_EXPORT_CAN_HANDLE_LAYERS, + NULL, NULL); + gimp_procedure_add_boolean_argument (procedure, "interlaced", _("_Interlace"), _("Use interlacing"), @@ -358,6 +367,7 @@ mng_export (GimpProcedure *procedure, GimpRunMode run_mode, GimpImage *image, GFile *file, + GimpExportOptions *options, GimpMetadata *metadata, GimpProcedureConfig *config, gpointer run_data) @@ -373,17 +383,12 @@ mng_export (GimpProcedure *procedure, if (run_mode == GIMP_RUN_INTERACTIVE) { gimp_ui_init (PLUG_IN_BINARY); - + if (! mng_save_dialog (image, procedure, G_OBJECT (config))) status = GIMP_PDB_CANCEL; } - export = gimp_export_image (&image, - GIMP_EXPORT_CAN_HANDLE_RGB | - GIMP_EXPORT_CAN_HANDLE_GRAY | - GIMP_EXPORT_CAN_HANDLE_INDEXED | - GIMP_EXPORT_CAN_HANDLE_ALPHA | - GIMP_EXPORT_CAN_HANDLE_LAYERS); + export = gimp_export_options_get_image (options, &image); drawables = gimp_image_list_layers (image); n_drawables = g_list_length (drawables); diff --git a/plug-ins/common/file-pat.c b/plug-ins/common/file-pat.c index 7c3d503f24..ffea80b44e 100644 --- a/plug-ins/common/file-pat.c +++ b/plug-ins/common/file-pat.c @@ -58,6 +58,7 @@ static GimpValueArray * pat_export (GimpProcedure *procedure, GimpRunMode run_mode, GimpImage *image, GFile *file, + GimpExportOptions *options, GimpMetadata *metadata, GimpProcedureConfig *config, gpointer run_data); @@ -131,6 +132,13 @@ pat_create_procedure (GimpPlugIn *plug_in, gimp_file_procedure_set_handles_remote (GIMP_FILE_PROCEDURE (procedure), TRUE); + gimp_export_procedure_set_capabilities (GIMP_EXPORT_PROCEDURE (procedure), + GIMP_EXPORT_CAN_HANDLE_GRAY | + GIMP_EXPORT_CAN_HANDLE_RGB | + GIMP_EXPORT_CAN_HANDLE_INDEXED | + GIMP_EXPORT_CAN_HANDLE_ALPHA, + NULL, NULL); + gimp_procedure_add_string_argument (procedure, "description", _("_Description"), _("Short description of the pattern"), @@ -146,6 +154,7 @@ pat_export (GimpProcedure *procedure, GimpRunMode run_mode, GimpImage *image, GFile *file, + GimpExportOptions *options, GimpMetadata *metadata, GimpProcedureConfig *config, gpointer run_data) @@ -186,11 +195,7 @@ pat_export (GimpProcedure *procedure, status = GIMP_PDB_CANCEL; } - export = gimp_export_image (&image, - GIMP_EXPORT_CAN_HANDLE_GRAY | - GIMP_EXPORT_CAN_HANDLE_RGB | - GIMP_EXPORT_CAN_HANDLE_INDEXED | - GIMP_EXPORT_CAN_HANDLE_ALPHA); + export = gimp_export_options_get_image (options, &image); drawables = gimp_image_list_layers (image); n_drawables = g_list_length (drawables); diff --git a/plug-ins/common/file-pcx.c b/plug-ins/common/file-pcx.c index 59adff25ba..8701426508 100644 --- a/plug-ins/common/file-pcx.c +++ b/plug-ins/common/file-pcx.c @@ -80,6 +80,7 @@ static GimpValueArray * pcx_export (GimpProcedure *procedure, GimpRunMode run_mode, GimpImage *image, GFile *file, + GimpExportOptions *options, GimpMetadata *metadata, GimpProcedureConfig *config, gpointer run_data); @@ -292,6 +293,12 @@ pcx_create_procedure (GimpPlugIn *plug_in, "image/x-pcx"); gimp_file_procedure_set_extensions (GIMP_FILE_PROCEDURE (procedure), "pcx,pcc"); + + gimp_export_procedure_set_capabilities (GIMP_EXPORT_PROCEDURE (procedure), + GIMP_EXPORT_CAN_HANDLE_RGB | + GIMP_EXPORT_CAN_HANDLE_GRAY | + GIMP_EXPORT_CAN_HANDLE_INDEXED, + NULL, NULL); } return procedure; @@ -364,6 +371,7 @@ pcx_export (GimpProcedure *procedure, GimpRunMode run_mode, GimpImage *image, GFile *file, + GimpExportOptions *options, GimpMetadata *metadata, GimpProcedureConfig *config, gpointer run_data) @@ -375,10 +383,7 @@ pcx_export (GimpProcedure *procedure, gegl_init (NULL, NULL); - export = gimp_export_image (&image, - GIMP_EXPORT_CAN_HANDLE_RGB | - GIMP_EXPORT_CAN_HANDLE_GRAY | - GIMP_EXPORT_CAN_HANDLE_INDEXED); + export = gimp_export_options_get_image (options, &image); drawables = gimp_image_list_layers (image); if (! export_image (file, diff --git a/plug-ins/common/file-pdf-export.c b/plug-ins/common/file-pdf-export.c index 73b1ecfbf0..1a3e21a7c2 100644 --- a/plug-ins/common/file-pdf-export.c +++ b/plug-ins/common/file-pdf-export.c @@ -187,6 +187,7 @@ static GimpValueArray * pdf_export (GimpProcedure *procedur GimpRunMode run_mode, GimpImage *image, GFile *file, + GimpExportOptions *options, GimpMetadata *metadata, GimpProcedureConfig *config, gpointer run_data); @@ -196,10 +197,16 @@ static GimpValueArray * pdf_export_multi (GimpProcedure *procedur static GimpPDBStatusType pdf_export_image (GimpProcedure *procedure, GimpProcedureConfig *config, + GimpExportOptions *options, gboolean single_image, gboolean show_progress, GError **error); +static void export_edit_options (GimpProcedure *procedure, + GimpProcedureConfig *config, + GimpExportOptions *options, + gpointer create_data); + static void init_image_list_defaults (GimpImage *image); static void validate_image_list (void); @@ -333,6 +340,14 @@ pdf_create_procedure (GimpPlugIn *plug_in, gimp_file_procedure_set_extensions (GIMP_FILE_PROCEDURE (procedure), "pdf"); + gimp_export_procedure_set_capabilities (GIMP_EXPORT_PROCEDURE (procedure), + GIMP_EXPORT_CAN_HANDLE_RGB | + GIMP_EXPORT_CAN_HANDLE_ALPHA | + GIMP_EXPORT_CAN_HANDLE_GRAY | + GIMP_EXPORT_CAN_HANDLE_LAYERS | + GIMP_EXPORT_CAN_HANDLE_INDEXED, + export_edit_options, NULL); + gimp_procedure_add_boolean_argument (procedure, "vectorize", _("Convert _bitmaps to vector graphics where possible"), _("Convert bitmaps to vector graphics where possible"), @@ -470,6 +485,7 @@ pdf_export (GimpProcedure *procedure, GimpRunMode run_mode, GimpImage *image, GFile *file, + GimpExportOptions *options, GimpMetadata *metadata, GimpProcedureConfig *config, gpointer run_data) @@ -495,7 +511,7 @@ pdf_export (GimpProcedure *procedure, } if (status == GIMP_PDB_SUCCESS) - status = pdf_export_image (procedure, config, TRUE, + status = pdf_export_image (procedure, config, options, TRUE, (run_mode != GIMP_RUN_NONINTERACTIVE), &error); @@ -510,6 +526,7 @@ pdf_export_multi (GimpProcedure *procedure, GError *error = NULL; GimpPDBStatusType status = GIMP_PDB_SUCCESS; GimpRunMode run_mode; + GimpExportOptions *options = NULL; gchar *uri; const gint32 *image_ids = NULL; GimpImage *image = NULL; @@ -524,6 +541,8 @@ pdf_export_multi (GimpProcedure *procedure, "images", &image_ids, NULL); + options = gimp_export_options_new (); + if (uri != NULL) { file = g_file_new_for_uri (uri); @@ -549,7 +568,7 @@ pdf_export_multi (GimpProcedure *procedure, } if (status == GIMP_PDB_SUCCESS) - status = pdf_export_image (procedure, config, FALSE, + status = pdf_export_image (procedure, config, options, FALSE, (run_mode != GIMP_RUN_NONINTERACTIVE), &error); @@ -635,21 +654,19 @@ get_missing_fonts (GList *layers) static GimpPDBStatusType pdf_export_image (GimpProcedure *procedure, GimpProcedureConfig *config, + GimpExportOptions *options, gboolean single_image, gboolean show_progress, GError **error) { - cairo_surface_t *pdf_file; - cairo_t *cr; - GimpExportCapabilities capabilities; - FILE *fp; - gint i; - gboolean apply_masks; - gboolean layers_as_pages = FALSE; - gboolean fill_background_color; + cairo_surface_t *pdf_file; + cairo_t *cr; + FILE *fp; + gint i; + gboolean layers_as_pages = FALSE; + gboolean fill_background_color; g_object_get (config, - "apply-masks", &apply_masks, "fill-background-color", &fill_background_color, NULL); @@ -682,17 +699,6 @@ pdf_export_image (GimpProcedure *procedure, cr = cairo_create (pdf_file); - capabilities = (GIMP_EXPORT_CAN_HANDLE_RGB | - GIMP_EXPORT_CAN_HANDLE_ALPHA | - GIMP_EXPORT_CAN_HANDLE_GRAY | - GIMP_EXPORT_CAN_HANDLE_LAYERS | - GIMP_EXPORT_CAN_HANDLE_INDEXED); - /* This seems counter-intuitive, but not setting the mask capability - * will apply any layer mask upon gimp_export_image(). - */ - if (! apply_masks) - capabilities |= GIMP_EXPORT_CAN_HANDLE_LAYER_MASKS; - for (i = 0; i < multi_page.image_count; i++) { GimpImage *image = multi_page.images[i]; @@ -716,8 +722,8 @@ pdf_export_image (GimpProcedure *procedure, */ cairo_save (cr); - if (! (gimp_export_image (&image, - capabilities) == GIMP_EXPORT_EXPORT)) + if (! (gimp_export_options_get_image (options, + &image) == GIMP_EXPORT_EXPORT)) { /* gimp_drawable_histogram() only works within the bounds of * the selection, which is a problem (see issue #2431). @@ -823,6 +829,34 @@ pdf_export_image (GimpProcedure *procedure, return GIMP_PDB_SUCCESS; } +static void +export_edit_options (GimpProcedure *procedure, + GimpProcedureConfig *config, + GimpExportOptions *options, + gpointer create_data) +{ + GimpExportCapabilities capabilities; + gboolean apply_masks; + + g_object_get (G_OBJECT (config), + "apply-masks", &apply_masks, + NULL); + + capabilities = (GIMP_EXPORT_CAN_HANDLE_RGB | + GIMP_EXPORT_CAN_HANDLE_ALPHA | + GIMP_EXPORT_CAN_HANDLE_GRAY | + GIMP_EXPORT_CAN_HANDLE_LAYERS | + GIMP_EXPORT_CAN_HANDLE_INDEXED); + + + if (! apply_masks) + capabilities |= GIMP_EXPORT_CAN_HANDLE_LAYER_MASKS; + + g_object_set (G_OBJECT (options), + "capabilities", capabilities, + NULL); +} + /******************************************************/ /* Beginning of parameter handling functions */ /******************************************************/ diff --git a/plug-ins/common/file-pix.c b/plug-ins/common/file-pix.c index 24a3f37cea..25c5893280 100644 --- a/plug-ins/common/file-pix.c +++ b/plug-ins/common/file-pix.c @@ -101,6 +101,7 @@ static GimpValueArray * pix_export (GimpProcedure *procedure, GimpRunMode run_mode, GimpImage *image, GFile *file, + GimpExportOptions *options, GimpMetadata *metadata, GimpProcedureConfig *config, gpointer run_data); @@ -172,10 +173,10 @@ pix_create_procedure (GimpPlugIn *plug_in, gimp_procedure_set_menu_label (procedure, _("Alias Pix image")); gimp_procedure_set_documentation (procedure, - "Loads files of the Alias|Wavefront " - "or Esm Software Pix file format", - "Loads files of the Alias|Wavefront " - "or Esm Software Pix file format", + _("Loads files of the Alias|Wavefront " + "or Esm Software Pix file format"), + _("Loads files of the Alias|Wavefront " + "or Esm Software Pix file format"), name); gimp_procedure_set_attribution (procedure, "Michael Taylor", @@ -203,10 +204,10 @@ pix_create_procedure (GimpPlugIn *plug_in, gimp_procedure_set_menu_label (procedure, _("Alias Pix image")); gimp_procedure_set_documentation (procedure, - "Export file in the Alias|Wavefront " - "pix/matte file format", - "Export file in the Alias|Wavefront " - "pix/matte file format", + _("Export file in the Alias|Wavefront " + "pix/matte file format"), + _("Export file in the Alias|Wavefront " + "pix/matte file format"), name); gimp_procedure_set_attribution (procedure, "Michael Taylor", @@ -215,6 +216,12 @@ pix_create_procedure (GimpPlugIn *plug_in, gimp_file_procedure_set_extensions (GIMP_FILE_PROCEDURE (procedure), "pix,matte,mask,alpha,als"); + + gimp_export_procedure_set_capabilities (GIMP_EXPORT_PROCEDURE (procedure), + GIMP_EXPORT_CAN_HANDLE_RGB | + GIMP_EXPORT_CAN_HANDLE_GRAY | + GIMP_EXPORT_CAN_HANDLE_INDEXED, + NULL, NULL); } return procedure; @@ -256,6 +263,7 @@ pix_export (GimpProcedure *procedure, GimpRunMode run_mode, GimpImage *image, GFile *file, + GimpExportOptions *options, GimpMetadata *metadata, GimpProcedureConfig *config, gpointer run_data) @@ -267,10 +275,7 @@ pix_export (GimpProcedure *procedure, gegl_init (NULL, NULL); - export = gimp_export_image (&image, - GIMP_EXPORT_CAN_HANDLE_RGB | - GIMP_EXPORT_CAN_HANDLE_GRAY | - GIMP_EXPORT_CAN_HANDLE_INDEXED); + export = gimp_export_options_get_image (options, &image); drawables = gimp_image_list_layers (image); if (! export_image (file, image, drawables->data, &error)) diff --git a/plug-ins/common/file-png.c b/plug-ins/common/file-png.c index 1ee4d60b55..4dfab2f844 100644 --- a/plug-ins/common/file-png.c +++ b/plug-ins/common/file-png.c @@ -97,6 +97,7 @@ static GimpValueArray * png_export (GimpProcedure *procedure, GimpRunMode run_mode, GimpImage *image, GFile *file, + GimpExportOptions *options, GimpMetadata *metadata, GimpProcedureConfig *config, gpointer run_data); @@ -234,6 +235,13 @@ png_create_procedure (GimpPlugIn *plug_in, gimp_file_procedure_set_extensions (GIMP_FILE_PROCEDURE (procedure), "png"); + gimp_export_procedure_set_capabilities (GIMP_EXPORT_PROCEDURE (procedure), + GIMP_EXPORT_CAN_HANDLE_RGB | + GIMP_EXPORT_CAN_HANDLE_GRAY | + GIMP_EXPORT_CAN_HANDLE_INDEXED | + GIMP_EXPORT_CAN_HANDLE_ALPHA, + NULL, NULL); + gimp_procedure_add_boolean_argument (procedure, "interlaced", _("_Interlacing (Adam7)"), _("Use Adam7 interlacing"), @@ -367,6 +375,7 @@ png_export (GimpProcedure *procedure, GimpRunMode run_mode, GimpImage *image, GFile *file, + GimpExportOptions *options, GimpMetadata *metadata, GimpProcedureConfig *config, gpointer run_data) @@ -382,11 +391,7 @@ png_export (GimpProcedure *procedure, orig_image = image; - export = gimp_export_image (&image, - GIMP_EXPORT_CAN_HANDLE_RGB | - GIMP_EXPORT_CAN_HANDLE_GRAY | - GIMP_EXPORT_CAN_HANDLE_INDEXED | - GIMP_EXPORT_CAN_HANDLE_ALPHA); + export = gimp_export_options_get_image (options, &image); drawables = gimp_image_list_layers (image); alpha = gimp_drawable_has_alpha (drawables->data); diff --git a/plug-ins/common/file-pnm.c b/plug-ins/common/file-pnm.c index aad51f07cf..c118e86cf7 100644 --- a/plug-ins/common/file-pnm.c +++ b/plug-ins/common/file-pnm.c @@ -155,6 +155,7 @@ static GimpValueArray * pnm_export (GimpProcedure *procedure, GimpRunMode run_mode, GimpImage *image, GFile *file, + GimpExportOptions *options, GimpMetadata *metadata, GimpProcedureConfig *config, gpointer run_data); @@ -367,6 +368,12 @@ pnm_create_procedure (GimpPlugIn *plug_in, gimp_file_procedure_set_extensions (GIMP_FILE_PROCEDURE (procedure), "pnm"); + gimp_export_procedure_set_capabilities (GIMP_EXPORT_PROCEDURE (procedure), + GIMP_EXPORT_CAN_HANDLE_RGB | + GIMP_EXPORT_CAN_HANDLE_GRAY | + GIMP_EXPORT_CAN_HANDLE_INDEXED, + NULL, NULL); + gimp_procedure_add_choice_argument (procedure, "raw", _("_Data formatting"), _("Whether to export ASCII or raw output"), @@ -406,6 +413,10 @@ pnm_create_procedure (GimpPlugIn *plug_in, gimp_file_procedure_set_extensions (GIMP_FILE_PROCEDURE (procedure), "pbm"); + gimp_export_procedure_set_capabilities (GIMP_EXPORT_PROCEDURE (procedure), + GIMP_EXPORT_CAN_HANDLE_BITMAP, + NULL, NULL); + gimp_procedure_add_choice_argument (procedure, "raw", _("_Data formatting"), _("Whether to export ASCII or raw output"), @@ -445,6 +456,10 @@ pnm_create_procedure (GimpPlugIn *plug_in, gimp_file_procedure_set_extensions (GIMP_FILE_PROCEDURE (procedure), "pgm"); + gimp_export_procedure_set_capabilities (GIMP_EXPORT_PROCEDURE (procedure), + GIMP_EXPORT_CAN_HANDLE_GRAY, + NULL, NULL); + gimp_procedure_add_choice_argument (procedure, "raw", _("_Data formatting"), _("Whether to export ASCII or raw output"), @@ -484,6 +499,11 @@ pnm_create_procedure (GimpPlugIn *plug_in, gimp_file_procedure_set_extensions (GIMP_FILE_PROCEDURE (procedure), "ppm"); + gimp_export_procedure_set_capabilities (GIMP_EXPORT_PROCEDURE (procedure), + GIMP_EXPORT_CAN_HANDLE_RGB | + GIMP_EXPORT_CAN_HANDLE_INDEXED, + NULL, NULL); + gimp_procedure_add_choice_argument (procedure, "raw", _("_Data formatting"), _("Whether to export ASCII or raw output"), @@ -521,6 +541,13 @@ pnm_create_procedure (GimpPlugIn *plug_in, "image/x-portable-arbitrarymap"); gimp_file_procedure_set_extensions (GIMP_FILE_PROCEDURE (procedure), "pam"); + + gimp_export_procedure_set_capabilities (GIMP_EXPORT_PROCEDURE (procedure), + GIMP_EXPORT_CAN_HANDLE_RGB | + GIMP_EXPORT_CAN_HANDLE_GRAY | + GIMP_EXPORT_CAN_HANDLE_ALPHA | + GIMP_EXPORT_CAN_HANDLE_INDEXED, + NULL, NULL); } else if (! strcmp (name, PFM_EXPORT_PROC)) { @@ -550,6 +577,12 @@ pnm_create_procedure (GimpPlugIn *plug_in, "image/x-portable-floatmap"); gimp_file_procedure_set_extensions (GIMP_FILE_PROCEDURE (procedure), "pfm"); + + gimp_export_procedure_set_capabilities (GIMP_EXPORT_PROCEDURE (procedure), + GIMP_EXPORT_CAN_HANDLE_RGB | + GIMP_EXPORT_CAN_HANDLE_GRAY, + NULL, NULL); + } return procedure; @@ -591,6 +624,7 @@ pnm_export (GimpProcedure *procedure, GimpRunMode run_mode, GimpImage *image, GFile *file, + GimpExportOptions *options, GimpMetadata *metadata, GimpProcedureConfig *config, gpointer run_data) @@ -613,45 +647,7 @@ pnm_export (GimpProcedure *procedure, status = GIMP_PDB_CANCEL; } - switch (file_type) - { - case FILE_TYPE_PNM: - export = gimp_export_image (&image, - GIMP_EXPORT_CAN_HANDLE_RGB | - GIMP_EXPORT_CAN_HANDLE_GRAY | - GIMP_EXPORT_CAN_HANDLE_INDEXED); - break; - - case FILE_TYPE_PBM: - export = gimp_export_image (&image, - GIMP_EXPORT_CAN_HANDLE_BITMAP); - break; - - case FILE_TYPE_PGM: - export = gimp_export_image (&image, - GIMP_EXPORT_CAN_HANDLE_GRAY); - break; - - case FILE_TYPE_PPM: - export = gimp_export_image (&image, - GIMP_EXPORT_CAN_HANDLE_RGB | - GIMP_EXPORT_CAN_HANDLE_INDEXED); - break; - - case FILE_TYPE_PAM: - export = gimp_export_image (&image, - GIMP_EXPORT_CAN_HANDLE_RGB | - GIMP_EXPORT_CAN_HANDLE_GRAY | - GIMP_EXPORT_CAN_HANDLE_ALPHA | - GIMP_EXPORT_CAN_HANDLE_INDEXED); - break; - - case FILE_TYPE_PFM: - export = gimp_export_image (&image, - GIMP_EXPORT_CAN_HANDLE_RGB | - GIMP_EXPORT_CAN_HANDLE_GRAY); - break; - } + export = gimp_export_options_get_image (options, &image); drawables = gimp_image_list_layers (image); if (status == GIMP_PDB_SUCCESS) diff --git a/plug-ins/common/file-ps.c b/plug-ins/common/file-ps.c index 7a781de130..38e305f006 100644 --- a/plug-ins/common/file-ps.c +++ b/plug-ins/common/file-ps.c @@ -159,6 +159,7 @@ static GimpValueArray * ps_export (GimpProcedure *procedure, GimpRunMode run_mode, GimpImage *image, GFile *file, + GimpExportOptions *options, GimpMetadata *metadata, GimpProcedureConfig *config, gpointer run_data); @@ -514,6 +515,12 @@ ps_create_procedure (GimpPlugIn *plug_in, gimp_file_procedure_set_handles_remote (GIMP_FILE_PROCEDURE (procedure), TRUE); + gimp_export_procedure_set_capabilities (GIMP_EXPORT_PROCEDURE (procedure), + GIMP_EXPORT_CAN_HANDLE_RGB | + GIMP_EXPORT_CAN_HANDLE_GRAY | + GIMP_EXPORT_CAN_HANDLE_INDEXED, + NULL, NULL); + gimp_procedure_add_double_argument (procedure, "width", _("_Width"), _("Width of the image in PostScript file " @@ -734,6 +741,7 @@ ps_export (GimpProcedure *procedure, GimpRunMode run_mode, GimpImage *image, GFile *file, + GimpExportOptions *options, GimpMetadata *metadata, GimpProcedureConfig *config, gpointer run_data) @@ -772,10 +780,7 @@ ps_export (GimpProcedure *procedure, break; } - export = gimp_export_image (&image, - GIMP_EXPORT_CAN_HANDLE_RGB | - GIMP_EXPORT_CAN_HANDLE_GRAY | - GIMP_EXPORT_CAN_HANDLE_INDEXED); + export = gimp_export_options_get_image (options, &image); drawables = gimp_image_list_layers (image); if (status == GIMP_PDB_SUCCESS) diff --git a/plug-ins/common/file-psp.c b/plug-ins/common/file-psp.c index 8303bcab2d..62eb2bd4b1 100644 --- a/plug-ins/common/file-psp.c +++ b/plug-ins/common/file-psp.c @@ -595,6 +595,7 @@ static GimpValueArray * psp_export (GimpProcedure *procedure, GimpRunMode run_mode, GimpImage *image, GFile *file, + GimpExportOptions *options, GimpMetadata *metadata, GimpProcedureConfig *config, gpointer run_data); @@ -713,6 +714,14 @@ psp_create_procedure (GimpPlugIn *plug_in, gimp_file_procedure_set_extensions (GIMP_FILE_PROCEDURE (procedure), "psp,tub"); + gimp_export_procedure_set_capabilities (GIMP_EXPORT_PROCEDURE (procedure), + GIMP_EXPORT_CAN_HANDLE_RGB | + GIMP_EXPORT_CAN_HANDLE_GRAY | + GIMP_EXPORT_CAN_HANDLE_INDEXED | + GIMP_EXPORT_CAN_HANDLE_ALPHA | + GIMP_EXPORT_CAN_HANDLE_LAYERS, + NULL, NULL); + gimp_procedure_add_choice_argument (procedure, "compression", _("_Data Compression"), _("Type of compression"), @@ -763,6 +772,7 @@ psp_export (GimpProcedure *procedure, GimpRunMode run_mode, GimpImage *image, GFile *file, + GimpExportOptions *options, GimpMetadata *metadata, GimpProcedureConfig *config, gpointer run_data) @@ -783,12 +793,7 @@ psp_export (GimpProcedure *procedure, status = GIMP_PDB_CANCEL; } - export = gimp_export_image (&image, - GIMP_EXPORT_CAN_HANDLE_RGB | - GIMP_EXPORT_CAN_HANDLE_GRAY | - GIMP_EXPORT_CAN_HANDLE_INDEXED | - GIMP_EXPORT_CAN_HANDLE_ALPHA | - GIMP_EXPORT_CAN_HANDLE_LAYERS); + export = gimp_export_options_get_image (options, &image); drawables = gimp_image_list_layers (image); n_drawables = g_list_length (drawables); diff --git a/plug-ins/common/file-qoi.c b/plug-ins/common/file-qoi.c index 95e6d35dd3..211c99522b 100644 --- a/plug-ins/common/file-qoi.c +++ b/plug-ins/common/file-qoi.c @@ -76,6 +76,7 @@ static GimpValueArray * qoi_export (GimpProcedure *procedure, GimpRunMode run_mode, GimpImage *image, GFile *file, + GimpExportOptions *options, GimpMetadata *metadata, GimpProcedureConfig *config, gpointer run_data); @@ -178,6 +179,14 @@ qoi_create_procedure (GimpPlugIn *plug_in, "image/qoi"); gimp_file_procedure_set_extensions (GIMP_FILE_PROCEDURE (procedure), "qoi"); + + gimp_export_procedure_set_capabilities (GIMP_EXPORT_PROCEDURE (procedure), + GIMP_EXPORT_CAN_HANDLE_RGB | + GIMP_EXPORT_CAN_HANDLE_GRAY | + GIMP_EXPORT_CAN_HANDLE_INDEXED | + GIMP_EXPORT_CAN_HANDLE_ALPHA, + NULL, NULL); + } return procedure; @@ -219,6 +228,7 @@ qoi_export (GimpProcedure *procedure, GimpRunMode run_mode, GimpImage *image, GFile *file, + GimpExportOptions *options, GimpMetadata *metadata, GimpProcedureConfig *config, gpointer run_data) @@ -230,11 +240,7 @@ qoi_export (GimpProcedure *procedure, gegl_init (NULL, NULL); - export = gimp_export_image (&image, - GIMP_EXPORT_CAN_HANDLE_RGB | - GIMP_EXPORT_CAN_HANDLE_GRAY | - GIMP_EXPORT_CAN_HANDLE_INDEXED | - GIMP_EXPORT_CAN_HANDLE_ALPHA); + export = gimp_export_options_get_image (options, &image); drawables = gimp_image_list_layers (image); if (! export_image (file, image, drawables->data, &error)) diff --git a/plug-ins/common/file-raw-data.c b/plug-ins/common/file-raw-data.c index e465165d0e..18705289b7 100644 --- a/plug-ins/common/file-raw-data.c +++ b/plug-ins/common/file-raw-data.c @@ -175,6 +175,7 @@ static GimpValueArray * raw_export (GimpProcedure *procedur GimpRunMode run_mode, GimpImage *image, GFile *file, + GimpExportOptions *options, GimpMetadata *metadata, GimpProcedureConfig *config, gpointer run_data); @@ -513,6 +514,13 @@ raw_create_procedure (GimpPlugIn *plug_in, gimp_file_procedure_set_extensions (GIMP_FILE_PROCEDURE (procedure), "data,raw"); + gimp_export_procedure_set_capabilities (GIMP_EXPORT_PROCEDURE (procedure), + GIMP_EXPORT_CAN_HANDLE_RGB | + GIMP_EXPORT_CAN_HANDLE_GRAY | + GIMP_EXPORT_CAN_HANDLE_INDEXED | + GIMP_EXPORT_CAN_HANDLE_ALPHA, + NULL, NULL); + gimp_procedure_add_choice_argument (procedure, "planar-configuration", _("Planar configuration"), _("How color pixel data are stored"), @@ -656,6 +664,7 @@ raw_export (GimpProcedure *procedure, GimpRunMode run_mode, GimpImage *image, GFile *file, + GimpExportOptions *options, GimpMetadata *metadata, GimpProcedureConfig *config, gpointer run_data) @@ -677,11 +686,7 @@ raw_export (GimpProcedure *procedure, NULL); } - export = gimp_export_image (&image, - GIMP_EXPORT_CAN_HANDLE_RGB | - GIMP_EXPORT_CAN_HANDLE_GRAY | - GIMP_EXPORT_CAN_HANDLE_INDEXED | - GIMP_EXPORT_CAN_HANDLE_ALPHA); + export = gimp_export_options_get_image (options, &image); drawables = gimp_image_list_layers (image); if (run_mode == GIMP_RUN_INTERACTIVE) diff --git a/plug-ins/common/file-sunras.c b/plug-ins/common/file-sunras.c index 4746ea3f1a..1ab960bf17 100644 --- a/plug-ins/common/file-sunras.c +++ b/plug-ins/common/file-sunras.c @@ -121,6 +121,7 @@ static GimpValueArray * sunras_export (GimpProcedure *procedur GimpRunMode run_mode, GimpImage *image, GFile *file, + GimpExportOptions *options, GimpMetadata *metadata, GimpProcedureConfig *config, gpointer run_data); @@ -275,8 +276,8 @@ sunras_create_procedure (GimpPlugIn *plug_in, gimp_procedure_set_menu_label (procedure, _("SUN Rasterfile image")); gimp_procedure_set_documentation (procedure, - "Load file of the SunRaster file format", - "Load file of the SunRaster file format", + _("Load file of the SunRaster file format"), + _("Load file of the SunRaster file format"), name); gimp_procedure_set_attribution (procedure, "Peter Kirchgessner", @@ -301,11 +302,11 @@ sunras_create_procedure (GimpPlugIn *plug_in, gimp_procedure_set_menu_label (procedure, _("SUN Rasterfile image")); gimp_procedure_set_documentation (procedure, - "Export file in the SunRaster file " - "format", - "SUNRAS exporting handles all image " - "types except those with alpha " - "channels.", + _("Export file in the SunRaster file " + "format"), + _("SUNRAS exporting handles all image " + "types except those with alpha " + "channels."), name); gimp_procedure_set_attribution (procedure, "Peter Kirchgessner", @@ -319,6 +320,12 @@ sunras_create_procedure (GimpPlugIn *plug_in, gimp_file_procedure_set_extensions (GIMP_FILE_PROCEDURE (procedure), "im1,im8,im24,im32,rs,ras,sun"); + gimp_export_procedure_set_capabilities (GIMP_EXPORT_PROCEDURE (procedure), + GIMP_EXPORT_CAN_HANDLE_RGB | + GIMP_EXPORT_CAN_HANDLE_GRAY | + GIMP_EXPORT_CAN_HANDLE_INDEXED, + NULL, NULL); + gimp_procedure_add_choice_argument (procedure, "rle", _("_Data Formatting"), _("Use standard or Run-Length Encoded output"), @@ -368,6 +375,7 @@ sunras_export (GimpProcedure *procedure, GimpRunMode run_mode, GimpImage *image, GFile *file, + GimpExportOptions *options, GimpMetadata *metadata, GimpProcedureConfig *config, gpointer run_data) @@ -387,10 +395,7 @@ sunras_export (GimpProcedure *procedure, status = GIMP_PDB_CANCEL; } - export = gimp_export_image (&image, - GIMP_EXPORT_CAN_HANDLE_RGB | - GIMP_EXPORT_CAN_HANDLE_GRAY | - GIMP_EXPORT_CAN_HANDLE_INDEXED); + export = gimp_export_options_get_image (options, &image); drawables = gimp_image_list_layers (image); if (status == GIMP_PDB_SUCCESS) diff --git a/plug-ins/common/file-tga.c b/plug-ins/common/file-tga.c index abecde8685..58a24c54bb 100644 --- a/plug-ins/common/file-tga.c +++ b/plug-ins/common/file-tga.c @@ -185,6 +185,7 @@ static GimpValueArray * tga_export (GimpProcedure *procedure, GimpRunMode run_mode, GimpImage *image, GFile *file, + GimpExportOptions *options, GimpMetadata *metadata, GimpProcedureConfig *config, gpointer run_data); @@ -302,6 +303,13 @@ tga_create_procedure (GimpPlugIn *plug_in, gimp_file_procedure_set_extensions (GIMP_FILE_PROCEDURE (procedure), "tga"); + gimp_export_procedure_set_capabilities (GIMP_EXPORT_PROCEDURE (procedure), + GIMP_EXPORT_CAN_HANDLE_RGB | + GIMP_EXPORT_CAN_HANDLE_GRAY | + GIMP_EXPORT_CAN_HANDLE_INDEXED | + GIMP_EXPORT_CAN_HANDLE_ALPHA, + NULL, NULL); + gimp_procedure_add_boolean_argument (procedure, "rle", _("_Use RLE compression"), _("Use RLE compression"), @@ -354,6 +362,7 @@ tga_export (GimpProcedure *procedure, GimpRunMode run_mode, GimpImage *image, GFile *file, + GimpExportOptions *options, GimpMetadata *metadata, GimpProcedureConfig *config, gpointer run_data) @@ -368,16 +377,12 @@ tga_export (GimpProcedure *procedure, if (run_mode == GIMP_RUN_INTERACTIVE) { gimp_ui_init (PLUG_IN_BINARY); - + if (! save_dialog (image, procedure, G_OBJECT (config))) status = GIMP_PDB_CANCEL; } - export = gimp_export_image (&image, - GIMP_EXPORT_CAN_HANDLE_RGB | - GIMP_EXPORT_CAN_HANDLE_GRAY | - GIMP_EXPORT_CAN_HANDLE_INDEXED | - GIMP_EXPORT_CAN_HANDLE_ALPHA); + export = gimp_export_options_get_image (options, &image); drawables = gimp_image_list_layers (image); if (status == GIMP_PDB_SUCCESS) diff --git a/plug-ins/common/file-xbm.c b/plug-ins/common/file-xbm.c index fac47afd80..aca1d7826d 100644 --- a/plug-ins/common/file-xbm.c +++ b/plug-ins/common/file-xbm.c @@ -89,6 +89,7 @@ static GimpValueArray * xbm_export (GimpProcedure *procedure, GimpRunMode run_mode, GimpImage *image, GFile *file, + GimpExportOptions *options, GimpMetadata *metadata, GimpProcedureConfig *config, gpointer run_data); @@ -209,6 +210,11 @@ xbm_create_procedure (GimpPlugIn *plug_in, gimp_file_procedure_set_extensions (GIMP_FILE_PROCEDURE (procedure), "xbm,icon,bitmap"); + gimp_export_procedure_set_capabilities (GIMP_EXPORT_PROCEDURE (procedure), + GIMP_EXPORT_CAN_HANDLE_BITMAP | + GIMP_EXPORT_CAN_HANDLE_ALPHA, + NULL, NULL); + gimp_procedure_add_boolean_argument (procedure, "save-comment", _("_Write comment"), _("Write a comment at the beginning of the file."), @@ -337,6 +343,7 @@ xbm_export (GimpProcedure *procedure, GimpRunMode run_mode, GimpImage *image, GFile *file, + GimpExportOptions *options, GimpMetadata *metadata, GimpProcedureConfig *config, gpointer run_data) @@ -356,9 +363,7 @@ xbm_export (GimpProcedure *procedure, mask_basename = g_strdup (init_prefix (file, G_OBJECT (config))); } - export = gimp_export_image (&image, - GIMP_EXPORT_CAN_HANDLE_BITMAP | - GIMP_EXPORT_CAN_HANDLE_ALPHA); + export = gimp_export_options_get_image (options, &image); drawables = gimp_image_list_layers (image); if (run_mode == GIMP_RUN_INTERACTIVE) diff --git a/plug-ins/common/file-xmc.c b/plug-ins/common/file-xmc.c index f9f5b25d54..61edbb0dc0 100644 --- a/plug-ins/common/file-xmc.c +++ b/plug-ins/common/file-xmc.c @@ -173,6 +173,7 @@ static GimpValueArray * xmc_export (GimpProcedure *pro GimpRunMode run_mode, GimpImage *image, GFile *file, + GimpExportOptions *options, GimpMetadata *metadata, GimpProcedureConfig *config, gpointer run_data); @@ -364,6 +365,13 @@ xmc_create_procedure (GimpPlugIn *plug_in, gimp_file_procedure_set_extensions (GIMP_FILE_PROCEDURE (procedure), XCURSOR_EXTENSION); + gimp_export_procedure_set_capabilities (GIMP_EXPORT_PROCEDURE (procedure), + GIMP_EXPORT_CAN_HANDLE_RGB | + GIMP_EXPORT_CAN_HANDLE_ALPHA | + GIMP_EXPORT_CAN_HANDLE_LAYERS | + GIMP_EXPORT_NEEDS_ALPHA, + NULL, NULL); + gimp_procedure_add_int_argument (procedure, "hot-spot-x", _("Hot spot _X"), _("X-coordinate of hot spot " @@ -525,6 +533,7 @@ xmc_export (GimpProcedure *procedure, GimpRunMode run_mode, GimpImage *image, GFile *file, + GimpExportOptions *options, GimpMetadata *metadata, GimpProcedureConfig *config, gpointer run_data) @@ -592,11 +601,7 @@ xmc_export (GimpProcedure *procedure, break; } - export = gimp_export_image (&image, - GIMP_EXPORT_CAN_HANDLE_RGB | - GIMP_EXPORT_CAN_HANDLE_ALPHA | - GIMP_EXPORT_CAN_HANDLE_LAYERS | - GIMP_EXPORT_NEEDS_ALPHA); + export = gimp_export_options_get_image (options, &image); drawables = gimp_image_list_layers (image); n_drawables = g_list_length (drawables); diff --git a/plug-ins/common/file-xpm.c b/plug-ins/common/file-xpm.c index 5e6faa9d9c..2576bf0256 100644 --- a/plug-ins/common/file-xpm.c +++ b/plug-ins/common/file-xpm.c @@ -115,6 +115,7 @@ static GimpValueArray * xpm_export (GimpProcedure *procedure, GimpRunMode run_mode, GimpImage *image, GFile *file, + GimpExportOptions *options, GimpMetadata *metadata, GimpProcedureConfig *config, gpointer run_data); @@ -197,16 +198,16 @@ xpm_create_procedure (GimpPlugIn *plug_in, gimp_procedure_set_menu_label (procedure, _("X PixMap image")); gimp_procedure_set_documentation (procedure, - "Load files in XPM (X11 Pixmap) format.", - "Load files in XPM (X11 Pixmap) format. " - "XPM is a portable image format " - "designed to be included in C source " - "code. XLib provides utility functions " - "to read this format. Newer code should " - "however be using gdk-pixbuf-csource " - "instead. XPM supports colored images, " - "unlike the XBM format which XPM was " - "designed to replace.", + _("Load files in XPM (X11 Pixmap) format."), + _("Load files in XPM (X11 Pixmap) format. " + "XPM is a portable image format " + "designed to be included in C source " + "code. XLib provides utility functions " + "to read this format. Newer code should " + "however be using gdk-pixbuf-csource " + "instead. XPM supports colored images, " + "unlike the XBM format which XPM was " + "designed to replace."), name); gimp_procedure_set_attribution (procedure, "Spencer Kimball & Peter Mattis & " @@ -232,16 +233,16 @@ xpm_create_procedure (GimpPlugIn *plug_in, gimp_procedure_set_menu_label (procedure, _("X PixMap image")); gimp_procedure_set_documentation (procedure, - "Export files in XPM (X11 Pixmap) format.", - "Export files in XPM (X11 Pixmap) format. " - "XPM is a portable image format " - "designed to be included in C source " - "code. XLib provides utility functions " - "to read this format. Newer code should " - "however be using gdk-pixbuf-csource " - "instead. XPM supports colored images, " - "unlike the XBM format which XPM was " - "designed to replace.", + _("Export files in XPM (X11 Pixmap) format."), + _("Export files in XPM (X11 Pixmap) format. " + "XPM is a portable image format " + "designed to be included in C source " + "code. XLib provides utility functions " + "to read this format. Newer code should " + "however be using gdk-pixbuf-csource " + "instead. XPM supports colored images, " + "unlike the XBM format which XPM was " + "designed to replace."), name); gimp_procedure_set_attribution (procedure, "Spencer Kimball & Peter Mattis & " @@ -256,6 +257,13 @@ xpm_create_procedure (GimpPlugIn *plug_in, gimp_file_procedure_set_extensions (GIMP_FILE_PROCEDURE (procedure), "xpm"); + gimp_export_procedure_set_capabilities (GIMP_EXPORT_PROCEDURE (procedure), + GIMP_EXPORT_CAN_HANDLE_RGB | + GIMP_EXPORT_CAN_HANDLE_GRAY | + GIMP_EXPORT_CAN_HANDLE_INDEXED | + GIMP_EXPORT_CAN_HANDLE_ALPHA, + NULL, NULL); + gimp_procedure_add_int_argument (procedure, "threshold", _("_Threshold"), _("Alpha threshold"), @@ -302,6 +310,7 @@ xpm_export (GimpProcedure *procedure, GimpRunMode run_mode, GimpImage *image, GFile *file, + GimpExportOptions *options, GimpMetadata *metadata, GimpProcedureConfig *config, gpointer run_data) @@ -313,17 +322,13 @@ xpm_export (GimpProcedure *procedure, gegl_init (NULL, NULL); - export = gimp_export_image (&image, - GIMP_EXPORT_CAN_HANDLE_RGB | - GIMP_EXPORT_CAN_HANDLE_GRAY | - GIMP_EXPORT_CAN_HANDLE_INDEXED | - GIMP_EXPORT_CAN_HANDLE_ALPHA); + export = gimp_export_options_get_image (options, &image); drawables = gimp_image_list_layers (image); if (run_mode == GIMP_RUN_INTERACTIVE) { gimp_ui_init (PLUG_IN_BINARY); - + if (gimp_drawable_has_alpha (drawables->data)) if (! save_dialog (image, procedure, G_OBJECT (config))) status = GIMP_PDB_CANCEL; diff --git a/plug-ins/common/file-xwd.c b/plug-ins/common/file-xwd.c index 9a2d1fcf85..92c3333e42 100644 --- a/plug-ins/common/file-xwd.c +++ b/plug-ins/common/file-xwd.c @@ -170,6 +170,7 @@ static GimpValueArray * xwd_export (GimpProcedure *procedure, GimpRunMode run_mode, GimpImage *image, GFile *file, + GimpExportOptions *options, GimpMetadata *metadata, GimpProcedureConfig *config, gpointer run_data); @@ -371,6 +372,12 @@ xwd_create_procedure (GimpPlugIn *plug_in, "image/x-xwindowdump"); gimp_file_procedure_set_extensions (GIMP_FILE_PROCEDURE (procedure), "xwd"); + + gimp_export_procedure_set_capabilities (GIMP_EXPORT_PROCEDURE (procedure), + GIMP_EXPORT_CAN_HANDLE_RGB | + GIMP_EXPORT_CAN_HANDLE_GRAY | + GIMP_EXPORT_CAN_HANDLE_INDEXED, + NULL, NULL); } return procedure; @@ -412,6 +419,7 @@ xwd_export (GimpProcedure *procedure, GimpRunMode run_mode, GimpImage *image, GFile *file, + GimpExportOptions *options, GimpMetadata *metadata, GimpProcedureConfig *config, gpointer run_data) @@ -423,10 +431,7 @@ xwd_export (GimpProcedure *procedure, gegl_init (NULL, NULL); - export = gimp_export_image (&image, - GIMP_EXPORT_CAN_HANDLE_RGB | - GIMP_EXPORT_CAN_HANDLE_GRAY | - GIMP_EXPORT_CAN_HANDLE_INDEXED); + export = gimp_export_options_get_image (options, &image); drawables = gimp_image_list_layers (image); if (! export_image (file, image, drawables->data, &error)) diff --git a/plug-ins/common/mail.c b/plug-ins/common/mail.c index 6a17140b52..316d43641b 100644 --- a/plug-ins/common/mail.c +++ b/plug-ins/common/mail.c @@ -289,7 +289,8 @@ send_image (GObject *config, GimpDrawable **drawables, gint32 run_mode) { - GimpPDBStatusType status = GIMP_PDB_SUCCESS; + GimpPDBStatusType status = GIMP_PDB_SUCCESS; + GimpExportOptions *options = NULL; gchar *ext; GFile *tmpfile; gchar *tmpname; @@ -329,7 +330,9 @@ send_image (GObject *config, tmpfile = gimp_temp_file (ext + 1); tmpname = g_file_get_path (tmpfile); - if (! (gimp_file_save (run_mode, image, tmpfile) && + options = gimp_export_options_new (); + + if (! (gimp_file_save (run_mode, image, tmpfile, options) && valid_file (tmpfile))) { goto error; diff --git a/plug-ins/file-bmp/bmp.c b/plug-ins/file-bmp/bmp.c index 7d809bf310..0f887dbf58 100644 --- a/plug-ins/file-bmp/bmp.c +++ b/plug-ins/file-bmp/bmp.c @@ -100,6 +100,7 @@ static GimpValueArray * bmp_export (GimpProcedure *procedure, GimpRunMode run_mode, GimpImage *image, GFile *file, + GimpExportOptions *options, GimpMetadata *metadata, GimpProcedureConfig *config, gpointer run_data); @@ -194,6 +195,13 @@ bmp_create_procedure (GimpPlugIn *plug_in, gimp_file_procedure_set_extensions (GIMP_FILE_PROCEDURE (procedure), "bmp"); + gimp_export_procedure_set_capabilities (GIMP_EXPORT_PROCEDURE (procedure), + GIMP_EXPORT_CAN_HANDLE_RGB | + GIMP_EXPORT_CAN_HANDLE_GRAY | + GIMP_EXPORT_CAN_HANDLE_ALPHA | + GIMP_EXPORT_CAN_HANDLE_INDEXED, + NULL, NULL); + gimp_procedure_add_boolean_argument (procedure, "use-rle", _("Ru_n-Length Encoded"), _("Use run-length-encoding compression " @@ -256,6 +264,7 @@ bmp_export (GimpProcedure *procedure, GimpRunMode run_mode, GimpImage *image, GFile *file, + GimpExportOptions *options, GimpMetadata *metadata, GimpProcedureConfig *config, gpointer run_data) @@ -270,11 +279,7 @@ bmp_export (GimpProcedure *procedure, if (run_mode == GIMP_RUN_INTERACTIVE) gimp_ui_init (PLUG_IN_BINARY); - export = gimp_export_image (&image, - GIMP_EXPORT_CAN_HANDLE_RGB | - GIMP_EXPORT_CAN_HANDLE_GRAY | - GIMP_EXPORT_CAN_HANDLE_ALPHA | - GIMP_EXPORT_CAN_HANDLE_INDEXED); + export = gimp_export_options_get_image (options, &image); drawables = gimp_image_list_layers (image); status = export_image (file, image, drawables->data, run_mode, diff --git a/plug-ins/file-dds/dds.c b/plug-ins/file-dds/dds.c index 6cc7419dd4..937a530831 100644 --- a/plug-ins/file-dds/dds.c +++ b/plug-ins/file-dds/dds.c @@ -77,6 +77,7 @@ static GimpValueArray * dds_export (GimpProcedure *procedure, GimpRunMode run_mode, GimpImage *image, GFile *file, + GimpExportOptions *options, GimpMetadata *metadata, GimpProcedureConfig *config, gpointer run_data); @@ -183,6 +184,14 @@ dds_create_procedure (GimpPlugIn *plug_in, gimp_file_procedure_set_extensions (GIMP_FILE_PROCEDURE (procedure), "dds"); + gimp_export_procedure_set_capabilities (GIMP_EXPORT_PROCEDURE (procedure), + GIMP_EXPORT_CAN_HANDLE_RGB | + GIMP_EXPORT_CAN_HANDLE_GRAY | + GIMP_EXPORT_CAN_HANDLE_INDEXED | + GIMP_EXPORT_CAN_HANDLE_ALPHA | + GIMP_EXPORT_CAN_HANDLE_LAYERS, + NULL, NULL); + gimp_procedure_add_choice_argument (procedure, "compression-format", _("Compressio_n"), _("Compression format"), @@ -370,6 +379,7 @@ dds_export (GimpProcedure *procedure, GimpRunMode run_mode, GimpImage *image, GFile *file, + GimpExportOptions *options, GimpMetadata *metadata, GimpProcedureConfig *config, gpointer run_data) @@ -385,12 +395,7 @@ dds_export (GimpProcedure *procedure, if (run_mode == GIMP_RUN_INTERACTIVE) gimp_ui_init ("dds"); - export = gimp_export_image (&image, - GIMP_EXPORT_CAN_HANDLE_RGB | - GIMP_EXPORT_CAN_HANDLE_GRAY | - GIMP_EXPORT_CAN_HANDLE_INDEXED | - GIMP_EXPORT_CAN_HANDLE_ALPHA | - GIMP_EXPORT_CAN_HANDLE_LAYERS); + export = gimp_export_options_get_image (options, &image); drawables = gimp_image_list_layers (image); g_object_get (config, diff --git a/plug-ins/file-fits/fits.c b/plug-ins/file-fits/fits.c index 6ccfafff80..007cf14d78 100644 --- a/plug-ins/file-fits/fits.c +++ b/plug-ins/file-fits/fits.c @@ -98,6 +98,7 @@ static GimpValueArray * fits_export (GimpProcedure *procedure, GimpRunMode run_mode, GimpImage *image, GFile *file, + GimpExportOptions *options, GimpMetadata *metadata, GimpProcedureConfig *config, gpointer run_data); @@ -239,6 +240,12 @@ fits_create_procedure (GimpPlugIn *plug_in, "image/x-fits"); gimp_file_procedure_set_extensions (GIMP_FILE_PROCEDURE (procedure), "fit,fits"); + + gimp_export_procedure_set_capabilities (GIMP_EXPORT_PROCEDURE (procedure), + GIMP_EXPORT_CAN_HANDLE_RGB | + GIMP_EXPORT_CAN_HANDLE_GRAY | + GIMP_EXPORT_CAN_HANDLE_INDEXED, + NULL, NULL); } return procedure; @@ -288,6 +295,7 @@ fits_export (GimpProcedure *procedure, GimpRunMode run_mode, GimpImage *image, GFile *file, + GimpExportOptions *options, GimpMetadata *metadata, GimpProcedureConfig *config, gpointer run_data) @@ -305,10 +313,7 @@ fits_export (GimpProcedure *procedure, if (run_mode == GIMP_RUN_INTERACTIVE) gimp_ui_init (PLUG_IN_BINARY); - export = gimp_export_image (&image, - GIMP_EXPORT_CAN_HANDLE_RGB | - GIMP_EXPORT_CAN_HANDLE_GRAY | - GIMP_EXPORT_CAN_HANDLE_INDEXED); + export = gimp_export_options_get_image (options, &image); drawables = gimp_image_list_layers (image); n_drawables = g_list_length (drawables); diff --git a/plug-ins/file-fli/fli-gimp.c b/plug-ins/file-fli/fli-gimp.c index 12053ac801..e392110c0b 100644 --- a/plug-ins/file-fli/fli-gimp.c +++ b/plug-ins/file-fli/fli-gimp.c @@ -105,6 +105,7 @@ static GimpValueArray * fli_export (GimpProcedure *procedure, GimpRunMode run_mode, GimpImage *image, GFile *file, + GimpExportOptions *options, GimpMetadata *metadata, GimpProcedureConfig *config, gpointer run_data); @@ -234,6 +235,13 @@ fli_create_procedure (GimpPlugIn *plug_in, gimp_file_procedure_set_extensions (GIMP_FILE_PROCEDURE (procedure), "fli,flc"); + gimp_export_procedure_set_capabilities (GIMP_EXPORT_PROCEDURE (procedure), + GIMP_EXPORT_CAN_HANDLE_INDEXED | + GIMP_EXPORT_CAN_HANDLE_GRAY | + GIMP_EXPORT_CAN_HANDLE_ALPHA | + GIMP_EXPORT_CAN_HANDLE_LAYERS, + NULL, NULL); + gimp_procedure_add_int_argument (procedure, "from-frame", _("_From frame"), _("Export beginning from this frame"), @@ -334,6 +342,7 @@ fli_export (GimpProcedure *procedure, GimpRunMode run_mode, GimpImage *image, GFile *file, + GimpExportOptions *options, GimpMetadata *metadata, GimpProcedureConfig *config, gpointer run_data) @@ -353,11 +362,7 @@ fli_export (GimpProcedure *procedure, status = GIMP_PDB_CANCEL; } - export = gimp_export_image (&image, - GIMP_EXPORT_CAN_HANDLE_INDEXED | - GIMP_EXPORT_CAN_HANDLE_GRAY | - GIMP_EXPORT_CAN_HANDLE_ALPHA | - GIMP_EXPORT_CAN_HANDLE_LAYERS); + export = gimp_export_options_get_image (options, &image); drawables = gimp_image_list_layers (image); if (status == GIMP_PDB_SUCCESS) diff --git a/plug-ins/file-icns/file-icns-export.c b/plug-ins/file-icns/file-icns-export.c index 2046d06b62..48c7ad1d04 100644 --- a/plug-ins/file-icns/file-icns-export.c +++ b/plug-ins/file-icns/file-icns-export.c @@ -460,14 +460,15 @@ icns_export_image (GFile *file, /* MacOS X format icons */ if (match != -1 && duplicates[match] == 0) { - GimpProcedure *procedure; - GimpValueArray *return_vals; - GimpImage *temp_image; - GimpLayer *temp_layer; - GFile *temp_file = NULL; - FILE *temp_fp; - gint temp_size; - gint macos_size; + GimpProcedure *procedure; + GimpValueArray *return_vals; + GimpImage *temp_image; + GimpLayer *temp_layer; + GFile *temp_file = NULL; + GimpExportOptions *options = gimp_export_options_new (); + FILE *temp_fp; + gint temp_size; + gint macos_size; temp_file = gimp_temp_file ("png"); @@ -483,6 +484,7 @@ icns_export_image (GFile *file, "run-mode", GIMP_RUN_NONINTERACTIVE, "image", temp_image, "file", temp_file, + "options", options, "interlaced", FALSE, "compression", 9, "bkgd", FALSE, diff --git a/plug-ins/file-icns/file-icns.c b/plug-ins/file-icns/file-icns.c index ff4fd8095e..7a112eaee0 100644 --- a/plug-ins/file-icns/file-icns.c +++ b/plug-ins/file-icns/file-icns.c @@ -80,6 +80,7 @@ static GimpValueArray * icns_export (GimpProcedure *procedure, GimpRunMode run_mode, GimpImage *image, GFile *file, + GimpExportOptions *options, GimpMetadata *metadata, GimpProcedureConfig *config, gpointer run_data); @@ -271,6 +272,7 @@ icns_export (GimpProcedure *procedure, GimpRunMode run_mode, GimpImage *image, GFile *file, + GimpExportOptions *options, GimpMetadata *metadata, GimpProcedureConfig *config, gpointer run_data) diff --git a/plug-ins/file-ico/ico.c b/plug-ins/file-ico/ico.c index c3ed31bf05..e0dfd1adf4 100644 --- a/plug-ins/file-ico/ico.c +++ b/plug-ins/file-ico/ico.c @@ -97,6 +97,7 @@ static GimpValueArray * ico_export (GimpProcedure *procedure, GimpRunMode run_mode, GimpImage *image, GFile *file, + GimpExportOptions *options, GimpMetadata *metadata, GimpProcedureConfig *config, gpointer run_data); @@ -104,6 +105,7 @@ static GimpValueArray * cur_export (GimpProcedure *procedure, GimpRunMode run_mode, GimpImage *image, GFile *file, + GimpExportOptions *options, GimpMetadata *metadata, GimpProcedureConfig *config, gpointer run_data); @@ -111,6 +113,7 @@ static GimpValueArray * ani_export (GimpProcedure *procedure, GimpRunMode run_mode, GimpImage *image, GFile *file, + GimpExportOptions *options, GimpMetadata *metadata, GimpProcedureConfig *config, gpointer run_data); @@ -575,6 +578,7 @@ ico_export (GimpProcedure *procedure, GimpRunMode run_mode, GimpImage *image, GFile *file, + GimpExportOptions *options, GimpMetadata *metadata, GimpProcedureConfig *config, gpointer run_data) @@ -594,6 +598,7 @@ cur_export (GimpProcedure *procedure, GimpRunMode run_mode, GimpImage *image, GFile *file, + GimpExportOptions *options, GimpMetadata *metadata, GimpProcedureConfig *config, gpointer run_data) @@ -643,7 +648,8 @@ ani_export (GimpProcedure *procedure, GimpRunMode run_mode, GimpImage *image, GFile *file, - GimpMetadata *metadata, + GimpExportOptions *options, + GimpMetadata *metadata, GimpProcedureConfig *config, gpointer run_data) { diff --git a/plug-ins/file-jpeg/jpeg.c b/plug-ins/file-jpeg/jpeg.c index eec22cca20..dd031bb2db 100644 --- a/plug-ins/file-jpeg/jpeg.c +++ b/plug-ins/file-jpeg/jpeg.c @@ -74,6 +74,7 @@ static GimpValueArray * jpeg_export (GimpProcedure *procedure, GimpRunMode run_mode, GimpImage *image, GFile *file, + GimpExportOptions *options, GimpMetadata *metadata, GimpProcedureConfig *config, gpointer run_data); @@ -197,6 +198,11 @@ jpeg_create_procedure (GimpPlugIn *plug_in, gimp_file_procedure_set_extensions (GIMP_FILE_PROCEDURE (procedure), "jpg,jpeg,jpe"); + gimp_export_procedure_set_capabilities (GIMP_EXPORT_PROCEDURE (procedure), + GIMP_EXPORT_CAN_HANDLE_RGB | + GIMP_EXPORT_CAN_HANDLE_GRAY, + NULL, NULL); + /* See bugs #63610 and #61088 for a discussion about the quality * settings */ @@ -415,6 +421,7 @@ jpeg_export (GimpProcedure *procedure, GimpRunMode run_mode, GimpImage *image, GFile *file, + GimpExportOptions *options, GimpMetadata *metadata, GimpProcedureConfig *config, gpointer run_data) @@ -518,9 +525,7 @@ jpeg_export (GimpProcedure *procedure, "original-num-quant-tables", orig_num_quant_tables, NULL); - export = gimp_export_image (&image, - GIMP_EXPORT_CAN_HANDLE_RGB | - GIMP_EXPORT_CAN_HANDLE_GRAY); + export = gimp_export_options_get_image (options, &image); drawables = gimp_image_list_layers (image); if (run_mode == GIMP_RUN_INTERACTIVE) diff --git a/plug-ins/file-psd/psd.c b/plug-ins/file-psd/psd.c index 6cd191927b..42b782572a 100644 --- a/plug-ins/file-psd/psd.c +++ b/plug-ins/file-psd/psd.c @@ -72,6 +72,7 @@ static GimpValueArray * psd_export (GimpProcedure *procedure, GimpRunMode run_mode, GimpImage *image, GFile *file, + GimpExportOptions *options, GimpMetadata *metadata, GimpProcedureConfig *config, gpointer run_data); @@ -134,10 +135,10 @@ psd_create_procedure (GimpPlugIn *plug_in, gimp_procedure_set_menu_label (procedure, _("Photoshop image")); gimp_procedure_set_documentation (procedure, - "Loads images from the Photoshop " - "PSD and PSB file formats", - "This plug-in loads images in Adobe " - "Photoshop (TM) native PSD and PSB format.", + _("Loads images from the Photoshop " + "PSD and PSB file formats"), + _("This plug-in loads images in Adobe " + "Photoshop (TM) native PSD and PSB format."), name); gimp_procedure_set_attribution (procedure, "John Marshall", @@ -163,11 +164,11 @@ psd_create_procedure (GimpPlugIn *plug_in, gimp_procedure_set_menu_label (procedure, _("Photoshop image (merged)")); gimp_procedure_set_documentation (procedure, - "Loads images from the Photoshop " - "PSD and PSB file formats", - "This plug-in loads the merged image " - "data in Adobe Photoshop (TM) native " - "PSD and PSB format.", + _("Loads images from the Photoshop " + "PSD and PSB file formats"), + _("This plug-in loads the merged image " + "data in Adobe Photoshop (TM) native " + "PSD and PSB format."), name); gimp_procedure_set_attribution (procedure, "Ell", @@ -192,11 +193,11 @@ psd_create_procedure (GimpPlugIn *plug_in, psd_load_thumb, NULL, NULL); gimp_procedure_set_documentation (procedure, - "Loads thumbnails from the " - "Photoshop PSD file format", - "This plug-in loads thumbnail images " - "from Adobe Photoshop (TM) native " - "PSD format files.", + _("Loads thumbnails from the " + "Photoshop PSD file format"), + _("This plug-in loads thumbnail images " + "from Adobe Photoshop (TM) native " + "PSD format files."), name); gimp_procedure_set_attribution (procedure, "John Marshall", @@ -214,14 +215,14 @@ psd_create_procedure (GimpPlugIn *plug_in, gimp_procedure_set_menu_label (procedure, _("Photoshop image")); gimp_procedure_set_documentation (procedure, - "Saves files in the Photoshop(tm) " - "PSD file format", - "This filter saves files of Adobe " - "Photoshop(tm) native PSD format. " - "These files may be of any image type " - "supported by GIMP, with or without " - "layers, layer masks, aux channels " - "and guides.", + _("Saves files in the Photoshop (TM) " + "PSD file format"), + _("This filter saves files of Adobe " + "Photoshop (TM) native PSD format. " + "These files may be of any image type " + "supported by GIMP, with or without " + "layers, layer masks, aux channels " + "and guides."), name); gimp_procedure_set_attribution (procedure, "Monigotes", @@ -233,6 +234,15 @@ psd_create_procedure (GimpPlugIn *plug_in, gimp_file_procedure_set_extensions (GIMP_FILE_PROCEDURE (procedure), "psd"); + gimp_export_procedure_set_capabilities (GIMP_EXPORT_PROCEDURE (procedure), + GIMP_EXPORT_CAN_HANDLE_RGB | + GIMP_EXPORT_CAN_HANDLE_GRAY | + GIMP_EXPORT_CAN_HANDLE_INDEXED | + GIMP_EXPORT_CAN_HANDLE_ALPHA | + GIMP_EXPORT_CAN_HANDLE_LAYERS | + GIMP_EXPORT_CAN_HANDLE_LAYER_MASKS, + NULL, NULL); + gimp_procedure_add_boolean_argument (procedure, "clippingpath", _("Assign a Clipping _Path"), _("Select a path to be the " @@ -421,6 +431,7 @@ psd_export (GimpProcedure *procedure, GimpRunMode run_mode, GimpImage *image, GFile *file, + GimpExportOptions *options, GimpMetadata *metadata, GimpProcedureConfig *config, gpointer run_data) @@ -441,13 +452,7 @@ psd_export (GimpProcedure *procedure, NULL); } - export = gimp_export_image (&image, - GIMP_EXPORT_CAN_HANDLE_RGB | - GIMP_EXPORT_CAN_HANDLE_GRAY | - GIMP_EXPORT_CAN_HANDLE_INDEXED | - GIMP_EXPORT_CAN_HANDLE_ALPHA | - GIMP_EXPORT_CAN_HANDLE_LAYERS | - GIMP_EXPORT_CAN_HANDLE_LAYER_MASKS); + export = gimp_export_options_get_image (options, &image); drawables = gimp_image_list_layers (image); if (export_image (file, image, G_OBJECT (config), &error)) diff --git a/plug-ins/file-sgi/sgi.c b/plug-ins/file-sgi/sgi.c index 8395e21741..44f547aa25 100644 --- a/plug-ins/file-sgi/sgi.c +++ b/plug-ins/file-sgi/sgi.c @@ -80,6 +80,7 @@ static GimpValueArray * sgi_export (GimpProcedure *procedure, GimpRunMode run_mode, GimpImage *image, GFile *file, + GimpExportOptions *options, GimpMetadata *metadata, GimpProcedureConfig *config, gpointer run_data); @@ -188,6 +189,13 @@ sgi_create_procedure (GimpPlugIn *plug_in, gimp_file_procedure_set_extensions (GIMP_FILE_PROCEDURE (procedure), "sgi,rgb,rgba,bw,icon"); + gimp_export_procedure_set_capabilities (GIMP_EXPORT_PROCEDURE (procedure), + GIMP_EXPORT_CAN_HANDLE_RGB | + GIMP_EXPORT_CAN_HANDLE_GRAY | + GIMP_EXPORT_CAN_HANDLE_INDEXED | + GIMP_EXPORT_CAN_HANDLE_ALPHA, + NULL, NULL); + gimp_procedure_add_int_argument (procedure, "compression", _("Compression _type"), _("Compression level (0 = none, 1 = RLE, 2 = ARLE)"), @@ -234,6 +242,7 @@ sgi_export (GimpProcedure *procedure, GimpRunMode run_mode, GimpImage *image, GFile *file, + GimpExportOptions *options, GimpMetadata *metadata, GimpProcedureConfig *config, gpointer run_data) @@ -253,11 +262,7 @@ sgi_export (GimpProcedure *procedure, status = GIMP_PDB_CANCEL; } - export = gimp_export_image (&image, - GIMP_EXPORT_CAN_HANDLE_RGB | - GIMP_EXPORT_CAN_HANDLE_GRAY | - GIMP_EXPORT_CAN_HANDLE_INDEXED | - GIMP_EXPORT_CAN_HANDLE_ALPHA); + export = gimp_export_options_get_image (options, &image); drawables = gimp_image_list_layers (image); if (status == GIMP_PDB_SUCCESS) diff --git a/plug-ins/file-tiff/file-tiff.c b/plug-ins/file-tiff/file-tiff.c index aeae08dba5..d7cc27ca0d 100644 --- a/plug-ins/file-tiff/file-tiff.c +++ b/plug-ins/file-tiff/file-tiff.c @@ -95,6 +95,7 @@ static GimpValueArray * tiff_export (GimpProcedure *procedure GimpRunMode run_mode, GimpImage *image, GFile *file, + GimpExportOptions *options, GimpMetadata *metadata, GimpProcedureConfig *config, gpointer run_data); @@ -103,9 +104,14 @@ static GimpPDBStatusType tiff_export_rec (GimpProcedure *procedure GimpImage *orig_image, GFile *file, GimpProcedureConfig *config, + GimpExportOptions *options, GimpMetadata *metadata, gboolean retried, GError **error); +static void export_edit_options (GimpProcedure *procedure, + GimpProcedureConfig *config, + GimpExportOptions *options, + gpointer create_data); static gboolean image_is_monochrome (GimpImage *image); static gboolean image_is_multi_layer (GimpImage *image); @@ -223,6 +229,11 @@ tiff_create_procedure (GimpPlugIn *plug_in, gimp_file_procedure_set_extensions (GIMP_FILE_PROCEDURE (procedure), "tif,tiff"); + /* TIFF capabilities are so dependent on export settings, we can't assign + * defaults until we know how the user wants to export it */ + gimp_export_procedure_set_capabilities (GIMP_EXPORT_PROCEDURE (procedure), + 0, export_edit_options, NULL); + gimp_procedure_add_boolean_argument (procedure, "bigtiff", _("Export in _BigTIFF variant file format"), _("The BigTIFF variant file format uses 64-bit offsets, " @@ -339,6 +350,7 @@ tiff_export (GimpProcedure *procedure, GimpRunMode run_mode, GimpImage *image, GFile *file, + GimpExportOptions *options, GimpMetadata *metadata, GimpProcedureConfig *config, gpointer run_data) @@ -358,8 +370,8 @@ tiff_export (GimpProcedure *procedure, break; } - status = tiff_export_rec (procedure, run_mode, image, - file, config, metadata, FALSE, &error); + status = tiff_export_rec (procedure, run_mode, image, file, + config, options, metadata, FALSE, &error); return gimp_procedure_new_return_values (procedure, status, error); } @@ -370,6 +382,7 @@ tiff_export_rec (GimpProcedure *procedure, GimpImage *orig_image, GFile *file, GimpProcedureConfig *config, + GimpExportOptions *options, GimpMetadata *metadata, gboolean retried, GError **error) @@ -396,43 +409,9 @@ tiff_export_rec (GimpProcedure *procedure, if (status == GIMP_PDB_SUCCESS) { - GimpExportCapabilities capabilities; - GimpCompression compression; - gboolean save_layers; - gboolean crop_layers; + g_object_get (config, "bigtiff", &bigtiff, NULL); - g_object_get (config, - "bigtiff", &bigtiff, - "save-layers", &save_layers, - "crop-layers", &crop_layers, - NULL); - compression = gimp_procedure_config_get_choice_id (config, "compression"); - - if (compression == GIMP_COMPRESSION_CCITTFAX3 || - compression == GIMP_COMPRESSION_CCITTFAX4) - { - /* G3/G4 are fax compressions. They only support - * monochrome images without alpha support. - */ - capabilities = GIMP_EXPORT_CAN_HANDLE_INDEXED; - } - else - { - capabilities = (GIMP_EXPORT_CAN_HANDLE_RGB | - GIMP_EXPORT_CAN_HANDLE_GRAY | - GIMP_EXPORT_CAN_HANDLE_INDEXED | - GIMP_EXPORT_CAN_HANDLE_ALPHA); - } - - if (save_layers && image_is_multi_layer (orig_image)) - { - capabilities |= GIMP_EXPORT_CAN_HANDLE_LAYERS; - - if (crop_layers) - capabilities |= GIMP_EXPORT_NEEDS_CROP; - } - - export = gimp_export_image (&image, capabilities); + export = gimp_export_options_get_image (options, &image); } drawables = gimp_image_list_layers (image); @@ -466,13 +445,59 @@ tiff_export_rec (GimpProcedure *procedure, tiff_reset_file_size_error (); g_clear_error (error); - return tiff_export_rec (procedure, run_mode, orig_image, - file, config, metadata, TRUE, error); + return tiff_export_rec (procedure, run_mode, orig_image, file, + config, options, metadata, TRUE, error); } return status; } +static void +export_edit_options (GimpProcedure *procedure, + GimpProcedureConfig *config, + GimpExportOptions *options, + gpointer create_data) +{ + GimpExportCapabilities capabilities; + GimpCompression compression; + gboolean save_layers; + gboolean crop_layers; + + g_object_get (config, + "save-layers", &save_layers, + "crop-layers", &crop_layers, + NULL); + compression = gimp_procedure_config_get_choice_id (config, "compression"); + + if (compression == GIMP_COMPRESSION_CCITTFAX3 || + compression == GIMP_COMPRESSION_CCITTFAX4) + { + /* G3/G4 are fax compressions. They only support + * monochrome images without alpha support. + */ + capabilities = GIMP_EXPORT_CAN_HANDLE_INDEXED; + } + else + { + capabilities = (GIMP_EXPORT_CAN_HANDLE_RGB | + GIMP_EXPORT_CAN_HANDLE_GRAY | + GIMP_EXPORT_CAN_HANDLE_INDEXED | + GIMP_EXPORT_CAN_HANDLE_ALPHA); + } + + if (save_layers) + { + capabilities |= GIMP_EXPORT_CAN_HANDLE_LAYERS; + + if (crop_layers) + capabilities |= GIMP_EXPORT_NEEDS_CROP; + } + + g_object_set (G_OBJECT (options), + "capabilities", capabilities, + NULL); +} + static gboolean image_is_monochrome (GimpImage *image) { diff --git a/plug-ins/file-webp/file-webp.c b/plug-ins/file-webp/file-webp.c index 4ac934dcb2..03dbe87fd7 100644 --- a/plug-ins/file-webp/file-webp.c +++ b/plug-ins/file-webp/file-webp.c @@ -70,10 +70,15 @@ static GimpValueArray * webp_export (GimpProcedure *procedure, GimpRunMode run_mode, GimpImage *image, GFile *file, + GimpExportOptions *options, GimpMetadata *metadata, GimpProcedureConfig *config, gpointer run_data); +static void export_edit_options (GimpProcedure *procedure, + GimpProcedureConfig *config, + GimpExportOptions *options, + gpointer create_data); G_DEFINE_TYPE (Webp, webp, GIMP_TYPE_PLUG_IN) @@ -165,6 +170,13 @@ webp_create_procedure (GimpPlugIn *plug_in, gimp_file_procedure_set_extensions (GIMP_FILE_PROCEDURE (procedure), "webp"); + gimp_export_procedure_set_capabilities (GIMP_EXPORT_PROCEDURE (procedure), + GIMP_EXPORT_CAN_HANDLE_RGB | + GIMP_EXPORT_CAN_HANDLE_GRAY | + GIMP_EXPORT_CAN_HANDLE_INDEXED | + GIMP_EXPORT_CAN_HANDLE_ALPHA, + export_edit_options, NULL); + gimp_procedure_add_int_argument (procedure, "preset", _("Source _type"), _("WebP encoder preset (Default=0, Picture=1, Photo=2, Drawing=3, " @@ -282,6 +294,7 @@ webp_export (GimpProcedure *procedure, GimpRunMode run_mode, GimpImage *image, GFile *file, + GimpExportOptions *options, GimpMetadata *metadata, GimpProcedureConfig *config, gpointer run_data) @@ -295,11 +308,10 @@ webp_export (GimpProcedure *procedure, gegl_init (NULL, NULL); - if (run_mode == GIMP_RUN_INTERACTIVE) - gimp_ui_init (PLUG_IN_BINARY); - if (run_mode == GIMP_RUN_INTERACTIVE) { + gimp_ui_init (PLUG_IN_BINARY); + if (! save_dialog (image, procedure, G_OBJECT (config))) return gimp_procedure_new_return_values (procedure, GIMP_PDB_CANCEL, @@ -311,17 +323,8 @@ webp_export (GimpProcedure *procedure, NULL); if (status == GIMP_PDB_SUCCESS) - { - GimpExportCapabilities capabilities = (GIMP_EXPORT_CAN_HANDLE_RGB | - GIMP_EXPORT_CAN_HANDLE_GRAY | - GIMP_EXPORT_CAN_HANDLE_INDEXED | - GIMP_EXPORT_CAN_HANDLE_ALPHA); + export = gimp_export_options_get_image (options, &image); - if (animation) - capabilities |= GIMP_EXPORT_CAN_HANDLE_LAYERS_AS_ANIMATION; - - export = gimp_export_image (&image, capabilities); - } drawables = gimp_image_list_layers (image); n_drawables = g_list_length (drawables); @@ -363,3 +366,29 @@ webp_export (GimpProcedure *procedure, g_list_free (drawables); return gimp_procedure_new_return_values (procedure, status, error); } + +static void +export_edit_options (GimpProcedure *procedure, + GimpProcedureConfig *config, + GimpExportOptions *options, + gpointer create_data) +{ + GimpExportCapabilities capabilities; + gboolean animation; + + g_object_get (G_OBJECT (config), + "animation", &animation, + NULL); + + capabilities = (GIMP_EXPORT_CAN_HANDLE_RGB | + GIMP_EXPORT_CAN_HANDLE_GRAY | + GIMP_EXPORT_CAN_HANDLE_INDEXED | + GIMP_EXPORT_CAN_HANDLE_ALPHA); + + if (animation) + capabilities |= GIMP_EXPORT_CAN_HANDLE_LAYERS_AS_ANIMATION; + + g_object_set (G_OBJECT (options), + "capabilities", capabilities, + NULL); +} diff --git a/plug-ins/python/colorxhtml.py b/plug-ins/python/colorxhtml.py index 179cd6fa20..8aee23b8f9 100755 --- a/plug-ins/python/colorxhtml.py +++ b/plug-ins/python/colorxhtml.py @@ -62,7 +62,7 @@ preamble = """ postamble = """\n\n\n\n""" -def export_colorxhtml(procedure, run_mode, image, file, metadata, config, data): +def export_colorxhtml(procedure, run_mode, image, file, options, metadata, config, data): if file is None: error = 'No file given' return procedure.new_return_values(Gimp.PDBStatusType.CALLING_ERROR, diff --git a/plug-ins/python/file-openraster.py b/plug-ins/python/file-openraster.py index 0a5baa1c41..604b291286 100755 --- a/plug-ins/python/file-openraster.py +++ b/plug-ins/python/file-openraster.py @@ -188,7 +188,7 @@ def thumbnail_ora(procedure, file, thumb_size, args, data): else: return procedure.new_return_values(result.index(0), GLib.Error(result.index(1))) -def export_ora(procedure, run_mode, image, file, metadata, config, data): +def export_ora(procedure, run_mode, image, file, options, metadata, config, data): def write_file_str(zfile, fname, data): # work around a permission bug in the zipfile library: # http://bugs.python.org/issue3394 @@ -216,7 +216,6 @@ def export_ora(procedure, run_mode, image, file, metadata, config, data): tmp = os.path.join(tempdir, 'tmp.png') interlace, compression = 0, 2 - #TODO: Use GimpExportOptions for this once available width, height = drawable.get_width(), drawable.get_height() tmp_img = Gimp.Image.new(width, height, image.get_base_type()) tmp_layer = Gimp.Layer.new_from_drawable (drawable, tmp_img) @@ -227,6 +226,7 @@ def export_ora(procedure, run_mode, image, file, metadata, config, data): pdb_config.set_property('run-mode', Gimp.RunMode.NONINTERACTIVE) pdb_config.set_property('image', tmp_img) pdb_config.set_property('file', Gio.File.new_for_path(tmp)) + pdb_config.set_property('options', None) pdb_config.set_property('interlaced', interlace) pdb_config.set_property('compression', compression) # write all PNG chunks except oFFs(ets)