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

232 lines
11 KiB
C
Raw Normal View History

libgimp: add a GimpProcedure class Mostly the same code as GimpProcedure in app/pdb/. Move the "run" function to GimpProcedure. Add API to GimpPlugIn to list and create procedures, and always keep a list of the plug-ins procedures around. Still only using the old params and return_vals.
2019-07-26 08:05:11 +08:00
/* GIMP - The GNU Image Manipulation Program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
app, libgimp: add copyright notices to the new stuff, minor cleanup
2019-07-31 06:12:36 +08:00
* gimpprocedure.h
* Copyright (C) 2019 Michael Natterer <mitch@gimp.org>
*
libgimp: add a GimpProcedure class Mostly the same code as GimpProcedure in app/pdb/. Move the "run" function to GimpProcedure. Add API to GimpPlugIn to list and create procedures, and always keep a list of the plug-ins procedures around. Still only using the old params and return_vals.
2019-07-26 08:05:11 +08:00
* 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/>.
*/
#if !defined (__GIMP_H_INSIDE__) && !defined (GIMP_COMPILATION)
#error "Only <libgimp/gimp.h> can be included directly."
#endif
#ifndef __GIMP_PROCEDURE_H__
#define __GIMP_PROCEDURE_H__
G_BEGIN_DECLS
/* For information look into the C source or the html documentation */
libgimp: cleanup and more docs for GimpProcedure
2019-08-02 05:46:25 +08:00
/**
* GimpRunFunc:
* @procedure: the #GimpProcedure that runs.
libgimp, plug-ins: rename gimp_procedure_new2() as gimp_procedure_new() and… … remove the latter. Now all GimpProcedure use this new implementation with use a config object.
2023-06-17 00:34:53 +08:00
* @config: the @procedure's arguments in a config object.
gir: Add (closure) tags
2020-05-05 03:31:30 +08:00
* @run_data: (closure): the run_data given in gimp_procedure_new().
libgimp: cleanup and more docs for GimpProcedure
2019-08-02 05:46:25 +08:00
*
* The run function is run during the lifetime of the GIMP session,
* each time a plug-in procedure is called.
*
* Returns: (transfer full): the @procedure's return values.
*
* Since: 3.0
**/
libgimp, plug-ins: rename gimp_procedure_new2() as gimp_procedure_new() and… … remove the latter. Now all GimpProcedure use this new implementation with use a config object.
2023-06-17 00:34:53 +08:00
typedef GimpValueArray * (* GimpRunFunc) (GimpProcedure *procedure,
GimpProcedureConfig *config,
gpointer run_data);
libgimp: add a GimpProcedure class Mostly the same code as GimpProcedure in app/pdb/. Move the "run" function to GimpProcedure. Add API to GimpPlugIn to list and create procedures, and always keep a list of the plug-ins procedures around. Still only using the old params and return_vals.
2019-07-26 08:05:11 +08:00
libgimp: add the concept of "argument sync" to GimpProcedure which can be set to GIMP_ARGUMENT_SYNC_NONE (the default) or GIMP_ARGUMENT_SYNC_PARASITE, which indicates that the argument should be synced with an image parasite of the same name.
2020-06-16 04:55:58 +08:00
/**
* GimpArgumentSync:
* @GIMP_ARGUMENT_SYNC_NONE: Don't sync this argument
* @GIMP_ARGUMENT_SYNC_PARASITE: Sync this argument with an image parasite
*
* Methods of syncing procedure arguments.
*
* Since: 3.0
**/
typedef enum
{
GIMP_ARGUMENT_SYNC_NONE,
GIMP_ARGUMENT_SYNC_PARASITE
} GimpArgumentSync;
libgimp: use G_DECLARE_(DERIVABLE|FINAL)_TYPE macros for all Gimp*Procedure. Though I am not fond of these macros for our core code (it makes the code more cumbersome especially for using private data in derivable types), this definitely makes sense for public API, since it would allow easier modifications with less chances of messing API/ABI stability.
2024-07-10 21:03:15 +08:00
#define GIMP_TYPE_PROCEDURE (gimp_procedure_get_type ())
G_DECLARE_DERIVABLE_TYPE (GimpProcedure, gimp_procedure, GIMP, PROCEDURE, GObject)
libgimp: add a GimpProcedure class Mostly the same code as GimpProcedure in app/pdb/. Move the "run" function to GimpProcedure. Add API to GimpPlugIn to list and create procedures, and always keep a list of the plug-ins procedures around. Still only using the old params and return_vals.
2019-07-26 08:05:11 +08:00
libgimp: add section docs for GimpPlugIn with general information and document the members of GimpProcedureClass. Also various doc fixes.
2019-09-10 17:17:12 +08:00
/**
* GimpProcedureClass:
* @install: called to install the procedure with the main GIMP
* application. This is an implementation detail and must never
* be called by any plug-in code.
* @uninstall: called to uninstall the procedure from the main GIMP
* application. This is an implementation detail and must never
* be called by any plug-in code.
libgimp: some documentation fixes and improvements
2019-12-28 02:56:21 +08:00
* @run: called when the procedure is executed via gimp_procedure_run().
libgimp: add section docs for GimpPlugIn with general information and document the members of GimpProcedureClass. Also various doc fixes.
2019-09-10 17:17:12 +08:00
* the default implementation simply calls the procedure's #GimpRunFunc,
* #GimpProcedure subclasses are free to modify the passed @args and
* call their own, subclass-specific run functions.
libgimp: some documentation fixes and improvements
2019-12-28 02:56:21 +08:00
* @create_config: called when a #GimpConfig object is created using
* gimp_procedure_create_config().
libgimp: add section docs for GimpPlugIn with general information and document the members of GimpProcedureClass. Also various doc fixes.
2019-09-10 17:17:12 +08:00
*
* Since: 3.0
**/
libgimp: add a GimpProcedure class Mostly the same code as GimpProcedure in app/pdb/. Move the "run" function to GimpProcedure. Add API to GimpPlugIn to list and create procedures, and always keep a list of the plug-ins procedures around. Still only using the old params and return_vals.
2019-07-26 08:05:11 +08:00
struct _GimpProcedureClass
{
GObjectClass parent_class;
libgimp: add a GimpPDB class and subclass GimpProcedure as GimpPDBProcedure The idea is that we already have a GimpProcedure object in libgimp which has name, help, blurb, arguments, return values and everything, so we really don't need a parallel API to query PDB procedures for their properties. - make run() a virtual function of GimpProcedure - move GIMP_PDB_ERROR to GimpPDB - GimpPDBProcedure is a trivial subblass which populates GimpProcedure's members by querying the PDB. - make "plug-in", "procedure-type" and "name" construct-only properties of GimpProcedure. This is all work in progress.
2019-08-06 18:17:27 +08:00
Issue #6767: sensitivity API NO_IMAGE not working in Python. When GIMP_PROCEDURE_SENSITIVE_NO_IMAGE is set on a GimpImageProcedure, add GIMP_PARAM_NO_VALIDATE to the param spec flags, allowing to pass a NULL image.
2021-04-30 05:53:35 +08:00
void (* install) (GimpProcedure *procedure);
void (* uninstall) (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
Issue #6767: sensitivity API NO_IMAGE not working in Python. When GIMP_PROCEDURE_SENSITIVE_NO_IMAGE is set on a GimpImageProcedure, add GIMP_PARAM_NO_VALIDATE to the param spec flags, allowing to pass a NULL image.
2021-04-30 05:53:35 +08:00
GimpValueArray * (* run) (GimpProcedure *procedure,
const GimpValueArray *args);
libgimp: add GimpProcedureConfig which implements the GimpConfig interface It's the base for bringing proper management of saved settings (including the last used values) and generated GUI using prop_widgets to plug-ins.
2019-09-20 18:31:11 +08:00
Issue #6767: sensitivity API NO_IMAGE not working in Python. When GIMP_PROCEDURE_SENSITIVE_NO_IMAGE is set on a GimpImageProcedure, add GIMP_PARAM_NO_VALIDATE to the param spec flags, allowing to pass a NULL image.
2021-04-30 05:53:35 +08:00
GimpProcedureConfig * (* create_config) (GimpProcedure *procedure,
GParamSpec **args,
gint n_args);
gboolean (* set_sensitivity) (GimpProcedure *procedure,
gint sensitivity_mask);
libgimp: add a GimpPDB class and subclass GimpProcedure as GimpPDBProcedure The idea is that we already have a GimpProcedure object in libgimp which has name, help, blurb, arguments, return values and everything, so we really don't need a parallel API to query PDB procedures for their properties. - make run() a virtual function of GimpProcedure - move GIMP_PDB_ERROR to GimpPDB - GimpPDBProcedure is a trivial subblass which populates GimpProcedure's members by querying the PDB. - make "plug-in", "procedure-type" and "name" construct-only properties of GimpProcedure. This is all work in progress.
2019-08-06 18:17:27 +08:00
/* Padding for future expansion */
libgimp: some documentation fixes and improvements
2019-12-28 02:56:21 +08:00
/*< private >*/
libgimp: add a GimpPDB class and subclass GimpProcedure as GimpPDBProcedure The idea is that we already have a GimpProcedure object in libgimp which has name, help, blurb, arguments, return values and everything, so we really don't need a parallel API to query PDB procedures for their properties. - make run() a virtual function of GimpProcedure - move GIMP_PDB_ERROR to GimpPDB - GimpPDBProcedure is a trivial subblass which populates GimpProcedure's members by querying the PDB. - make "plug-in", "procedure-type" and "name" construct-only properties of GimpProcedure. This is all work in progress.
2019-08-06 18:17:27 +08:00
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);
libgimp: add a GimpProcedure class Mostly the same code as GimpProcedure in app/pdb/. Move the "run" function to GimpProcedure. Add API to GimpPlugIn to list and create procedures, and always keep a list of the plug-ins procedures around. Still only using the old params and return_vals.
2019-07-26 08:05:11 +08:00
};
libgimp: add some const to input parameters, like const GimpValueArray* for procedure arguments. This implies creating a new value array in gimp_procedure_run() if the passed array is too short, instead of just appending to the passed array, which was ugly anyway.
2019-08-07 06:02:29 +08:00
GimpProcedure * gimp_procedure_new (GimpPlugIn *plug_in,
const gchar *name,
GimpPDBProcType proc_type,
GimpRunFunc run_func,
gpointer run_data,
GDestroyNotify run_data_destroy);
GimpPlugIn * gimp_procedure_get_plug_in (GimpProcedure *procedure);
const gchar * gimp_procedure_get_name (GimpProcedure *procedure);
GimpPDBProcType gimp_procedure_get_proc_type (GimpProcedure *procedure);
void gimp_procedure_set_image_types (GimpProcedure *procedure,
const gchar *image_types);
const gchar * gimp_procedure_get_image_types (GimpProcedure *procedure);
app, libgimp, pdb: new API to advertize when procedures are sensitive. The new function gimp_procedure_set_sensitivity_mask() allows plug-ins to tell when a procedure should be marked as sensitive or not. gimp_procedure_get_sensitivity_mask() retrieves this information. Currently plug-ins are automatically marked as sensitive when an image is present and a single drawable is selected. Nowadays, we can have multiple selected layers so we should allow plug-ins to tell us if they support working on multiple drawables. Actually we could even imagine new plug-ins which would be made to work only on multiple drawables. Oppositely, there are a lot of plug-ins which don't care at all if any drawable is selected at all (so we should allow no drawable selected). Finally why not even imagine plug-ins which don't care if no image is shown? E.g. plug-ins to create new images or whatnot. This new API allows our core to know all this and show procedure sensitivity accordingly. By default, when the function is not called, the 1 image with 1 drawable selected case is the default, allowing existing plug-ins easier update. Note: this only handles the sensitivity part right now. A plug-in which would advertize working on several layer would still not work, because the core won't allow sending several layers. It's coming in further commits.
2021-04-02 05:49:11 +08:00
void gimp_procedure_set_sensitivity_mask (GimpProcedure *procedure,
gint sensitivity_mask);
gint gimp_procedure_get_sensitivity_mask (GimpProcedure *procedure);
libgimp: add some const to input parameters, like const GimpValueArray* for procedure arguments. This implies creating a new value array in gimp_procedure_run() if the passed array is too short, instead of just appending to the passed array, which was ugly anyway.
2019-08-07 06:02:29 +08:00
void gimp_procedure_set_menu_label (GimpProcedure *procedure,
const gchar *menu_label);
const gchar * gimp_procedure_get_menu_label (GimpProcedure *procedure);
void gimp_procedure_add_menu_path (GimpProcedure *procedure,
const gchar *menu_path);
GList * gimp_procedure_get_menu_paths (GimpProcedure *procedure);
libgimp: move the GimpProcedure icon API next to the menu API
2019-08-18 20:04:45 +08:00
void gimp_procedure_set_icon_name (GimpProcedure *procedure,
const gchar *icon_name);
void gimp_procedure_set_icon_file (GimpProcedure *procedure,
GFile *file);
void gimp_procedure_set_icon_pixbuf (GimpProcedure *procedure,
GdkPixbuf *pixbuf);
GimpIconType gimp_procedure_get_icon_type (GimpProcedure *procedure);
const gchar * gimp_procedure_get_icon_name (GimpProcedure *procedure);
GFile * gimp_procedure_get_icon_file (GimpProcedure *procedure);
GdkPixbuf * gimp_procedure_get_icon_pixbuf (GimpProcedure *procedure);
libgimp: add some const to input parameters, like const GimpValueArray* for procedure arguments. This implies creating a new value array in gimp_procedure_run() if the passed array is too short, instead of just appending to the passed array, which was ugly anyway.
2019-08-07 06:02:29 +08:00
void gimp_procedure_set_documentation (GimpProcedure *procedure,
const gchar *blurb,
const gchar *help,
const gchar *help_id);
const gchar * gimp_procedure_get_blurb (GimpProcedure *procedure);
const gchar * gimp_procedure_get_help (GimpProcedure *procedure);
const gchar * gimp_procedure_get_help_id (GimpProcedure *procedure);
void gimp_procedure_set_attribution (GimpProcedure *procedure,
const gchar *authors,
const gchar *copyright,
const gchar *date);
const gchar * gimp_procedure_get_authors (GimpProcedure *procedure);
const gchar * gimp_procedure_get_copyright (GimpProcedure *procedure);
const gchar * gimp_procedure_get_date (GimpProcedure *procedure);
libgimp: add gimp_procedure_find_argument(), aux_argument(), return_value()
2019-10-12 18:49:32 +08:00
GParamSpec * gimp_procedure_find_argument (GimpProcedure *procedure,
const gchar *name);
GParamSpec * gimp_procedure_find_aux_argument (GimpProcedure *procedure,
const gchar *name);
GParamSpec * gimp_procedure_find_return_value (GimpProcedure *procedure,
const gchar *name);
libgimp: add some const to input parameters, like const GimpValueArray* for procedure arguments. This implies creating a new value array in gimp_procedure_run() if the passed array is too short, instead of just appending to the passed array, which was ugly anyway.
2019-08-07 06:02:29 +08:00
GParamSpec ** gimp_procedure_get_arguments (GimpProcedure *procedure,
libgimp: add the concept of "Auxiliary arguments" to GimpProcedure Aux arguments are arbitrary values the procedure wants managed and remembered across invocations in GimpProcedureConfig. They are not passed to run() and are not known to the PDB, they only exist in the procedure's config object.
2019-09-24 18:39:02 +08:00
gint *n_arguments);
GParamSpec ** gimp_procedure_get_aux_arguments (GimpProcedure *procedure,
libgimp: add some const to input parameters, like const GimpValueArray* for procedure arguments. This implies creating a new value array in gimp_procedure_run() if the passed array is too short, instead of just appending to the passed array, which was ugly anyway.
2019-08-07 06:02:29 +08:00
gint *n_arguments);
GParamSpec ** gimp_procedure_get_return_values (GimpProcedure *procedure,
gint *n_return_values);
app, libgimp, libgimpbase: plug-in and PDB protocol refactoring part two - Change the wire protocol's GPProcInstall to transmit the entire information needed for constructing all GParamSpecs we use, don't use GimpPDBArgType in GPProcInstall but an enum private to the wire protocol plus the GParamSpec's GType name. Bump the wire protocol version. - Add gimpgpparamspecs.[ch] in both app/plug-in/ and libgimp/ which take care of converting between GPParamDef and GParamSpec. They share code as far as possible. - Change pluginrc writing and parsing to re-use GPParamDef and the utility functions from gimpgpparamspecs. - Remove gimp_pdb_compat_param_spec() from app/pdb/gimp-pdb-compat.[ch], the entire core uses proper GParamSpecs from the wire protocol now, the whole file will follow down the drain once we use a GValue representation on the wire too. - In gimp_plug_in_handle_proc_install(), change the "run-mode" parameter to a GParamSpecEnum(GIMP_TYPE_RUN_MODE) (if it is not already an enum). and change all places in app/ to treat it as an enum value. - plug-ins: fix cml-explorer to register correctly, a typo in "run-mode" was never noticed until now. - Add gimpgpcompat.[ch] in libgimp to deal with all the transforms between old-style wire communication and using GParamSpec and GValue, it contains some functions that are subject to change or even removal in the next steps. - Change the libgimp GimpProcedure and GimpPlugIn in many ways to be able to actually install procedures the new way. - plug-ins: change goat-exercise to completely use the new GimpPlugIn and GimpProcedure API, look here to see how plug-ins will look in the future, of course subject to change until this is finished. - Next: changing GPParam to transmit all information about a GValue.
2019-07-27 22:37:55 +08:00
libgimp: add the concept of "argument sync" to GimpProcedure which can be set to GIMP_ARGUMENT_SYNC_NONE (the default) or GIMP_ARGUMENT_SYNC_PARASITE, which indicates that the argument should be synced with an image parasite of the same name.
2020-06-16 04:55:58 +08:00
void gimp_procedure_set_argument_sync (GimpProcedure *procedure,
const gchar *arg_name,
GimpArgumentSync sync);
GimpArgumentSync gimp_procedure_get_argument_sync (GimpProcedure *procedure,
const gchar *arg_name);
libgimp: add some const to input parameters, like const GimpValueArray* for procedure arguments. This implies creating a new value array in gimp_procedure_run() if the passed array is too short, instead of just appending to the passed array, which was ugly anyway.
2019-08-07 06:02:29 +08:00
GimpValueArray * gimp_procedure_new_return_values (GimpProcedure *procedure,
GimpPDBStatusType status,
GError *error);
app, libgimp, libgimpbase: plug-in and PDB protocol refactoring part two - Change the wire protocol's GPProcInstall to transmit the entire information needed for constructing all GParamSpecs we use, don't use GimpPDBArgType in GPProcInstall but an enum private to the wire protocol plus the GParamSpec's GType name. Bump the wire protocol version. - Add gimpgpparamspecs.[ch] in both app/plug-in/ and libgimp/ which take care of converting between GPParamDef and GParamSpec. They share code as far as possible. - Change pluginrc writing and parsing to re-use GPParamDef and the utility functions from gimpgpparamspecs. - Remove gimp_pdb_compat_param_spec() from app/pdb/gimp-pdb-compat.[ch], the entire core uses proper GParamSpecs from the wire protocol now, the whole file will follow down the drain once we use a GValue representation on the wire too. - In gimp_plug_in_handle_proc_install(), change the "run-mode" parameter to a GParamSpecEnum(GIMP_TYPE_RUN_MODE) (if it is not already an enum). and change all places in app/ to treat it as an enum value. - plug-ins: fix cml-explorer to register correctly, a typo in "run-mode" was never noticed until now. - Add gimpgpcompat.[ch] in libgimp to deal with all the transforms between old-style wire communication and using GParamSpec and GValue, it contains some functions that are subject to change or even removal in the next steps. - Change the libgimp GimpProcedure and GimpPlugIn in many ways to be able to actually install procedures the new way. - plug-ins: change goat-exercise to completely use the new GimpPlugIn and GimpProcedure API, look here to see how plug-ins will look in the future, of course subject to change until this is finished. - Next: changing GPParam to transmit all information about a GValue.
2019-07-27 22:37:55 +08:00
libgimp: add some const to input parameters, like const GimpValueArray* for procedure arguments. This implies creating a new value array in gimp_procedure_run() if the passed array is too short, instead of just appending to the passed array, which was ugly anyway.
2019-08-07 06:02:29 +08:00
GimpValueArray * gimp_procedure_run (GimpProcedure *procedure,
libgimp, plug-ins: move gimp_pdb_run_procedure*() to gimp_procedure_run*(). The gimp_procedure_run() already existed, though it was with an ordered GimpValueArray array of arguments. Its usage feels redundant to the series of gimp_pdb_run_procedure*() functions (which is confusing), but gimp_procedure_run() was actually a bit more generic, because it does not necessarily calls GimpProcedure-s through the PDB! For instance, it can runs a local GimpProcedure, such as the case of one procedure which would want to call another procedure in the same plug-in, but without having to go through PDB. Of course, for local code, you may as well run relevant functions directly, yet it makes sense that if one of the redundant-looking function is removed, it should be the more specific one. Also gimp_procedure_run() feels a lot simpler and logical, API wise. A main difference in usage is that now, plug-in developers have to first explicitly look up the GimpPdbProcedure with gimp_pdb_lookup_procedure() when they wish to call PDB procedures on the wire. This was done anyway in the gimp_pdb_run_procedure*() code, now it's explicit (rather than calling by name directly). Concretely: * gimp_pdb_run_procedure(), gimp_pdb_run_procedure_config() and gimp_pdb_run_procedure_valist() are removed. * gimp_procedure_run() API is modified to use a variable args list instead of a GimpValueArray. * gimp_procedure_run_config() and gimp_procedure_run_valist() are added. * gimp_procedure_run_config() in particular will be the one used in bindings which don't have variable args support through a (rename-to gimp_procedure_run) annotation.
2023-10-18 23:11:20 +08:00
const gchar *first_arg_name,
...) G_GNUC_NULL_TERMINATED;
GimpValueArray * gimp_procedure_run_valist (GimpProcedure *procedure,
const gchar *first_arg_name,
va_list args);
GimpValueArray * gimp_procedure_run_config (GimpProcedure *procedure,
GimpProcedureConfig *config);
libgimp: add a GimpProcedure class Mostly the same code as GimpProcedure in app/pdb/. Move the "run" function to GimpProcedure. Add API to GimpPlugIn to list and create procedures, and always keep a list of the plug-ins procedures around. Still only using the old params and return_vals.
2019-07-26 08:05:11 +08:00
libgimp: add some const to input parameters, like const GimpValueArray* for procedure arguments. This implies creating a new value array in gimp_procedure_run() if the passed array is too short, instead of just appending to the passed array, which was ugly anyway.
2019-08-07 06:02:29 +08:00
void gimp_procedure_extension_ready (GimpProcedure *procedure);
libgimp: add gimp_procedure_extension_ready() which must be called by GIMP_EXTENSION procedures when they are ready to run their temporary procedures. Move gimp_extension_ack() to gimpobsolete.[ch].
2019-08-02 05:24:49 +08:00
libgimp: add GimpProcedureConfig which implements the GimpConfig interface It's the base for bringing proper management of saved settings (including the last used values) and generated GUI using prop_widgets to plug-ins.
2019-09-20 18:31:11 +08:00
GimpProcedureConfig *
gimp_procedure_create_config (GimpProcedure *procedure);
libgimp: add a GimpProcedure class Mostly the same code as GimpProcedure in app/pdb/. Move the "run" function to GimpProcedure. Add API to GimpPlugIn to list and create procedures, and always keep a list of the plug-ins procedures around. Still only using the old params and return_vals.
2019-07-26 08:05:11 +08:00
libgimp, plug-ins: move gimp_pdb_run_procedure*() to gimp_procedure_run*(). The gimp_procedure_run() already existed, though it was with an ordered GimpValueArray array of arguments. Its usage feels redundant to the series of gimp_pdb_run_procedure*() functions (which is confusing), but gimp_procedure_run() was actually a bit more generic, because it does not necessarily calls GimpProcedure-s through the PDB! For instance, it can runs a local GimpProcedure, such as the case of one procedure which would want to call another procedure in the same plug-in, but without having to go through PDB. Of course, for local code, you may as well run relevant functions directly, yet it makes sense that if one of the redundant-looking function is removed, it should be the more specific one. Also gimp_procedure_run() feels a lot simpler and logical, API wise. A main difference in usage is that now, plug-in developers have to first explicitly look up the GimpPdbProcedure with gimp_pdb_lookup_procedure() when they wish to call PDB procedures on the wire. This was done anyway in the gimp_pdb_run_procedure*() code, now it's explicit (rather than calling by name directly). Concretely: * gimp_pdb_run_procedure(), gimp_pdb_run_procedure_config() and gimp_pdb_run_procedure_valist() are removed. * gimp_procedure_run() API is modified to use a variable args list instead of a GimpValueArray. * gimp_procedure_run_config() and gimp_procedure_run_valist() are added. * gimp_procedure_run_config() in particular will be the one used in bindings which don't have variable args support through a (rename-to gimp_procedure_run) annotation.
2023-10-18 23:11:20 +08:00
/* Internal use */
libgimp, plug-ins: make generic gimp_procedure_add_argument() private. Same for gimp_procedure_add_aux_argument() and gimp_procedure_add_return_value(). We now have specific public functions for every supported type and it's in fact much better to use them. The generic functions gave the feeling that we could use any GParamSpec as procedure argument, whereas we in fact depend on what the PDB support, and only these subtypes.
2024-07-06 04:29:35 +08:00
G_GNUC_INTERNAL GParamSpec * _gimp_procedure_add_argument (GimpProcedure *procedure,
GParamSpec *pspec);
G_GNUC_INTERNAL GParamSpec * _gimp_procedure_add_aux_argument (GimpProcedure *procedure,
GParamSpec *pspec);
G_GNUC_INTERNAL GParamSpec * _gimp_procedure_add_return_value (GimpProcedure *procedure,
GParamSpec *pspec);
libgimp: reimplement gimp_procedure_run_config() for public usage. Previous gimp_procedure_run_config() was in fact only good for private usage inside the various run() methods for the different GimpProcedure subtypes. The problem with this implementation is that the returned config object is not complete. For instance, for a GimpLoadProcedure, the "run-mode" and "file" properties are not part of the config object so you cannot call a GimpLoadProcedure with any of the gimp_procedure_run*() functions. Note: we had some working usage, e.g. in file-openraster, but only because it was running the load procedure as a GimpPDBProcedure whose returned config object was indeed always complete! As a consequence, I rename gimp_procedure_run_config() as an internal-only function _gimp_procedure_create_run_config() and I create a new gimp_procedure_run_config() which always return a full config with all arguments.
2024-05-02 03:47:55 +08:00
G_GNUC_INTERNAL GimpProcedureConfig * _gimp_procedure_create_run_config (GimpProcedure *procedure);
G_GNUC_INTERNAL GimpValueArray * _gimp_procedure_run_array (GimpProcedure *procedure,
GimpValueArray *args);
libgimp, plug-ins: move gimp_pdb_run_procedure*() to gimp_procedure_run*(). The gimp_procedure_run() already existed, though it was with an ordered GimpValueArray array of arguments. Its usage feels redundant to the series of gimp_pdb_run_procedure*() functions (which is confusing), but gimp_procedure_run() was actually a bit more generic, because it does not necessarily calls GimpProcedure-s through the PDB! For instance, it can runs a local GimpProcedure, such as the case of one procedure which would want to call another procedure in the same plug-in, but without having to go through PDB. Of course, for local code, you may as well run relevant functions directly, yet it makes sense that if one of the redundant-looking function is removed, it should be the more specific one. Also gimp_procedure_run() feels a lot simpler and logical, API wise. A main difference in usage is that now, plug-in developers have to first explicitly look up the GimpPdbProcedure with gimp_pdb_lookup_procedure() when they wish to call PDB procedures on the wire. This was done anyway in the gimp_pdb_run_procedure*() code, now it's explicit (rather than calling by name directly). Concretely: * gimp_pdb_run_procedure(), gimp_pdb_run_procedure_config() and gimp_pdb_run_procedure_valist() are removed. * gimp_procedure_run() API is modified to use a variable args list instead of a GimpValueArray. * gimp_procedure_run_config() and gimp_procedure_run_valist() are added. * gimp_procedure_run_config() in particular will be the one used in bindings which don't have variable args support through a (rename-to gimp_procedure_run) annotation.
2023-10-18 23:11:20 +08:00
libgimp: add a GimpProcedure class Mostly the same code as GimpProcedure in app/pdb/. Move the "run" function to GimpProcedure. Add API to GimpPlugIn to list and create procedures, and always keep a list of the plug-ins procedures around. Still only using the old params and return_vals.
2019-07-26 08:05:11 +08:00
G_END_DECLS
#endif /* __GIMP_PROCEDURE_H__ */