dnrops
/
gimp
mirror of https://github.com/GNOME/gimp.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
gimp/libgimp/gimpsaveprocedure.c

265 lines
8.7 KiB
C
Raw Normal View History

libgimp: add GimpFileProcedure, GimpLoadProcedure and GimpSaveProcedure which are GimpProcedure subclasses with API to register as load/save handlers and their own kind of run functions that get their standard arguments passed directly instead of packed into a GimpValueArray. They also register their standard arguments themselves, which removes quite some boilerplate from load/save plug-ins. Remove gimpprocedure-private.[ch] because install() and uninstall() are now virtual functions of GimpProcedure.
2019-08-11 02:25:37 +08:00
/* GIMP - The GNU Image Manipulation Program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* gimpsaveprocedure.c
* Copyright (C) 2019 Michael Natterer <mitch@gimp.org>
*
* 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/>.
*/
#include "config.h"
#include "gimp.h"
pdb, libgimp: move the old file proc registering API to gimplegacy.[ch] Also, #define GIMP_DISABLE_COMPAT_CRUFT in all GimpPlugIn related files to prevent accidential use of the old API.
2019-08-11 19:21:55 +08:00
libgimp: add GimpFileProcedure, GimpLoadProcedure and GimpSaveProcedure which are GimpProcedure subclasses with API to register as load/save handlers and their own kind of run functions that get their standard arguments passed directly instead of packed into a GimpValueArray. They also register their standard arguments themselves, which removes quite some boilerplate from load/save plug-ins. Remove gimpprocedure-private.[ch] because install() and uninstall() are now virtual functions of GimpProcedure.
2019-08-11 02:25:37 +08:00
#include "gimpsaveprocedure.h"
pdb: move the file procedure register API from "fileops" to "pdb" because it has nothing to do with the other procedures in fileops and only sets properties on procedures.
2019-09-11 03:24:09 +08:00
#include "gimppdb_pdb.h"
libgimp: add GimpFileProcedure, GimpLoadProcedure and GimpSaveProcedure which are GimpProcedure subclasses with API to register as load/save handlers and their own kind of run functions that get their standard arguments passed directly instead of packed into a GimpValueArray. They also register their standard arguments themselves, which removes quite some boilerplate from load/save plug-ins. Remove gimpprocedure-private.[ch] because install() and uninstall() are now virtual functions of GimpProcedure.
2019-08-11 02:25:37 +08:00
struct _GimpSaveProcedurePrivate
{
libgimp: rename GimpLoad,SaveFunc to GimpRunLoad,SaveFunc and document gimp_load,save_procedure_new().
2019-08-11 20:58:55 +08:00
GimpRunSaveFunc run_func;
libgimp: add GimpFileProcedure, GimpLoadProcedure and GimpSaveProcedure which are GimpProcedure subclasses with API to register as load/save handlers and their own kind of run functions that get their standard arguments passed directly instead of packed into a GimpValueArray. They also register their standard arguments themselves, which removes quite some boilerplate from load/save plug-ins. Remove gimpprocedure-private.[ch] because install() and uninstall() are now virtual functions of GimpProcedure.
2019-08-11 02:25:37 +08:00
gpointer run_data;
GDestroyNotify run_data_destroy;
};
libgimp: implement GimpProcedure::create_config() in all subclasses
2019-09-24 06:59:50 +08:00
static void gimp_save_procedure_constructed (GObject *object);
static void gimp_save_procedure_finalize (GObject *object);
libgimp: add GimpFileProcedure, GimpLoadProcedure and GimpSaveProcedure which are GimpProcedure subclasses with API to register as load/save handlers and their own kind of run functions that get their standard arguments passed directly instead of packed into a GimpValueArray. They also register their standard arguments themselves, which removes quite some boilerplate from load/save plug-ins. Remove gimpprocedure-private.[ch] because install() and uninstall() are now virtual functions of GimpProcedure.
2019-08-11 02:25:37 +08:00
libgimp: implement GimpProcedure::create_config() in all subclasses
2019-09-24 06:59:50 +08:00
static void gimp_save_procedure_install (GimpProcedure *procedure);
libgimp: add GimpFileProcedure, GimpLoadProcedure and GimpSaveProcedure which are GimpProcedure subclasses with API to register as load/save handlers and their own kind of run functions that get their standard arguments passed directly instead of packed into a GimpValueArray. They also register their standard arguments themselves, which removes quite some boilerplate from load/save plug-ins. Remove gimpprocedure-private.[ch] because install() and uninstall() are now virtual functions of GimpProcedure.
2019-08-11 02:25:37 +08:00
static GimpValueArray *
libgimp: implement GimpProcedure::create_config() in all subclasses
2019-09-24 06:59:50 +08:00
gimp_save_procedure_run (GimpProcedure *procedure,
const GimpValueArray *args);
static GimpProcedureConfig *
gimp_save_procedure_create_config (GimpProcedure *procedure,
GParamSpec **args,
gint n_args);
libgimp: add GimpFileProcedure, GimpLoadProcedure and GimpSaveProcedure which are GimpProcedure subclasses with API to register as load/save handlers and their own kind of run functions that get their standard arguments passed directly instead of packed into a GimpValueArray. They also register their standard arguments themselves, which removes quite some boilerplate from load/save plug-ins. Remove gimpprocedure-private.[ch] because install() and uninstall() are now virtual functions of GimpProcedure.
2019-08-11 02:25:37 +08:00
G_DEFINE_TYPE_WITH_PRIVATE (GimpSaveProcedure, gimp_save_procedure,
GIMP_TYPE_FILE_PROCEDURE)
#define parent_class gimp_save_procedure_parent_class
static void
gimp_save_procedure_class_init (GimpSaveProcedureClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
GimpProcedureClass *procedure_class = GIMP_PROCEDURE_CLASS (klass);
libgimp: implement GimpProcedure::create_config() in all subclasses
2019-09-24 06:59:50 +08:00
object_class->constructed = gimp_save_procedure_constructed;
object_class->finalize = gimp_save_procedure_finalize;
libgimp: add GimpFileProcedure, GimpLoadProcedure and GimpSaveProcedure which are GimpProcedure subclasses with API to register as load/save handlers and their own kind of run functions that get their standard arguments passed directly instead of packed into a GimpValueArray. They also register their standard arguments themselves, which removes quite some boilerplate from load/save plug-ins. Remove gimpprocedure-private.[ch] because install() and uninstall() are now virtual functions of GimpProcedure.
2019-08-11 02:25:37 +08:00
libgimp: implement GimpProcedure::create_config() in all subclasses
2019-09-24 06:59:50 +08:00
procedure_class->install = gimp_save_procedure_install;
procedure_class->run = gimp_save_procedure_run;
procedure_class->create_config = gimp_save_procedure_create_config;
libgimp: add GimpFileProcedure, GimpLoadProcedure and GimpSaveProcedure which are GimpProcedure subclasses with API to register as load/save handlers and their own kind of run functions that get their standard arguments passed directly instead of packed into a GimpValueArray. They also register their standard arguments themselves, which removes quite some boilerplate from load/save plug-ins. Remove gimpprocedure-private.[ch] because install() and uninstall() are now virtual functions of GimpProcedure.
2019-08-11 02:25:37 +08:00
}
static void
gimp_save_procedure_init (GimpSaveProcedure *procedure)
{
procedure->priv = gimp_save_procedure_get_instance_private (procedure);
}
static void
gimp_save_procedure_constructed (GObject *object)
{
GimpProcedure *procedure = GIMP_PROCEDURE (object);
G_OBJECT_CLASS (parent_class)->constructed (object);
libgimp, plug-ins: use the new macros everwhere Except for gimp_param_spec_string() which is on its way back to the core.
2019-08-19 16:02:07 +08:00
GIMP_PROC_ARG_IMAGE (procedure, "image",
"Image",
"The image to save",
app, libgimp: get rid of all ID GTypes and ID param specs Turn all ID param specs into object param specs (e.g. GimpParamImageID becomes GimpParamImage) and convert between IDs and objects in gimpgpparams.c directly above the the wire protocol, so all of app/, libgimp/ and plug-ins/ can deal directly with objects down to the lowest level and not care about IDs. Use the actual object param specs for procedure arguments and return values again instead of a plain g_param_spec_object() and bring back the none_ok parameter. This implies changing the PDB type checking functions to work on pure integers instead of IDs (one can't check whether object creation is possible if performing that check requires the object to already exist). For example gimp_foo_is_valid() becomes gimp_foo_id_is_valid() and is not involved in automatic object creation magic at the protocol level. Added wrappers which still say gimp_foo_is_valid() and take the respective objects. Adapted all code, and it all becomes nicer and less convoluted, even the generated PDB wrappers in app/ and libgimp/.
2019-08-29 17:25:35 +08:00
FALSE,
libgimp, plug-ins: use the new macros everwhere Except for gimp_param_spec_string() which is on its way back to the core.
2019-08-19 16:02:07 +08:00
G_PARAM_READWRITE);
GIMP_PROC_ARG_DRAWABLE (procedure, "drawable",
"Drawable",
Move GimpParamSpecString from libgimp back to app It's just too weird to be public. Remove its properties from the wire protocol and from pluginrc. Instead, have all GParamSpecs' flags on the wire and in pluginrc, so we can use stuff like GIMP_PARAM_NO_VALIDATE. Port the remaining few places to GIMP_PROC_ARG_STRING(). I'm sure something is broken now wrt UTF-8 validation, will add tighter checks in the next commit.
2019-08-19 18:54:52 +08:00
"The drawable to save",
app, libgimp: get rid of all ID GTypes and ID param specs Turn all ID param specs into object param specs (e.g. GimpParamImageID becomes GimpParamImage) and convert between IDs and objects in gimpgpparams.c directly above the the wire protocol, so all of app/, libgimp/ and plug-ins/ can deal directly with objects down to the lowest level and not care about IDs. Use the actual object param specs for procedure arguments and return values again instead of a plain g_param_spec_object() and bring back the none_ok parameter. This implies changing the PDB type checking functions to work on pure integers instead of IDs (one can't check whether object creation is possible if performing that check requires the object to already exist). For example gimp_foo_is_valid() becomes gimp_foo_id_is_valid() and is not involved in automatic object creation magic at the protocol level. Added wrappers which still say gimp_foo_is_valid() and take the respective objects. Adapted all code, and it all becomes nicer and less convoluted, even the generated PDB wrappers in app/ and libgimp/.
2019-08-29 17:25:35 +08:00
FALSE,
libgimp, plug-ins: use the new macros everwhere Except for gimp_param_spec_string() which is on its way back to the core.
2019-08-19 16:02:07 +08:00
G_PARAM_READWRITE);
pdb, app, libgimp, plug-ins: replace most PDB filenames/URIs by GFile and in an attack of madness, changes almost all file plug-in code to use GFile instead of filenames, which means passing the GFile down to the bottom and get its filename at the very end where it's actually needed.
2019-09-12 03:48:34 +08:00
GIMP_PROC_ARG_FILE (procedure, "file",
"File",
"The file to save to",
GIMP_PARAM_READWRITE);
libgimp: add GimpFileProcedure, GimpLoadProcedure and GimpSaveProcedure which are GimpProcedure subclasses with API to register as load/save handlers and their own kind of run functions that get their standard arguments passed directly instead of packed into a GimpValueArray. They also register their standard arguments themselves, which removes quite some boilerplate from load/save plug-ins. Remove gimpprocedure-private.[ch] because install() and uninstall() are now virtual functions of GimpProcedure.
2019-08-11 02:25:37 +08:00
}
static void
gimp_save_procedure_finalize (GObject *object)
{
GimpSaveProcedure *procedure = GIMP_SAVE_PROCEDURE (object);
if (procedure->priv->run_data_destroy)
procedure->priv->run_data_destroy (procedure->priv->run_data);
G_OBJECT_CLASS (parent_class)->finalize (object);
}
static void
gimp_save_procedure_install (GimpProcedure *procedure)
{
GimpFileProcedure *file_proc = GIMP_FILE_PROCEDURE (procedure);
const gchar *mime_types;
gint priority;
GIMP_PROCEDURE_CLASS (parent_class)->install (procedure);
pdb: move the file procedure register API from "fileops" to "pdb" because it has nothing to do with the other procedures in fileops and only sets properties on procedures.
2019-09-11 03:24:09 +08:00
_gimp_pdb_set_file_proc_save_handler (gimp_procedure_get_name (procedure),
gimp_file_procedure_get_extensions (file_proc),
gimp_file_procedure_get_prefixes (file_proc));
libgimp: add GimpFileProcedure, GimpLoadProcedure and GimpSaveProcedure which are GimpProcedure subclasses with API to register as load/save handlers and their own kind of run functions that get their standard arguments passed directly instead of packed into a GimpValueArray. They also register their standard arguments themselves, which removes quite some boilerplate from load/save plug-ins. Remove gimpprocedure-private.[ch] because install() and uninstall() are now virtual functions of GimpProcedure.
2019-08-11 02:25:37 +08:00
Change the "handles uri" flag of file procedures to "handle remote" And always pass URIs to all file procedures, the ones what didn't register as "handles remove" will only ever get local file:// URIs. Change all file plug-ins (also legacy ones) to expect URIs instead of filenames, and convert to local paths in the plug-in. The wire protocol should now be almost 100% clean of non-UTF-8 strings.
2019-08-19 18:05:12 +08:00
if (gimp_file_procedure_get_handles_remote (file_proc))
pdb: move the file procedure register API from "fileops" to "pdb" because it has nothing to do with the other procedures in fileops and only sets properties on procedures.
2019-09-11 03:24:09 +08:00
_gimp_pdb_set_file_proc_handles_remote (gimp_procedure_get_name (procedure));
libgimp: add GimpFileProcedure, GimpLoadProcedure and GimpSaveProcedure which are GimpProcedure subclasses with API to register as load/save handlers and their own kind of run functions that get their standard arguments passed directly instead of packed into a GimpValueArray. They also register their standard arguments themselves, which removes quite some boilerplate from load/save plug-ins. Remove gimpprocedure-private.[ch] because install() and uninstall() are now virtual functions of GimpProcedure.
2019-08-11 02:25:37 +08:00
mime_types = gimp_file_procedure_get_mime_types (file_proc);
if (mime_types)
pdb: move the file procedure register API from "fileops" to "pdb" because it has nothing to do with the other procedures in fileops and only sets properties on procedures.
2019-09-11 03:24:09 +08:00
_gimp_pdb_set_file_proc_mime_types (gimp_procedure_get_name (procedure),
mime_types);
libgimp: add GimpFileProcedure, GimpLoadProcedure and GimpSaveProcedure which are GimpProcedure subclasses with API to register as load/save handlers and their own kind of run functions that get their standard arguments passed directly instead of packed into a GimpValueArray. They also register their standard arguments themselves, which removes quite some boilerplate from load/save plug-ins. Remove gimpprocedure-private.[ch] because install() and uninstall() are now virtual functions of GimpProcedure.
2019-08-11 02:25:37 +08:00
priority = gimp_file_procedure_get_priority (file_proc);
if (priority != 0)
pdb: move the file procedure register API from "fileops" to "pdb" because it has nothing to do with the other procedures in fileops and only sets properties on procedures.
2019-09-11 03:24:09 +08:00
_gimp_pdb_set_file_proc_priority (gimp_procedure_get_name (procedure),
priority);
libgimp: add GimpFileProcedure, GimpLoadProcedure and GimpSaveProcedure which are GimpProcedure subclasses with API to register as load/save handlers and their own kind of run functions that get their standard arguments passed directly instead of packed into a GimpValueArray. They also register their standard arguments themselves, which removes quite some boilerplate from load/save plug-ins. Remove gimpprocedure-private.[ch] because install() and uninstall() are now virtual functions of GimpProcedure.
2019-08-11 02:25:37 +08:00
}
libgimp: implement GimpProcedure::create_config() in all subclasses
2019-09-24 06:59:50 +08:00
#define ARG_OFFSET 4
libgimp: add GimpFileProcedure, GimpLoadProcedure and GimpSaveProcedure which are GimpProcedure subclasses with API to register as load/save handlers and their own kind of run functions that get their standard arguments passed directly instead of packed into a GimpValueArray. They also register their standard arguments themselves, which removes quite some boilerplate from load/save plug-ins. Remove gimpprocedure-private.[ch] because install() and uninstall() are now virtual functions of GimpProcedure.
2019-08-11 02:25:37 +08:00
static GimpValueArray *
gimp_save_procedure_run (GimpProcedure *procedure,
const GimpValueArray *args)
{
GimpSaveProcedure *save_proc = GIMP_SAVE_PROCEDURE (procedure);
GimpValueArray *remaining;
GimpValueArray *return_values;
GimpRunMode run_mode;
libgimp: GimpSaveProcedure() now uses GimpImage/GimpDrawable object... ... as parameters. And GimpLoadProcedure() now expects the run() function to return a GimpImage object.
2019-08-14 20:59:40 +08:00
GimpImage *image;
GimpDrawable *drawable;
libgimp: add GimpFileProcedure, GimpLoadProcedure and GimpSaveProcedure which are GimpProcedure subclasses with API to register as load/save handlers and their own kind of run functions that get their standard arguments passed directly instead of packed into a GimpValueArray. They also register their standard arguments themselves, which removes quite some boilerplate from load/save plug-ins. Remove gimpprocedure-private.[ch] because install() and uninstall() are now virtual functions of GimpProcedure.
2019-08-11 02:25:37 +08:00
GFile *file;
gint i;
pdb, app, libgimp, plug-ins: replace most PDB filenames/URIs by GFile and in an attack of madness, changes almost all file plug-in code to use GFile instead of filenames, which means passing the GFile down to the bottom and get its filename at the very end where it's actually needed.
2019-09-12 03:48:34 +08:00
run_mode = GIMP_VALUES_GET_ENUM (args, 0);
image = GIMP_VALUES_GET_IMAGE (args, 1);
drawable = GIMP_VALUES_GET_DRAWABLE (args, 2);
file = GIMP_VALUES_GET_FILE (args, 3);
libgimp: add GimpFileProcedure, GimpLoadProcedure and GimpSaveProcedure which are GimpProcedure subclasses with API to register as load/save handlers and their own kind of run functions that get their standard arguments passed directly instead of packed into a GimpValueArray. They also register their standard arguments themselves, which removes quite some boilerplate from load/save plug-ins. Remove gimpprocedure-private.[ch] because install() and uninstall() are now virtual functions of GimpProcedure.
2019-08-11 02:25:37 +08:00
libgimp: implement GimpProcedure::create_config() in all subclasses
2019-09-24 06:59:50 +08:00
remaining = gimp_value_array_new (gimp_value_array_length (args) - ARG_OFFSET);
libgimp: add GimpFileProcedure, GimpLoadProcedure and GimpSaveProcedure which are GimpProcedure subclasses with API to register as load/save handlers and their own kind of run functions that get their standard arguments passed directly instead of packed into a GimpValueArray. They also register their standard arguments themselves, which removes quite some boilerplate from load/save plug-ins. Remove gimpprocedure-private.[ch] because install() and uninstall() are now virtual functions of GimpProcedure.
2019-08-11 02:25:37 +08:00
libgimp: implement GimpProcedure::create_config() in all subclasses
2019-09-24 06:59:50 +08:00
for (i = ARG_OFFSET; i < gimp_value_array_length (args); i++)
libgimp: add GimpFileProcedure, GimpLoadProcedure and GimpSaveProcedure which are GimpProcedure subclasses with API to register as load/save handlers and their own kind of run functions that get their standard arguments passed directly instead of packed into a GimpValueArray. They also register their standard arguments themselves, which removes quite some boilerplate from load/save plug-ins. Remove gimpprocedure-private.[ch] because install() and uninstall() are now virtual functions of GimpProcedure.
2019-08-11 02:25:37 +08:00
{
GValue *value = gimp_value_array_index (args, i);
gimp_value_array_append (remaining, value);
}
return_values = save_proc->priv->run_func (procedure,
run_mode,
libgimp: GimpSaveProcedure() now uses GimpImage/GimpDrawable object... ... as parameters. And GimpLoadProcedure() now expects the run() function to return a GimpImage object.
2019-08-14 20:59:40 +08:00
image, drawable,
libgimp: add GimpFileProcedure, GimpLoadProcedure and GimpSaveProcedure which are GimpProcedure subclasses with API to register as load/save handlers and their own kind of run functions that get their standard arguments passed directly instead of packed into a GimpValueArray. They also register their standard arguments themselves, which removes quite some boilerplate from load/save plug-ins. Remove gimpprocedure-private.[ch] because install() and uninstall() are now virtual functions of GimpProcedure.
2019-08-11 02:25:37 +08:00
file,
remaining,
save_proc->priv->run_data);
gimp_value_array_unref (remaining);
return return_values;
}
libgimp: implement GimpProcedure::create_config() in all subclasses
2019-09-24 06:59:50 +08:00
static GimpProcedureConfig *
gimp_save_procedure_create_config (GimpProcedure *procedure,
GParamSpec **args,
gint n_args)
{
if (n_args > ARG_OFFSET)
{
args += ARG_OFFSET;
n_args -= ARG_OFFSET;
}
else
{
args = NULL;
n_args = 0;
}
return GIMP_PROCEDURE_CLASS (parent_class)->create_config (procedure,
args,
n_args);
}
libgimp: add GimpFileProcedure, GimpLoadProcedure and GimpSaveProcedure which are GimpProcedure subclasses with API to register as load/save handlers and their own kind of run functions that get their standard arguments passed directly instead of packed into a GimpValueArray. They also register their standard arguments themselves, which removes quite some boilerplate from load/save plug-ins. Remove gimpprocedure-private.[ch] because install() and uninstall() are now virtual functions of GimpProcedure.
2019-08-11 02:25:37 +08:00
/* public functions */
libgimp: rename GimpLoad,SaveFunc to GimpRunLoad,SaveFunc and document gimp_load,save_procedure_new().
2019-08-11 20:58:55 +08:00
/**
* gimp_save_procedure_new:
* @plug_in: a #GimpPlugIn.
* @name: the new procedure's name.
* @proc_type: the new procedure's #GimpPDBProcType.
* @run_func: the run function for the new 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
* 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.
*
* It automatically adds the standard
*
libgimp: doc fixes and improvements in procedure subclasses
2019-10-30 05:15:58 +08:00
* (#GimpRunMode, #GimpImage, #GimpDrawable, #GFile)
libgimp: rename GimpLoad,SaveFunc to GimpRunLoad,SaveFunc and document gimp_load,save_procedure_new().
2019-08-11 20:58:55 +08:00
*
* arguments of a save procedure. It is possible to add additional
* arguments.
*
* When invoked via gimp_procedure_run(), it unpacks these standard
libgimp/ documentation typo fixes Found via `codespell -i 3 -w -S ./ChangeLog*,*.po -I ../gimp-word-whitelist.txt ./libgimp`
2019-08-20 08:52:05 +08:00
* arguments and calls @run_func which is a #GimpRunSaveFunc. The
libgimp: rename GimpLoad,SaveFunc to GimpRunLoad,SaveFunc and document gimp_load,save_procedure_new().
2019-08-11 20:58:55 +08:00
* "args" #GimpValueArray of #GimpRunSaveFunc only contains
* additionally added arguments.
*
* Returns: a new #GimpProcedure.
*
* Since: 3.0
**/
libgimp: add GimpFileProcedure, GimpLoadProcedure and GimpSaveProcedure which are GimpProcedure subclasses with API to register as load/save handlers and their own kind of run functions that get their standard arguments passed directly instead of packed into a GimpValueArray. They also register their standard arguments themselves, which removes quite some boilerplate from load/save plug-ins. Remove gimpprocedure-private.[ch] because install() and uninstall() are now virtual functions of GimpProcedure.
2019-08-11 02:25:37 +08:00
GimpProcedure *
gimp_save_procedure_new (GimpPlugIn *plug_in,
const gchar *name,
GimpPDBProcType proc_type,
libgimp: rename GimpLoad,SaveFunc to GimpRunLoad,SaveFunc and document gimp_load,save_procedure_new().
2019-08-11 20:58:55 +08:00
GimpRunSaveFunc run_func,
libgimp: add GimpFileProcedure, GimpLoadProcedure and GimpSaveProcedure which are GimpProcedure subclasses with API to register as load/save handlers and their own kind of run functions that get their standard arguments passed directly instead of packed into a GimpValueArray. They also register their standard arguments themselves, which removes quite some boilerplate from load/save plug-ins. Remove gimpprocedure-private.[ch] because install() and uninstall() are now virtual functions of GimpProcedure.
2019-08-11 02:25:37 +08:00
gpointer run_data,
GDestroyNotify run_data_destroy)
{
GimpSaveProcedure *procedure;
g_return_val_if_fail (GIMP_IS_PLUG_IN (plug_in), NULL);
g_return_val_if_fail (gimp_is_canonical_identifier (name), NULL);
Properly prefix the values of enum GimpPDBProcType to be GIMP_PDB_PROC_TYPE_PLUGIN, _EXTENSION etc.
2019-08-30 18:52:28 +08:00
g_return_val_if_fail (proc_type != GIMP_PDB_PROC_TYPE_INTERNAL, NULL);
g_return_val_if_fail (proc_type != GIMP_PDB_PROC_TYPE_EXTENSION, NULL);
libgimp: add GimpFileProcedure, GimpLoadProcedure and GimpSaveProcedure which are GimpProcedure subclasses with API to register as load/save handlers and their own kind of run functions that get their standard arguments passed directly instead of packed into a GimpValueArray. They also register their standard arguments themselves, which removes quite some boilerplate from load/save plug-ins. Remove gimpprocedure-private.[ch] because install() and uninstall() are now virtual functions of GimpProcedure.
2019-08-11 02:25:37 +08:00
g_return_val_if_fail (run_func != NULL, NULL);
procedure = g_object_new (GIMP_TYPE_SAVE_PROCEDURE,
"plug-in", plug_in,
"name", name,
"procedure-type", proc_type,
NULL);
procedure->priv->run_func = run_func;
procedure->priv->run_data = run_data;
procedure->priv->run_data_destroy = run_data_destroy;
return GIMP_PROCEDURE (procedure);
}