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

libgimp: GimpSaveProcedure to GimpExportProcedure

Browse source 
This patch continues porting save API to
export for the 3.0 release.
This commit is contained in:
Alx Sa 2024-04-20 03:08:57 +00:00
parent 62ab8e2604
commit a0d040bddc
66 changed files with 801 additions and 801 deletions
Download patch file Download diff file Expand all files Collapse all files

28
libgimp/gimp.def
View file

@ -270,6 +270,20 @@ EXPORTS
gimp_export_comment gimp_export_comment
gimp_export_exif gimp_export_exif
gimp_export_iptc gimp_export_iptc
gimp_export_procedure_get_support_comment
gimp_export_procedure_get_support_exif
gimp_export_procedure_get_support_iptc
gimp_export_procedure_get_support_profile
gimp_export_procedure_get_support_thumbnail
gimp_export_procedure_get_support_xmp
gimp_export_procedure_get_type
gimp_export_procedure_new
gimp_export_procedure_set_support_comment
gimp_export_procedure_set_support_exif
gimp_export_procedure_set_support_iptc
gimp_export_procedure_set_support_profile
gimp_export_procedure_set_support_thumbnail
gimp_export_procedure_set_support_xmp
gimp_export_thumbnail gimp_export_thumbnail
gimp_export_xmp gimp_export_xmp
gimp_file_load gimp_file_load
@ -810,20 +824,6 @@ EXPORTS
gimp_resource_rename gimp_resource_rename
gimp_resource_select_new gimp_resource_select_new
gimp_resource_select_set gimp_resource_select_set
gimp_save_procedure_get_support_comment
gimp_save_procedure_get_support_exif
gimp_save_procedure_get_support_iptc
gimp_save_procedure_get_support_profile
gimp_save_procedure_get_support_thumbnail
gimp_save_procedure_get_support_xmp
gimp_save_procedure_get_type
gimp_save_procedure_new
gimp_save_procedure_set_support_comment
gimp_save_procedure_set_support_exif
gimp_save_procedure_set_support_iptc
gimp_save_procedure_set_support_profile
gimp_save_procedure_set_support_thumbnail
gimp_save_procedure_set_support_xmp
gimp_selection_all gimp_selection_all
gimp_selection_border gimp_selection_border
gimp_selection_bounds gimp_selection_bounds

2
libgimp/gimp.h
View file

@ -42,6 +42,7 @@
#include <libgimp/gimpchannel.h> #include <libgimp/gimpchannel.h>
#include <libgimp/gimpdisplay.h> #include <libgimp/gimpdisplay.h>
#include <libgimp/gimpdrawable.h> #include <libgimp/gimpdrawable.h>
#include <libgimp/gimpexportprocedure.h>
#include <libgimp/gimpfont.h> #include <libgimp/gimpfont.h>
#include <libgimp/gimpgimprc.h> #include <libgimp/gimpgimprc.h>
#include <libgimp/gimpgradient.h> #include <libgimp/gimpgradient.h>
@ -62,7 +63,6 @@
#include <libgimp/gimpprocedure-params.h> #include <libgimp/gimpprocedure-params.h>
#include <libgimp/gimpprogress.h> #include <libgimp/gimpprogress.h>
#include <libgimp/gimpresource.h> #include <libgimp/gimpresource.h>
#include <libgimp/gimpsaveprocedure.h>
#include <libgimp/gimpselection.h> #include <libgimp/gimpselection.h>
#include <libgimp/gimptextlayer.h> #include <libgimp/gimptextlayer.h>
#include <libgimp/gimpthumbnailprocedure.h> #include <libgimp/gimpthumbnailprocedure.h>

298
libgimp/gimpsaveprocedure.c → libgimp/gimpexportprocedure.c
View file

@ -1,7 +1,7 @@
/* GIMP - The GNU Image Manipulation Program /* GIMP - The GNU Image Manipulation Program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis * Copyright (C) 1995 Spencer Kimball and Peter Mattis
* *
* gimpsaveprocedure.c * gimpexportprocedure.c
* Copyright (C) 2019 Michael Natterer <mitch@gimp.org> * Copyright (C) 2019 Michael Natterer <mitch@gimp.org>
* *
* This program is free software: you can redistribute it and/or modify * This program is free software: you can redistribute it and/or modify
@ -26,7 +26,7 @@
#include "gimppdb_pdb.h" #include "gimppdb_pdb.h"
#include "gimpplugin-private.h" #include "gimpplugin-private.h"
#include "gimpsaveprocedure.h" #include "gimpexportprocedure.h"
#include "gimpprocedureconfig-private.h" #include "gimpprocedureconfig-private.h"
#include "libgimp-intl.h" #include "libgimp-intl.h"
@ -43,9 +43,9 @@ enum
N_PROPS N_PROPS
}; };
struct _GimpSaveProcedurePrivate struct _GimpExportProcedurePrivate
{ {
GimpRunSaveFunc run_func; GimpRunExportFunc run_func;
gpointer run_data; gpointer run_data;
GDestroyNotify run_data_destroy; GDestroyNotify run_data_destroy;
@ -60,55 +60,55 @@ struct _GimpSaveProcedurePrivate
}; };
static void gimp_save_procedure_constructed (GObject *object); static void gimp_export_procedure_constructed (GObject *object);
static void gimp_save_procedure_finalize (GObject *object); static void gimp_export_procedure_finalize (GObject *object);
static void gimp_save_procedure_set_property (GObject *object, static void gimp_export_procedure_set_property (GObject *object,
guint property_id, guint property_id,
const GValue *value, const GValue *value,
GParamSpec *pspec); GParamSpec *pspec);
static void gimp_save_procedure_get_property (GObject *object, static void gimp_export_procedure_get_property (GObject *object,
guint property_id, guint property_id,
GValue *value, GValue *value,
GParamSpec *pspec); GParamSpec *pspec);
static void gimp_save_procedure_install (GimpProcedure *procedure); static void gimp_export_procedure_install (GimpProcedure *procedure);
static GimpValueArray * static GimpValueArray *
gimp_save_procedure_run (GimpProcedure *procedure, gimp_export_procedure_run (GimpProcedure *procedure,
const GimpValueArray *args); const GimpValueArray *args);
static GimpProcedureConfig * static GimpProcedureConfig *
gimp_save_procedure_create_config (GimpProcedure *procedure, gimp_export_procedure_create_config (GimpProcedure *procedure,
GParamSpec **args, GParamSpec **args,
gint n_args); gint n_args);
static void gimp_save_procedure_add_metadata (GimpSaveProcedure *save_procedure); static void gimp_export_procedure_add_metadata (GimpExportProcedure *export_procedure);
G_DEFINE_TYPE_WITH_PRIVATE (GimpSaveProcedure, gimp_save_procedure, G_DEFINE_TYPE_WITH_PRIVATE (GimpExportProcedure, gimp_export_procedure,
GIMP_TYPE_FILE_PROCEDURE) GIMP_TYPE_FILE_PROCEDURE)
#define parent_class gimp_save_procedure_parent_class #define parent_class gimp_export_procedure_parent_class
static GParamSpec *props[N_PROPS] = { NULL, }; static GParamSpec *props[N_PROPS] = { NULL, };
static void static void
gimp_save_procedure_class_init (GimpSaveProcedureClass *klass) gimp_export_procedure_class_init (GimpExportProcedureClass *klass)
{ {
GObjectClass *object_class = G_OBJECT_CLASS (klass); GObjectClass *object_class = G_OBJECT_CLASS (klass);
GimpProcedureClass *procedure_class = GIMP_PROCEDURE_CLASS (klass); GimpProcedureClass *procedure_class = GIMP_PROCEDURE_CLASS (klass);
object_class->constructed = gimp_save_procedure_constructed; object_class->constructed = gimp_export_procedure_constructed;
object_class->finalize = gimp_save_procedure_finalize; object_class->finalize = gimp_export_procedure_finalize;
object_class->get_property = gimp_save_procedure_get_property; object_class->get_property = gimp_export_procedure_get_property;
object_class->set_property = gimp_save_procedure_set_property; object_class->set_property = gimp_export_procedure_set_property;
procedure_class->install = gimp_save_procedure_install; procedure_class->install = gimp_export_procedure_install;
procedure_class->run = gimp_save_procedure_run; procedure_class->run = gimp_export_procedure_run;
procedure_class->create_config = gimp_save_procedure_create_config; procedure_class->create_config = gimp_export_procedure_create_config;
/** /**
* GimpSaveProcedure:supports-exif: * GimpExportProcedure:supports-exif:
* *
* Whether the save procedure supports EXIF. * Whether the export procedure supports EXIF.
* *
* Since: 3.0.0 * Since: 3.0.0
*/ */
@ -119,9 +119,9 @@ gimp_save_procedure_class_init (GimpSaveProcedureClass *klass)
G_PARAM_CONSTRUCT | G_PARAM_CONSTRUCT |
GIMP_PARAM_READWRITE); GIMP_PARAM_READWRITE);
/** /**
* GimpSaveProcedure:supports-iptc: * GimpExportProcedure:supports-iptc:
* *
* Whether the save procedure supports IPTC. * Whether the export procedure supports IPTC.
* *
* Since: 3.0.0 * Since: 3.0.0
*/ */
@ -132,9 +132,9 @@ gimp_save_procedure_class_init (GimpSaveProcedureClass *klass)
G_PARAM_CONSTRUCT | G_PARAM_CONSTRUCT |
GIMP_PARAM_READWRITE); GIMP_PARAM_READWRITE);
/** /**
* GimpSaveProcedure:supports-xmp: * GimpExportProcedure:supports-xmp:
* *
* Whether the save procedure supports XMP. * Whether the export procedure supports XMP.
* *
* Since: 3.0.0 * Since: 3.0.0
*/ */
@ -145,9 +145,9 @@ gimp_save_procedure_class_init (GimpSaveProcedureClass *klass)
G_PARAM_CONSTRUCT | G_PARAM_CONSTRUCT |
GIMP_PARAM_READWRITE); GIMP_PARAM_READWRITE);
/** /**
* GimpSaveProcedure:supports-profile: * GimpExportProcedure:supports-profile:
* *
* Whether the save procedure supports ICC color profiles. * Whether the export procedure supports ICC color profiles.
* *
* Since: 3.0.0 * Since: 3.0.0
*/ */
@ -158,9 +158,9 @@ gimp_save_procedure_class_init (GimpSaveProcedureClass *klass)
G_PARAM_CONSTRUCT | G_PARAM_CONSTRUCT |
GIMP_PARAM_READWRITE); GIMP_PARAM_READWRITE);
/** /**
* GimpSaveProcedure:supports-thumbnail: * GimpExportProcedure:supports-thumbnail:
* *
* Whether the save procedure supports storing a thumbnail. * Whether the export procedure supports storing a thumbnail.
* *
* Since: 3.0.0 * Since: 3.0.0
*/ */
@ -171,9 +171,9 @@ gimp_save_procedure_class_init (GimpSaveProcedureClass *klass)
G_PARAM_CONSTRUCT | G_PARAM_CONSTRUCT |
GIMP_PARAM_READWRITE); GIMP_PARAM_READWRITE);
/** /**
* GimpSaveProcedure:supports-comment: * GimpExportProcedure:supports-comment:
* *
* Whether the save procedure supports storing a comment. * Whether the export procedure supports storing a comment.
* *
* Since: 3.0.0 * Since: 3.0.0
*/ */
@ -188,15 +188,15 @@ gimp_save_procedure_class_init (GimpSaveProcedureClass *klass)
} }
static void static void
gimp_save_procedure_init (GimpSaveProcedure *procedure) gimp_export_procedure_init (GimpExportProcedure *procedure)
{ {
procedure->priv = gimp_save_procedure_get_instance_private (procedure); procedure->priv = gimp_export_procedure_get_instance_private (procedure);
procedure->priv->export_metadata = FALSE; procedure->priv->export_metadata = FALSE;
} }
static void static void
gimp_save_procedure_constructed (GObject *object) gimp_export_procedure_constructed (GObject *object)
{ {
GimpProcedure *procedure = GIMP_PROCEDURE (object); GimpProcedure *procedure = GIMP_PROCEDURE (object);
@ -204,32 +204,32 @@ gimp_save_procedure_constructed (GObject *object)
GIMP_PROC_ARG_IMAGE (procedure, "image", GIMP_PROC_ARG_IMAGE (procedure, "image",
"Image", "Image",
"The image to save", "The image to export",
FALSE, FALSE,
G_PARAM_READWRITE); G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "num-drawables", GIMP_PROC_ARG_INT (procedure, "num-drawables",
"Number of drawables", "Number of drawables",
"Number of drawables to be saved", "Number of drawables to be exported",
0, G_MAXINT, 1, 0, G_MAXINT, 1,
G_PARAM_READWRITE); G_PARAM_READWRITE);
GIMP_PROC_ARG_OBJECT_ARRAY (procedure, "drawables", GIMP_PROC_ARG_OBJECT_ARRAY (procedure, "drawables",
"Drawables", "Drawables",
"The drawables to save", "The drawables to export",
GIMP_TYPE_DRAWABLE, GIMP_TYPE_DRAWABLE,
G_PARAM_READWRITE | GIMP_PARAM_NO_VALIDATE); G_PARAM_READWRITE | GIMP_PARAM_NO_VALIDATE);
GIMP_PROC_ARG_FILE (procedure, "file", GIMP_PROC_ARG_FILE (procedure, "file",
"File", "File",
"The file to save to", "The file to export to",
GIMP_PARAM_READWRITE); GIMP_PARAM_READWRITE);
} }
static void static void
gimp_save_procedure_finalize (GObject *object) gimp_export_procedure_finalize (GObject *object)
{ {
GimpSaveProcedure *procedure = GIMP_SAVE_PROCEDURE (object); GimpExportProcedure *procedure = GIMP_EXPORT_PROCEDURE (object);
if (procedure->priv->run_data_destroy) if (procedure->priv->run_data_destroy)
procedure->priv->run_data_destroy (procedure->priv->run_data); procedure->priv->run_data_destroy (procedure->priv->run_data);
@ -238,12 +238,12 @@ gimp_save_procedure_finalize (GObject *object)
} }
static void static void
gimp_save_procedure_set_property (GObject *object, gimp_export_procedure_set_property (GObject *object,
guint property_id, guint property_id,
const GValue *value, const GValue *value,
GParamSpec *pspec) GParamSpec *pspec)
{ {
GimpSaveProcedure *procedure = GIMP_SAVE_PROCEDURE (object); GimpExportProcedure *procedure = GIMP_EXPORT_PROCEDURE (object);
switch (property_id) switch (property_id)
{ {
@ -273,12 +273,12 @@ gimp_save_procedure_set_property (GObject *object,
} }
static void static void
gimp_save_procedure_get_property (GObject *object, gimp_export_procedure_get_property (GObject *object,
guint property_id, guint property_id,
GValue *value, GValue *value,
GParamSpec *pspec) GParamSpec *pspec)
{ {
GimpSaveProcedure *procedure = GIMP_SAVE_PROCEDURE (object); GimpExportProcedure *procedure = GIMP_EXPORT_PROCEDURE (object);
switch (property_id) switch (property_id)
{ {
@ -308,13 +308,13 @@ gimp_save_procedure_get_property (GObject *object,
} }
static void static void
gimp_save_procedure_install (GimpProcedure *procedure) gimp_export_procedure_install (GimpProcedure *procedure)
{ {
GimpFileProcedure *file_proc = GIMP_FILE_PROCEDURE (procedure); GimpFileProcedure *file_proc = GIMP_FILE_PROCEDURE (procedure);
const gchar *mime_types; const gchar *mime_types;
gint priority; gint priority;
gimp_save_procedure_add_metadata (GIMP_SAVE_PROCEDURE (procedure)); gimp_export_procedure_add_metadata (GIMP_EXPORT_PROCEDURE (procedure));
GIMP_PROCEDURE_CLASS (parent_class)->install (procedure); GIMP_PROCEDURE_CLASS (parent_class)->install (procedure);
_gimp_pdb_set_file_proc_save_handler (gimp_procedure_get_name (procedure), _gimp_pdb_set_file_proc_save_handler (gimp_procedure_get_name (procedure),
@ -338,11 +338,11 @@ gimp_save_procedure_install (GimpProcedure *procedure)
#define ARG_OFFSET 5 #define ARG_OFFSET 5
static GimpValueArray * static GimpValueArray *
gimp_save_procedure_run (GimpProcedure *procedure, gimp_export_procedure_run (GimpProcedure *procedure,
const GimpValueArray *args) const GimpValueArray *args)
{ {
GimpPlugIn *plug_in; GimpPlugIn *plug_in;
GimpSaveProcedure *save_proc = GIMP_SAVE_PROCEDURE (procedure); GimpExportProcedure *export_proc = GIMP_EXPORT_PROCEDURE (procedure);
GimpValueArray *remaining; GimpValueArray *remaining;
GimpValueArray *return_values; GimpValueArray *return_values;
GimpProcedureConfig *config; GimpProcedureConfig *config;
@ -371,12 +371,12 @@ gimp_save_procedure_run (GimpProcedure *procedure,
} }
config = gimp_procedure_create_config (procedure); config = gimp_procedure_create_config (procedure);
if (save_proc->priv->export_metadata) if (export_proc->priv->export_metadata)
{ {
mimetype = (gchar *) gimp_file_procedure_get_mime_types (GIMP_FILE_PROCEDURE (procedure)); mimetype = (gchar *) gimp_file_procedure_get_mime_types (GIMP_FILE_PROCEDURE (procedure));
if (mimetype == NULL) if (mimetype == NULL)
{ {
g_printerr ("%s: ERROR: the GimpSaveProcedureConfig object was created " g_printerr ("%s: ERROR: the GimpExportProcedureConfig object was created "
"with export_metadata but you didn't set any MimeType with gimp_file_procedure_set_mime_types()!\n", "with export_metadata but you didn't set any MimeType with gimp_file_procedure_set_mime_types()!\n",
G_STRFUNC); G_STRFUNC);
} }
@ -403,10 +403,10 @@ gimp_save_procedure_run (GimpProcedure *procedure,
metadata = _gimp_procedure_config_begin_export (config, image, run_mode, remaining, mimetype); metadata = _gimp_procedure_config_begin_export (config, image, run_mode, remaining, mimetype);
g_free (mimetype); g_free (mimetype);
return_values = save_proc->priv->run_func (procedure, run_mode, return_values = export_proc->priv->run_func (procedure, run_mode,
image, n_drawables, drawables, image, n_drawables, drawables,
file, metadata, config, file, metadata, config,
save_proc->priv->run_data); export_proc->priv->run_data);
if (return_values != NULL && if (return_values != NULL &&
gimp_value_array_length (return_values) > 0 && gimp_value_array_length (return_values) > 0 &&
@ -421,7 +421,7 @@ gimp_save_procedure_run (GimpProcedure *procedure,
plug_in = gimp_procedure_get_plug_in (procedure); plug_in = gimp_procedure_get_plug_in (procedure);
if (G_OBJECT (config)->ref_count > 1 && if (G_OBJECT (config)->ref_count > 1 &&
_gimp_plug_in_manage_memory_manually (plug_in)) _gimp_plug_in_manage_memory_manually (plug_in))
g_printerr ("%s: ERROR: the GimpSaveProcedureConfig object was refed " g_printerr ("%s: ERROR: the GimpExportProcedureConfig object was refed "
"by plug-in, it MUST NOT do that!\n", G_STRFUNC); "by plug-in, it MUST NOT do that!\n", G_STRFUNC);
g_object_unref (config); g_object_unref (config);
@ -431,11 +431,11 @@ gimp_save_procedure_run (GimpProcedure *procedure,
} }
static GimpProcedureConfig * static GimpProcedureConfig *
gimp_save_procedure_create_config (GimpProcedure *procedure, gimp_export_procedure_create_config (GimpProcedure *procedure,
GParamSpec **args, GParamSpec **args,
gint n_args) gint n_args)
{ {
gimp_save_procedure_add_metadata (GIMP_SAVE_PROCEDURE (procedure)); gimp_export_procedure_add_metadata (GIMP_EXPORT_PROCEDURE (procedure));
if (n_args > ARG_OFFSET) if (n_args > ARG_OFFSET)
{ {
@ -454,45 +454,45 @@ gimp_save_procedure_create_config (GimpProcedure *procedure,
} }
static void static void
gimp_save_procedure_add_metadata (GimpSaveProcedure *save_procedure) gimp_export_procedure_add_metadata (GimpExportProcedure *export_procedure)
{ {
GimpProcedure *procedure = GIMP_PROCEDURE (save_procedure); GimpProcedure *procedure = GIMP_PROCEDURE (export_procedure);
static gboolean ran_once = FALSE; static gboolean ran_once = FALSE;
if (ran_once) if (ran_once)
return; return;
if (save_procedure->priv->supports_exif) if (export_procedure->priv->supports_exif)
GIMP_PROC_AUX_ARG_BOOLEAN (procedure, "save-exif", GIMP_PROC_AUX_ARG_BOOLEAN (procedure, "save-exif",
_("Save _Exif"), _("Save _Exif"),
_("Save Exif (Exchangeable image file format) metadata"), _("Save Exif (Exchangeable image file format) metadata"),
gimp_export_exif (), gimp_export_exif (),
G_PARAM_READWRITE); G_PARAM_READWRITE);
if (save_procedure->priv->supports_iptc) if (export_procedure->priv->supports_iptc)
GIMP_PROC_AUX_ARG_BOOLEAN (procedure, "save-iptc", GIMP_PROC_AUX_ARG_BOOLEAN (procedure, "save-iptc",
_("Save _IPTC"), _("Save _IPTC"),
_("Save IPTC (International Press Telecommunications Council) metadata"), _("Save IPTC (International Press Telecommunications Council) metadata"),
gimp_export_iptc (), gimp_export_iptc (),
G_PARAM_READWRITE); G_PARAM_READWRITE);
if (save_procedure->priv->supports_xmp) if (export_procedure->priv->supports_xmp)
GIMP_PROC_AUX_ARG_BOOLEAN (procedure, "save-xmp", GIMP_PROC_AUX_ARG_BOOLEAN (procedure, "save-xmp",
_("Save _XMP"), _("Save _XMP"),
_("Save XMP (Extensible Metadata Platform) metadata"), _("Save XMP (Extensible Metadata Platform) metadata"),
gimp_export_xmp (), gimp_export_xmp (),
G_PARAM_READWRITE); G_PARAM_READWRITE);
if (save_procedure->priv->supports_profile) if (export_procedure->priv->supports_profile)
GIMP_PROC_AUX_ARG_BOOLEAN (procedure, "save-color-profile", GIMP_PROC_AUX_ARG_BOOLEAN (procedure, "save-color-profile",
_("Save color _profile"), _("Save color _profile"),
_("Save the ICC color profile as metadata"), _("Save the ICC color profile as metadata"),
gimp_export_color_profile (), gimp_export_color_profile (),
G_PARAM_READWRITE); G_PARAM_READWRITE);
if (save_procedure->priv->supports_thumbnail) if (export_procedure->priv->supports_thumbnail)
GIMP_PROC_AUX_ARG_BOOLEAN (procedure, "save-thumbnail", GIMP_PROC_AUX_ARG_BOOLEAN (procedure, "save-thumbnail",
_("Save _thumbnail"), _("Save _thumbnail"),
_("Save a smaller representation of the image as metadata"), _("Save a smaller representation of the image as metadata"),
gimp_export_thumbnail (), gimp_export_thumbnail (),
G_PARAM_READWRITE); G_PARAM_READWRITE);
if (save_procedure->priv->supports_comment) if (export_procedure->priv->supports_comment)
{ {
GIMP_PROC_AUX_ARG_BOOLEAN (procedure, "save-comment", GIMP_PROC_AUX_ARG_BOOLEAN (procedure, "save-comment",
_("Save c_omment"), _("Save c_omment"),
@ -516,7 +516,7 @@ gimp_save_procedure_add_metadata (GimpSaveProcedure *save_procedure)
/* public functions */ /* public functions */
/** /**
* gimp_save_procedure_new: * gimp_export_procedure_new:
* @plug_in: a #GimpPlugIn. * @plug_in: a #GimpPlugIn.
* @name: the new procedure's name. * @name: the new procedure's name.
* @proc_type: the new procedure's #GimpPDBProcType. * @proc_type: the new procedure's #GimpPDBProcType.
@ -525,24 +525,24 @@ gimp_save_procedure_add_metadata (GimpSaveProcedure *save_procedure)
* @run_data: user data passed to @run_func. * @run_data: user data passed to @run_func.
* @run_data_destroy: (nullable): free function for @run_data, or %NULL. * @run_data_destroy: (nullable): free function for @run_data, or %NULL.
* *
* Creates a new save procedure named @name which will call @run_func * Creates a new export procedure named @name which will call @run_func
* when invoked. * when invoked.
* *
* See gimp_procedure_new() for information about @proc_type. * See gimp_procedure_new() for information about @proc_type.
* *
* #GimpSaveProcedure is a #GimpProcedure subclass that makes it easier * #GimpExportProcedure is a #GimpProcedure subclass that makes it easier
* to write file save procedures. * to write file export procedures.
* *
* It automatically adds the standard * It automatically adds the standard
* *
* (#GimpRunMode, #GimpImage, #GimpDrawable, #GFile) * (#GimpRunMode, #GimpImage, #GimpDrawable, #GFile)
* *
* arguments of a save procedure. It is possible to add additional * arguments of an export procedure. It is possible to add additional
* arguments. * arguments.
* *
* When invoked via gimp_procedure_run(), it unpacks these standard * When invoked via gimp_procedure_run(), it unpacks these standard
* arguments and calls @run_func which is a #GimpRunSaveFunc. The * arguments and calls @run_func which is a #GimpRunExportFunc. The
* #GimpProcedureConfig of #GimpRunSaveFunc only contains additionally added * #GimpProcedureConfig of #GimpRunExportFunc only contains additionally added
* arguments. * arguments.
* *
* If @export_metadata is TRUE, then the class will also handle the metadata * If @export_metadata is TRUE, then the class will also handle the metadata
@ -554,15 +554,15 @@ gimp_save_procedure_add_metadata (GimpSaveProcedure *save_procedure)
* Since: 3.0 * Since: 3.0
**/ **/
GimpProcedure * GimpProcedure *
gimp_save_procedure_new (GimpPlugIn *plug_in, gimp_export_procedure_new (GimpPlugIn *plug_in,
const gchar *name, const gchar *name,
GimpPDBProcType proc_type, GimpPDBProcType proc_type,
gboolean export_metadata, gboolean export_metadata,
GimpRunSaveFunc run_func, GimpRunExportFunc run_func,
gpointer run_data, gpointer run_data,
GDestroyNotify run_data_destroy) GDestroyNotify run_data_destroy)
{ {
GimpSaveProcedure *procedure; GimpExportProcedure *procedure;
g_return_val_if_fail (GIMP_IS_PLUG_IN (plug_in), NULL); g_return_val_if_fail (GIMP_IS_PLUG_IN (plug_in), NULL);
g_return_val_if_fail (gimp_is_canonical_identifier (name), NULL); g_return_val_if_fail (gimp_is_canonical_identifier (name), NULL);
@ -570,7 +570,7 @@ gimp_save_procedure_new (GimpPlugIn *plug_in,
g_return_val_if_fail (proc_type != GIMP_PDB_PROC_TYPE_EXTENSION, NULL); g_return_val_if_fail (proc_type != GIMP_PDB_PROC_TYPE_EXTENSION, NULL);
g_return_val_if_fail (run_func != NULL, NULL); g_return_val_if_fail (run_func != NULL, NULL);
procedure = g_object_new (GIMP_TYPE_SAVE_PROCEDURE, procedure = g_object_new (GIMP_TYPE_EXPORT_PROCEDURE,
"plug-in", plug_in, "plug-in", plug_in,
"name", name, "name", name,
"procedure-type", proc_type, "procedure-type", proc_type,
@ -585,11 +585,11 @@ gimp_save_procedure_new (GimpPlugIn *plug_in,
} }
/** /**
* gimp_save_procedure_set_support_exif: * gimp_export_procedure_set_support_exif:
* @procedure: a #GimpProcedure. * @procedure: a #GimpProcedure.
* @supports: whether Exif metadata are supported. * @supports: whether Exif metadata are supported.
* *
* Determine whether @procedure supports saving Exif data. By default, * Determine whether @procedure supports exporting Exif data. By default,
* it won't (so there is usually no reason to run this function with * it won't (so there is usually no reason to run this function with
* %FALSE). * %FALSE).
* *
@ -598,14 +598,14 @@ gimp_save_procedure_new (GimpPlugIn *plug_in,
* - Automatically adds a standard auxiliary argument "save-exif" in the * - Automatically adds a standard auxiliary argument "save-exif" in the
* end of the argument list of @procedure, with relevant blurb and * end of the argument list of @procedure, with relevant blurb and
* description. * description.
* - If used with other gimp_save_procedure_set_support_*() functions, * - If used with other gimp_export_procedure_set_support_*() functions,
* they will always be ordered the same (the order of the calls don't * they will always be ordered the same (the order of the calls don't
* matter), keeping all save procedures consistent. * matter), keeping all export procedures consistent.
* - Generated GimpSaveProcedureDialog will contain the metadata * - Generated GimpExportProcedureDialog will contain the metadata
* options, once again always in the same order and with consistent * options, once again always in the same order and with consistent
* GUI style across plug-ins. * GUI style across plug-ins.
* - API from [class@ProcedureConfig] will automatically process these * - API from [class@ProcedureConfig] will automatically process these
* properties to decide whether to save a given metadata or not. * properties to decide whether to export a given metadata or not.
* *
* Note that since this is an auxiliary argument, it won't be part of * Note that since this is an auxiliary argument, it won't be part of
* the PDB arguments. By default, the value will be [func@export_exif]. * the PDB arguments. By default, the value will be [func@export_exif].
@ -613,10 +613,10 @@ gimp_save_procedure_new (GimpPlugIn *plug_in,
* Since: 3.0 * Since: 3.0
**/ **/
void void
gimp_save_procedure_set_support_exif (GimpSaveProcedure *procedure, gimp_export_procedure_set_support_exif (GimpExportProcedure *procedure,
gboolean supports) gboolean supports)
{ {
g_return_if_fail (GIMP_IS_SAVE_PROCEDURE (procedure)); g_return_if_fail (GIMP_IS_EXPORT_PROCEDURE (procedure));
g_object_set (procedure, g_object_set (procedure,
"supports-exif", supports, "supports-exif", supports,
@ -624,11 +624,11 @@ gimp_save_procedure_set_support_exif (GimpSaveProcedure *procedure,
} }
/** /**
* gimp_save_procedure_set_support_iptc: * gimp_export_procedure_set_support_iptc:
* @procedure: a #GimpProcedure. * @procedure: a #GimpProcedure.
* @supports: whether IPTC metadata are supported. * @supports: whether IPTC metadata are supported.
* *
* Determine whether @procedure supports saving IPTC data. By default, * Determine whether @procedure supports exporting IPTC data. By default,
* it won't (so there is usually no reason to run this function with * it won't (so there is usually no reason to run this function with
* %FALSE). * %FALSE).
* *
@ -637,14 +637,14 @@ gimp_save_procedure_set_support_exif (GimpSaveProcedure *procedure,
* - Automatically adds a standard auxiliary argument "save-iptc" in the * - Automatically adds a standard auxiliary argument "save-iptc" in the
* end of the argument list of @procedure, with relevant blurb and * end of the argument list of @procedure, with relevant blurb and
* description. * description.
* - If used with other gimp_save_procedure_set_support_*() functions, * - If used with other gimp_export_procedure_set_support_*() functions,
* they will always be ordered the same (the order of the calls don't * they will always be ordered the same (the order of the calls don't
* matter), keeping all save procedures consistent. * matter), keeping all export procedures consistent.
* - Generated GimpSaveProcedureDialog will contain the metadata * - Generated GimpExportProcedureDialog will contain the metadata
* options, once again always in the same order and with consistent * options, once again always in the same order and with consistent
* GUI style across plug-ins. * GUI style across plug-ins.
* - API from [class@ProcedureConfig] will automatically process these * - API from [class@ProcedureConfig] will automatically process these
* properties to decide whether to save a given metadata or not. * properties to decide whether to export a given metadata or not.
* *
* Note that since this is an auxiliary argument, it won't be part of * Note that since this is an auxiliary argument, it won't be part of
* the PDB arguments. By default, the value will be [func@export_iptc]. * the PDB arguments. By default, the value will be [func@export_iptc].
@ -652,10 +652,10 @@ gimp_save_procedure_set_support_exif (GimpSaveProcedure *procedure,
* Since: 3.0 * Since: 3.0
**/ **/
void void
gimp_save_procedure_set_support_iptc (GimpSaveProcedure *procedure, gimp_export_procedure_set_support_iptc (GimpExportProcedure *procedure,
gboolean supports) gboolean supports)
{ {
g_return_if_fail (GIMP_IS_SAVE_PROCEDURE (procedure)); g_return_if_fail (GIMP_IS_EXPORT_PROCEDURE (procedure));
g_object_set (procedure, g_object_set (procedure,
"supports-iptc", supports, "supports-iptc", supports,
@ -663,11 +663,11 @@ gimp_save_procedure_set_support_iptc (GimpSaveProcedure *procedure,
} }
/** /**
* gimp_save_procedure_set_support_xmp: * gimp_export_procedure_set_support_xmp:
* @procedure: a #GimpProcedure. * @procedure: a #GimpProcedure.
* @supports: whether XMP metadata are supported. * @supports: whether XMP metadata are supported.
* *
* Determine whether @procedure supports saving XMP data. By default, * Determine whether @procedure supports exporting XMP data. By default,
* it won't (so there is usually no reason to run this function with * it won't (so there is usually no reason to run this function with
* %FALSE). * %FALSE).
* *
@ -676,14 +676,14 @@ gimp_save_procedure_set_support_iptc (GimpSaveProcedure *procedure,
* - Automatically adds a standard auxiliary argument "save-xmp" in the * - Automatically adds a standard auxiliary argument "save-xmp" in the
* end of the argument list of @procedure, with relevant blurb and * end of the argument list of @procedure, with relevant blurb and
* description. * description.
* - If used with other gimp_save_procedure_set_support_*() functions, * - If used with other gimp_export_procedure_set_support_*() functions,
* they will always be ordered the same (the order of the calls don't * they will always be ordered the same (the order of the calls don't
* matter), keeping all save procedures consistent. * matter), keeping all export procedures consistent.
* - Generated GimpSaveProcedureDialog will contain the metadata * - Generated GimpExportProcedureDialog will contain the metadata
* options, once again always in the same order and with consistent * options, once again always in the same order and with consistent
* GUI style across plug-ins. * GUI style across plug-ins.
* - API from [class@ProcedureConfig] will automatically process these * - API from [class@ProcedureConfig] will automatically process these
* properties to decide whether to save a given metadata or not. * properties to decide whether to export a given metadata or not.
* *
* Note that since this is an auxiliary argument, it won't be part of * Note that since this is an auxiliary argument, it won't be part of
* the PDB arguments. By default, the value will be [func@export_xmp]. * the PDB arguments. By default, the value will be [func@export_xmp].
@ -691,10 +691,10 @@ gimp_save_procedure_set_support_iptc (GimpSaveProcedure *procedure,
* Since: 3.0 * Since: 3.0
**/ **/
void void
gimp_save_procedure_set_support_xmp (GimpSaveProcedure *procedure, gimp_export_procedure_set_support_xmp (GimpExportProcedure *procedure,
gboolean supports) gboolean supports)
{ {
g_return_if_fail (GIMP_IS_SAVE_PROCEDURE (procedure)); g_return_if_fail (GIMP_IS_EXPORT_PROCEDURE (procedure));
g_object_set (procedure, g_object_set (procedure,
"supports-xmp", supports, "supports-xmp", supports,
@ -702,11 +702,11 @@ gimp_save_procedure_set_support_xmp (GimpSaveProcedure *procedure,
} }
/** /**
* gimp_save_procedure_set_support_profile: * gimp_export_procedure_set_support_profile:
* @procedure: a #GimpProcedure. * @procedure: a #GimpProcedure.
* @supports: whether color profiles can be stored. * @supports: whether color profiles can be stored.
* *
* Determine whether @procedure supports saving ICC color profiles. By * Determine whether @procedure supports exporting ICC color profiles. By
* default, it won't (so there is usually no reason to run this function * default, it won't (so there is usually no reason to run this function
* with %FALSE). * with %FALSE).
* *
@ -715,14 +715,14 @@ gimp_save_procedure_set_support_xmp (GimpSaveProcedure *procedure,
* - Automatically adds a standard auxiliary argument * - Automatically adds a standard auxiliary argument
* "save-color-profile" in the end of the argument list of @procedure, * "save-color-profile" in the end of the argument list of @procedure,
* with relevant blurb and description. * with relevant blurb and description.
* - If used with other gimp_save_procedure_set_support_*() functions, * - If used with other gimp_export_procedure_set_support_*() functions,
* they will always be ordered the same (the order of the calls don't * they will always be ordered the same (the order of the calls don't
* matter), keeping all save procedures consistent. * matter), keeping all export procedures consistent.
* - Generated GimpSaveProcedureDialog will contain the metadata * - Generated GimpExportProcedureDialog will contain the metadata
* options, once again always in the same order and with consistent * options, once again always in the same order and with consistent
* GUI style across plug-ins. * GUI style across plug-ins.
* - API from [class@ProcedureConfig] will automatically process these * - API from [class@ProcedureConfig] will automatically process these
* properties to decide whether to save a given metadata or not. * properties to decide whether to export a given metadata or not.
* *
* Note that since this is an auxiliary argument, it won't be part of * Note that since this is an auxiliary argument, it won't be part of
* the PDB arguments. By default, the value will be [func@export_color_profile]. * the PDB arguments. By default, the value will be [func@export_color_profile].
@ -730,10 +730,10 @@ gimp_save_procedure_set_support_xmp (GimpSaveProcedure *procedure,
* Since: 3.0 * Since: 3.0
**/ **/
void void
gimp_save_procedure_set_support_profile (GimpSaveProcedure *procedure, gimp_export_procedure_set_support_profile (GimpExportProcedure *procedure,
gboolean supports) gboolean supports)
{ {
g_return_if_fail (GIMP_IS_SAVE_PROCEDURE (procedure)); g_return_if_fail (GIMP_IS_EXPORT_PROCEDURE (procedure));
g_object_set (procedure, g_object_set (procedure,
"supports-profile", supports, "supports-profile", supports,
@ -741,11 +741,11 @@ gimp_save_procedure_set_support_profile (GimpSaveProcedure *procedure,
} }
/** /**
* gimp_save_procedure_set_support_thumbnail: * gimp_export_procedure_set_support_thumbnail:
* @procedure: a #GimpProcedure. * @procedure: a #GimpProcedure.
* @supports: whether a thumbnail can be stored. * @supports: whether a thumbnail can be stored.
* *
* Determine whether @procedure supports saving a thumbnail. By default, * Determine whether @procedure supports exporting a thumbnail. By default,
* it won't (so there is usually no reason to run this function with * it won't (so there is usually no reason to run this function with
* %FALSE). * %FALSE).
* *
@ -754,14 +754,14 @@ gimp_save_procedure_set_support_profile (GimpSaveProcedure *procedure,
* - Automatically adds a standard auxiliary argument "save-thumbnail" * - Automatically adds a standard auxiliary argument "save-thumbnail"
* in the end of the argument list of @procedure, with relevant blurb * in the end of the argument list of @procedure, with relevant blurb
* and description. * and description.
* - If used with other gimp_save_procedure_set_support_*() functions, * - If used with other gimp_export_procedure_set_support_*() functions,
* they will always be ordered the same (the order of the calls don't * they will always be ordered the same (the order of the calls don't
* matter), keeping all save procedures consistent. * matter), keeping all export procedures consistent.
* - Generated GimpSaveProcedureDialog will contain the metadata * - Generated GimpExportProcedureDialog will contain the metadata
* options, once again always in the same order and with consistent * options, once again always in the same order and with consistent
* GUI style across plug-ins. * GUI style across plug-ins.
* - API from [class@ProcedureConfig] will automatically process these * - API from [class@ProcedureConfig] will automatically process these
* properties to decide whether to save a given metadata or not. * properties to decide whether to export a given metadata or not.
* *
* Note that since this is an auxiliary argument, it won't be part of * Note that since this is an auxiliary argument, it won't be part of
* the PDB arguments. By default, the value will be * the PDB arguments. By default, the value will be
@ -770,10 +770,10 @@ gimp_save_procedure_set_support_profile (GimpSaveProcedure *procedure,
* Since: 3.0 * Since: 3.0
**/ **/
void void
gimp_save_procedure_set_support_thumbnail (GimpSaveProcedure *procedure, gimp_export_procedure_set_support_thumbnail (GimpExportProcedure *procedure,
gboolean supports) gboolean supports)
{ {
g_return_if_fail (GIMP_IS_SAVE_PROCEDURE (procedure)); g_return_if_fail (GIMP_IS_EXPORT_PROCEDURE (procedure));
g_object_set (procedure, g_object_set (procedure,
"supports-thumbnail", supports, "supports-thumbnail", supports,
@ -781,11 +781,11 @@ gimp_save_procedure_set_support_thumbnail (GimpSaveProcedure *procedure,
} }
/** /**
* gimp_save_procedure_set_support_comment: * gimp_export_procedure_set_support_comment:
* @procedure: a #GimpProcedure. * @procedure: a #GimpProcedure.
* @supports: whether a comment can be stored. * @supports: whether a comment can be stored.
* *
* Determine whether @procedure supports saving a comment. By default, * Determine whether @procedure supports exporting a comment. By default,
* it won't (so there is usually no reason to run this function with * it won't (so there is usually no reason to run this function with
* %FALSE). * %FALSE).
* *
@ -794,14 +794,14 @@ gimp_save_procedure_set_support_thumbnail (GimpSaveProcedure *procedure,
* - Automatically adds a standard auxiliary argument "save-comment" * - Automatically adds a standard auxiliary argument "save-comment"
* in the end of the argument list of @procedure, with relevant blurb * in the end of the argument list of @procedure, with relevant blurb
* and description. * and description.
* - If used with other gimp_save_procedure_set_support_*() functions, * - If used with other gimp_export_procedure_set_support_*() functions,
* they will always be ordered the same (the order of the calls don't * they will always be ordered the same (the order of the calls don't
* matter), keeping all save procedures consistent. * matter), keeping all export procedures consistent.
* - Generated GimpSaveProcedureDialog will contain the metadata * - Generated GimpExportProcedureDialog will contain the metadata
* options, once again always in the same order and with consistent * options, once again always in the same order and with consistent
* GUI style across plug-ins. * GUI style across plug-ins.
* - API from [class@ProcedureConfig] will automatically process these * - API from [class@ProcedureConfig] will automatically process these
* properties to decide whether to save a given metadata or not. * properties to decide whether to export a given metadata or not.
* *
* Note that since this is an auxiliary argument, it won't be part of * Note that since this is an auxiliary argument, it won't be part of
* the PDB arguments. By default, the value will be * the PDB arguments. By default, the value will be
@ -810,10 +810,10 @@ gimp_save_procedure_set_support_thumbnail (GimpSaveProcedure *procedure,
* Since: 3.0 * Since: 3.0
**/ **/
void void
gimp_save_procedure_set_support_comment (GimpSaveProcedure *procedure, gimp_export_procedure_set_support_comment (GimpExportProcedure *procedure,
gboolean supports) gboolean supports)
{ {
g_return_if_fail (GIMP_IS_SAVE_PROCEDURE (procedure)); g_return_if_fail (GIMP_IS_EXPORT_PROCEDURE (procedure));
g_object_set (procedure, g_object_set (procedure,
"supports-comment", supports, "supports-comment", supports,
@ -821,97 +821,97 @@ gimp_save_procedure_set_support_comment (GimpSaveProcedure *procedure,
} }
/** /**
* gimp_save_procedure_get_support_exif: * gimp_export_procedure_get_support_exif:
* @procedure: a #GimpProcedure. * @procedure: a #GimpProcedure.
* *
* Returns: %TRUE if @procedure supports Exif saving. * Returns: %TRUE if @procedure supports Exif exporting.
* *
* Since: 3.0 * Since: 3.0
**/ **/
gboolean gboolean
gimp_save_procedure_get_support_exif (GimpSaveProcedure *procedure) gimp_export_procedure_get_support_exif (GimpExportProcedure *procedure)
{ {
g_return_val_if_fail (GIMP_IS_SAVE_PROCEDURE (procedure), FALSE); g_return_val_if_fail (GIMP_IS_EXPORT_PROCEDURE (procedure), FALSE);
return procedure->priv->supports_exif; return procedure->priv->supports_exif;
} }
/** /**
* gimp_save_procedure_get_support_iptc: * gimp_export_procedure_get_support_iptc:
* @procedure: a #GimpProcedure. * @procedure: a #GimpProcedure.
* *
* Returns: %TRUE if @procedure supports IPTC saving. * Returns: %TRUE if @procedure supports IPTC exporting.
* *
* Since: 3.0 * Since: 3.0
**/ **/
gboolean gboolean
gimp_save_procedure_get_support_iptc (GimpSaveProcedure *procedure) gimp_export_procedure_get_support_iptc (GimpExportProcedure *procedure)
{ {
g_return_val_if_fail (GIMP_IS_SAVE_PROCEDURE (procedure), FALSE); g_return_val_if_fail (GIMP_IS_EXPORT_PROCEDURE (procedure), FALSE);
return procedure->priv->supports_iptc; return procedure->priv->supports_iptc;
} }
/** /**
* gimp_save_procedure_get_support_xmp: * gimp_export_procedure_get_support_xmp:
* @procedure: a #GimpProcedure. * @procedure: a #GimpProcedure.
* *
* Returns: %TRUE if @procedure supports XMP saving. * Returns: %TRUE if @procedure supports XMP exporting.
* *
* Since: 3.0 * Since: 3.0
**/ **/
gboolean gboolean
gimp_save_procedure_get_support_xmp (GimpSaveProcedure *procedure) gimp_export_procedure_get_support_xmp (GimpExportProcedure *procedure)
{ {
g_return_val_if_fail (GIMP_IS_SAVE_PROCEDURE (procedure), FALSE); g_return_val_if_fail (GIMP_IS_EXPORT_PROCEDURE (procedure), FALSE);
return procedure->priv->supports_xmp; return procedure->priv->supports_xmp;
} }
/** /**
* gimp_save_procedure_get_support_profile: * gimp_export_procedure_get_support_profile:
* @procedure: a #GimpProcedure. * @procedure: a #GimpProcedure.
* *
* Returns: %TRUE if @procedure supports ICC color profile saving. * Returns: %TRUE if @procedure supports ICC color profile exporting.
* *
* Since: 3.0 * Since: 3.0
**/ **/
gboolean gboolean
gimp_save_procedure_get_support_profile (GimpSaveProcedure *procedure) gimp_export_procedure_get_support_profile (GimpExportProcedure *procedure)
{ {
g_return_val_if_fail (GIMP_IS_SAVE_PROCEDURE (procedure), FALSE); g_return_val_if_fail (GIMP_IS_EXPORT_PROCEDURE (procedure), FALSE);
return procedure->priv->supports_profile; return procedure->priv->supports_profile;
} }
/** /**
* gimp_save_procedure_get_support_thumbnail: * gimp_export_procedure_get_support_thumbnail:
* @procedure: a #GimpProcedure. * @procedure: a #GimpProcedure.
* *
* Returns: %TRUE if @procedure supports thumbnail saving. * Returns: %TRUE if @procedure supports thumbnail exporting.
* *
* Since: 3.0 * Since: 3.0
**/ **/
gboolean gboolean
gimp_save_procedure_get_support_thumbnail (GimpSaveProcedure *procedure) gimp_export_procedure_get_support_thumbnail (GimpExportProcedure *procedure)
{ {
g_return_val_if_fail (GIMP_IS_SAVE_PROCEDURE (procedure), FALSE); g_return_val_if_fail (GIMP_IS_EXPORT_PROCEDURE (procedure), FALSE);
return procedure->priv->supports_thumbnail; return procedure->priv->supports_thumbnail;
} }
/** /**
* gimp_save_procedure_get_support_comment: * gimp_export_procedure_get_support_comment:
* @procedure: a #GimpProcedure. * @procedure: a #GimpProcedure.
* *
* Returns: %TRUE if @procedure supports comment saving. * Returns: %TRUE if @procedure supports comment exporting.
* *
* Since: 3.0 * Since: 3.0
**/ **/
gboolean gboolean
gimp_save_procedure_get_support_comment (GimpSaveProcedure *procedure) gimp_export_procedure_get_support_comment (GimpExportProcedure *procedure)
{ {
g_return_val_if_fail (GIMP_IS_SAVE_PROCEDURE (procedure), FALSE); g_return_val_if_fail (GIMP_IS_EXPORT_PROCEDURE (procedure), FALSE);
return procedure->priv->supports_comment; return procedure->priv->supports_comment;
} }

127
libgimp/gimpexportprocedure.h Normal file
View file

@ -0,0 +1,127 @@
/* GIMP - The GNU Image Manipulation Program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* gimpexportprocedure.h
* Copyright (C) 2019 Michael Natterer <mitch@gimp.org>
*
* 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
* <https://www.gnu.org/licenses/>.
*/
#ifndef __GIMP_EXPORT_PROCEDURE_H__
#define __GIMP_EXPORT_PROCEDURE_H__
#include <libgimp/gimpfileprocedure.h>
G_BEGIN_DECLS
/* For information look into the C source or the html documentation */
/**
* GimpRunExportFunc:
* @procedure: the #GimpProcedure that runs.
* @run_mode: the #GimpRunMode.
* @image: the image to export.
* @n_drawables: the number of drawables to export.
* @drawables: (array length=n_drawables): the drawables to export.
* @file: the #GFile to export to.
* @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().
* @config: the @procedure's remaining arguments.
* @run_data: (closure): the run_data given in gimp_export_procedure_new().
*
* The export function is run during the lifetime of the GIMP session,
* each time a plug-in export procedure is called.
*
* If a MimeType was passed in gimp_export_procedure_new(), then @metadata will be
* non-%NULL and can be tweaked by the run() function if needed. Otherwise you
* can let it as-is and it will be stored back into the exported @file according
* to rules on metadata export shared across formats.
*
* Returns: (transfer full): the @procedure's return values.
*
* Since: 3.0
**/
typedef GimpValueArray * (* GimpRunExportFunc) (GimpProcedure *procedure,
GimpRunMode run_mode,
GimpImage *image,
gint n_drawables,
GimpDrawable **drawables,
GFile *file,
GimpMetadata *metadata,
GimpProcedureConfig *config,
gpointer run_data);
#define GIMP_TYPE_EXPORT_PROCEDURE (gimp_export_procedure_get_type ())
#define GIMP_EXPORT_PROCEDURE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GIMP_TYPE_EXPORT_PROCEDURE, GimpExportProcedure))
#define GIMP_EXPORT_PROCEDURE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GIMP_TYPE_EXPORT_PROCEDURE, GimpExportProcedureClass))
#define GIMP_IS_EXPORT_PROCEDURE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GIMP_TYPE_EXPORT_PROCEDURE))
#define GIMP_IS_EXPORT_PROCEDURE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_EXPORT_PROCEDURE))
#define GIMP_EXPORT_PROCEDURE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GIMP_TYPE_EXPORT_PROCEDURE, GimpExportProcedureClass))
typedef struct _GimpExportProcedure GimpExportProcedure;
typedef struct _GimpExportProcedureClass GimpExportProcedureClass;
typedef struct _GimpExportProcedurePrivate GimpExportProcedurePrivate;
struct _GimpExportProcedure
{
GimpFileProcedure parent_instance;
GimpExportProcedurePrivate *priv;
};
struct _GimpExportProcedureClass
{
GimpFileProcedureClass parent_class;
};
GType gimp_export_procedure_get_type (void) G_GNUC_CONST;
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);
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
#endif /* __GIMP_EXPORT_PROCEDURE_H__ */

116
libgimp/gimpsaveproceduredialog.c → libgimp/gimpexportproceduredialog.c
View file

@ -1,7 +1,7 @@
/* GIMP - The GNU Image Manipulation Program /* GIMP - The GNU Image Manipulation Program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis * Copyright (C) 1995 Spencer Kimball and Peter Mattis
* *
* gimpsaveproceduredialog.c * gimpexportproceduredialog.c
* Copyright (C) 2020 Jehan * Copyright (C) 2020 Jehan
* *
* This program is free software: you can redistribute it and/or modify * This program is free software: you can redistribute it and/or modify
@ -31,7 +31,7 @@
#include "libgimp-intl.h" #include "libgimp-intl.h"
struct _GimpSaveProcedureDialogPrivate struct _GimpExportProcedureDialogPrivate
{ {
GList *additional_metadata; GList *additional_metadata;
GimpImage *image; GimpImage *image;
@ -41,24 +41,24 @@ struct _GimpSaveProcedureDialogPrivate
}; };
static void gimp_save_procedure_dialog_finalize (GObject *object); static void gimp_export_procedure_dialog_finalize (GObject *object);
static void gimp_save_procedure_dialog_fill_list (GimpProcedureDialog *dialog, static void gimp_export_procedure_dialog_fill_list (GimpProcedureDialog *dialog,
GimpProcedure *procedure, GimpProcedure *procedure,
GimpProcedureConfig *config, GimpProcedureConfig *config,
GList *properties); GList *properties);
static gpointer gimp_save_procedure_dialog_edit_metadata_thread (gpointer data); static gpointer gimp_export_procedure_dialog_edit_metadata_thread (gpointer data);
static gboolean gimp_save_procedure_dialog_activate_edit_metadata (GtkLinkButton *link, static gboolean gimp_export_procedure_dialog_activate_edit_metadata (GtkLinkButton *link,
GimpSaveProcedureDialog *dialog); GimpExportProcedureDialog *dialog);
G_DEFINE_TYPE_WITH_PRIVATE (GimpSaveProcedureDialog, gimp_save_procedure_dialog, GIMP_TYPE_PROCEDURE_DIALOG) G_DEFINE_TYPE_WITH_PRIVATE (GimpExportProcedureDialog, gimp_export_procedure_dialog, GIMP_TYPE_PROCEDURE_DIALOG)
#define parent_class gimp_save_procedure_dialog_parent_class #define parent_class gimp_export_procedure_dialog_parent_class
static void static void
gimp_save_procedure_dialog_class_init (GimpSaveProcedureDialogClass *klass) gimp_export_procedure_dialog_class_init (GimpExportProcedureDialogClass *klass)
{ {
GObjectClass *object_class; GObjectClass *object_class;
GimpProcedureDialogClass *proc_dialog_class; GimpProcedureDialogClass *proc_dialog_class;
@ -66,14 +66,14 @@ gimp_save_procedure_dialog_class_init (GimpSaveProcedureDialogClass *klass)
object_class = G_OBJECT_CLASS (klass); object_class = G_OBJECT_CLASS (klass);
proc_dialog_class = GIMP_PROCEDURE_DIALOG_CLASS (klass); proc_dialog_class = GIMP_PROCEDURE_DIALOG_CLASS (klass);
object_class->finalize = gimp_save_procedure_dialog_finalize; object_class->finalize = gimp_export_procedure_dialog_finalize;
proc_dialog_class->fill_list = gimp_save_procedure_dialog_fill_list; proc_dialog_class->fill_list = gimp_export_procedure_dialog_fill_list;
} }
static void static void
gimp_save_procedure_dialog_init (GimpSaveProcedureDialog *dialog) gimp_export_procedure_dialog_init (GimpExportProcedureDialog *dialog)
{ {
dialog->priv = gimp_save_procedure_dialog_get_instance_private (dialog); dialog->priv = gimp_export_procedure_dialog_get_instance_private (dialog);
dialog->priv->additional_metadata = NULL; dialog->priv->additional_metadata = NULL;
dialog->priv->image = NULL; dialog->priv->image = NULL;
@ -82,9 +82,9 @@ gimp_save_procedure_dialog_init (GimpSaveProcedureDialog *dialog)
} }
static void static void
gimp_save_procedure_dialog_finalize (GObject *object) gimp_export_procedure_dialog_finalize (GObject *object)
{ {
GimpSaveProcedureDialog *dialog = GIMP_SAVE_PROCEDURE_DIALOG (object); GimpExportProcedureDialog *dialog = GIMP_EXPORT_PROCEDURE_DIALOG (object);
g_list_free_full (dialog->priv->additional_metadata, g_free); g_list_free_full (dialog->priv->additional_metadata, g_free);
g_clear_pointer (&dialog->priv->metadata_thread, g_thread_unref); g_clear_pointer (&dialog->priv->metadata_thread, g_thread_unref);
@ -94,39 +94,39 @@ gimp_save_procedure_dialog_finalize (GObject *object)
} }
static void static void
gimp_save_procedure_dialog_fill_list (GimpProcedureDialog *dialog, gimp_export_procedure_dialog_fill_list (GimpProcedureDialog *dialog,
GimpProcedure *procedure, GimpProcedure *procedure,
GimpProcedureConfig *config, GimpProcedureConfig *config,
GList *properties) GList *properties)
{ {
GimpSaveProcedureDialog *save_dialog; GimpExportProcedureDialog *export_dialog;
GimpSaveProcedure *save_procedure; GimpExportProcedure *export_procedure;
GtkWidget *content_area; GtkWidget *content_area;
GList *properties2 = NULL; GList *properties2 = NULL;
GList *iter; GList *iter;
save_dialog = GIMP_SAVE_PROCEDURE_DIALOG (dialog); export_dialog = GIMP_EXPORT_PROCEDURE_DIALOG (dialog);
save_procedure = GIMP_SAVE_PROCEDURE (procedure); export_procedure = GIMP_EXPORT_PROCEDURE (procedure);
content_area = gtk_dialog_get_content_area (GTK_DIALOG (dialog)); content_area = gtk_dialog_get_content_area (GTK_DIALOG (dialog));
for (iter = properties; iter; iter = iter->next) for (iter = properties; iter; iter = iter->next)
{ {
gchar *propname = iter->data; gchar *propname = iter->data;
if ((gimp_save_procedure_get_support_exif (save_procedure) && if ((gimp_export_procedure_get_support_exif (export_procedure) &&
g_strcmp0 (propname, "save-exif") == 0) || g_strcmp0 (propname, "save-exif") == 0) ||
(gimp_save_procedure_get_support_iptc (save_procedure) && (gimp_export_procedure_get_support_iptc (export_procedure) &&
g_strcmp0 (propname, "save-iptc") == 0) || g_strcmp0 (propname, "save-iptc") == 0) ||
(gimp_save_procedure_get_support_xmp (save_procedure) && (gimp_export_procedure_get_support_xmp (export_procedure) &&
g_strcmp0 (propname, "save-xmp") == 0) || g_strcmp0 (propname, "save-xmp") == 0) ||
(gimp_save_procedure_get_support_profile (save_procedure) && (gimp_export_procedure_get_support_profile (export_procedure) &&
g_strcmp0 (propname, "save-color-profile") == 0) || g_strcmp0 (propname, "save-color-profile") == 0) ||
(gimp_save_procedure_get_support_thumbnail (save_procedure) && (gimp_export_procedure_get_support_thumbnail (export_procedure) &&
g_strcmp0 (propname, "save-thumbnail") == 0) || g_strcmp0 (propname, "save-thumbnail") == 0) ||
(gimp_save_procedure_get_support_comment (save_procedure) && (gimp_export_procedure_get_support_comment (export_procedure) &&
(g_strcmp0 (propname, "save-comment") == 0 || (g_strcmp0 (propname, "save-comment") == 0 ||
g_strcmp0 (propname, "gimp-comment") == 0)) || g_strcmp0 (propname, "gimp-comment") == 0)) ||
g_list_find (save_dialog->priv->additional_metadata, propname)) g_list_find (export_dialog->priv->additional_metadata, propname))
/* Ignoring the standards and custom metadata. */ /* Ignoring the standards and custom metadata. */
continue; continue;
@ -137,13 +137,13 @@ gimp_save_procedure_dialog_fill_list (GimpProcedureDialog *dialog,
g_list_free (properties2); g_list_free (properties2);
if (gimp_save_procedure_get_support_exif (save_procedure) || if (gimp_export_procedure_get_support_exif (export_procedure) ||
gimp_save_procedure_get_support_iptc (save_procedure) || gimp_export_procedure_get_support_iptc (export_procedure) ||
gimp_save_procedure_get_support_xmp (save_procedure) || gimp_export_procedure_get_support_xmp (export_procedure) ||
gimp_save_procedure_get_support_profile (save_procedure) || gimp_export_procedure_get_support_profile (export_procedure) ||
gimp_save_procedure_get_support_thumbnail (save_procedure) || gimp_export_procedure_get_support_thumbnail (export_procedure) ||
g_list_length (save_dialog->priv->additional_metadata) > 0 || g_list_length (export_dialog->priv->additional_metadata) > 0 ||
gimp_save_procedure_get_support_comment (save_procedure)) gimp_export_procedure_get_support_comment (export_procedure))
{ {
GtkWidget *frame; GtkWidget *frame;
GtkWidget *frame_title; GtkWidget *frame_title;
@ -175,7 +175,7 @@ gimp_save_procedure_dialog_fill_list (GimpProcedureDialog *dialog,
link = gtk_link_button_new_with_label (_("Edit Metadata"), _("(edit)")); link = gtk_link_button_new_with_label (_("Edit Metadata"), _("(edit)"));
gtk_link_button_set_visited (GTK_LINK_BUTTON (link), FALSE); gtk_link_button_set_visited (GTK_LINK_BUTTON (link), FALSE);
g_signal_connect (link, "activate-link", g_signal_connect (link, "activate-link",
G_CALLBACK (gimp_save_procedure_dialog_activate_edit_metadata), G_CALLBACK (gimp_export_procedure_dialog_activate_edit_metadata),
dialog); dialog);
gtk_box_pack_start (GTK_BOX (frame_title), link, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (frame_title), link, FALSE, FALSE, 0);
gtk_widget_show (link); gtk_widget_show (link);
@ -191,14 +191,14 @@ gimp_save_procedure_dialog_fill_list (GimpProcedureDialog *dialog,
gtk_widget_show (grid); gtk_widget_show (grid);
/* Line for 3 metadata formats: Exif, IPTC, XMP. */ /* Line for 3 metadata formats: Exif, IPTC, XMP. */
n_metadata = gimp_save_procedure_get_support_exif (save_procedure) + n_metadata = gimp_export_procedure_get_support_exif (export_procedure) +
gimp_save_procedure_get_support_iptc (save_procedure) + gimp_export_procedure_get_support_iptc (export_procedure) +
gimp_save_procedure_get_support_xmp (save_procedure); gimp_export_procedure_get_support_xmp (export_procedure);
n_metadata = MAX (n_metadata, n_metadata = MAX (n_metadata,
gimp_save_procedure_get_support_profile (save_procedure) + gimp_export_procedure_get_support_profile (export_procedure) +
gimp_save_procedure_get_support_thumbnail (save_procedure)); gimp_export_procedure_get_support_thumbnail (export_procedure));
if (gimp_save_procedure_get_support_exif (save_procedure)) if (gimp_export_procedure_get_support_exif (export_procedure))
{ {
widget = gimp_prop_check_button_new (G_OBJECT (config), widget = gimp_prop_check_button_new (G_OBJECT (config),
"save-exif", NULL); "save-exif", NULL);
@ -208,7 +208,7 @@ gimp_save_procedure_dialog_fill_list (GimpProcedureDialog *dialog,
top = 1; top = 1;
gtk_widget_show (widget); gtk_widget_show (widget);
} }
if (gimp_save_procedure_get_support_iptc (save_procedure)) if (gimp_export_procedure_get_support_iptc (export_procedure))
{ {
widget = gimp_prop_check_button_new (G_OBJECT (config), widget = gimp_prop_check_button_new (G_OBJECT (config),
"save-iptc", NULL); "save-iptc", NULL);
@ -218,7 +218,7 @@ gimp_save_procedure_dialog_fill_list (GimpProcedureDialog *dialog,
top = 1; top = 1;
gtk_widget_show (widget); gtk_widget_show (widget);
} }
if (gimp_save_procedure_get_support_xmp (save_procedure)) if (gimp_export_procedure_get_support_xmp (export_procedure))
{ {
widget = gimp_prop_check_button_new (G_OBJECT (config), widget = gimp_prop_check_button_new (G_OBJECT (config),
"save-xmp", NULL); "save-xmp", NULL);
@ -232,7 +232,7 @@ gimp_save_procedure_dialog_fill_list (GimpProcedureDialog *dialog,
/* Line for specific metadata: profile, thumbnail. */ /* Line for specific metadata: profile, thumbnail. */
left = 0; left = 0;
if (gimp_save_procedure_get_support_profile (save_procedure)) if (gimp_export_procedure_get_support_profile (export_procedure))
{ {
widget = gimp_prop_check_button_new (G_OBJECT (config), widget = gimp_prop_check_button_new (G_OBJECT (config),
"save-color-profile", NULL); "save-color-profile", NULL);
@ -241,7 +241,7 @@ gimp_save_procedure_dialog_fill_list (GimpProcedureDialog *dialog,
left += 6 / n_metadata; left += 6 / n_metadata;
gtk_widget_show (widget); gtk_widget_show (widget);
} }
if (gimp_save_procedure_get_support_thumbnail (save_procedure)) if (gimp_export_procedure_get_support_thumbnail (export_procedure))
{ {
widget = gimp_prop_check_button_new (G_OBJECT (config), widget = gimp_prop_check_button_new (G_OBJECT (config),
"save-thumbnail", NULL); "save-thumbnail", NULL);
@ -255,7 +255,7 @@ gimp_save_procedure_dialog_fill_list (GimpProcedureDialog *dialog,
/* Custom metadata: n_metadata items per line. */ /* Custom metadata: n_metadata items per line. */
left = 0; left = 0;
for (iter = save_dialog->priv->additional_metadata; iter; iter = iter->next) for (iter = export_dialog->priv->additional_metadata; iter; iter = iter->next)
{ {
widget = gimp_procedure_dialog_get_widget (dialog, iter->data, G_TYPE_NONE); widget = gimp_procedure_dialog_get_widget (dialog, iter->data, G_TYPE_NONE);
gtk_grid_attach (GTK_GRID (grid), widget, left, top, 6 / n_metadata, 1); gtk_grid_attach (GTK_GRID (grid), widget, left, top, 6 / n_metadata, 1);
@ -271,7 +271,7 @@ gimp_save_procedure_dialog_fill_list (GimpProcedureDialog *dialog,
top++; top++;
/* Last line for comment field. */ /* Last line for comment field. */
if (gimp_save_procedure_get_support_comment (save_procedure)) if (gimp_export_procedure_get_support_comment (export_procedure))
{ {
GtkTextBuffer *buffer; GtkTextBuffer *buffer;
const gchar *tooltip; const gchar *tooltip;
@ -325,9 +325,9 @@ gimp_save_procedure_dialog_fill_list (GimpProcedureDialog *dialog,
} }
static gpointer static gpointer
gimp_save_procedure_dialog_edit_metadata_thread (gpointer data) gimp_export_procedure_dialog_edit_metadata_thread (gpointer data)
{ {
GimpSaveProcedureDialog *dialog = data; GimpExportProcedureDialog *dialog = data;
GimpProcedure *procedure; GimpProcedure *procedure;
procedure = gimp_pdb_lookup_procedure (gimp_get_pdb (), "plug-in-metadata-editor"); procedure = gimp_pdb_lookup_procedure (gimp_get_pdb (), "plug-in-metadata-editor");
@ -345,8 +345,8 @@ gimp_save_procedure_dialog_edit_metadata_thread (gpointer data)
} }
static gboolean static gboolean
gimp_save_procedure_dialog_activate_edit_metadata (GtkLinkButton *link, gimp_export_procedure_dialog_activate_edit_metadata (GtkLinkButton *link,
GimpSaveProcedureDialog *dialog) GimpExportProcedureDialog *dialog)
{ {
gtk_link_button_set_visited (link, TRUE); gtk_link_button_set_visited (link, TRUE);
@ -355,7 +355,7 @@ gimp_save_procedure_dialog_activate_edit_metadata (GtkLinkButton *link
if (! dialog->priv->metadata_thread) if (! dialog->priv->metadata_thread)
/* Only run if not already running. */ /* Only run if not already running. */
dialog->priv->metadata_thread = g_thread_try_new ("Edit Metadata", dialog->priv->metadata_thread = g_thread_try_new ("Edit Metadata",
gimp_save_procedure_dialog_edit_metadata_thread, gimp_export_procedure_dialog_edit_metadata_thread,
dialog, NULL); dialog, NULL);
g_mutex_unlock (&dialog->priv->metadata_thread_mutex); g_mutex_unlock (&dialog->priv->metadata_thread_mutex);
@ -369,7 +369,7 @@ gimp_save_procedure_dialog_activate_edit_metadata (GtkLinkButton *link
GtkWidget * GtkWidget *
gimp_save_procedure_dialog_new (GimpSaveProcedure *procedure, gimp_export_procedure_dialog_new (GimpExportProcedure *procedure,
GimpProcedureConfig *config, GimpProcedureConfig *config,
GimpImage *image) GimpImage *image)
{ {
@ -379,7 +379,7 @@ gimp_save_procedure_dialog_new (GimpSaveProcedure *procedure,
const gchar *help_id; const gchar *help_id;
gboolean use_header_bar; gboolean use_header_bar;
g_return_val_if_fail (GIMP_IS_SAVE_PROCEDURE (procedure), NULL); g_return_val_if_fail (GIMP_IS_EXPORT_PROCEDURE (procedure), NULL);
g_return_val_if_fail (GIMP_IS_PROCEDURE_CONFIG (config), NULL); g_return_val_if_fail (GIMP_IS_PROCEDURE_CONFIG (config), NULL);
g_return_val_if_fail (gimp_procedure_config_get_procedure (config) == g_return_val_if_fail (gimp_procedure_config_get_procedure (config) ==
GIMP_PROCEDURE (procedure), NULL); GIMP_PROCEDURE (procedure), NULL);
@ -403,7 +403,7 @@ gimp_save_procedure_dialog_new (GimpSaveProcedure *procedure,
"gtk-dialogs-use-header", &use_header_bar, "gtk-dialogs-use-header", &use_header_bar,
NULL); NULL);
dialog = g_object_new (GIMP_TYPE_SAVE_PROCEDURE_DIALOG, dialog = g_object_new (GIMP_TYPE_EXPORT_PROCEDURE_DIALOG,
"procedure", procedure, "procedure", procedure,
"config", config, "config", config,
"title", title, "title", title,
@ -411,14 +411,14 @@ gimp_save_procedure_dialog_new (GimpSaveProcedure *procedure,
"help-id", help_id, "help-id", help_id,
"use-header-bar", use_header_bar, "use-header-bar", use_header_bar,
NULL); NULL);
GIMP_SAVE_PROCEDURE_DIALOG (dialog)->priv->image = image; GIMP_EXPORT_PROCEDURE_DIALOG (dialog)->priv->image = image;
g_free (title); g_free (title);
return dialog; return dialog;
} }
void void
gimp_save_procedure_dialog_add_metadata (GimpSaveProcedureDialog *dialog, gimp_export_procedure_dialog_add_metadata (GimpExportProcedureDialog *dialog,
const gchar *property) const gchar *property)
{ {
if (! g_list_find (dialog->priv->additional_metadata, property)) if (! g_list_find (dialog->priv->additional_metadata, property))

79
libgimp/gimpexportproceduredialog.h Normal file
View file

@ -0,0 +1,79 @@
/* GIMP - The GNU Image Manipulation Program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* gimpexportproceduredialog.h
* Copyright (C) 2020 Jehan
*
* 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 <https://www.gnu.org/licenses/>.
*/
#if !defined (__GIMP_UI_H_INSIDE__) && !defined (GIMP_COMPILATION)
#error "Only <libgimp/gimpui.h> can be included directly."
#endif
#ifndef __GIMP_EXPORT_PROCEDURE_DIALOG_H__
#define __GIMP_EXPORT_PROCEDURE_DIALOG_H__
G_BEGIN_DECLS
/* For information look into the C source or the html documentation */
#define GIMP_TYPE_EXPORT_PROCEDURE_DIALOG (gimp_export_procedure_dialog_get_type ())
#define GIMP_EXPORT_PROCEDURE_DIALOG(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GIMP_TYPE_EXPORT_PROCEDURE_DIALOG, GimpExportProcedureDialog))
#define GIMP_EXPORT_PROCEDURE_DIALOG_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GIMP_TYPE_EXPORT_PROCEDURE_DIALOG, GimpExportProcedureDialogClass))
#define GIMP_IS_EXPORT_PROCEDURE_DIALOG(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GIMP_TYPE_EXPORT_PROCEDURE_DIALOG))
#define GIMP_IS_EXPORT_PROCEDURE_DIALOG_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_EXPORT_PROCEDURE_DIALOG))
#define GIMP_EXPORT_PROCEDURE_DIALOG_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GIMP_TYPE_EXPORT_PROCEDURE_DIALOG, GimpExportProcedureDialogClass))
typedef struct _GimpExportProcedureDialogClass GimpExportProcedureDialogClass;
typedef struct _GimpExportProcedureDialogPrivate GimpExportProcedureDialogPrivate;
struct _GimpExportProcedureDialog
{
GimpProcedureDialog parent_instance;
GimpExportProcedureDialogPrivate *priv;
};
struct _GimpExportProcedureDialogClass
{
GimpProcedureDialogClass parent_class;
/* Padding for future expansion */
void (*_gimp_reserved1) (void);
void (*_gimp_reserved2) (void);
void (*_gimp_reserved3) (void);
void (*_gimp_reserved4) (void);
void (*_gimp_reserved5) (void);
void (*_gimp_reserved6) (void);
void (*_gimp_reserved7) (void);
void (*_gimp_reserved8) (void);
};
GType gimp_export_procedure_dialog_get_type (void) G_GNUC_CONST;
GtkWidget * gimp_export_procedure_dialog_new (GimpExportProcedure *procedure,
GimpProcedureConfig *config,
GimpImage *image);
void gimp_export_procedure_dialog_add_metadata (GimpExportProcedureDialog *dialog,
const gchar *property);
G_END_DECLS
#endif /* __GIMP_EXPORT_PROCEDURE_DIALOG_H__ */

2
libgimp/gimpfileprocedure.c
View file

@ -105,7 +105,7 @@ gimp_file_procedure_finalize (GObject *object)
* *
* This name can be used for any public-facing strings, such as * This name can be used for any public-facing strings, such as
* graphical interface labels. An example usage would be * graphical interface labels. An example usage would be
* %GimpSaveProcedureDialog title looking like "Export Image as %s". * %GimpExportProcedureDialog title looking like "Export Image as %s".
* *
* Note that since the format name is public-facing, it is recommended * Note that since the format name is public-facing, it is recommended
* to localize it at runtime, for instance through gettext, like: * to localize it at runtime, for instance through gettext, like:

2
libgimp/gimploadprocedure.c
View file

@ -284,7 +284,7 @@ gimp_load_procedure_run (GimpProcedure *procedure,
plug_in = gimp_procedure_get_plug_in (procedure); plug_in = gimp_procedure_get_plug_in (procedure);
if (G_OBJECT (config)->ref_count > 1 && if (G_OBJECT (config)->ref_count > 1 &&
_gimp_plug_in_manage_memory_manually (plug_in)) _gimp_plug_in_manage_memory_manually (plug_in))
g_printerr ("%s: ERROR: the GimpSaveProcedureConfig object was refed " g_printerr ("%s: ERROR: the GimpExportProcedureConfig object was refed "
"by plug-in, it MUST NOT do that!\n", G_STRFUNC); "by plug-in, it MUST NOT do that!\n", G_STRFUNC);
g_object_unref (config); g_object_unref (config);

10
libgimp/gimpprocedureconfig.c
View file

@ -369,10 +369,10 @@ gimp_procedure_config_set_parasite (GimpProcedureConfig *config,
* @file: the file @exported_image was written to * @file: the file @exported_image was written to
* *
* Note: There is normally no need to call this function because it's * Note: There is normally no need to call this function because it's
* already called by [class@SaveProcedure] at the end of the `run()` callback. * already called by [class@ExportProcedure] at the end of the `run()` callback.
* *
* Only use this function if the [class@Metadata] passed as argument of a * Only use this function if the [class@Metadata] passed as argument of a
* [class@SaveProcedure]'s run() method needs to be written at a specific * [class@ExportProcedure]'s run() method needs to be written at a specific
* point of the export, other than its end. * point of the export, other than its end.
* *
* This function syncs back @config's export properties to the * This function syncs back @config's export properties to the
@ -781,7 +781,7 @@ _gimp_procedure_config_end_run (GimpProcedureConfig *config,
* @mime_type: (nullable): exported file format's mime type, or %NULL. * @mime_type: (nullable): exported file format's mime type, or %NULL.
* *
* This is a variant of [method@ProcedureConfig.begin_run] to be used * This is a variant of [method@ProcedureConfig.begin_run] to be used
* by file export procedures using [class@SaveProcedure]. It must be * by file export procedures using [class@ExportProcedure]. It must be
* paired with a call to [method@ProcedureConfig.end_export] at the end * paired with a call to [method@ProcedureConfig.end_export] at the end
* of run(). * of run().
* *
@ -794,7 +794,7 @@ _gimp_procedure_config_end_run (GimpProcedureConfig *config,
* properties. (The corresponding [method@Image.metadata_save_finish] * properties. (The corresponding [method@Image.metadata_save_finish]
* will be called by [method@ProcedureConfig.end_export]). * will be called by [method@ProcedureConfig.end_export]).
* *
* The following boolean arguments of the used [class@SaveProcedure] are * The following boolean arguments of the used [class@ExportProcedure] are
* synced. The procedure can but must not provide these arguments. * synced. The procedure can but must not provide these arguments.
* *
* - "save-exif" for %GIMP_METADATA_SAVE_EXIF. * - "save-exif" for %GIMP_METADATA_SAVE_EXIF.
@ -887,7 +887,7 @@ _gimp_procedure_config_begin_export (GimpProcedureConfig *config,
* @status: the return status of the [class@Procedure]'s run() * @status: the return status of the [class@Procedure]'s run()
* *
* This is a variant of [method@ProcedureConfig.end_run] to be used by * This is a variant of [method@ProcedureConfig.end_run] to be used by
* file export procedures using [class@SaveProcedure]. It must be paired * file export procedures using [class@ExportProcedure]. It must be paired
* with a call to [method@ProcedureConfig.begin_export] at the * with a call to [method@ProcedureConfig.begin_export] at the
* beginning of run(). * beginning of run().
* *

4
libgimp/gimpproceduredialog.c
View file

@ -292,7 +292,7 @@ gimp_procedure_dialog_constructed (GObject *object)
if (GIMP_IS_LOAD_PROCEDURE (procedure)) if (GIMP_IS_LOAD_PROCEDURE (procedure))
ok_label = _("_Open"); ok_label = _("_Open");
else if (GIMP_IS_SAVE_PROCEDURE (procedure)) else if (GIMP_IS_EXPORT_PROCEDURE (procedure))
ok_label = _("_Export"); ok_label = _("_Export");
else else
ok_label = _("_OK"); ok_label = _("_OK");
@ -565,7 +565,7 @@ gimp_procedure_dialog_set_ok_label (GimpProcedureDialog *dialog,
if (GIMP_IS_LOAD_PROCEDURE (procedure)) if (GIMP_IS_LOAD_PROCEDURE (procedure))
ok_label = _("_Open"); ok_label = _("_Open");
else if (GIMP_IS_SAVE_PROCEDURE (procedure)) else if (GIMP_IS_EXPORT_PROCEDURE (procedure))
ok_label = _("_Export"); ok_label = _("_Export");
else else
ok_label = _("_OK"); ok_label = _("_OK");

127
libgimp/gimpsaveprocedure.h
View file

@ -1,127 +0,0 @@
/* GIMP - The GNU Image Manipulation Program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* gimpsaveprocedure.h
* Copyright (C) 2019 Michael Natterer <mitch@gimp.org>
*
* 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
* <https://www.gnu.org/licenses/>.
*/
#ifndef __GIMP_SAVE_PROCEDURE_H__
#define __GIMP_SAVE_PROCEDURE_H__
#include <libgimp/gimpfileprocedure.h>
G_BEGIN_DECLS
/* For information look into the C source or the html documentation */
/**
* GimpRunSaveFunc:
* @procedure: the #GimpProcedure that runs.
* @run_mode: the #GimpRunMode.
* @image: the image to save.
* @n_drawables: the number of drawables to save.
* @drawables: (array length=n_drawables): the drawables to save.
* @file: the #GFile to save to.
* @metadata: metadata object prepared for the mimetype passed in
* gimp_file_procedure_set_mime_types() if export_metadata
* argument was set in gimp_save_procedure_new().
* @config: the @procedure's remaining arguments.
* @run_data: (closure): the run_data given in gimp_save_procedure_new().
*
* The save function is run during the lifetime of the GIMP session,
* each time a plug-in save procedure is called.
*
* If a MimeType was passed in gimp_save_procedure_new(), then @metadata will be
* non-%NULL and can be tweaked by the run() function if needed. Otherwise you
* can let it as-is and it will be stored back into the exported @file according
* to rules on metadata export shared across formats.
*
* Returns: (transfer full): the @procedure's return values.
*
* Since: 3.0
**/
typedef GimpValueArray * (* GimpRunSaveFunc) (GimpProcedure *procedure,
GimpRunMode run_mode,
GimpImage *image,
gint n_drawables,
GimpDrawable **drawables,
GFile *file,
GimpMetadata *metadata,
GimpProcedureConfig *config,
gpointer run_data);
#define GIMP_TYPE_SAVE_PROCEDURE (gimp_save_procedure_get_type ())
#define GIMP_SAVE_PROCEDURE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GIMP_TYPE_SAVE_PROCEDURE, GimpSaveProcedure))
#define GIMP_SAVE_PROCEDURE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GIMP_TYPE_SAVE_PROCEDURE, GimpSaveProcedureClass))
#define GIMP_IS_SAVE_PROCEDURE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GIMP_TYPE_SAVE_PROCEDURE))
#define GIMP_IS_SAVE_PROCEDURE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_SAVE_PROCEDURE))
#define GIMP_SAVE_PROCEDURE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GIMP_TYPE_SAVE_PROCEDURE, GimpSaveProcedureClass))
typedef struct _GimpSaveProcedure GimpSaveProcedure;
typedef struct _GimpSaveProcedureClass GimpSaveProcedureClass;
typedef struct _GimpSaveProcedurePrivate GimpSaveProcedurePrivate;
struct _GimpSaveProcedure
{
GimpFileProcedure parent_instance;
GimpSaveProcedurePrivate *priv;
};
struct _GimpSaveProcedureClass
{
GimpFileProcedureClass parent_class;
};
GType gimp_save_procedure_get_type (void) G_GNUC_CONST;
GimpProcedure * gimp_save_procedure_new (GimpPlugIn *plug_in,
const gchar *name,
GimpPDBProcType proc_type,
gboolean export_metadata,
GimpRunSaveFunc run_func,
gpointer run_data,
GDestroyNotify run_data_destroy);
void gimp_save_procedure_set_support_exif (GimpSaveProcedure *procedure,
gboolean supports);
void gimp_save_procedure_set_support_iptc (GimpSaveProcedure *procedure,
gboolean supports);
void gimp_save_procedure_set_support_xmp (GimpSaveProcedure *procedure,
gboolean supports);
void gimp_save_procedure_set_support_profile (GimpSaveProcedure *procedure,
gboolean supports);
void gimp_save_procedure_set_support_thumbnail (GimpSaveProcedure *procedure,
gboolean supports);
void gimp_save_procedure_set_support_comment (GimpSaveProcedure *procedure,
gboolean supports);
gboolean gimp_save_procedure_get_support_exif (GimpSaveProcedure *procedure);
gboolean gimp_save_procedure_get_support_iptc (GimpSaveProcedure *procedure);
gboolean gimp_save_procedure_get_support_xmp (GimpSaveProcedure *procedure);
gboolean gimp_save_procedure_get_support_profile (GimpSaveProcedure *procedure);
gboolean gimp_save_procedure_get_support_thumbnail (GimpSaveProcedure *procedure);
gboolean gimp_save_procedure_get_support_comment (GimpSaveProcedure *procedure);
G_END_DECLS
#endif /* __GIMP_SAVE_PROCEDURE_H__ */

79
libgimp/gimpsaveproceduredialog.h
View file

@ -1,79 +0,0 @@
/* GIMP - The GNU Image Manipulation Program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* gimpsaveproceduredialog.h
* Copyright (C) 2020 Jehan
*
* 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 <https://www.gnu.org/licenses/>.
*/
#if !defined (__GIMP_UI_H_INSIDE__) && !defined (GIMP_COMPILATION)
#error "Only <libgimp/gimpui.h> can be included directly."
#endif
#ifndef __GIMP_SAVE_PROCEDURE_DIALOG_H__
#define __GIMP_SAVE_PROCEDURE_DIALOG_H__
G_BEGIN_DECLS
/* For information look into the C source or the html documentation */
#define GIMP_TYPE_SAVE_PROCEDURE_DIALOG (gimp_save_procedure_dialog_get_type ())
#define GIMP_SAVE_PROCEDURE_DIALOG(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GIMP_TYPE_SAVE_PROCEDURE_DIALOG, GimpSaveProcedureDialog))
#define GIMP_SAVE_PROCEDURE_DIALOG_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GIMP_TYPE_SAVE_PROCEDURE_DIALOG, GimpSaveProcedureDialogClass))
#define GIMP_IS_SAVE_PROCEDURE_DIALOG(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GIMP_TYPE_SAVE_PROCEDURE_DIALOG))
#define GIMP_IS_SAVE_PROCEDURE_DIALOG_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_SAVE_PROCEDURE_DIALOG))
#define GIMP_SAVE_PROCEDURE_DIALOG_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GIMP_TYPE_SAVE_PROCEDURE_DIALOG, GimpSaveProcedureDialogClass))
typedef struct _GimpSaveProcedureDialogClass GimpSaveProcedureDialogClass;
typedef struct _GimpSaveProcedureDialogPrivate GimpSaveProcedureDialogPrivate;
struct _GimpSaveProcedureDialog
{
GimpProcedureDialog parent_instance;
GimpSaveProcedureDialogPrivate *priv;
};
struct _GimpSaveProcedureDialogClass
{
GimpProcedureDialogClass parent_class;
/* Padding for future expansion */
void (*_gimp_reserved1) (void);
void (*_gimp_reserved2) (void);
void (*_gimp_reserved3) (void);
void (*_gimp_reserved4) (void);
void (*_gimp_reserved5) (void);
void (*_gimp_reserved6) (void);
void (*_gimp_reserved7) (void);
void (*_gimp_reserved8) (void);
};
GType gimp_save_procedure_dialog_get_type (void) G_GNUC_CONST;
GtkWidget * gimp_save_procedure_dialog_new (GimpSaveProcedure *procedure,
GimpProcedureConfig *config,
GimpImage *image);
void gimp_save_procedure_dialog_add_metadata (GimpSaveProcedureDialog *dialog,
const gchar *property);
G_END_DECLS
#endif /* __GIMP_SAVE_PROCEDURE_DIALOG_H__ */

6
libgimp/gimpui.def
View file

@ -18,6 +18,9 @@ EXPORTS
gimp_export_dialog_get_content_area gimp_export_dialog_get_content_area
gimp_export_dialog_new gimp_export_dialog_new
gimp_export_image gimp_export_image
gimp_export_procedure_dialog_add_metadata
gimp_export_procedure_dialog_get_type
gimp_export_procedure_dialog_new
gimp_font_chooser_get_type gimp_font_chooser_get_type
gimp_font_chooser_new gimp_font_chooser_new
gimp_gradient_chooser_get_type gimp_gradient_chooser_get_type
@ -76,9 +79,6 @@ EXPORTS
gimp_resource_chooser_set_clickable gimp_resource_chooser_set_clickable
gimp_resource_chooser_set_drag_target gimp_resource_chooser_set_drag_target
gimp_resource_chooser_set_resource gimp_resource_chooser_set_resource
gimp_save_procedure_dialog_add_metadata
gimp_save_procedure_dialog_get_type
gimp_save_procedure_dialog_new
gimp_ui_init gimp_ui_init
gimp_vectors_combo_box_get_type gimp_vectors_combo_box_get_type
gimp_vectors_combo_box_new gimp_vectors_combo_box_new

2
libgimp/gimpui.h
View file

@ -42,11 +42,11 @@
#include <libgimp/gimppatternchooser.h> #include <libgimp/gimppatternchooser.h>
#include <libgimp/gimpprocbrowserdialog.h> #include <libgimp/gimpprocbrowserdialog.h>
#include <libgimp/gimpproceduredialog.h> #include <libgimp/gimpproceduredialog.h>
#include <libgimp/gimpexportproceduredialog.h>
#include <libgimp/gimpprocview.h> #include <libgimp/gimpprocview.h>
#include <libgimp/gimpprogressbar.h> #include <libgimp/gimpprogressbar.h>
#include <libgimp/gimppropwidgets.h> #include <libgimp/gimppropwidgets.h>
#include <libgimp/gimpresourcechooser.h> #include <libgimp/gimpresourcechooser.h>
#include <libgimp/gimpsaveproceduredialog.h>
#include <libgimp/gimpzoompreview.h> #include <libgimp/gimpzoompreview.h>
#undef __GIMP_UI_H_INSIDE__ #undef __GIMP_UI_H_INSIDE__

2
libgimp/gimpuitypes.h
View file

@ -29,7 +29,7 @@ G_BEGIN_DECLS
typedef struct _GimpProcedureDialog GimpProcedureDialog; typedef struct _GimpProcedureDialog GimpProcedureDialog;
typedef struct _GimpSaveProcedureDialog GimpSaveProcedureDialog; typedef struct _GimpExportProcedureDialog GimpExportProcedureDialog;
typedef struct _GimpAspectPreview GimpAspectPreview; typedef struct _GimpAspectPreview GimpAspectPreview;
typedef struct _GimpDrawablePreview GimpDrawablePreview; typedef struct _GimpDrawablePreview GimpDrawablePreview;

8
libgimp/meson.build
View file

@ -198,7 +198,7 @@ libgimp_sources_introspectable = [
'gimpprogress.c', 'gimpprogress.c',
'gimpresource.c', 'gimpresource.c',
'gimpresourceselect.c', 'gimpresourceselect.c',
'gimpsaveprocedure.c', 'gimpexportprocedure.c',
'gimpselection.c', 'gimpselection.c',
'gimptextlayer.c', 'gimptextlayer.c',
'gimpthumbnailprocedure.c', 'gimpthumbnailprocedure.c',
@ -256,7 +256,7 @@ libgimp_headers_introspectable = [
'gimpprogress.h', 'gimpprogress.h',
'gimpresource.h', 'gimpresource.h',
'gimpresourceselect.h', 'gimpresourceselect.h',
'gimpsaveprocedure.h', 'gimpexportprocedure.h',
'gimpselection.h', 'gimpselection.h',
'gimptextlayer.h', 'gimptextlayer.h',
'gimpthumbnailprocedure.h', 'gimpthumbnailprocedure.h',
@ -287,7 +287,7 @@ libgimpui_sources_introspectable = [
'gimpprogressbar.c', 'gimpprogressbar.c',
'gimppropwidgets.c', 'gimppropwidgets.c',
'gimpresourcechooser.c', 'gimpresourcechooser.c',
'gimpsaveproceduredialog.c', 'gimpexportproceduredialog.c',
'gimpui.c', 'gimpui.c',
'gimpzoompreview.c', 'gimpzoompreview.c',
] ]
@ -320,7 +320,7 @@ libgimpui_headers_introspectable = [
'gimpprogressbar.h', 'gimpprogressbar.h',
'gimppropwidgets.h', 'gimppropwidgets.h',
'gimpresourcechooser.h', 'gimpresourcechooser.h',
'gimpsaveproceduredialog.h', 'gimpexportproceduredialog.h',
'gimpzoompreview.h', 'gimpzoompreview.h',
] ]

4
plug-ins/common/file-aa.c
View file

@ -123,7 +123,7 @@ ascii_create_procedure (GimpPlugIn *plug_in,
{ {
gint i; gint i;
procedure = gimp_save_procedure_new (plug_in, name, procedure = gimp_export_procedure_new (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN, GIMP_PDB_PROC_TYPE_PLUGIN,
FALSE, ascii_export, NULL, NULL); FALSE, ascii_export, NULL, NULL);
@ -377,7 +377,7 @@ save_dialog (GimpProcedure *procedure,
gint i; gint i;
gboolean run; gboolean run;
dialog = gimp_save_procedure_dialog_new (GIMP_SAVE_PROCEDURE (procedure), dialog = gimp_export_procedure_dialog_new (GIMP_EXPORT_PROCEDURE (procedure),
GIMP_PROCEDURE_CONFIG (config), GIMP_PROCEDURE_CONFIG (config),
image); image);

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

@ -162,7 +162,7 @@ cel_create_procedure (GimpPlugIn *plug_in,
} }
else if (! strcmp (name, EXPORT_PROC)) else if (! strcmp (name, EXPORT_PROC))
{ {
procedure = gimp_save_procedure_new (plug_in, name, procedure = gimp_export_procedure_new (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN, GIMP_PDB_PROC_TYPE_PLUGIN,
FALSE, cel_export, NULL, NULL); FALSE, cel_export, NULL, NULL);

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

@ -331,7 +331,7 @@ compressor_create_procedure (GimpPlugIn *plug_in,
} }
else if (! strcmp (name, compressor->save_proc)) else if (! strcmp (name, compressor->save_proc))
{ {
procedure = gimp_save_procedure_new (plug_in, name, procedure = gimp_export_procedure_new (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN, GIMP_PDB_PROC_TYPE_PLUGIN,
FALSE, compressor_export, FALSE, compressor_export,
(gpointer) compressor, NULL); (gpointer) compressor, NULL);

4
plug-ins/common/file-csource.c
View file

@ -114,7 +114,7 @@ csource_create_procedure (GimpPlugIn *plug_in,
if (! strcmp (name, EXPORT_PROC)) if (! strcmp (name, EXPORT_PROC))
{ {
procedure = gimp_save_procedure_new (plug_in, name, procedure = gimp_export_procedure_new (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN, GIMP_PDB_PROC_TYPE_PLUGIN,
FALSE, csource_export, NULL, NULL); FALSE, csource_export, NULL, NULL);
@ -958,7 +958,7 @@ save_dialog (GimpImage *image,
GtkWidget *vbox; GtkWidget *vbox;
gboolean run; gboolean run;
dialog = gimp_save_procedure_dialog_new (GIMP_SAVE_PROCEDURE (procedure), dialog = gimp_export_procedure_dialog_new (GIMP_EXPORT_PROCEDURE (procedure),
GIMP_PROCEDURE_CONFIG (config), GIMP_PROCEDURE_CONFIG (config),
image); image);

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

@ -198,7 +198,7 @@ dicom_create_procedure (GimpPlugIn *plug_in,
} }
else if (! strcmp (name, EXPORT_PROC)) else if (! strcmp (name, EXPORT_PROC))
{ {
procedure = gimp_save_procedure_new (plug_in, name, procedure = gimp_export_procedure_new (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN, GIMP_PDB_PROC_TYPE_PLUGIN,
FALSE, dicom_export, NULL, NULL); FALSE, dicom_export, NULL, NULL);

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

@ -155,7 +155,7 @@ farbfeld_create_procedure (GimpPlugIn *plug_in,
} }
else if (! strcmp (name, EXPORT_PROC)) else if (! strcmp (name, EXPORT_PROC))
{ {
procedure = gimp_save_procedure_new (plug_in, name, procedure = gimp_export_procedure_new (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN, GIMP_PDB_PROC_TYPE_PLUGIN,
FALSE, farbfeld_export, NULL, NULL); FALSE, farbfeld_export, NULL, NULL);

4
plug-ins/common/file-gbr.c
View file

@ -117,7 +117,7 @@ gbr_create_procedure (GimpPlugIn *plug_in,
if (! strcmp (name, EXPORT_PROC)) if (! strcmp (name, EXPORT_PROC))
{ {
procedure = gimp_save_procedure_new (plug_in, name, procedure = gimp_export_procedure_new (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN, GIMP_PDB_PROC_TYPE_PLUGIN,
FALSE, gbr_export, NULL, NULL); FALSE, gbr_export, NULL, NULL);
@ -290,7 +290,7 @@ save_dialog (GimpProcedure *procedure,
GtkWidget *real_entry; GtkWidget *real_entry;
gboolean run; gboolean run;
dialog = gimp_save_procedure_dialog_new (GIMP_SAVE_PROCEDURE (procedure), dialog = gimp_export_procedure_dialog_new (GIMP_EXPORT_PROCEDURE (procedure),
GIMP_PROCEDURE_CONFIG (config), GIMP_PROCEDURE_CONFIG (config),
image); image);

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

@ -215,7 +215,7 @@ goat_create_procedure (GimpPlugIn *plug_in,
} }
else if (! g_strcmp0 (name, format->export_proc)) else if (! g_strcmp0 (name, format->export_proc))
{ {
procedure = gimp_save_procedure_new (plug_in, name, procedure = gimp_export_procedure_new (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN, GIMP_PDB_PROC_TYPE_PLUGIN,
FALSE, goat_export, FALSE, goat_export,
(gpointer) format, NULL); (gpointer) format, NULL);

4
plug-ins/common/file-gif-save.c
View file

@ -142,7 +142,7 @@ gif_create_procedure (GimpPlugIn *plug_in,
if (! strcmp (name, EXPORT_PROC)) if (! strcmp (name, EXPORT_PROC))
{ {
procedure = gimp_save_procedure_new (plug_in, name, procedure = gimp_export_procedure_new (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN, GIMP_PDB_PROC_TYPE_PLUGIN,
FALSE, gif_export, NULL, NULL); FALSE, gif_export, NULL, NULL);
@ -1264,7 +1264,7 @@ save_dialog (GimpImage *image,
animation_supported = n_layers > 1; animation_supported = n_layers > 1;
dialog = gimp_save_procedure_dialog_new (GIMP_SAVE_PROCEDURE (procedure), dialog = gimp_export_procedure_dialog_new (GIMP_EXPORT_PROCEDURE (procedure),
GIMP_PROCEDURE_CONFIG (config), GIMP_PROCEDURE_CONFIG (config),
image); image);

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

@ -148,7 +148,7 @@ gih_create_procedure (GimpPlugIn *plug_in,
if (! strcmp (name, EXPORT_PROC)) if (! strcmp (name, EXPORT_PROC))
{ {
procedure = gimp_save_procedure_new (plug_in, name, procedure = gimp_export_procedure_new (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN, GIMP_PDB_PROC_TYPE_PLUGIN,
FALSE, gih_export, NULL, NULL); FALSE, gih_export, NULL, NULL);
@ -666,7 +666,7 @@ gih_save_dialog (GimpImage *image,
gint dimension; gint dimension;
gboolean run; gboolean run;
dialog = gimp_save_procedure_dialog_new (GIMP_SAVE_PROCEDURE (procedure), dialog = gimp_export_procedure_dialog_new (GIMP_EXPORT_PROCEDURE (procedure),
GIMP_PROCEDURE_CONFIG (config), GIMP_PROCEDURE_CONFIG (config),
image); image);

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

@ -109,7 +109,7 @@ header_create_procedure (GimpPlugIn *plug_in,
if (! strcmp (name, EXPORT_PROC)) if (! strcmp (name, EXPORT_PROC))
{ {
procedure = gimp_save_procedure_new (plug_in, name, procedure = gimp_export_procedure_new (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN, GIMP_PDB_PROC_TYPE_PLUGIN,
FALSE, header_export, NULL, NULL); FALSE, header_export, NULL, NULL);

6
plug-ins/common/file-heif.c
View file

@ -228,7 +228,7 @@ heif_create_procedure (GimpPlugIn *plug_in,
} }
else if (! strcmp (name, EXPORT_PROC)) else if (! strcmp (name, EXPORT_PROC))
{ {
procedure = gimp_save_procedure_new (plug_in, name, procedure = gimp_export_procedure_new (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN, GIMP_PDB_PROC_TYPE_PLUGIN,
FALSE, heif_export, NULL, NULL); FALSE, heif_export, NULL, NULL);
@ -336,7 +336,7 @@ heif_create_procedure (GimpPlugIn *plug_in,
} }
else if (! strcmp (name, EXPORT_PROC_AV1)) else if (! strcmp (name, EXPORT_PROC_AV1))
{ {
procedure = gimp_save_procedure_new (plug_in, name, procedure = gimp_export_procedure_new (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN, GIMP_PDB_PROC_TYPE_PLUGIN,
FALSE, heif_av1_export, NULL, FALSE, heif_av1_export, NULL,
NULL); NULL);
@ -2457,7 +2457,7 @@ save_dialog (GimpProcedure *procedure,
GtkListStore *store_speeds; GtkListStore *store_speeds;
gboolean run; gboolean run;
dialog = gimp_save_procedure_dialog_new (GIMP_SAVE_PROCEDURE (procedure), dialog = gimp_export_procedure_dialog_new (GIMP_EXPORT_PROCEDURE (procedure),
GIMP_PROCEDURE_CONFIG (config), GIMP_PROCEDURE_CONFIG (config),
image); image);

4
plug-ins/common/file-html-table.c
View file

@ -145,7 +145,7 @@ html_create_procedure (GimpPlugIn *plug_in,
if (! strcmp (name, EXPORT_PROC)) if (! strcmp (name, EXPORT_PROC))
{ {
procedure = gimp_save_procedure_new (plug_in, name, procedure = gimp_export_procedure_new (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN, GIMP_PDB_PROC_TYPE_PLUGIN,
FALSE, html_export, NULL, NULL); FALSE, html_export, NULL, NULL);
@ -595,7 +595,7 @@ save_dialog (GimpImage *image,
gimp_ui_init (PLUG_IN_BINARY); gimp_ui_init (PLUG_IN_BINARY);
dialog = gimp_save_procedure_dialog_new (GIMP_SAVE_PROCEDURE (procedure), dialog = gimp_export_procedure_dialog_new (GIMP_EXPORT_PROCEDURE (procedure),
GIMP_PROCEDURE_CONFIG (config), GIMP_PROCEDURE_CONFIG (config),
image); image);

4
plug-ins/common/file-jpegxl.c
View file

@ -160,7 +160,7 @@ jpegxl_create_procedure (GimpPlugIn *plug_in,
} }
else if (! strcmp (name, EXPORT_PROC)) else if (! strcmp (name, EXPORT_PROC))
{ {
procedure = gimp_save_procedure_new (plug_in, name, procedure = gimp_export_procedure_new (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN, GIMP_PDB_PROC_TYPE_PLUGIN,
FALSE, jpegxl_export, NULL, NULL); FALSE, jpegxl_export, NULL, NULL);
@ -1995,7 +1995,7 @@ save_dialog (GimpImage *image,
GimpColorProfile *cmyk_profile = NULL; GimpColorProfile *cmyk_profile = NULL;
gboolean run; gboolean run;
dialog = gimp_save_procedure_dialog_new (GIMP_SAVE_PROCEDURE (procedure), dialog = gimp_export_procedure_dialog_new (GIMP_EXPORT_PROCEDURE (procedure),
GIMP_PROCEDURE_CONFIG (config), GIMP_PROCEDURE_CONFIG (config),
image); image);

4
plug-ins/common/file-mng.c
View file

@ -246,7 +246,7 @@ mng_create_procedure (GimpPlugIn *plug_in,
if (! strcmp (name, EXPORT_PROC)) if (! strcmp (name, EXPORT_PROC))
{ {
procedure = gimp_save_procedure_new (plug_in, name, procedure = gimp_export_procedure_new (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN, GIMP_PDB_PROC_TYPE_PLUGIN,
FALSE, mng_export, NULL, NULL); FALSE, mng_export, NULL, NULL);
@ -1582,7 +1582,7 @@ mng_save_dialog (GimpImage *image,
gint num_layers; gint num_layers;
gboolean run; gboolean run;
dialog = gimp_save_procedure_dialog_new (GIMP_SAVE_PROCEDURE (procedure), dialog = gimp_export_procedure_dialog_new (GIMP_EXPORT_PROCEDURE (procedure),
GIMP_PROCEDURE_CONFIG (config), GIMP_PROCEDURE_CONFIG (config),
image); image);

4
plug-ins/common/file-pat.c
View file

@ -104,7 +104,7 @@ pat_create_procedure (GimpPlugIn *plug_in,
if (! strcmp (name, EXPORT_PROC)) if (! strcmp (name, EXPORT_PROC))
{ {
procedure = gimp_save_procedure_new (plug_in, name, procedure = gimp_export_procedure_new (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN, GIMP_PDB_PROC_TYPE_PLUGIN,
FALSE, pat_export, NULL, NULL); FALSE, pat_export, NULL, NULL);
@ -262,7 +262,7 @@ save_dialog (GimpImage *image,
GtkWidget *real_entry; GtkWidget *real_entry;
gboolean run; gboolean run;
dialog = gimp_save_procedure_dialog_new (GIMP_SAVE_PROCEDURE (procedure), dialog = gimp_export_procedure_dialog_new (GIMP_EXPORT_PROCEDURE (procedure),
GIMP_PROCEDURE_CONFIG (config), GIMP_PROCEDURE_CONFIG (config),
image); image);

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

@ -267,7 +267,7 @@ pcx_create_procedure (GimpPlugIn *plug_in,
} }
else if (! strcmp (name, EXPORT_PROC)) else if (! strcmp (name, EXPORT_PROC))
{ {
procedure = gimp_save_procedure_new (plug_in, name, procedure = gimp_export_procedure_new (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN, GIMP_PDB_PROC_TYPE_PLUGIN,
FALSE, pcx_export, NULL, NULL); FALSE, pcx_export, NULL, NULL);

4
plug-ins/common/file-pdf-save.c
View file

@ -307,7 +307,7 @@ pdf_create_procedure (GimpPlugIn *plug_in,
if (! strcmp (name, EXPORT_PROC)) if (! strcmp (name, EXPORT_PROC))
{ {
procedure = gimp_save_procedure_new (plug_in, name, procedure = gimp_export_procedure_new (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN, GIMP_PDB_PROC_TYPE_PLUGIN,
TRUE, pdf_export, NULL, NULL); TRUE, pdf_export, NULL, NULL);
@ -901,7 +901,7 @@ gui_single (GimpProcedure *procedure,
gimp_ui_init (PLUG_IN_BINARY); gimp_ui_init (PLUG_IN_BINARY);
window = gimp_save_procedure_dialog_new (GIMP_SAVE_PROCEDURE (procedure), window = gimp_export_procedure_dialog_new (GIMP_EXPORT_PROCEDURE (procedure),
GIMP_PROCEDURE_CONFIG (config), GIMP_PROCEDURE_CONFIG (config),
image); image);

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

@ -193,7 +193,7 @@ pix_create_procedure (GimpPlugIn *plug_in,
} }
else if (! strcmp (name, EXPORT_PROC)) else if (! strcmp (name, EXPORT_PROC))
{ {
procedure = gimp_save_procedure_new (plug_in, name, procedure = gimp_export_procedure_new (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN, GIMP_PDB_PROC_TYPE_PLUGIN,
FALSE, pix_export, NULL, NULL); FALSE, pix_export, NULL, NULL);

24
plug-ins/common/file-png.c
View file

@ -208,7 +208,7 @@ png_create_procedure (GimpPlugIn *plug_in,
} }
else if (! strcmp (name, EXPORT_PROC)) else if (! strcmp (name, EXPORT_PROC))
{ {
procedure = gimp_save_procedure_new (plug_in, name, procedure = gimp_export_procedure_new (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN, GIMP_PDB_PROC_TYPE_PLUGIN,
TRUE, png_export, NULL, NULL); TRUE, png_export, NULL, NULL);
@ -301,14 +301,14 @@ png_create_procedure (GimpPlugIn *plug_in,
NULL), NULL),
"auto", G_PARAM_READWRITE); "auto", G_PARAM_READWRITE);
gimp_save_procedure_set_support_exif (GIMP_SAVE_PROCEDURE (procedure), TRUE); gimp_export_procedure_set_support_exif (GIMP_EXPORT_PROCEDURE (procedure), TRUE);
gimp_save_procedure_set_support_iptc (GIMP_SAVE_PROCEDURE (procedure), TRUE); gimp_export_procedure_set_support_iptc (GIMP_EXPORT_PROCEDURE (procedure), TRUE);
gimp_save_procedure_set_support_xmp (GIMP_SAVE_PROCEDURE (procedure), TRUE); gimp_export_procedure_set_support_xmp (GIMP_EXPORT_PROCEDURE (procedure), TRUE);
#if defined(PNG_iCCP_SUPPORTED) #if defined(PNG_iCCP_SUPPORTED)
gimp_save_procedure_set_support_profile (GIMP_SAVE_PROCEDURE (procedure), TRUE); gimp_export_procedure_set_support_profile (GIMP_EXPORT_PROCEDURE (procedure), TRUE);
#endif #endif
gimp_save_procedure_set_support_thumbnail (GIMP_SAVE_PROCEDURE (procedure), TRUE); gimp_export_procedure_set_support_thumbnail (GIMP_EXPORT_PROCEDURE (procedure), TRUE);
gimp_save_procedure_set_support_comment (GIMP_SAVE_PROCEDURE (procedure), TRUE); gimp_export_procedure_set_support_comment (GIMP_EXPORT_PROCEDURE (procedure), TRUE);
} }
return procedure; return procedure;
@ -2395,7 +2395,7 @@ export_dialog (GimpImage *image,
indexed = (gimp_image_get_base_type (image) == GIMP_INDEXED); indexed = (gimp_image_get_base_type (image) == GIMP_INDEXED);
dialog = gimp_save_procedure_dialog_new (GIMP_SAVE_PROCEDURE (procedure), dialog = gimp_export_procedure_dialog_new (GIMP_EXPORT_PROCEDURE (procedure),
GIMP_PROCEDURE_CONFIG (config), GIMP_PROCEDURE_CONFIG (config),
image); image);
@ -2410,10 +2410,10 @@ export_dialog (GimpImage *image,
"optimize-palette", "optimize-palette",
indexed, NULL, NULL, FALSE); indexed, NULL, NULL, FALSE);
gimp_save_procedure_dialog_add_metadata (GIMP_SAVE_PROCEDURE_DIALOG (dialog), "bkgd"); gimp_export_procedure_dialog_add_metadata (GIMP_EXPORT_PROCEDURE_DIALOG (dialog), "bkgd");
gimp_save_procedure_dialog_add_metadata (GIMP_SAVE_PROCEDURE_DIALOG (dialog), "offs"); gimp_export_procedure_dialog_add_metadata (GIMP_EXPORT_PROCEDURE_DIALOG (dialog), "offs");
gimp_save_procedure_dialog_add_metadata (GIMP_SAVE_PROCEDURE_DIALOG (dialog), "phys"); gimp_export_procedure_dialog_add_metadata (GIMP_EXPORT_PROCEDURE_DIALOG (dialog), "phys");
gimp_save_procedure_dialog_add_metadata (GIMP_SAVE_PROCEDURE_DIALOG (dialog), "time"); gimp_export_procedure_dialog_add_metadata (GIMP_EXPORT_PROCEDURE_DIALOG (dialog), "time");
gimp_procedure_dialog_fill (GIMP_PROCEDURE_DIALOG (dialog), gimp_procedure_dialog_fill (GIMP_PROCEDURE_DIALOG (dialog),
"format", "compression", "format", "compression",
"interlaced", "save-transparent", "interlaced", "save-transparent",

14
plug-ins/common/file-pnm.c
View file

@ -340,7 +340,7 @@ pnm_create_procedure (GimpPlugIn *plug_in,
} }
else if (! strcmp (name, PNM_EXPORT_PROC)) else if (! strcmp (name, PNM_EXPORT_PROC))
{ {
procedure = gimp_save_procedure_new (plug_in, name, procedure = gimp_export_procedure_new (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN, GIMP_PDB_PROC_TYPE_PLUGIN,
FALSE, pnm_export, FALSE, pnm_export,
GINT_TO_POINTER (FILE_TYPE_PNM), GINT_TO_POINTER (FILE_TYPE_PNM),
@ -377,7 +377,7 @@ pnm_create_procedure (GimpPlugIn *plug_in,
} }
else if (! strcmp (name, PBM_EXPORT_PROC)) else if (! strcmp (name, PBM_EXPORT_PROC))
{ {
procedure = gimp_save_procedure_new (plug_in, name, procedure = gimp_export_procedure_new (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN, GIMP_PDB_PROC_TYPE_PLUGIN,
FALSE, pnm_export, FALSE, pnm_export,
GINT_TO_POINTER (FILE_TYPE_PBM), GINT_TO_POINTER (FILE_TYPE_PBM),
@ -413,7 +413,7 @@ pnm_create_procedure (GimpPlugIn *plug_in,
} }
else if (! strcmp (name, PGM_EXPORT_PROC)) else if (! strcmp (name, PGM_EXPORT_PROC))
{ {
procedure = gimp_save_procedure_new (plug_in, name, procedure = gimp_export_procedure_new (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN, GIMP_PDB_PROC_TYPE_PLUGIN,
FALSE, pnm_export, FALSE, pnm_export,
GINT_TO_POINTER (FILE_TYPE_PGM), GINT_TO_POINTER (FILE_TYPE_PGM),
@ -449,7 +449,7 @@ pnm_create_procedure (GimpPlugIn *plug_in,
} }
else if (! strcmp (name, PPM_EXPORT_PROC)) else if (! strcmp (name, PPM_EXPORT_PROC))
{ {
procedure = gimp_save_procedure_new (plug_in, name, procedure = gimp_export_procedure_new (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN, GIMP_PDB_PROC_TYPE_PLUGIN,
FALSE, pnm_export, FALSE, pnm_export,
GINT_TO_POINTER (FILE_TYPE_PPM), GINT_TO_POINTER (FILE_TYPE_PPM),
@ -485,7 +485,7 @@ pnm_create_procedure (GimpPlugIn *plug_in,
} }
else if (! strcmp (name, PAM_EXPORT_PROC)) else if (! strcmp (name, PAM_EXPORT_PROC))
{ {
procedure = gimp_save_procedure_new (plug_in, name, procedure = gimp_export_procedure_new (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN, GIMP_PDB_PROC_TYPE_PLUGIN,
FALSE, pnm_export, FALSE, pnm_export,
GINT_TO_POINTER (FILE_TYPE_PAM), GINT_TO_POINTER (FILE_TYPE_PAM),
@ -514,7 +514,7 @@ pnm_create_procedure (GimpPlugIn *plug_in,
} }
else if (! strcmp (name, PFM_EXPORT_PROC)) else if (! strcmp (name, PFM_EXPORT_PROC))
{ {
procedure = gimp_save_procedure_new (plug_in, name, procedure = gimp_export_procedure_new (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN, GIMP_PDB_PROC_TYPE_PLUGIN,
FALSE, pnm_export, FALSE, pnm_export,
GINT_TO_POINTER (FILE_TYPE_PFM), GINT_TO_POINTER (FILE_TYPE_PFM),
@ -2020,7 +2020,7 @@ save_dialog (GimpProcedure *procedure,
GtkListStore *store; GtkListStore *store;
gboolean run; gboolean run;
dialog = gimp_save_procedure_dialog_new (GIMP_SAVE_PROCEDURE (procedure), dialog = gimp_export_procedure_dialog_new (GIMP_EXPORT_PROCEDURE (procedure),
GIMP_PROCEDURE_CONFIG (config), GIMP_PROCEDURE_CONFIG (config),
image); image);
/* file save type */ /* file save type */

4
plug-ins/common/file-ps.c
View file

@ -443,7 +443,7 @@ ps_create_procedure (GimpPlugIn *plug_in,
else if (! strcmp (name, EXPORT_PS_PROC) || else if (! strcmp (name, EXPORT_PS_PROC) ||
! strcmp (name, EXPORT_EPS_PROC)) ! strcmp (name, EXPORT_EPS_PROC))
{ {
procedure = gimp_save_procedure_new (plug_in, name, procedure = gimp_export_procedure_new (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN, GIMP_PDB_PROC_TYPE_PLUGIN,
FALSE, ps_export, NULL, NULL); FALSE, ps_export, NULL, NULL);
@ -3855,7 +3855,7 @@ save_dialog (GimpProcedure *procedure,
GtkWidget *hbox, *vbox; GtkWidget *hbox, *vbox;
gboolean run; gboolean run;
dialog = gimp_save_procedure_dialog_new (GIMP_SAVE_PROCEDURE (procedure), dialog = gimp_export_procedure_dialog_new (GIMP_EXPORT_PROCEDURE (procedure),
GIMP_PROCEDURE_CONFIG (config), GIMP_PROCEDURE_CONFIG (config),
image); image);

4
plug-ins/common/file-psp.c
View file

@ -688,7 +688,7 @@ psp_create_procedure (GimpPlugIn *plug_in,
} }
else if (! strcmp (name, EXPORT_PROC)) else if (! strcmp (name, EXPORT_PROC))
{ {
procedure = gimp_save_procedure_new (plug_in, name, procedure = gimp_export_procedure_new (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN, GIMP_PDB_PROC_TYPE_PLUGIN,
FALSE, psp_export, NULL, NULL); FALSE, psp_export, NULL, NULL);
@ -831,7 +831,7 @@ save_dialog (GimpProcedure *procedure,
GtkWidget *frame; GtkWidget *frame;
gint run; gint run;
dialog = gimp_save_procedure_dialog_new (GIMP_SAVE_PROCEDURE (procedure), dialog = gimp_export_procedure_dialog_new (GIMP_EXPORT_PROCEDURE (procedure),
GIMP_PROCEDURE_CONFIG (config), GIMP_PROCEDURE_CONFIG (config),
image); image);

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

@ -158,7 +158,7 @@ qoi_create_procedure (GimpPlugIn *plug_in,
} }
else if (! strcmp (name, EXPORT_PROC)) else if (! strcmp (name, EXPORT_PROC))
{ {
procedure = gimp_save_procedure_new (plug_in, name, procedure = gimp_export_procedure_new (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN, GIMP_PDB_PROC_TYPE_PLUGIN,
FALSE, qoi_export, NULL, NULL); FALSE, qoi_export, NULL, NULL);

4
plug-ins/common/file-raw-data.c
View file

@ -446,7 +446,7 @@ raw_create_procedure (GimpPlugIn *plug_in,
} }
else if (! strcmp (name, EXPORT_PROC)) else if (! strcmp (name, EXPORT_PROC))
{ {
procedure = gimp_save_procedure_new (plug_in, name, procedure = gimp_export_procedure_new (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN, GIMP_PDB_PROC_TYPE_PLUGIN,
FALSE, raw_export, NULL, NULL); FALSE, raw_export, NULL, NULL);
@ -2907,7 +2907,7 @@ save_dialog (GimpImage *image,
else else
planar_label = g_strdup (_("_Planar")); planar_label = g_strdup (_("_Planar"));
dialog = gimp_save_procedure_dialog_new (GIMP_SAVE_PROCEDURE (procedure), dialog = gimp_export_procedure_dialog_new (GIMP_EXPORT_PROCEDURE (procedure),
GIMP_PROCEDURE_CONFIG (config), GIMP_PROCEDURE_CONFIG (config),
image); image);

4
plug-ins/common/file-sunras.c
View file

@ -294,7 +294,7 @@ sunras_create_procedure (GimpPlugIn *plug_in,
} }
else if (! strcmp (name, EXPORT_PROC)) else if (! strcmp (name, EXPORT_PROC))
{ {
procedure = gimp_save_procedure_new (plug_in, name, procedure = gimp_export_procedure_new (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN, GIMP_PDB_PROC_TYPE_PLUGIN,
FALSE, sunras_export, NULL, NULL); FALSE, sunras_export, NULL, NULL);
@ -1787,7 +1787,7 @@ save_dialog (GimpImage *image,
GtkListStore *store; GtkListStore *store;
gboolean run; gboolean run;
dialog = gimp_save_procedure_dialog_new (GIMP_SAVE_PROCEDURE (procedure), dialog = gimp_export_procedure_dialog_new (GIMP_EXPORT_PROCEDURE (procedure),
GIMP_PROCEDURE_CONFIG (config), GIMP_PROCEDURE_CONFIG (config),
image); image);

4
plug-ins/common/file-tga.c
View file

@ -280,7 +280,7 @@ tga_create_procedure (GimpPlugIn *plug_in,
} }
else if (! strcmp (name, EXPORT_PROC)) else if (! strcmp (name, EXPORT_PROC))
{ {
procedure = gimp_save_procedure_new (plug_in, name, procedure = gimp_export_procedure_new (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN, GIMP_PDB_PROC_TYPE_PLUGIN,
FALSE, tga_export, NULL, NULL); FALSE, tga_export, NULL, NULL);
@ -1445,7 +1445,7 @@ save_dialog (GimpImage *image,
GtkWidget *vbox; GtkWidget *vbox;
gboolean run; gboolean run;
dialog = gimp_save_procedure_dialog_new (GIMP_SAVE_PROCEDURE (procedure), dialog = gimp_export_procedure_dialog_new (GIMP_EXPORT_PROCEDURE (procedure),
GIMP_PROCEDURE_CONFIG (config), GIMP_PROCEDURE_CONFIG (config),
image); image);

4
plug-ins/common/file-xbm.c
View file

@ -181,7 +181,7 @@ xbm_create_procedure (GimpPlugIn *plug_in,
} }
else if (! strcmp (name, EXPORT_PROC)) else if (! strcmp (name, EXPORT_PROC))
{ {
procedure = gimp_save_procedure_new (plug_in, name, procedure = gimp_export_procedure_new (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN, GIMP_PDB_PROC_TYPE_PLUGIN,
FALSE, xbm_export, NULL, NULL); FALSE, xbm_export, NULL, NULL);
@ -1246,7 +1246,7 @@ save_dialog (GimpImage *image,
GtkWidget *hint; GtkWidget *hint;
gboolean run; gboolean run;
dialog = gimp_save_procedure_dialog_new (GIMP_SAVE_PROCEDURE (procedure), dialog = gimp_export_procedure_dialog_new (GIMP_EXPORT_PROCEDURE (procedure),
GIMP_PROCEDURE_CONFIG (config), GIMP_PROCEDURE_CONFIG (config),
image); image);

4
plug-ins/common/file-xmc.c
View file

@ -341,7 +341,7 @@ xmc_create_procedure (GimpPlugIn *plug_in,
} }
else if (! strcmp (name, EXPORT_PROC)) else if (! strcmp (name, EXPORT_PROC))
{ {
procedure = gimp_save_procedure_new (plug_in, name, procedure = gimp_export_procedure_new (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN, GIMP_PDB_PROC_TYPE_PLUGIN,
FALSE, xmc_export, NULL, NULL); FALSE, xmc_export, NULL, NULL);
@ -1109,7 +1109,7 @@ save_dialog (GimpProcedure *procedure,
GtkWidget *combo; GtkWidget *combo;
gboolean run; gboolean run;
dialog = gimp_save_procedure_dialog_new (GIMP_SAVE_PROCEDURE (procedure), dialog = gimp_export_procedure_dialog_new (GIMP_EXPORT_PROCEDURE (procedure),
GIMP_PROCEDURE_CONFIG (config), GIMP_PROCEDURE_CONFIG (config),
image); image);

4
plug-ins/common/file-xpm.c
View file

@ -225,7 +225,7 @@ xpm_create_procedure (GimpPlugIn *plug_in,
} }
else if (! strcmp (name, EXPORT_PROC)) else if (! strcmp (name, EXPORT_PROC))
{ {
procedure = gimp_save_procedure_new (plug_in, name, procedure = gimp_export_procedure_new (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN, GIMP_PDB_PROC_TYPE_PLUGIN,
FALSE, xpm_export, NULL, NULL); FALSE, xpm_export, NULL, NULL);
@ -884,7 +884,7 @@ save_dialog (GimpImage *image,
GtkWidget *dialog; GtkWidget *dialog;
gboolean run; gboolean run;
dialog = gimp_save_procedure_dialog_new (GIMP_SAVE_PROCEDURE (procedure), dialog = gimp_export_procedure_dialog_new (GIMP_EXPORT_PROCEDURE (procedure),
GIMP_PROCEDURE_CONFIG (config), GIMP_PROCEDURE_CONFIG (config),
image); image);

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

@ -348,7 +348,7 @@ xwd_create_procedure (GimpPlugIn *plug_in,
} }
else if (! strcmp (name, EXPORT_PROC)) else if (! strcmp (name, EXPORT_PROC))
{ {
procedure = gimp_save_procedure_new (plug_in, name, procedure = gimp_export_procedure_new (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN, GIMP_PDB_PROC_TYPE_PLUGIN,
FALSE, xwd_export, NULL, NULL); FALSE, xwd_export, NULL, NULL);

2
plug-ins/file-bmp/bmp-save.c
View file

@ -992,7 +992,7 @@ save_dialog (GimpProcedure *procedure,
gboolean is_format_sensitive; gboolean is_format_sensitive;
gboolean run; gboolean run;
dialog = gimp_save_procedure_dialog_new (GIMP_SAVE_PROCEDURE (procedure), dialog = gimp_export_procedure_dialog_new (GIMP_EXPORT_PROCEDURE (procedure),
GIMP_PROCEDURE_CONFIG (config), GIMP_PROCEDURE_CONFIG (config),
image); image);

2
plug-ins/file-bmp/bmp.c
View file

@ -172,7 +172,7 @@ bmp_create_procedure (GimpPlugIn *plug_in,
} }
else if (! strcmp (name, EXPORT_PROC)) else if (! strcmp (name, EXPORT_PROC))
{ {
procedure = gimp_save_procedure_new (plug_in, name, procedure = gimp_export_procedure_new (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN, GIMP_PDB_PROC_TYPE_PLUGIN,
FALSE, bmp_export, NULL, NULL); FALSE, bmp_export, NULL, NULL);

2
plug-ins/file-dds/dds.c
View file

@ -160,7 +160,7 @@ dds_create_procedure (GimpPlugIn *plug_in,
} }
else if (! strcmp (name, EXPORT_PROC)) else if (! strcmp (name, EXPORT_PROC))
{ {
procedure = gimp_save_procedure_new (plug_in, name, procedure = gimp_export_procedure_new (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN, GIMP_PDB_PROC_TYPE_PLUGIN,
FALSE, dds_export, NULL, NULL); FALSE, dds_export, NULL, NULL);

2
plug-ins/file-dds/ddswrite.c
View file

@ -1918,7 +1918,7 @@ save_dialog (GimpImage *image,
"save-type", "layer", "save-type", "layer",
NULL); NULL);
dialog = gimp_save_procedure_dialog_new (GIMP_SAVE_PROCEDURE (procedure), dialog = gimp_export_procedure_dialog_new (GIMP_EXPORT_PROCEDURE (procedure),
GIMP_PROCEDURE_CONFIG (config), GIMP_PROCEDURE_CONFIG (config),
image); image);

2
plug-ins/file-fits/fits.c
View file

@ -211,7 +211,7 @@ fits_create_procedure (GimpPlugIn *plug_in,
} }
else if (! strcmp (name, EXPORT_PROC)) else if (! strcmp (name, EXPORT_PROC))
{ {
procedure = gimp_save_procedure_new (plug_in, name, procedure = gimp_export_procedure_new (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN, GIMP_PDB_PROC_TYPE_PLUGIN,
FALSE, fits_export, NULL, NULL); FALSE, fits_export, NULL, NULL);

4
plug-ins/file-fli/fli-gimp.c
View file

@ -212,7 +212,7 @@ fli_create_procedure (GimpPlugIn *plug_in,
} }
else if (! strcmp (name, EXPORT_PROC)) else if (! strcmp (name, EXPORT_PROC))
{ {
procedure = gimp_save_procedure_new (plug_in, name, procedure = gimp_export_procedure_new (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN, GIMP_PDB_PROC_TYPE_PLUGIN,
FALSE, fli_export, NULL, NULL); FALSE, fli_export, NULL, NULL);
@ -968,7 +968,7 @@ save_dialog (GimpImage *image,
"to-frame", n_frames, "to-frame", n_frames,
NULL); NULL);
dialog = gimp_save_procedure_dialog_new (GIMP_SAVE_PROCEDURE (procedure), dialog = gimp_export_procedure_dialog_new (GIMP_EXPORT_PROCEDURE (procedure),
GIMP_PROCEDURE_CONFIG (config), GIMP_PROCEDURE_CONFIG (config),
image); image);
/* /*

2
plug-ins/file-icns/file-icns.c
View file

@ -169,7 +169,7 @@ icns_create_procedure (GimpPlugIn *plug_in,
} }
else if (! strcmp (name, EXPORT_PROC)) else if (! strcmp (name, EXPORT_PROC))
{ {
procedure = gimp_save_procedure_new (plug_in, name, procedure = gimp_export_procedure_new (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN, GIMP_PDB_PROC_TYPE_PLUGIN,
FALSE, icns_export, NULL, NULL); FALSE, icns_export, NULL, NULL);

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

@ -289,7 +289,7 @@ ico_create_procedure (GimpPlugIn *plug_in,
} }
else if (! strcmp (name, EXPORT_PROC)) else if (! strcmp (name, EXPORT_PROC))
{ {
procedure = gimp_save_procedure_new (plug_in, name, procedure = gimp_export_procedure_new (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN, GIMP_PDB_PROC_TYPE_PLUGIN,
FALSE, ico_export, NULL, NULL); FALSE, ico_export, NULL, NULL);
@ -314,7 +314,7 @@ ico_create_procedure (GimpPlugIn *plug_in,
} }
else if (! strcmp (name, EXPORT_CUR_PROC)) else if (! strcmp (name, EXPORT_CUR_PROC))
{ {
procedure = gimp_save_procedure_new (plug_in, name, procedure = gimp_export_procedure_new (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN, GIMP_PDB_PROC_TYPE_PLUGIN,
FALSE, cur_export, NULL, NULL); FALSE, cur_export, NULL, NULL);
@ -361,7 +361,7 @@ ico_create_procedure (GimpPlugIn *plug_in,
} }
else if (! strcmp (name, EXPORT_ANI_PROC)) else if (! strcmp (name, EXPORT_ANI_PROC))
{ {
procedure = gimp_save_procedure_new (plug_in, name, procedure = gimp_export_procedure_new (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN, GIMP_PDB_PROC_TYPE_PLUGIN,
FALSE, ani_export, NULL, NULL); FALSE, ani_export, NULL, NULL);

2
plug-ins/file-jpeg/jpeg-save.c
View file

@ -854,7 +854,7 @@ save_dialog (GimpProcedure *procedure,
"restart", &restart, "restart", &restart,
NULL); NULL);
dialog = gimp_save_procedure_dialog_new (GIMP_SAVE_PROCEDURE (procedure), dialog = gimp_export_procedure_dialog_new (GIMP_EXPORT_PROCEDURE (procedure),
GIMP_PROCEDURE_CONFIG (config), GIMP_PROCEDURE_CONFIG (config),
gimp_item_get_image (GIMP_ITEM (drawable))); gimp_item_get_image (GIMP_ITEM (drawable)));

14
plug-ins/file-jpeg/jpeg.c
View file

@ -174,7 +174,7 @@ jpeg_create_procedure (GimpPlugIn *plug_in,
} }
else if (! strcmp (name, EXPORT_PROC)) else if (! strcmp (name, EXPORT_PROC))
{ {
procedure = gimp_save_procedure_new (plug_in, name, procedure = gimp_export_procedure_new (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN, GIMP_PDB_PROC_TYPE_PLUGIN,
TRUE, jpeg_export, NULL, NULL); TRUE, jpeg_export, NULL, NULL);
@ -305,12 +305,12 @@ jpeg_create_procedure (GimpPlugIn *plug_in,
NULL, FALSE, NULL, FALSE,
G_PARAM_READWRITE); G_PARAM_READWRITE);
gimp_save_procedure_set_support_exif (GIMP_SAVE_PROCEDURE (procedure), TRUE); gimp_export_procedure_set_support_exif (GIMP_EXPORT_PROCEDURE (procedure), TRUE);
gimp_save_procedure_set_support_iptc (GIMP_SAVE_PROCEDURE (procedure), TRUE); gimp_export_procedure_set_support_iptc (GIMP_EXPORT_PROCEDURE (procedure), TRUE);
gimp_save_procedure_set_support_xmp (GIMP_SAVE_PROCEDURE (procedure), TRUE); gimp_export_procedure_set_support_xmp (GIMP_EXPORT_PROCEDURE (procedure), TRUE);
gimp_save_procedure_set_support_profile (GIMP_SAVE_PROCEDURE (procedure), TRUE); gimp_export_procedure_set_support_profile (GIMP_EXPORT_PROCEDURE (procedure), TRUE);
gimp_save_procedure_set_support_thumbnail (GIMP_SAVE_PROCEDURE (procedure), TRUE); gimp_export_procedure_set_support_thumbnail (GIMP_EXPORT_PROCEDURE (procedure), TRUE);
gimp_save_procedure_set_support_comment (GIMP_SAVE_PROCEDURE (procedure), TRUE); gimp_export_procedure_set_support_comment (GIMP_EXPORT_PROCEDURE (procedure), TRUE);
} }
return procedure; return procedure;

2
plug-ins/file-psd/psd.c
View file

@ -207,7 +207,7 @@ psd_create_procedure (GimpPlugIn *plug_in,
} }
else if (! strcmp (name, EXPORT_PROC)) else if (! strcmp (name, EXPORT_PROC))
{ {
procedure = gimp_save_procedure_new (plug_in, name, procedure = gimp_export_procedure_new (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN, GIMP_PDB_PROC_TYPE_PLUGIN,
TRUE, psd_export, NULL, NULL); TRUE, psd_export, NULL, NULL);

4
plug-ins/file-sgi/sgi.c
View file

@ -164,7 +164,7 @@ sgi_create_procedure (GimpPlugIn *plug_in,
} }
else if (! strcmp (name, EXPORT_PROC)) else if (! strcmp (name, EXPORT_PROC))
{ {
procedure = gimp_save_procedure_new (plug_in, name, procedure = gimp_export_procedure_new (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN, GIMP_PDB_PROC_TYPE_PLUGIN,
FALSE, sgi_export, NULL, NULL); FALSE, sgi_export, NULL, NULL);
@ -737,7 +737,7 @@ save_dialog (GimpProcedure *procedure,
GtkListStore *store; GtkListStore *store;
gboolean run; gboolean run;
dialog = gimp_save_procedure_dialog_new (GIMP_SAVE_PROCEDURE (procedure), dialog = gimp_export_procedure_dialog_new (GIMP_EXPORT_PROCEDURE (procedure),
GIMP_PROCEDURE_CONFIG (config), GIMP_PROCEDURE_CONFIG (config),
image); image);

4
plug-ins/file-tiff/file-tiff-save.c
View file

@ -1259,7 +1259,7 @@ save_dialog (GimpImage *image,
} }
g_strfreev (parasites); g_strfreev (parasites);
dialog = gimp_save_procedure_dialog_new (GIMP_SAVE_PROCEDURE (procedure), dialog = gimp_export_procedure_dialog_new (GIMP_EXPORT_PROCEDURE (procedure),
GIMP_PROCEDURE_CONFIG (config), GIMP_PROCEDURE_CONFIG (config),
image); image);
@ -1342,7 +1342,7 @@ save_dialog (GimpImage *image,
g_object_unref (cmyk_profile); g_object_unref (cmyk_profile);
} }
gimp_save_procedure_dialog_add_metadata (GIMP_SAVE_PROCEDURE_DIALOG (dialog), "save-geotiff"); gimp_export_procedure_dialog_add_metadata (GIMP_EXPORT_PROCEDURE_DIALOG (dialog), "save-geotiff");
gimp_procedure_dialog_set_sensitive (GIMP_PROCEDURE_DIALOG (dialog), gimp_procedure_dialog_set_sensitive (GIMP_PROCEDURE_DIALOG (dialog),
"save-geotiff", "save-geotiff",
has_geotiff, NULL, NULL, FALSE); has_geotiff, NULL, NULL, FALSE);

14
plug-ins/file-tiff/file-tiff.c
View file

@ -199,7 +199,7 @@ tiff_create_procedure (GimpPlugIn *plug_in,
} }
else if (! strcmp (name, EXPORT_PROC)) else if (! strcmp (name, EXPORT_PROC))
{ {
procedure = gimp_save_procedure_new (plug_in, name, procedure = gimp_export_procedure_new (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN, GIMP_PDB_PROC_TYPE_PLUGIN,
TRUE, tiff_export, NULL, NULL); TRUE, tiff_export, NULL, NULL);
@ -278,14 +278,14 @@ tiff_create_procedure (GimpPlugIn *plug_in,
TRUE, TRUE,
G_PARAM_READWRITE); G_PARAM_READWRITE);
gimp_save_procedure_set_support_exif (GIMP_SAVE_PROCEDURE (procedure), TRUE); gimp_export_procedure_set_support_exif (GIMP_EXPORT_PROCEDURE (procedure), TRUE);
gimp_save_procedure_set_support_iptc (GIMP_SAVE_PROCEDURE (procedure), TRUE); gimp_export_procedure_set_support_iptc (GIMP_EXPORT_PROCEDURE (procedure), TRUE);
gimp_save_procedure_set_support_xmp (GIMP_SAVE_PROCEDURE (procedure), TRUE); gimp_export_procedure_set_support_xmp (GIMP_EXPORT_PROCEDURE (procedure), TRUE);
#ifdef TIFFTAG_ICCPROFILE #ifdef TIFFTAG_ICCPROFILE
gimp_save_procedure_set_support_profile (GIMP_SAVE_PROCEDURE (procedure), TRUE); gimp_export_procedure_set_support_profile (GIMP_EXPORT_PROCEDURE (procedure), TRUE);
#endif #endif
gimp_save_procedure_set_support_thumbnail (GIMP_SAVE_PROCEDURE (procedure), TRUE); gimp_export_procedure_set_support_thumbnail (GIMP_EXPORT_PROCEDURE (procedure), TRUE);
gimp_save_procedure_set_support_comment (GIMP_SAVE_PROCEDURE (procedure), TRUE); gimp_export_procedure_set_support_comment (GIMP_EXPORT_PROCEDURE (procedure), TRUE);
} }
return procedure; return procedure;

2
plug-ins/file-webp/file-webp-dialog.c
View file

@ -72,7 +72,7 @@ save_dialog (GimpImage *image,
animation_supported = nlayers > 1; animation_supported = nlayers > 1;
dialog = gimp_save_procedure_dialog_new (GIMP_SAVE_PROCEDURE (procedure), dialog = gimp_export_procedure_dialog_new (GIMP_EXPORT_PROCEDURE (procedure),
GIMP_PROCEDURE_CONFIG (config), GIMP_PROCEDURE_CONFIG (config),
image); image);

12
plug-ins/file-webp/file-webp.c
View file

@ -142,7 +142,7 @@ webp_create_procedure (GimpPlugIn *plug_in,
} }
else if (! strcmp (name, EXPORT_PROC)) else if (! strcmp (name, EXPORT_PROC))
{ {
procedure = gimp_save_procedure_new (plug_in, name, procedure = gimp_export_procedure_new (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN, GIMP_PDB_PROC_TYPE_PLUGIN,
TRUE, webp_export, NULL, NULL); TRUE, webp_export, NULL, NULL);
@ -238,11 +238,11 @@ webp_create_procedure (GimpPlugIn *plug_in,
FALSE, FALSE,
G_PARAM_READWRITE); G_PARAM_READWRITE);
gimp_save_procedure_set_support_exif (GIMP_SAVE_PROCEDURE (procedure), TRUE); gimp_export_procedure_set_support_exif (GIMP_EXPORT_PROCEDURE (procedure), TRUE);
gimp_save_procedure_set_support_iptc (GIMP_SAVE_PROCEDURE (procedure), TRUE); gimp_export_procedure_set_support_iptc (GIMP_EXPORT_PROCEDURE (procedure), TRUE);
gimp_save_procedure_set_support_xmp (GIMP_SAVE_PROCEDURE (procedure), TRUE); gimp_export_procedure_set_support_xmp (GIMP_EXPORT_PROCEDURE (procedure), TRUE);
gimp_save_procedure_set_support_profile (GIMP_SAVE_PROCEDURE (procedure), TRUE); gimp_export_procedure_set_support_profile (GIMP_EXPORT_PROCEDURE (procedure), TRUE);
gimp_save_procedure_set_support_thumbnail (GIMP_SAVE_PROCEDURE (procedure), TRUE); gimp_export_procedure_set_support_thumbnail (GIMP_EXPORT_PROCEDURE (procedure), TRUE);
} }
return procedure; return procedure;

2
plug-ins/python/colorxhtml.py
View file

@ -299,7 +299,7 @@ class ColorXhtml(Gimp.PlugIn):
def do_create_procedure(self, name): def do_create_procedure(self, name):
procedure = None procedure = None
if name == 'file-colorxhtml-export': if name == 'file-colorxhtml-export':
procedure = Gimp.SaveProcedure.new(self, name, procedure = Gimp.ExportProcedure.new(self, name,
Gimp.PDBProcType.PLUGIN, Gimp.PDBProcType.PLUGIN,
False, export_colorxhtml, None) False, export_colorxhtml, None)
procedure.set_image_types("RGB") procedure.set_image_types("RGB")

2
plug-ins/python/file-openraster.py
View file

@ -464,7 +464,7 @@ class FileOpenRaster (Gimp.PlugIn):
def do_create_procedure(self, name): def do_create_procedure(self, name):
if name == 'file-openraster-export': if name == 'file-openraster-export':
procedure = Gimp.SaveProcedure.new(self, name, procedure = Gimp.ExportProcedure.new(self, name,
Gimp.PDBProcType.PLUGIN, Gimp.PDBProcType.PLUGIN,
False, export_ora, None) False, export_ora, None)
procedure.set_image_types("*"); procedure.set_image_types("*");

4
po-libgimp/POTFILES.in
View file

@ -5,6 +5,8 @@ libgimp/gimp.c
libgimp/gimpbrushchooser.c libgimp/gimpbrushchooser.c
libgimp/gimpdrawablechooser.c libgimp/gimpdrawablechooser.c
libgimp/gimpexport.c libgimp/gimpexport.c
libgimp/gimpexportprocedure.c
libgimp/gimpexportproceduredialog.c
libgimp/gimpimagemetadata.c libgimp/gimpimagemetadata.c
libgimp/gimpimagemetadata-save.c libgimp/gimpimagemetadata-save.c
libgimp/gimploadprocedure.c libgimp/gimploadprocedure.c
@ -16,8 +18,6 @@ libgimp/gimpprocedure.c
libgimp/gimpproceduredialog.c libgimp/gimpproceduredialog.c
libgimp/gimpprocview.c libgimp/gimpprocview.c
libgimp/gimppropwidgets.c libgimp/gimppropwidgets.c
libgimp/gimpsaveprocedure.c
libgimp/gimpsaveproceduredialog.c
libgimp/gimpunitcache.c libgimp/gimpunitcache.c
libgimpbase/gimpbaseenums.c libgimpbase/gimpbaseenums.c