[gimp] app, libgimp, pdb: new API to advertize when procedures are sensitive.
- From: Jehan <jehanp src gnome org>
- To: commits-list gnome org
- Cc:
- Subject: [gimp] app, libgimp, pdb: new API to advertize when procedures are sensitive.
- Date: Sat, 3 Apr 2021 23:40:12 +0000 (UTC)
commit dc7853233b73f2635d4b9b3cdb2c9f6716637354
Author: Jehan <jehan girinstud io>
Date: Thu Apr 1 23:49:11 2021 +0200
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.
app/actions/filters-actions.c | 4 +--
app/actions/gimpgeglprocedure.c | 14 ++++++---
app/actions/plug-in-actions.c | 10 ++-----
app/pdb/internal-procs.c | 2 +-
app/pdb/pdb-cmds.c | 63 +++++++++++++++++++++++++++++++++++++++
app/plug-in/gimpplugin-proc.c | 33 ++++++++++++++++++++
app/plug-in/gimpplugin-proc.h | 4 +++
app/plug-in/gimppluginprocedure.c | 38 +++++++++++++++++++----
app/plug-in/gimppluginprocedure.h | 4 +++
app/plug-in/plug-in-rc.c | 10 +++++++
libgimp/gimppdb_pdb.c | 38 +++++++++++++++++++++++
libgimp/gimppdb_pdb.h | 2 ++
libgimp/gimpprocedure.c | 59 ++++++++++++++++++++++++++++++++++++
libgimp/gimpprocedure.h | 5 ++++
pdb/groups/pdb.pdb | 37 +++++++++++++++++++++++
15 files changed, 304 insertions(+), 19 deletions(-)
---
diff --git a/app/actions/filters-actions.c b/app/actions/filters-actions.c
index c89e60a881..bc83a543ac 100644
--- a/app/actions/filters-actions.c
+++ b/app/actions/filters-actions.c
@@ -1033,7 +1033,7 @@ filters_actions_update (GimpActionGroup *group,
gint i;
if (proc &&
- gimp_procedure_get_sensitive (proc, GIMP_OBJECT (drawable), NULL))
+ gimp_procedure_get_sensitive (proc, GIMP_OBJECT (image), NULL))
{
gimp_action_group_set_action_sensitive (group, "filters-repeat", TRUE);
gimp_action_group_set_action_sensitive (group, "filters-reshow", TRUE);
@@ -1051,7 +1051,7 @@ filters_actions_update (GimpActionGroup *group,
proc = gimp_filter_history_nth (group->gimp, i);
- sensitive = gimp_procedure_get_sensitive (proc, GIMP_OBJECT (drawable),
+ sensitive = gimp_procedure_get_sensitive (proc, GIMP_OBJECT (image),
NULL);
gimp_action_group_set_action_sensitive (group, name, sensitive);
diff --git a/app/actions/gimpgeglprocedure.c b/app/actions/gimpgeglprocedure.c
index d87b62b007..b186fab59c 100644
--- a/app/actions/gimpgeglprocedure.c
+++ b/app/actions/gimpgeglprocedure.c
@@ -168,12 +168,17 @@ gimp_gegl_procedure_get_sensitive (GimpProcedure *procedure,
GimpObject *object,
const gchar **tooltip)
{
- GimpDrawable *drawable = GIMP_DRAWABLE (object);
- gboolean sensitive = FALSE;
+ GimpImage *image = GIMP_IMAGE (object);
+ GList *drawables = NULL;
+ gboolean sensitive = FALSE;
- if (drawable)
+ if (image)
+ drawables = gimp_image_get_selected_drawables (image);
+
+ if (g_list_length (drawables) == 1)
{
- GimpItem *item;
+ GimpDrawable *drawable = drawables->data;
+ GimpItem *item;
if (GIMP_IS_LAYER_MASK (drawable))
item = GIMP_ITEM (gimp_layer_mask_get_layer (GIMP_LAYER_MASK (drawable)));
@@ -185,6 +190,7 @@ gimp_gegl_procedure_get_sensitive (GimpProcedure *procedure,
if (gimp_viewable_get_children (GIMP_VIEWABLE (drawable)))
sensitive = FALSE;
}
+ g_list_free (drawables);
return sensitive;
}
diff --git a/app/actions/plug-in-actions.c b/app/actions/plug-in-actions.c
index c0fd6485bd..dff6df4185 100644
--- a/app/actions/plug-in-actions.c
+++ b/app/actions/plug-in-actions.c
@@ -163,7 +163,7 @@ plug_in_actions_update (GimpActionGroup *group,
const gchar *tooltip;
sensitive = gimp_procedure_get_sensitive (procedure,
- GIMP_OBJECT (drawable),
+ GIMP_OBJECT (image),
&tooltip);
gimp_action_group_set_action_sensitive (group,
@@ -330,22 +330,18 @@ plug_in_actions_add_proc (GimpActionGroup *group,
{
GimpContext *context = gimp_get_user_context (group->gimp);
GimpImage *image = gimp_context_get_image (context);
- GimpDrawable *drawable = NULL;
gboolean sensitive;
const gchar *tooltip;
- if (image)
- drawable = gimp_image_get_active_drawable (image);
-
sensitive = gimp_procedure_get_sensitive (GIMP_PROCEDURE (proc),
- GIMP_OBJECT (drawable),
+ GIMP_OBJECT (image),
&tooltip);
gimp_action_group_set_action_sensitive (group,
gimp_object_get_name (proc),
sensitive);
- if (! sensitive && drawable && tooltip)
+ if (! sensitive && tooltip)
gimp_action_group_set_action_tooltip (group,
gimp_object_get_name (proc),
tooltip);
diff --git a/app/pdb/internal-procs.c b/app/pdb/internal-procs.c
index 075987c886..b3863af48b 100644
--- a/app/pdb/internal-procs.c
+++ b/app/pdb/internal-procs.c
@@ -28,7 +28,7 @@
#include "internal-procs.h"
-/* 756 procedures registered total */
+/* 757 procedures registered total */
void
internal_procs_init (GimpPDB *pdb)
diff --git a/app/pdb/pdb-cmds.c b/app/pdb/pdb-cmds.c
index 6b1c80af7b..3688d4dcd0 100644
--- a/app/pdb/pdb-cmds.c
+++ b/app/pdb/pdb-cmds.c
@@ -425,6 +425,39 @@ pdb_get_proc_image_types_invoker (GimpProcedure *procedure,
return return_vals;
}
+static GimpValueArray *
+pdb_set_proc_sensitivity_mask_invoker (GimpProcedure *procedure,
+ Gimp *gimp,
+ GimpContext *context,
+ GimpProgress *progress,
+ const GimpValueArray *args,
+ GError **error)
+{
+ gboolean success = TRUE;
+ const gchar *procedure_name;
+ gint mask;
+
+ procedure_name = g_value_get_string (gimp_value_array_index (args, 0));
+ mask = g_value_get_int (gimp_value_array_index (args, 1));
+
+ if (success)
+ {
+ GimpPlugIn *plug_in = gimp->plug_in_manager->current_plug_in;
+
+ if (plug_in &&
+ gimp_pdb_is_canonical_procedure (procedure_name, error))
+ {
+ success = gimp_plug_in_set_proc_sensitivity_mask (plug_in, procedure_name,
+ mask, error);
+ }
+ else
+ success = FALSE;
+ }
+
+ return gimp_procedure_get_return_values (procedure, success,
+ error ? *error : NULL);
+}
+
static GimpValueArray *
pdb_set_proc_menu_label_invoker (GimpProcedure *procedure,
Gimp *gimp,
@@ -1518,6 +1551,36 @@ register_pdb_procs (GimpPDB *pdb)
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
+ /*
+ * gimp-pdb-set-proc-sensitivity-mask
+ */
+ procedure = gimp_procedure_new (pdb_set_proc_sensitivity_mask_invoker);
+ gimp_object_set_static_name (GIMP_OBJECT (procedure),
+ "gimp-pdb-set-proc-sensitivity-mask");
+ gimp_procedure_set_static_help (procedure,
+ "Set the sensitivity mask for a plug-in procedure.",
+ "This procedure sets the sensitivity mask for the given procedure.",
+ NULL);
+ gimp_procedure_set_static_attribution (procedure,
+ "Jehan",
+ "Jehan",
+ "2021");
+ gimp_procedure_add_argument (procedure,
+ gimp_param_spec_string ("procedure-name",
+ "procedure name",
+ "The procedure",
+ FALSE, FALSE, TRUE,
+ NULL,
+ GIMP_PARAM_READWRITE));
+ gimp_procedure_add_argument (procedure,
+ g_param_spec_int ("mask",
+ "mask",
+ "The procedure's sensitivity mask",
+ G_MININT32, G_MAXINT32, 0,
+ GIMP_PARAM_READWRITE));
+ gimp_pdb_register_procedure (pdb, procedure);
+ g_object_unref (procedure);
+
/*
* gimp-pdb-set-proc-menu-label
*/
diff --git a/app/plug-in/gimpplugin-proc.c b/app/plug-in/gimpplugin-proc.c
index bbea29261c..75391103c8 100644
--- a/app/plug-in/gimpplugin-proc.c
+++ b/app/plug-in/gimpplugin-proc.c
@@ -81,6 +81,39 @@ gimp_plug_in_set_proc_image_types (GimpPlugIn *plug_in,
return TRUE;
}
+gboolean
+gimp_plug_in_set_proc_sensitivity_mask (GimpPlugIn *plug_in,
+ const gchar *proc_name,
+ gint sensitivity_mask,
+ GError **error)
+{
+ GimpPlugInProcedure *proc;
+
+ g_return_val_if_fail (GIMP_IS_PLUG_IN (plug_in), FALSE);
+ g_return_val_if_fail (proc_name != NULL, FALSE);
+
+ proc = gimp_plug_in_proc_find (plug_in, proc_name);
+
+ if (! proc)
+ {
+ g_set_error (error, GIMP_PDB_ERROR, GIMP_PDB_ERROR_PROCEDURE_NOT_FOUND,
+ "Plug-in \"%s\"\n(%s)\n"
+ "attempted to register the sensitivity mask \"%x\" "
+ "for procedure \"%s\".\n"
+ "It has however not installed that procedure. "
+ "This is not allowed.",
+ gimp_object_get_name (plug_in),
+ gimp_file_get_utf8_name (plug_in->file),
+ sensitivity_mask, proc_name);
+
+ return FALSE;
+ }
+
+ gimp_plug_in_procedure_set_sensitivity_mask (proc, sensitivity_mask);
+
+ return TRUE;
+}
+
gboolean
gimp_plug_in_set_proc_menu_label (GimpPlugIn *plug_in,
const gchar *proc_name,
diff --git a/app/plug-in/gimpplugin-proc.h b/app/plug-in/gimpplugin-proc.h
index 993379d06c..1a42c2ea9b 100644
--- a/app/plug-in/gimpplugin-proc.h
+++ b/app/plug-in/gimpplugin-proc.h
@@ -25,6 +25,10 @@ gboolean gimp_plug_in_set_proc_image_types (GimpPlugIn *plug_in,
const gchar *proc_name,
const gchar *image_types,
GError **error);
+gboolean gimp_plug_in_set_proc_sensitivity_mask (GimpPlugIn *plug_in,
+ const gchar *proc_name,
+ gint sensitivity_mask,
+ GError **error);
gboolean gimp_plug_in_set_proc_menu_label (GimpPlugIn *plug_in,
const gchar *proc_name,
const gchar *menu_label,
diff --git a/app/plug-in/gimppluginprocedure.c b/app/plug-in/gimppluginprocedure.c
index 91048ff087..102cc58c18 100644
--- a/app/plug-in/gimppluginprocedure.c
+++ b/app/plug-in/gimppluginprocedure.c
@@ -33,6 +33,7 @@
#include "core/gimp.h"
#include "core/gimp-memsize.h"
#include "core/gimpdrawable.h"
+#include "core/gimpimage.h"
#include "core/gimpmarshal.h"
#include "core/gimpparamspecs.h"
@@ -303,17 +304,20 @@ gimp_plug_in_procedure_get_sensitive (GimpProcedure *procedure,
const gchar **tooltip)
{
GimpPlugInProcedure *proc = GIMP_PLUG_IN_PROCEDURE (procedure);
- GimpDrawable *drawable;
+ GimpImage *image;
+ GList *drawables = NULL;
GimpImageType image_type = -1;
gboolean sensitive = FALSE;
- g_return_val_if_fail (object == NULL || GIMP_IS_DRAWABLE (object), FALSE);
+ g_return_val_if_fail (object == NULL || GIMP_IS_IMAGE (object), FALSE);
- drawable = GIMP_DRAWABLE (object);
+ image = GIMP_IMAGE (object);
+ if (image)
+ drawables = gimp_image_get_selected_drawables (image);
- if (drawable)
+ if (drawables)
{
- const Babl *format = gimp_drawable_get_format (drawable);
+ const Babl *format = gimp_drawable_get_format (drawables->data);
image_type = gimp_babl_format_get_image_type (format);
}
@@ -342,6 +346,21 @@ gimp_plug_in_procedure_get_sensitive (GimpProcedure *procedure,
break;
}
+ if (! image &&
+ (proc->sensitivity_mask & GIMP_PROCEDURE_SENSITIVE_NO_IMAGE) != 0)
+ sensitive = TRUE;
+ else if (g_list_length (drawables) == 1 && proc->sensitivity_mask != 0 &&
+ (proc->sensitivity_mask & GIMP_PROCEDURE_SENSITIVE_DRAWABLE) == 0)
+ sensitive = FALSE;
+ else if (g_list_length (drawables) == 0 &&
+ (proc->sensitivity_mask & GIMP_PROCEDURE_SENSITIVE_NO_DRAWABLES) == 0)
+ sensitive = FALSE;
+ else if (g_list_length (drawables) > 1 &&
+ (proc->sensitivity_mask & GIMP_PROCEDURE_SENSITIVE_DRAWABLES) == 0)
+ sensitive = FALSE;
+
+ g_list_free (drawables);
+
if (! sensitive)
*tooltip = proc->image_types_tooltip;
@@ -1086,6 +1105,15 @@ gimp_plug_in_procedure_set_image_types (GimpPlugInProcedure *proc,
}
}
+void
+gimp_plug_in_procedure_set_sensitivity_mask (GimpPlugInProcedure *proc,
+ gint sensitivity_mask)
+{
+ g_return_if_fail (GIMP_IS_PLUG_IN_PROCEDURE (proc));
+
+ proc->sensitivity_mask = sensitivity_mask;
+}
+
static GSList *
extensions_parse (gchar *extensions)
{
diff --git a/app/plug-in/gimppluginprocedure.h b/app/plug-in/gimppluginprocedure.h
index 7d6bd5664f..b9a924726b 100644
--- a/app/plug-in/gimppluginprocedure.h
+++ b/app/plug-in/gimppluginprocedure.h
@@ -51,6 +51,7 @@ struct _GimpPlugInProcedure
gchar *image_types;
GimpPlugInImageType image_types_val;
gchar *image_types_tooltip;
+ gint sensitivity_mask;
gint64 mtime;
gboolean installed_during_init;
@@ -123,6 +124,9 @@ gboolean gimp_plug_in_procedure_take_icon (GimpPlugInProcedure *pro
void gimp_plug_in_procedure_set_image_types (GimpPlugInProcedure *proc,
const gchar *image_types);
+void gimp_plug_in_procedure_set_sensitivity_mask (GimpPlugInProcedure *proc,
+ gint sensitivity_mask);
+
void gimp_plug_in_procedure_set_file_proc (GimpPlugInProcedure *proc,
const gchar *extensions,
const gchar *prefixes,
diff --git a/app/plug-in/plug-in-rc.c b/app/plug-in/plug-in-rc.c
index 95323767a3..1070fd10fc 100644
--- a/app/plug-in/plug-in-rc.c
+++ b/app/plug-in/plug-in-rc.c
@@ -389,6 +389,7 @@ plug_in_procedure_deserialize (GScanner *scanner,
gint n_args;
gint n_return_vals;
gint n_menu_paths;
+ gint sensitivity_mask;
gint i;
if (! gimp_scanner_parse_string (scanner, &str))
@@ -458,6 +459,11 @@ plug_in_procedure_deserialize (GScanner *scanner,
gimp_plug_in_procedure_set_image_types (*proc, str);
g_free (str);
+ if (! gimp_scanner_parse_int (scanner, &sensitivity_mask))
+ return G_TOKEN_INT;
+
+ gimp_plug_in_procedure_set_sensitivity_mask (*proc, sensitivity_mask);
+
if (! gimp_scanner_parse_int (scanner, (gint *) &n_args))
return G_TOKEN_INT;
if (! gimp_scanner_parse_int (scanner, (gint *) &n_return_vals))
@@ -1281,6 +1287,10 @@ plug_in_rc_write (GSList *plug_in_defs,
gimp_config_writer_string (writer, proc->image_types);
gimp_config_writer_linefeed (writer);
+ gimp_config_writer_printf (writer, "%d",
+ proc->sensitivity_mask);
+ gimp_config_writer_linefeed (writer);
+
gimp_config_writer_printf (writer, "%d %d",
procedure->num_args,
procedure->num_values);
diff --git a/libgimp/gimppdb_pdb.c b/libgimp/gimppdb_pdb.c
index 1773afde92..8fc6e01b35 100644
--- a/libgimp/gimppdb_pdb.c
+++ b/libgimp/gimppdb_pdb.c
@@ -423,6 +423,44 @@ _gimp_pdb_get_proc_image_types (const gchar *procedure_name)
return image_types;
}
+/**
+ * _gimp_pdb_set_proc_sensitivity_mask:
+ * @procedure_name: The procedure.
+ * @mask: The procedure's sensitivity mask.
+ *
+ * Set the sensitivity mask for a plug-in procedure.
+ *
+ * This procedure sets the sensitivity mask for the given procedure.
+ *
+ * Returns: TRUE on success.
+ *
+ * Since: 3.0
+ **/
+gboolean
+_gimp_pdb_set_proc_sensitivity_mask (const gchar *procedure_name,
+ gint mask)
+{
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
+ gboolean success = TRUE;
+
+ args = gimp_value_array_new_from_types (NULL,
+ G_TYPE_STRING, procedure_name,
+ G_TYPE_INT, mask,
+ G_TYPE_NONE);
+
+ return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
+ "gimp-pdb-set-proc-sensitivity-mask",
+ args);
+ gimp_value_array_unref (args);
+
+ success = GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS;
+
+ gimp_value_array_unref (return_vals);
+
+ return success;
+}
+
/**
* _gimp_pdb_set_proc_menu_label:
* @procedure_name: The procedure for which to install the menu path.
diff --git a/libgimp/gimppdb_pdb.h b/libgimp/gimppdb_pdb.h
index e2ae9d3741..3d1d77056b 100644
--- a/libgimp/gimppdb_pdb.h
+++ b/libgimp/gimppdb_pdb.h
@@ -55,6 +55,8 @@ G_GNUC_INTERNAL GParamSpec* _gimp_pdb_get_proc_return_value (const gcha
G_GNUC_INTERNAL gboolean _gimp_pdb_set_proc_image_types (const gchar *procedure_name,
const gchar *image_types);
G_GNUC_INTERNAL gchar* _gimp_pdb_get_proc_image_types (const gchar *procedure_name);
+G_GNUC_INTERNAL gboolean _gimp_pdb_set_proc_sensitivity_mask (const gchar *procedure_name,
+ gint mask);
G_GNUC_INTERNAL gboolean _gimp_pdb_set_proc_menu_label (const gchar *procedure_name,
const gchar *menu_label);
G_GNUC_INTERNAL gchar* _gimp_pdb_get_proc_menu_label (const gchar *procedure_name);
diff --git a/libgimp/gimpprocedure.c b/libgimp/gimpprocedure.c
index 542b960d50..13c72b25f1 100644
--- a/libgimp/gimpprocedure.c
+++ b/libgimp/gimpprocedure.c
@@ -72,6 +72,8 @@ struct _GimpProcedurePrivate
gchar *copyright;
gchar *date;
+ gint sensitivity_mask;
+
gint32 n_args;
GParamSpec **args;
@@ -424,6 +426,9 @@ gimp_procedure_real_install (GimpProcedure *procedure)
procedure->priv->menu_label);
}
+ _gimp_pdb_set_proc_sensitivity_mask (gimp_procedure_get_name (procedure),
+ procedure->priv->sensitivity_mask);
+
for (list = gimp_procedure_get_menu_paths (procedure);
list;
list = g_list_next (list))
@@ -700,6 +705,60 @@ gimp_procedure_get_image_types (GimpProcedure *procedure)
return procedure->priv->image_types;
}
+/**
+ * gimp_procedure_set_sensitivity_mask:
+ * @procedure: A #GimpProcedure.
+ * @sensitivity_mask: A binary mask of #GimpProcedureSensitivityMask.
+ *
+ * Sets the case when @procedure is supposed to be sensitive or not.
+ * Note that it will be used by the core to determine whether to show a
+ * procedure as sensitive (hence forbid running it otherwise), yet it
+ * will not forbid thid-party plug-ins for instance to run manually your
+ * registered procedure. Therefore you should still handle non-supported
+ * cases appropriately by returning with %GIMP_PDB_EXECUTION_ERROR and a
+ * suitable error message.
+ *
+ * Similarly third-party plug-ins should verify they are allowed to call
+ * a procedure with gimp_procedure_get_sensitivity_mask() when running
+ * with dynamic contents.
+ *
+ * Note that by default, a procedure works on an image with a single
+ * drawable selected. Hence not setting the mask, setting it with 0 or
+ * setting it with a mask of %GIMP_PROCEDURE_SENSITIVE_DRAWABLE only are
+ * equivalent.
+ *
+ * Since: 3.0
+ **/
+void
+gimp_procedure_set_sensitivity_mask (GimpProcedure *procedure,
+ gint sensitivity_mask)
+{
+ g_return_if_fail (GIMP_IS_PROCEDURE (procedure));
+
+ procedure->priv->sensitivity_mask = sensitivity_mask;
+
+ if (procedure->priv->installed)
+ _gimp_pdb_set_proc_sensitivity_mask (gimp_procedure_get_name (procedure),
+ procedure->priv->sensitivity_mask);
+}
+
+/**
+ * gimp_procedure_get_sensitivity_mask:
+ * @procedure: A #GimpProcedure.
+ *
+ * Returns: The procedure's sensitivity mask given in
+ * gimp_procedure_set_sensitivity_mask().
+ *
+ * Since: 3.0
+ **/
+gint
+gimp_procedure_get_sensitivity_mask (GimpProcedure *procedure)
+{
+ g_return_val_if_fail (GIMP_IS_PROCEDURE (procedure), 0);
+
+ return procedure->priv->sensitivity_mask;
+}
+
/**
* gimp_procedure_set_menu_label:
* @procedure: A #GimpProcedure.
diff --git a/libgimp/gimpprocedure.h b/libgimp/gimpprocedure.h
index 23acc5a8c0..c52f8adb0b 100644
--- a/libgimp/gimpprocedure.h
+++ b/libgimp/gimpprocedure.h
@@ -144,6 +144,11 @@ void gimp_procedure_set_image_types (GimpProcedure *proced
const gchar *image_types);
const gchar * gimp_procedure_get_image_types (GimpProcedure *procedure);
+void gimp_procedure_set_sensitivity_mask (GimpProcedure *procedure,
+ gint sensitivity_mask);
+gint gimp_procedure_get_sensitivity_mask (GimpProcedure *procedure);
+
+
void gimp_procedure_set_menu_label (GimpProcedure *procedure,
const gchar *menu_label);
const gchar * gimp_procedure_get_menu_label (GimpProcedure *procedure);
diff --git a/pdb/groups/pdb.pdb b/pdb/groups/pdb.pdb
index 9ac205fee4..a678123841 100644
--- a/pdb/groups/pdb.pdb
+++ b/pdb/groups/pdb.pdb
@@ -426,6 +426,42 @@ CODE
);
}
+sub pdb_set_proc_sensitivity_mask {
+ $blurb = "Set the sensitivity mask for a plug-in procedure.";
+
+ $help = <<HELP;
+This procedure sets the sensitivity mask for the given procedure.
+HELP
+
+ &jehan_pdb_misc('2021', '3.0');
+
+ $lib_private = 1;
+
+ @inargs = (
+ { name => 'procedure_name', type => 'string', non_empty => 1,
+ desc => 'The procedure' },
+ { name => 'mask', type => 'int32',,
+ desc => "The procedure's sensitivity mask" }
+ );
+
+ %invoke = (
+ code => <<'CODE'
+{
+ GimpPlugIn *plug_in = gimp->plug_in_manager->current_plug_in;
+
+ if (plug_in &&
+ gimp_pdb_is_canonical_procedure (procedure_name, error))
+ {
+ success = gimp_plug_in_set_proc_sensitivity_mask (plug_in, procedure_name,
+ mask, error);
+ }
+ else
+ success = FALSE;
+}
+CODE
+ );
+}
+
sub pdb_set_proc_menu_label {
$blurb = "Set the menu label for a plug-in procedure.";
@@ -1309,6 +1345,7 @@ CODE
pdb_get_proc_return_value
pdb_set_proc_image_types
pdb_get_proc_image_types
+ pdb_set_proc_sensitivity_mask
pdb_set_proc_menu_label
pdb_get_proc_menu_label
pdb_add_proc_menu_path
[
Date Prev][
Date Next] [
Thread Prev][
Thread Next]
[
Thread Index]
[
Date Index]
[
Author Index]
