procyberian/gimp
2
0
Fork 0
mirror of https://gitlab.gnome.org/GNOME/gimp.git synced 2025-07-03 09:23:24 +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_exif
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_xmp
gimp_file_load
@ -810,20 +824,6 @@ EXPORTS
gimp_resource_rename
gimp_resource_select_new
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_border
gimp_selection_bounds

2
libgimp/gimp.h
View file

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

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

@ -1,7 +1,7 @@
/* GIMP - The GNU Image Manipulation Program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* gimpsaveprocedure.c
* gimpexportprocedure.c
* Copyright (C) 2019 Michael Natterer <mitch@gimp.org>
*
* This program is free software: you can redistribute it and/or modify
@ -26,7 +26,7 @@
#include "gimppdb_pdb.h"
#include "gimpplugin-private.h"
#include "gimpsaveprocedure.h"
#include "gimpexportprocedure.h"
#include "gimpprocedureconfig-private.h"
#include "libgimp-intl.h"
@ -43,72 +43,72 @@ enum
N_PROPS
};
struct _GimpSaveProcedurePrivate
struct _GimpExportProcedurePrivate
{
GimpRunSaveFunc run_func;
gpointer run_data;
GDestroyNotify run_data_destroy;
GimpRunExportFunc run_func;
gpointer run_data;
GDestroyNotify run_data_destroy;
gboolean supports_exif;
gboolean supports_iptc;
gboolean supports_xmp;
gboolean supports_profile;
gboolean supports_thumbnail;
gboolean supports_comment;
gboolean supports_exif;
gboolean supports_iptc;
gboolean supports_xmp;
gboolean supports_profile;
gboolean supports_thumbnail;
gboolean supports_comment;
gboolean export_metadata;
gboolean export_metadata;
};
static void gimp_save_procedure_constructed (GObject *object);
static void gimp_save_procedure_finalize (GObject *object);
static void gimp_save_procedure_set_property (GObject *object,
guint property_id,
const GValue *value,
GParamSpec *pspec);
static void gimp_save_procedure_get_property (GObject *object,
guint property_id,
GValue *value,
GParamSpec *pspec);
static void gimp_export_procedure_constructed (GObject *object);
static void gimp_export_procedure_finalize (GObject *object);
static void gimp_export_procedure_set_property (GObject *object,
guint property_id,
const GValue *value,
GParamSpec *pspec);
static void gimp_export_procedure_get_property (GObject *object,
guint property_id,
GValue *value,
GParamSpec *pspec);
static void gimp_save_procedure_install (GimpProcedure *procedure);
static void gimp_export_procedure_install (GimpProcedure *procedure);
static GimpValueArray *
gimp_save_procedure_run (GimpProcedure *procedure,
const GimpValueArray *args);
gimp_export_procedure_run (GimpProcedure *procedure,
const GimpValueArray *args);
static GimpProcedureConfig *
gimp_save_procedure_create_config (GimpProcedure *procedure,
GParamSpec **args,
gint n_args);
gimp_export_procedure_create_config (GimpProcedure *procedure,
GParamSpec **args,
gint n_args);
static void gimp_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)
#define parent_class gimp_save_procedure_parent_class
#define parent_class gimp_export_procedure_parent_class
static GParamSpec *props[N_PROPS] = { NULL, };
static void
gimp_save_procedure_class_init (GimpSaveProcedureClass *klass)
gimp_export_procedure_class_init (GimpExportProcedureClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
GimpProcedureClass *procedure_class = GIMP_PROCEDURE_CLASS (klass);
object_class->constructed = gimp_save_procedure_constructed;
object_class->finalize = gimp_save_procedure_finalize;
object_class->get_property = gimp_save_procedure_get_property;
object_class->set_property = gimp_save_procedure_set_property;
object_class->constructed = gimp_export_procedure_constructed;
object_class->finalize = gimp_export_procedure_finalize;
object_class->get_property = gimp_export_procedure_get_property;
object_class->set_property = gimp_export_procedure_set_property;
procedure_class->install = gimp_save_procedure_install;
procedure_class->run = gimp_save_procedure_run;
procedure_class->create_config = gimp_save_procedure_create_config;
procedure_class->install = gimp_export_procedure_install;
procedure_class->run = gimp_export_procedure_run;
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
*/
@ -119,9 +119,9 @@ gimp_save_procedure_class_init (GimpSaveProcedureClass *klass)
G_PARAM_CONSTRUCT |
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
*/
@ -132,9 +132,9 @@ gimp_save_procedure_class_init (GimpSaveProcedureClass *klass)
G_PARAM_CONSTRUCT |
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
*/
@ -145,9 +145,9 @@ gimp_save_procedure_class_init (GimpSaveProcedureClass *klass)
G_PARAM_CONSTRUCT |
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
*/
@ -158,9 +158,9 @@ gimp_save_procedure_class_init (GimpSaveProcedureClass *klass)
G_PARAM_CONSTRUCT |
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
*/
@ -171,9 +171,9 @@ gimp_save_procedure_class_init (GimpSaveProcedureClass *klass)
G_PARAM_CONSTRUCT |
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
*/
@ -188,15 +188,15 @@ gimp_save_procedure_class_init (GimpSaveProcedureClass *klass)
}
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;
}
static void
gimp_save_procedure_constructed (GObject *object)
gimp_export_procedure_constructed (GObject *object)
{
GimpProcedure *procedure = GIMP_PROCEDURE (object);
@ -204,32 +204,32 @@ gimp_save_procedure_constructed (GObject *object)
GIMP_PROC_ARG_IMAGE (procedure, "image",
"Image",
"The image to save",
"The image to export",
FALSE,
G_PARAM_READWRITE);
GIMP_PROC_ARG_INT (procedure, "num-drawables",
"Number of drawables",
"Number of drawables to be saved",
"Number of drawables to be exported",
0, G_MAXINT, 1,
G_PARAM_READWRITE);
GIMP_PROC_ARG_OBJECT_ARRAY (procedure, "drawables",
"Drawables",
"The drawables to save",
"The drawables to export",
GIMP_TYPE_DRAWABLE,
G_PARAM_READWRITE | GIMP_PARAM_NO_VALIDATE);
GIMP_PROC_ARG_FILE (procedure, "file",
"File",
"The file to save to",
"The file to export to",
GIMP_PARAM_READWRITE);
}
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)
procedure->priv->run_data_destroy (procedure->priv->run_data);
@ -238,12 +238,12 @@ gimp_save_procedure_finalize (GObject *object)
}
static void
gimp_save_procedure_set_property (GObject *object,
guint property_id,
const GValue *value,
GParamSpec *pspec)
gimp_export_procedure_set_property (GObject *object,
guint property_id,
const GValue *value,
GParamSpec *pspec)
{
GimpSaveProcedure *procedure = GIMP_SAVE_PROCEDURE (object);
GimpExportProcedure *procedure = GIMP_EXPORT_PROCEDURE (object);
switch (property_id)
{
@ -273,12 +273,12 @@ gimp_save_procedure_set_property (GObject *object,
}
static void
gimp_save_procedure_get_property (GObject *object,
guint property_id,
GValue *value,
GParamSpec *pspec)
gimp_export_procedure_get_property (GObject *object,
guint property_id,
GValue *value,
GParamSpec *pspec)
{
GimpSaveProcedure *procedure = GIMP_SAVE_PROCEDURE (object);
GimpExportProcedure *procedure = GIMP_EXPORT_PROCEDURE (object);
switch (property_id)
{
@ -308,13 +308,13 @@ gimp_save_procedure_get_property (GObject *object,
}
static void
gimp_save_procedure_install (GimpProcedure *procedure)
gimp_export_procedure_install (GimpProcedure *procedure)
{
GimpFileProcedure *file_proc = GIMP_FILE_PROCEDURE (procedure);
const gchar *mime_types;
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_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
static GimpValueArray *
gimp_save_procedure_run (GimpProcedure *procedure,
const GimpValueArray *args)
gimp_export_procedure_run (GimpProcedure *procedure,
const GimpValueArray *args)
{
GimpPlugIn *plug_in;
GimpSaveProcedure *save_proc = GIMP_SAVE_PROCEDURE (procedure);
GimpExportProcedure *export_proc = GIMP_EXPORT_PROCEDURE (procedure);
GimpValueArray *remaining;
GimpValueArray *return_values;
GimpProcedureConfig *config;
@ -371,12 +371,12 @@ gimp_save_procedure_run (GimpProcedure *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));
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",
G_STRFUNC);
}
@ -403,10 +403,10 @@ gimp_save_procedure_run (GimpProcedure *procedure,
metadata = _gimp_procedure_config_begin_export (config, image, run_mode, remaining, 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,
file, metadata, config,
save_proc->priv->run_data);
export_proc->priv->run_data);
if (return_values != NULL &&
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);
if (G_OBJECT (config)->ref_count > 1 &&
_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);
g_object_unref (config);
@ -431,11 +431,11 @@ gimp_save_procedure_run (GimpProcedure *procedure,
}
static GimpProcedureConfig *
gimp_save_procedure_create_config (GimpProcedure *procedure,
GParamSpec **args,
gint n_args)
gimp_export_procedure_create_config (GimpProcedure *procedure,
GParamSpec **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)
{
@ -454,45 +454,45 @@ gimp_save_procedure_create_config (GimpProcedure *procedure,
}
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;
if (ran_once)
return;
if (save_procedure->priv->supports_exif)
if (export_procedure->priv->supports_exif)
GIMP_PROC_AUX_ARG_BOOLEAN (procedure, "save-exif",
_("Save _Exif"),
_("Save Exif (Exchangeable image file format) metadata"),
gimp_export_exif (),
G_PARAM_READWRITE);
if (save_procedure->priv->supports_iptc)
if (export_procedure->priv->supports_iptc)
GIMP_PROC_AUX_ARG_BOOLEAN (procedure, "save-iptc",
_("Save _IPTC"),
_("Save IPTC (International Press Telecommunications Council) metadata"),
gimp_export_iptc (),
G_PARAM_READWRITE);
if (save_procedure->priv->supports_xmp)
if (export_procedure->priv->supports_xmp)
GIMP_PROC_AUX_ARG_BOOLEAN (procedure, "save-xmp",
_("Save _XMP"),
_("Save XMP (Extensible Metadata Platform) metadata"),
gimp_export_xmp (),
G_PARAM_READWRITE);
if (save_procedure->priv->supports_profile)
if (export_procedure->priv->supports_profile)
GIMP_PROC_AUX_ARG_BOOLEAN (procedure, "save-color-profile",
_("Save color _profile"),
_("Save the ICC color profile as metadata"),
gimp_export_color_profile (),
G_PARAM_READWRITE);
if (save_procedure->priv->supports_thumbnail)
if (export_procedure->priv->supports_thumbnail)
GIMP_PROC_AUX_ARG_BOOLEAN (procedure, "save-thumbnail",
_("Save _thumbnail"),
_("Save a smaller representation of the image as metadata"),
gimp_export_thumbnail (),
G_PARAM_READWRITE);
if (save_procedure->priv->supports_comment)
if (export_procedure->priv->supports_comment)
{
GIMP_PROC_AUX_ARG_BOOLEAN (procedure, "save-comment",
_("Save c_omment"),
@ -516,7 +516,7 @@ gimp_save_procedure_add_metadata (GimpSaveProcedure *save_procedure)
/* public functions */
/**
* gimp_save_procedure_new:
* gimp_export_procedure_new:
* @plug_in: a #GimpPlugIn.
* @name: the new procedure's name.
* @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_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.
*
* See gimp_procedure_new() for information about @proc_type.
*
* #GimpSaveProcedure is a #GimpProcedure subclass that makes it easier
* to write file save procedures.
* #GimpExportProcedure is a #GimpProcedure subclass that makes it easier
* to write file export procedures.
*
* It automatically adds the standard
*
* (#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.
*
* When invoked via gimp_procedure_run(), it unpacks these standard
* arguments and calls @run_func which is a #GimpRunSaveFunc. The
* #GimpProcedureConfig of #GimpRunSaveFunc only contains additionally added
* arguments and calls @run_func which is a #GimpRunExportFunc. The
* #GimpProcedureConfig of #GimpRunExportFunc only contains additionally added
* arguments.
*
* 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
**/
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)
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)
{
GimpSaveProcedure *procedure;
GimpExportProcedure *procedure;
g_return_val_if_fail (GIMP_IS_PLUG_IN (plug_in), 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 (run_func != NULL, NULL);
procedure = g_object_new (GIMP_TYPE_SAVE_PROCEDURE,
procedure = g_object_new (GIMP_TYPE_EXPORT_PROCEDURE,
"plug-in", plug_in,
"name", name,
"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.
* @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
* %FALSE).
*
@ -598,14 +598,14 @@ gimp_save_procedure_new (GimpPlugIn *plug_in,
* - Automatically adds a standard auxiliary argument "save-exif" in the
* end of the argument list of @procedure, 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
* matter), keeping all save procedures consistent.
* - Generated GimpSaveProcedureDialog will contain the metadata
* matter), keeping all export procedures consistent.
* - Generated GimpExportProcedureDialog will contain the metadata
* options, once again always in the same order and with consistent
* GUI style across plug-ins.
* - 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
* 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
**/
void
gimp_save_procedure_set_support_exif (GimpSaveProcedure *procedure,
gboolean supports)
gimp_export_procedure_set_support_exif (GimpExportProcedure *procedure,
gboolean supports)
{
g_return_if_fail (GIMP_IS_SAVE_PROCEDURE (procedure));
g_return_if_fail (GIMP_IS_EXPORT_PROCEDURE (procedure));
g_object_set (procedure,
"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.
* @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
* %FALSE).
*
@ -637,14 +637,14 @@ gimp_save_procedure_set_support_exif (GimpSaveProcedure *procedure,
* - Automatically adds a standard auxiliary argument "save-iptc" in the
* end of the argument list of @procedure, 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
* matter), keeping all save procedures consistent.
* - Generated GimpSaveProcedureDialog will contain the metadata
* matter), keeping all export procedures consistent.
* - Generated GimpExportProcedureDialog will contain the metadata
* options, once again always in the same order and with consistent
* GUI style across plug-ins.
* - 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
* 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
**/
void
gimp_save_procedure_set_support_iptc (GimpSaveProcedure *procedure,
gboolean supports)
gimp_export_procedure_set_support_iptc (GimpExportProcedure *procedure,
gboolean supports)
{
g_return_if_fail (GIMP_IS_SAVE_PROCEDURE (procedure));
g_return_if_fail (GIMP_IS_EXPORT_PROCEDURE (procedure));
g_object_set (procedure,
"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.
* @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
* %FALSE).
*
@ -676,14 +676,14 @@ gimp_save_procedure_set_support_iptc (GimpSaveProcedure *procedure,
* - Automatically adds a standard auxiliary argument "save-xmp" in the
* end of the argument list of @procedure, 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
* matter), keeping all save procedures consistent.
* - Generated GimpSaveProcedureDialog will contain the metadata
* matter), keeping all export procedures consistent.
* - Generated GimpExportProcedureDialog will contain the metadata
* options, once again always in the same order and with consistent
* GUI style across plug-ins.
* - 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
* 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
**/
void
gimp_save_procedure_set_support_xmp (GimpSaveProcedure *procedure,
gboolean supports)
gimp_export_procedure_set_support_xmp (GimpExportProcedure *procedure,
gboolean supports)
{
g_return_if_fail (GIMP_IS_SAVE_PROCEDURE (procedure));
g_return_if_fail (GIMP_IS_EXPORT_PROCEDURE (procedure));
g_object_set (procedure,
"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.
* @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
* with %FALSE).
*
@ -715,14 +715,14 @@ gimp_save_procedure_set_support_xmp (GimpSaveProcedure *procedure,
* - Automatically adds a standard auxiliary argument
* "save-color-profile" in the end of the argument list of @procedure,
* 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
* matter), keeping all save procedures consistent.
* - Generated GimpSaveProcedureDialog will contain the metadata
* matter), keeping all export procedures consistent.
* - Generated GimpExportProcedureDialog will contain the metadata
* options, once again always in the same order and with consistent
* GUI style across plug-ins.
* - 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
* 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
**/
void
gimp_save_procedure_set_support_profile (GimpSaveProcedure *procedure,
gboolean supports)
gimp_export_procedure_set_support_profile (GimpExportProcedure *procedure,
gboolean supports)
{
g_return_if_fail (GIMP_IS_SAVE_PROCEDURE (procedure));
g_return_if_fail (GIMP_IS_EXPORT_PROCEDURE (procedure));
g_object_set (procedure,
"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.
* @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
* %FALSE).
*
@ -754,14 +754,14 @@ gimp_save_procedure_set_support_profile (GimpSaveProcedure *procedure,
* - Automatically adds a standard auxiliary argument "save-thumbnail"
* in the end of the argument list of @procedure, 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
* matter), keeping all save procedures consistent.
* - Generated GimpSaveProcedureDialog will contain the metadata
* matter), keeping all export procedures consistent.
* - Generated GimpExportProcedureDialog will contain the metadata
* options, once again always in the same order and with consistent
* GUI style across plug-ins.
* - 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
* the PDB arguments. By default, the value will be
@ -770,10 +770,10 @@ gimp_save_procedure_set_support_profile (GimpSaveProcedure *procedure,
* Since: 3.0
**/
void
gimp_save_procedure_set_support_thumbnail (GimpSaveProcedure *procedure,
gboolean supports)
gimp_export_procedure_set_support_thumbnail (GimpExportProcedure *procedure,
gboolean supports)
{
g_return_if_fail (GIMP_IS_SAVE_PROCEDURE (procedure));
g_return_if_fail (GIMP_IS_EXPORT_PROCEDURE (procedure));
g_object_set (procedure,
"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.
* @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
* %FALSE).
*
@ -794,14 +794,14 @@ gimp_save_procedure_set_support_thumbnail (GimpSaveProcedure *procedure,
* - Automatically adds a standard auxiliary argument "save-comment"
* in the end of the argument list of @procedure, 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
* matter), keeping all save procedures consistent.
* - Generated GimpSaveProcedureDialog will contain the metadata
* matter), keeping all export procedures consistent.
* - Generated GimpExportProcedureDialog will contain the metadata
* options, once again always in the same order and with consistent
* GUI style across plug-ins.
* - 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
* the PDB arguments. By default, the value will be
@ -810,10 +810,10 @@ gimp_save_procedure_set_support_thumbnail (GimpSaveProcedure *procedure,
* Since: 3.0
**/
void
gimp_save_procedure_set_support_comment (GimpSaveProcedure *procedure,
gboolean supports)
gimp_export_procedure_set_support_comment (GimpExportProcedure *procedure,
gboolean supports)
{
g_return_if_fail (GIMP_IS_SAVE_PROCEDURE (procedure));
g_return_if_fail (GIMP_IS_EXPORT_PROCEDURE (procedure));
g_object_set (procedure,
"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.
*
* Returns: %TRUE if @procedure supports Exif saving.
* Returns: %TRUE if @procedure supports Exif exporting.
*
* Since: 3.0
**/
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;
}
/**
* gimp_save_procedure_get_support_iptc:
* gimp_export_procedure_get_support_iptc:
* @procedure: a #GimpProcedure.
*
* Returns: %TRUE if @procedure supports IPTC saving.
* Returns: %TRUE if @procedure supports IPTC exporting.
*
* Since: 3.0
**/
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;
}
/**
* gimp_save_procedure_get_support_xmp:
* gimp_export_procedure_get_support_xmp:
* @procedure: a #GimpProcedure.
*
* Returns: %TRUE if @procedure supports XMP saving.
* Returns: %TRUE if @procedure supports XMP exporting.
*
* Since: 3.0
**/
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;
}
/**
* gimp_save_procedure_get_support_profile:
* gimp_export_procedure_get_support_profile:
* @procedure: a #GimpProcedure.
*
* Returns: %TRUE if @procedure supports ICC color profile saving.
* Returns: %TRUE if @procedure supports ICC color profile exporting.
*
* Since: 3.0
**/
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;
}
/**
* gimp_save_procedure_get_support_thumbnail:
* gimp_export_procedure_get_support_thumbnail:
* @procedure: a #GimpProcedure.
*
* Returns: %TRUE if @procedure supports thumbnail saving.
* Returns: %TRUE if @procedure supports thumbnail exporting.
*
* Since: 3.0
**/
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;
}
/**
* gimp_save_procedure_get_support_comment:
* gimp_export_procedure_get_support_comment:
* @procedure: a #GimpProcedure.
*
* Returns: %TRUE if @procedure supports comment saving.
* Returns: %TRUE if @procedure supports comment exporting.
*
* Since: 3.0
**/
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;
}

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__ */

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

@ -1,7 +1,7 @@
/* GIMP - The GNU Image Manipulation Program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* gimpsaveproceduredialog.c
* gimpexportproceduredialog.c
* Copyright (C) 2020 Jehan
*
* This program is free software: you can redistribute it and/or modify
@ -31,7 +31,7 @@
#include "libgimp-intl.h"
struct _GimpSaveProcedureDialogPrivate
struct _GimpExportProcedureDialogPrivate
{
GList *additional_metadata;
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,
GimpProcedure *procedure,
GimpProcedureConfig *config,
GList *properties);
static void gimp_export_procedure_dialog_fill_list (GimpProcedureDialog *dialog,
GimpProcedure *procedure,
GimpProcedureConfig *config,
GList *properties);
static gpointer gimp_save_procedure_dialog_edit_metadata_thread (gpointer data);
static gboolean gimp_save_procedure_dialog_activate_edit_metadata (GtkLinkButton *link,
GimpSaveProcedureDialog *dialog);
static gpointer gimp_export_procedure_dialog_edit_metadata_thread (gpointer data);
static gboolean gimp_export_procedure_dialog_activate_edit_metadata (GtkLinkButton *link,
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
gimp_save_procedure_dialog_class_init (GimpSaveProcedureDialogClass *klass)
gimp_export_procedure_dialog_class_init (GimpExportProcedureDialogClass *klass)
{
GObjectClass *object_class;
GimpProcedureDialogClass *proc_dialog_class;
@ -66,14 +66,14 @@ gimp_save_procedure_dialog_class_init (GimpSaveProcedureDialogClass *klass)
object_class = G_OBJECT_CLASS (klass);
proc_dialog_class = GIMP_PROCEDURE_DIALOG_CLASS (klass);
object_class->finalize = gimp_save_procedure_dialog_finalize;
proc_dialog_class->fill_list = gimp_save_procedure_dialog_fill_list;
object_class->finalize = gimp_export_procedure_dialog_finalize;
proc_dialog_class->fill_list = gimp_export_procedure_dialog_fill_list;
}
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->image = NULL;
@ -82,9 +82,9 @@ gimp_save_procedure_dialog_init (GimpSaveProcedureDialog *dialog)
}
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_clear_pointer (&dialog->priv->metadata_thread, g_thread_unref);
@ -94,39 +94,39 @@ gimp_save_procedure_dialog_finalize (GObject *object)
}
static void
gimp_save_procedure_dialog_fill_list (GimpProcedureDialog *dialog,
GimpProcedure *procedure,
GimpProcedureConfig *config,
GList *properties)
gimp_export_procedure_dialog_fill_list (GimpProcedureDialog *dialog,
GimpProcedure *procedure,
GimpProcedureConfig *config,
GList *properties)
{
GimpSaveProcedureDialog *save_dialog;
GimpSaveProcedure *save_procedure;
GtkWidget *content_area;
GList *properties2 = NULL;
GList *iter;
GimpExportProcedureDialog *export_dialog;
GimpExportProcedure *export_procedure;
GtkWidget *content_area;
GList *properties2 = NULL;
GList *iter;
save_dialog = GIMP_SAVE_PROCEDURE_DIALOG (dialog);
save_procedure = GIMP_SAVE_PROCEDURE (procedure);
content_area = gtk_dialog_get_content_area (GTK_DIALOG (dialog));
export_dialog = GIMP_EXPORT_PROCEDURE_DIALOG (dialog);
export_procedure = GIMP_EXPORT_PROCEDURE (procedure);
content_area = gtk_dialog_get_content_area (GTK_DIALOG (dialog));
for (iter = properties; iter; iter = iter->next)
{
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) ||
(gimp_save_procedure_get_support_iptc (save_procedure) &&
(gimp_export_procedure_get_support_iptc (export_procedure) &&
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) ||
(gimp_save_procedure_get_support_profile (save_procedure) &&
(gimp_export_procedure_get_support_profile (export_procedure) &&
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) ||
(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, "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. */
continue;
@ -137,13 +137,13 @@ gimp_save_procedure_dialog_fill_list (GimpProcedureDialog *dialog,
g_list_free (properties2);
if (gimp_save_procedure_get_support_exif (save_procedure) ||
gimp_save_procedure_get_support_iptc (save_procedure) ||
gimp_save_procedure_get_support_xmp (save_procedure) ||
gimp_save_procedure_get_support_profile (save_procedure) ||
gimp_save_procedure_get_support_thumbnail (save_procedure) ||
g_list_length (save_dialog->priv->additional_metadata) > 0 ||
gimp_save_procedure_get_support_comment (save_procedure))
if (gimp_export_procedure_get_support_exif (export_procedure) ||
gimp_export_procedure_get_support_iptc (export_procedure) ||
gimp_export_procedure_get_support_xmp (export_procedure) ||
gimp_export_procedure_get_support_profile (export_procedure) ||
gimp_export_procedure_get_support_thumbnail (export_procedure) ||
g_list_length (export_dialog->priv->additional_metadata) > 0 ||
gimp_export_procedure_get_support_comment (export_procedure))
{
GtkWidget *frame;
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)"));
gtk_link_button_set_visited (GTK_LINK_BUTTON (link), FALSE);
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);
gtk_box_pack_start (GTK_BOX (frame_title), link, FALSE, FALSE, 0);
gtk_widget_show (link);
@ -191,14 +191,14 @@ gimp_save_procedure_dialog_fill_list (GimpProcedureDialog *dialog,
gtk_widget_show (grid);
/* Line for 3 metadata formats: Exif, IPTC, XMP. */
n_metadata = gimp_save_procedure_get_support_exif (save_procedure) +
gimp_save_procedure_get_support_iptc (save_procedure) +
gimp_save_procedure_get_support_xmp (save_procedure);
n_metadata = gimp_export_procedure_get_support_exif (export_procedure) +
gimp_export_procedure_get_support_iptc (export_procedure) +
gimp_export_procedure_get_support_xmp (export_procedure);
n_metadata = MAX (n_metadata,
gimp_save_procedure_get_support_profile (save_procedure) +
gimp_save_procedure_get_support_thumbnail (save_procedure));
gimp_export_procedure_get_support_profile (export_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),
"save-exif", NULL);
@ -208,7 +208,7 @@ gimp_save_procedure_dialog_fill_list (GimpProcedureDialog *dialog,
top = 1;
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),
"save-iptc", NULL);
@ -218,7 +218,7 @@ gimp_save_procedure_dialog_fill_list (GimpProcedureDialog *dialog,
top = 1;
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),
"save-xmp", NULL);
@ -232,7 +232,7 @@ gimp_save_procedure_dialog_fill_list (GimpProcedureDialog *dialog,
/* Line for specific metadata: profile, thumbnail. */
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),
"save-color-profile", NULL);
@ -241,7 +241,7 @@ gimp_save_procedure_dialog_fill_list (GimpProcedureDialog *dialog,
left += 6 / n_metadata;
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),
"save-thumbnail", NULL);
@ -255,7 +255,7 @@ gimp_save_procedure_dialog_fill_list (GimpProcedureDialog *dialog,
/* Custom metadata: n_metadata items per line. */
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);
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++;
/* 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;
const gchar *tooltip;
@ -325,10 +325,10 @@ gimp_save_procedure_dialog_fill_list (GimpProcedureDialog *dialog,
}
static gpointer
gimp_save_procedure_dialog_edit_metadata_thread (gpointer data)
gimp_export_procedure_dialog_edit_metadata_thread (gpointer data)
{
GimpSaveProcedureDialog *dialog = data;
GimpProcedure *procedure;
GimpExportProcedureDialog *dialog = data;
GimpProcedure *procedure;
procedure = gimp_pdb_lookup_procedure (gimp_get_pdb (), "plug-in-metadata-editor");
gimp_procedure_run (procedure,
@ -345,8 +345,8 @@ gimp_save_procedure_dialog_edit_metadata_thread (gpointer data)
}
static gboolean
gimp_save_procedure_dialog_activate_edit_metadata (GtkLinkButton *link,
GimpSaveProcedureDialog *dialog)
gimp_export_procedure_dialog_activate_edit_metadata (GtkLinkButton *link,
GimpExportProcedureDialog *dialog)
{
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)
/* Only run if not already running. */
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);
g_mutex_unlock (&dialog->priv->metadata_thread_mutex);
@ -369,9 +369,9 @@ gimp_save_procedure_dialog_activate_edit_metadata (GtkLinkButton *link
GtkWidget *
gimp_save_procedure_dialog_new (GimpSaveProcedure *procedure,
GimpProcedureConfig *config,
GimpImage *image)
gimp_export_procedure_dialog_new (GimpExportProcedure *procedure,
GimpProcedureConfig *config,
GimpImage *image)
{
GtkWidget *dialog;
gchar *title;
@ -379,7 +379,7 @@ gimp_save_procedure_dialog_new (GimpSaveProcedure *procedure,
const gchar *help_id;
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_procedure_config_get_procedure (config) ==
GIMP_PROCEDURE (procedure), NULL);
@ -403,7 +403,7 @@ gimp_save_procedure_dialog_new (GimpSaveProcedure *procedure,
"gtk-dialogs-use-header", &use_header_bar,
NULL);
dialog = g_object_new (GIMP_TYPE_SAVE_PROCEDURE_DIALOG,
dialog = g_object_new (GIMP_TYPE_EXPORT_PROCEDURE_DIALOG,
"procedure", procedure,
"config", config,
"title", title,
@ -411,15 +411,15 @@ gimp_save_procedure_dialog_new (GimpSaveProcedure *procedure,
"help-id", help_id,
"use-header-bar", use_header_bar,
NULL);
GIMP_SAVE_PROCEDURE_DIALOG (dialog)->priv->image = image;
GIMP_EXPORT_PROCEDURE_DIALOG (dialog)->priv->image = image;
g_free (title);
return dialog;
}
void
gimp_save_procedure_dialog_add_metadata (GimpSaveProcedureDialog *dialog,
const gchar *property)
gimp_export_procedure_dialog_add_metadata (GimpExportProcedureDialog *dialog,
const gchar *property)
{
if (! g_list_find (dialog->priv->additional_metadata, property))
dialog->priv->additional_metadata = g_list_append (dialog->priv->additional_metadata,

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
* 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
* 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);
if (G_OBJECT (config)->ref_count > 1 &&
_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);
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
*
* 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
* [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.
*
* 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.
*
* 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
* of run().
*
@ -794,7 +794,7 @@ _gimp_procedure_config_end_run (GimpProcedureConfig *config,
* properties. (The corresponding [method@Image.metadata_save_finish]
* 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.
*
* - "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()
*
* 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
* 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))
ok_label = _("_Open");
else if (GIMP_IS_SAVE_PROCEDURE (procedure))
else if (GIMP_IS_EXPORT_PROCEDURE (procedure))
ok_label = _("_Export");
else
ok_label = _("_OK");
@ -565,7 +565,7 @@ gimp_procedure_dialog_set_ok_label (GimpProcedureDialog *dialog,
if (GIMP_IS_LOAD_PROCEDURE (procedure))
ok_label = _("_Open");
else if (GIMP_IS_SAVE_PROCEDURE (procedure))
else if (GIMP_IS_EXPORT_PROCEDURE (procedure))
ok_label = _("_Export");
else
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_new
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_new
gimp_gradient_chooser_get_type
@ -76,9 +79,6 @@ EXPORTS
gimp_resource_chooser_set_clickable
gimp_resource_chooser_set_drag_target
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_vectors_combo_box_get_type
gimp_vectors_combo_box_new

2
libgimp/gimpui.h
View file

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

38
libgimp/gimpuitypes.h
View file

@ -28,29 +28,29 @@ G_BEGIN_DECLS
/* For information look into the html documentation */
typedef struct _GimpProcedureDialog GimpProcedureDialog;
typedef struct _GimpSaveProcedureDialog GimpSaveProcedureDialog;
typedef struct _GimpProcedureDialog GimpProcedureDialog;
typedef struct _GimpExportProcedureDialog GimpExportProcedureDialog;
typedef struct _GimpAspectPreview GimpAspectPreview;
typedef struct _GimpDrawablePreview GimpDrawablePreview;
typedef struct _GimpProcBrowserDialog GimpProcBrowserDialog;
typedef struct _GimpProgressBar GimpProgressBar;
typedef struct _GimpZoomPreview GimpZoomPreview;
typedef struct _GimpAspectPreview GimpAspectPreview;
typedef struct _GimpDrawablePreview GimpDrawablePreview;
typedef struct _GimpProcBrowserDialog GimpProcBrowserDialog;
typedef struct _GimpProgressBar GimpProgressBar;
typedef struct _GimpZoomPreview GimpZoomPreview;
typedef struct _GimpDrawableComboBox GimpDrawableComboBox;
typedef struct _GimpChannelComboBox GimpChannelComboBox;
typedef struct _GimpLayerComboBox GimpLayerComboBox;
typedef struct _GimpVectorsComboBox GimpVectorsComboBox;
typedef struct _GimpImageComboBox GimpImageComboBox;
typedef struct _GimpDrawableComboBox GimpDrawableComboBox;
typedef struct _GimpChannelComboBox GimpChannelComboBox;
typedef struct _GimpLayerComboBox GimpLayerComboBox;
typedef struct _GimpVectorsComboBox GimpVectorsComboBox;
typedef struct _GimpImageComboBox GimpImageComboBox;
typedef struct _GimpDrawableChooser GimpDrawableChooser;
typedef struct _GimpDrawableChooser GimpDrawableChooser;
typedef struct _GimpResourceChooser GimpResourceChooser;
typedef struct _GimpBrushChooser GimpBrushChooser;
typedef struct _GimpFontChooser GimpFontChooser;
typedef struct _GimpGradientChooser GimpGradientChooser;
typedef struct _GimpPaletteChooser GimpPaletteChooser;
typedef struct _GimpPatternChooser GimpPatternChooser;
typedef struct _GimpResourceChooser GimpResourceChooser;
typedef struct _GimpBrushChooser GimpBrushChooser;
typedef struct _GimpFontChooser GimpFontChooser;
typedef struct _GimpGradientChooser GimpGradientChooser;
typedef struct _GimpPaletteChooser GimpPaletteChooser;
typedef struct _GimpPatternChooser GimpPatternChooser;
G_END_DECLS

8
libgimp/meson.build
View file

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@ -142,9 +142,9 @@ gif_create_procedure (GimpPlugIn *plug_in,
if (! strcmp (name, EXPORT_PROC))
{
procedure = gimp_save_procedure_new (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN,
FALSE, gif_export, NULL, NULL);
procedure = gimp_export_procedure_new (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN,
FALSE, gif_export, NULL, NULL);
gimp_procedure_set_image_types (procedure, "INDEXED*, GRAY*");
@ -1264,9 +1264,9 @@ save_dialog (GimpImage *image,
animation_supported = n_layers > 1;
dialog = gimp_save_procedure_dialog_new (GIMP_SAVE_PROCEDURE (procedure),
GIMP_PROCEDURE_CONFIG (config),
image);
dialog = gimp_export_procedure_dialog_new (GIMP_EXPORT_PROCEDURE (procedure),
GIMP_PROCEDURE_CONFIG (config),
image);
/* Warn user that image will be converted to 8 bits if not already */
if (gimp_image_get_precision (orig_image) != GIMP_PRECISION_U8_NON_LINEAR &&

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

@ -148,9 +148,9 @@ gih_create_procedure (GimpPlugIn *plug_in,
if (! strcmp (name, EXPORT_PROC))
{
procedure = gimp_save_procedure_new (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN,
FALSE, gih_export, NULL, NULL);
procedure = gimp_export_procedure_new (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN,
FALSE, gih_export, NULL, NULL);
gimp_procedure_set_image_types (procedure, "RGB*, GRAY*");
@ -666,9 +666,9 @@ gih_save_dialog (GimpImage *image,
gint dimension;
gboolean run;
dialog = gimp_save_procedure_dialog_new (GIMP_SAVE_PROCEDURE (procedure),
GIMP_PROCEDURE_CONFIG (config),
image);
dialog = gimp_export_procedure_dialog_new (GIMP_EXPORT_PROCEDURE (procedure),
GIMP_PROCEDURE_CONFIG (config),
image);
gtk_widget_set_halign (gimp_procedure_dialog_get_label (GIMP_PROCEDURE_DIALOG (dialog),
"info-text", NULL, TRUE, FALSE),

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@ -340,11 +340,11 @@ pnm_create_procedure (GimpPlugIn *plug_in,
}
else if (! strcmp (name, PNM_EXPORT_PROC))
{
procedure = gimp_save_procedure_new (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN,
FALSE, pnm_export,
GINT_TO_POINTER (FILE_TYPE_PNM),
NULL);
procedure = gimp_export_procedure_new (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN,
FALSE, pnm_export,
GINT_TO_POINTER (FILE_TYPE_PNM),
NULL);
gimp_procedure_set_image_types (procedure, "RGB, GRAY, INDEXED");
@ -377,11 +377,11 @@ pnm_create_procedure (GimpPlugIn *plug_in,
}
else if (! strcmp (name, PBM_EXPORT_PROC))
{
procedure = gimp_save_procedure_new (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN,
FALSE, pnm_export,
GINT_TO_POINTER (FILE_TYPE_PBM),
NULL);
procedure = gimp_export_procedure_new (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN,
FALSE, pnm_export,
GINT_TO_POINTER (FILE_TYPE_PBM),
NULL);
gimp_procedure_set_image_types (procedure, "RGB, GRAY, INDEXED");
gimp_file_procedure_set_format_name (GIMP_FILE_PROCEDURE (procedure),
@ -413,11 +413,11 @@ pnm_create_procedure (GimpPlugIn *plug_in,
}
else if (! strcmp (name, PGM_EXPORT_PROC))
{
procedure = gimp_save_procedure_new (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN,
FALSE, pnm_export,
GINT_TO_POINTER (FILE_TYPE_PGM),
NULL);
procedure = gimp_export_procedure_new (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN,
FALSE, pnm_export,
GINT_TO_POINTER (FILE_TYPE_PGM),
NULL);
gimp_procedure_set_image_types (procedure, "RGB, GRAY, INDEXED");
@ -449,11 +449,11 @@ pnm_create_procedure (GimpPlugIn *plug_in,
}
else if (! strcmp (name, PPM_EXPORT_PROC))
{
procedure = gimp_save_procedure_new (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN,
FALSE, pnm_export,
GINT_TO_POINTER (FILE_TYPE_PPM),
NULL);
procedure = gimp_export_procedure_new (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN,
FALSE, pnm_export,
GINT_TO_POINTER (FILE_TYPE_PPM),
NULL);
gimp_procedure_set_image_types (procedure, "RGB, GRAY, INDEXED");
@ -485,11 +485,11 @@ pnm_create_procedure (GimpPlugIn *plug_in,
}
else if (! strcmp (name, PAM_EXPORT_PROC))
{
procedure = gimp_save_procedure_new (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN,
FALSE, pnm_export,
GINT_TO_POINTER (FILE_TYPE_PAM),
NULL);
procedure = gimp_export_procedure_new (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN,
FALSE, pnm_export,
GINT_TO_POINTER (FILE_TYPE_PAM),
NULL);
gimp_procedure_set_image_types (procedure, "RGB*, GRAY*, INDEXED*");
@ -514,11 +514,11 @@ pnm_create_procedure (GimpPlugIn *plug_in,
}
else if (! strcmp (name, PFM_EXPORT_PROC))
{
procedure = gimp_save_procedure_new (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN,
FALSE, pnm_export,
GINT_TO_POINTER (FILE_TYPE_PFM),
NULL);
procedure = gimp_export_procedure_new (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN,
FALSE, pnm_export,
GINT_TO_POINTER (FILE_TYPE_PFM),
NULL);
gimp_procedure_set_image_types (procedure, "RGB, GRAY, INDEXED");
@ -2020,9 +2020,9 @@ save_dialog (GimpProcedure *procedure,
GtkListStore *store;
gboolean run;
dialog = gimp_save_procedure_dialog_new (GIMP_SAVE_PROCEDURE (procedure),
GIMP_PROCEDURE_CONFIG (config),
image);
dialog = gimp_export_procedure_dialog_new (GIMP_EXPORT_PROCEDURE (procedure),
GIMP_PROCEDURE_CONFIG (config),
image);
/* file save type */
store = gimp_int_store_new (_("_ASCII"), 0,
_("_Raw"), 1,

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

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

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

@ -688,9 +688,9 @@ psp_create_procedure (GimpPlugIn *plug_in,
}
else if (! strcmp (name, EXPORT_PROC))
{
procedure = gimp_save_procedure_new (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN,
FALSE, psp_export, NULL, NULL);
procedure = gimp_export_procedure_new (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN,
FALSE, psp_export, NULL, NULL);
gimp_procedure_set_image_types (procedure, "*");
@ -831,9 +831,9 @@ save_dialog (GimpProcedure *procedure,
GtkWidget *frame;
gint run;
dialog = gimp_save_procedure_dialog_new (GIMP_SAVE_PROCEDURE (procedure),
GIMP_PROCEDURE_CONFIG (config),
image);
dialog = gimp_export_procedure_dialog_new (GIMP_EXPORT_PROCEDURE (procedure),
GIMP_PROCEDURE_CONFIG (config),
image);
/* file save type */
store = gimp_int_store_new (_("None"), PSP_COMP_NONE,

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

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

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

@ -446,9 +446,9 @@ raw_create_procedure (GimpPlugIn *plug_in,
}
else if (! strcmp (name, EXPORT_PROC))
{
procedure = gimp_save_procedure_new (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN,
FALSE, raw_export, NULL, NULL);
procedure = gimp_export_procedure_new (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN,
FALSE, raw_export, NULL, NULL);
gimp_procedure_set_image_types (procedure, "INDEXED, GRAY, RGB, RGBA");
@ -2907,9 +2907,9 @@ save_dialog (GimpImage *image,
else
planar_label = g_strdup (_("_Planar"));
dialog = gimp_save_procedure_dialog_new (GIMP_SAVE_PROCEDURE (procedure),
GIMP_PROCEDURE_CONFIG (config),
image);
dialog = gimp_export_procedure_dialog_new (GIMP_EXPORT_PROCEDURE (procedure),
GIMP_PROCEDURE_CONFIG (config),
image);
/* Image type combo */
store = gimp_int_store_new (contiguous_label, RAW_PLANAR_CONTIGUOUS,

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

@ -294,9 +294,9 @@ sunras_create_procedure (GimpPlugIn *plug_in,
}
else if (! strcmp (name, EXPORT_PROC))
{
procedure = gimp_save_procedure_new (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN,
FALSE, sunras_export, NULL, NULL);
procedure = gimp_export_procedure_new (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN,
FALSE, sunras_export, NULL, NULL);
gimp_procedure_set_image_types (procedure, "RGB, GRAY, INDEXED");
@ -1787,9 +1787,9 @@ save_dialog (GimpImage *image,
GtkListStore *store;
gboolean run;
dialog = gimp_save_procedure_dialog_new (GIMP_SAVE_PROCEDURE (procedure),
GIMP_PROCEDURE_CONFIG (config),
image);
dialog = gimp_export_procedure_dialog_new (GIMP_EXPORT_PROCEDURE (procedure),
GIMP_PROCEDURE_CONFIG (config),
image);
store = gimp_int_store_new (_("S_tandard"), FALSE,
_("R_un-Length Encoded"), TRUE,

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

@ -280,9 +280,9 @@ tga_create_procedure (GimpPlugIn *plug_in,
}
else if (! strcmp (name, EXPORT_PROC))
{
procedure = gimp_save_procedure_new (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN,
FALSE, tga_export, NULL, NULL);
procedure = gimp_export_procedure_new (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN,
FALSE, tga_export, NULL, NULL);
gimp_procedure_set_image_types (procedure, "*");
@ -1445,9 +1445,9 @@ save_dialog (GimpImage *image,
GtkWidget *vbox;
gboolean run;
dialog = gimp_save_procedure_dialog_new (GIMP_SAVE_PROCEDURE (procedure),
GIMP_PROCEDURE_CONFIG (config),
image);
dialog = gimp_export_procedure_dialog_new (GIMP_EXPORT_PROCEDURE (procedure),
GIMP_PROCEDURE_CONFIG (config),
image);
store = gimp_int_store_new (_("Bottom left"), ORIGIN_BOTTOM_LEFT,
_("Top left"), ORIGIN_TOP_LEFT,

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

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

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

@ -341,9 +341,9 @@ xmc_create_procedure (GimpPlugIn *plug_in,
}
else if (! strcmp (name, EXPORT_PROC))
{
procedure = gimp_save_procedure_new (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN,
FALSE, xmc_export, NULL, NULL);
procedure = gimp_export_procedure_new (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN,
FALSE, xmc_export, NULL, NULL);
gimp_procedure_set_image_types (procedure, "RGBA");
@ -1109,9 +1109,9 @@ save_dialog (GimpProcedure *procedure,
GtkWidget *combo;
gboolean run;
dialog = gimp_save_procedure_dialog_new (GIMP_SAVE_PROCEDURE (procedure),
GIMP_PROCEDURE_CONFIG (config),
image);
dialog = gimp_export_procedure_dialog_new (GIMP_EXPORT_PROCEDURE (procedure),
GIMP_PROCEDURE_CONFIG (config),
image);
/* Define hot-spot ranges relative to the image */
button = gimp_procedure_dialog_get_widget (GIMP_PROCEDURE_DIALOG (dialog),

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@ -212,9 +212,9 @@ fli_create_procedure (GimpPlugIn *plug_in,
}
else if (! strcmp (name, EXPORT_PROC))
{
procedure = gimp_save_procedure_new (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN,
FALSE, fli_export, NULL, NULL);
procedure = gimp_export_procedure_new (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN,
FALSE, fli_export, NULL, NULL);
gimp_procedure_set_image_types (procedure, "INDEXED, GRAY");
@ -968,9 +968,9 @@ save_dialog (GimpImage *image,
"to-frame", n_frames,
NULL);
dialog = gimp_save_procedure_dialog_new (GIMP_SAVE_PROCEDURE (procedure),
GIMP_PROCEDURE_CONFIG (config),
image);
dialog = gimp_export_procedure_dialog_new (GIMP_EXPORT_PROCEDURE (procedure),
GIMP_PROCEDURE_CONFIG (config),
image);
/*
* Maybe I add on-the-fly RGB conversion, to keep palettechanges...
* But for now you can set a start- and a end-frame:

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

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

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

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

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

@ -854,9 +854,9 @@ save_dialog (GimpProcedure *procedure,
"restart", &restart,
NULL);
dialog = gimp_save_procedure_dialog_new (GIMP_SAVE_PROCEDURE (procedure),
GIMP_PROCEDURE_CONFIG (config),
gimp_item_get_image (GIMP_ITEM (drawable)));
dialog = gimp_export_procedure_dialog_new (GIMP_EXPORT_PROCEDURE (procedure),
GIMP_PROCEDURE_CONFIG (config),
gimp_item_get_image (GIMP_ITEM (drawable)));
/* custom quantization tables - now used also for original quality */
gimp_procedure_dialog_set_sensitive (GIMP_PROCEDURE_DIALOG (dialog),

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

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

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

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

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

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

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

@ -1259,9 +1259,9 @@ save_dialog (GimpImage *image,
}
g_strfreev (parasites);
dialog = gimp_save_procedure_dialog_new (GIMP_SAVE_PROCEDURE (procedure),
GIMP_PROCEDURE_CONFIG (config),
image);
dialog = gimp_export_procedure_dialog_new (GIMP_EXPORT_PROCEDURE (procedure),
GIMP_PROCEDURE_CONFIG (config),
image);
if (classic_tiff_failed)
{
@ -1342,7 +1342,7 @@ save_dialog (GimpImage *image,
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),
"save-geotiff",
has_geotiff, NULL, NULL, FALSE);

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

@ -199,9 +199,9 @@ tiff_create_procedure (GimpPlugIn *plug_in,
}
else if (! strcmp (name, EXPORT_PROC))
{
procedure = gimp_save_procedure_new (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN,
TRUE, tiff_export, NULL, NULL);
procedure = gimp_export_procedure_new (plug_in, name,
GIMP_PDB_PROC_TYPE_PLUGIN,
TRUE, tiff_export, NULL, NULL);
gimp_procedure_set_image_types (procedure, "*");
@ -278,14 +278,14 @@ tiff_create_procedure (GimpPlugIn *plug_in,
TRUE,
G_PARAM_READWRITE);
gimp_save_procedure_set_support_exif (GIMP_SAVE_PROCEDURE (procedure), TRUE);
gimp_save_procedure_set_support_iptc (GIMP_SAVE_PROCEDURE (procedure), TRUE);
gimp_save_procedure_set_support_xmp (GIMP_SAVE_PROCEDURE (procedure), TRUE);
gimp_export_procedure_set_support_exif (GIMP_EXPORT_PROCEDURE (procedure), TRUE);
gimp_export_procedure_set_support_iptc (GIMP_EXPORT_PROCEDURE (procedure), TRUE);
gimp_export_procedure_set_support_xmp (GIMP_EXPORT_PROCEDURE (procedure), TRUE);
#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
gimp_save_procedure_set_support_thumbnail (GIMP_SAVE_PROCEDURE (procedure), TRUE);
gimp_save_procedure_set_support_comment (GIMP_SAVE_PROCEDURE (procedure), TRUE);
gimp_export_procedure_set_support_thumbnail (GIMP_EXPORT_PROCEDURE (procedure), TRUE);
gimp_export_procedure_set_support_comment (GIMP_EXPORT_PROCEDURE (procedure), TRUE);
}
return procedure;

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

@ -72,9 +72,9 @@ save_dialog (GimpImage *image,
animation_supported = nlayers > 1;
dialog = gimp_save_procedure_dialog_new (GIMP_SAVE_PROCEDURE (procedure),
GIMP_PROCEDURE_CONFIG (config),
image);
dialog = gimp_export_procedure_dialog_new (GIMP_EXPORT_PROCEDURE (procedure),
GIMP_PROCEDURE_CONFIG (config),
image);
/* Create the combobox containing the presets */
store = gimp_int_store_new (_("Default"), WEBP_PRESET_DEFAULT,

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

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

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

@ -299,9 +299,9 @@ class ColorXhtml(Gimp.PlugIn):
def do_create_procedure(self, name):
procedure = None
if name == 'file-colorxhtml-export':
procedure = Gimp.SaveProcedure.new(self, name,
Gimp.PDBProcType.PLUGIN,
False, export_colorxhtml, None)
procedure = Gimp.ExportProcedure.new(self, name,
Gimp.PDBProcType.PLUGIN,
False, export_colorxhtml, None)
procedure.set_image_types("RGB")
procedure.set_documentation (
_("Save as colored HTML text"),

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

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

4
po-libgimp/POTFILES.in
View file

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