From c49dec3416eab6d8a208a5d2b0e5ea39e29db27b Mon Sep 17 00:00:00 2001 From: Jehan Date: Mon, 25 Nov 2024 17:02:44 +0900 Subject: [PATCH] app, libgimp, pdb: 4 new libgimp/PDB procedures for GimpDrawableFilter. * gimp_drawable_filter_get_name * gimp_drawable_filter_get_operation_name * gimp_drawable_filter_get_visible * gimp_drawable_filter_set_visible --- app/pdb/drawable-filter-cmds.c | 234 +++++++++++++++++++++++++++++++ app/pdb/internal-procs.c | 2 +- libgimp/gimp.def | 4 + libgimp/gimpdrawablefilter_pdb.c | 154 ++++++++++++++++++++ libgimp/gimpdrawablefilter_pdb.h | 9 +- pdb/groups/drawable_filter.pdb | 120 ++++++++++++++++ 6 files changed, 520 insertions(+), 3 deletions(-) diff --git a/app/pdb/drawable-filter-cmds.c b/app/pdb/drawable-filter-cmds.c index 3000bd125e..c4eab42207 100644 --- a/app/pdb/drawable-filter-cmds.c +++ b/app/pdb/drawable-filter-cmds.c @@ -72,6 +72,120 @@ drawable_filter_id_is_valid_invoker (GimpProcedure *procedure, return return_vals; } +static GimpValueArray * +drawable_filter_get_name_invoker (GimpProcedure *procedure, + Gimp *gimp, + GimpContext *context, + GimpProgress *progress, + const GimpValueArray *args, + GError **error) +{ + gboolean success = TRUE; + GimpValueArray *return_vals; + GimpDrawableFilter *filter; + gchar *name = NULL; + + filter = g_value_get_object (gimp_value_array_index (args, 0)); + + if (success) + { + name = g_strdup (gimp_object_get_name (GIMP_OBJECT (filter))); + } + + return_vals = gimp_procedure_get_return_values (procedure, success, + error ? *error : NULL); + + if (success) + g_value_take_string (gimp_value_array_index (return_vals, 1), name); + + return return_vals; +} + +static GimpValueArray * +drawable_filter_get_operation_name_invoker (GimpProcedure *procedure, + Gimp *gimp, + GimpContext *context, + GimpProgress *progress, + const GimpValueArray *args, + GError **error) +{ + gboolean success = TRUE; + GimpValueArray *return_vals; + GimpDrawableFilter *filter; + gchar *name = NULL; + + filter = g_value_get_object (gimp_value_array_index (args, 0)); + + if (success) + { + GeglNode *node; + + node = gimp_drawable_filter_get_operation (filter); + name = g_strdup (gegl_node_get_operation (node)); + } + + return_vals = gimp_procedure_get_return_values (procedure, success, + error ? *error : NULL); + + if (success) + g_value_take_string (gimp_value_array_index (return_vals, 1), name); + + return return_vals; +} + +static GimpValueArray * +drawable_filter_get_visible_invoker (GimpProcedure *procedure, + Gimp *gimp, + GimpContext *context, + GimpProgress *progress, + const GimpValueArray *args, + GError **error) +{ + gboolean success = TRUE; + GimpValueArray *return_vals; + GimpDrawableFilter *filter; + gboolean visible = FALSE; + + filter = g_value_get_object (gimp_value_array_index (args, 0)); + + if (success) + { + visible = gimp_filter_get_active (GIMP_FILTER (filter)); + } + + return_vals = gimp_procedure_get_return_values (procedure, success, + error ? *error : NULL); + + if (success) + g_value_set_boolean (gimp_value_array_index (return_vals, 1), visible); + + return return_vals; +} + +static GimpValueArray * +drawable_filter_set_visible_invoker (GimpProcedure *procedure, + Gimp *gimp, + GimpContext *context, + GimpProgress *progress, + const GimpValueArray *args, + GError **error) +{ + gboolean success = TRUE; + GimpDrawableFilter *filter; + gboolean visible; + + filter = g_value_get_object (gimp_value_array_index (args, 0)); + visible = g_value_get_boolean (gimp_value_array_index (args, 1)); + + if (success) + { + gimp_filter_set_active (GIMP_FILTER (filter), visible); + } + + return gimp_procedure_get_return_values (procedure, success, + error ? *error : NULL); +} + static GimpValueArray * drawable_filter_delete_invoker (GimpProcedure *procedure, Gimp *gimp, @@ -140,6 +254,126 @@ register_drawable_filter_procs (GimpPDB *pdb) gimp_pdb_register_procedure (pdb, procedure); g_object_unref (procedure); + /* + * gimp-drawable-filter-get-name + */ + procedure = gimp_procedure_new (drawable_filter_get_name_invoker); + gimp_object_set_static_name (GIMP_OBJECT (procedure), + "gimp-drawable-filter-get-name"); + gimp_procedure_set_static_help (procedure, + "Get a drawable filter's name.", + "This procedure returns the specified filter's name.\n" + "Since it is not possible to set a drawable filter's name yet, this will be the operation's name. Eventually this filter's name will be a free form field so do not rely on this information for any processing.", + NULL); + gimp_procedure_set_static_attribution (procedure, + "Jehan", + "Jehan", + "2024"); + gimp_procedure_add_argument (procedure, + gimp_param_spec_drawable_filter ("filter", + "filter", + "The filter whose name you want", + FALSE, + GIMP_PARAM_READWRITE)); + gimp_procedure_add_return_value (procedure, + gimp_param_spec_string ("name", + "name", + "The filter's name", + FALSE, FALSE, FALSE, + NULL, + GIMP_PARAM_READWRITE)); + gimp_pdb_register_procedure (pdb, procedure); + g_object_unref (procedure); + + /* + * gimp-drawable-filter-get-operation-name + */ + procedure = gimp_procedure_new (drawable_filter_get_operation_name_invoker); + gimp_object_set_static_name (GIMP_OBJECT (procedure), + "gimp-drawable-filter-get-operation-name"); + gimp_procedure_set_static_help (procedure, + "Get a drawable filter's operation name.", + "This procedure returns the specified filter's operation name.", + NULL); + gimp_procedure_set_static_attribution (procedure, + "Jehan", + "Jehan", + "2024"); + gimp_procedure_add_argument (procedure, + gimp_param_spec_drawable_filter ("filter", + "filter", + "The filter whose operation name you want", + FALSE, + GIMP_PARAM_READWRITE)); + gimp_procedure_add_return_value (procedure, + gimp_param_spec_string ("name", + "name", + "The filter's operation name", + FALSE, FALSE, FALSE, + NULL, + GIMP_PARAM_READWRITE)); + gimp_pdb_register_procedure (pdb, procedure); + g_object_unref (procedure); + + /* + * gimp-drawable-filter-get-visible + */ + procedure = gimp_procedure_new (drawable_filter_get_visible_invoker); + gimp_object_set_static_name (GIMP_OBJECT (procedure), + "gimp-drawable-filter-get-visible"); + gimp_procedure_set_static_help (procedure, + "Get the visibility of the specified filter.", + "This procedure returns the specified filter's visibility.", + NULL); + gimp_procedure_set_static_attribution (procedure, + "Jehan", + "Jehan", + "2024"); + gimp_procedure_add_argument (procedure, + gimp_param_spec_drawable_filter ("filter", + "filter", + "The filter", + FALSE, + GIMP_PARAM_READWRITE)); + gimp_procedure_add_return_value (procedure, + g_param_spec_boolean ("visible", + "visible", + "The filter visibility", + FALSE, + GIMP_PARAM_READWRITE)); + gimp_pdb_register_procedure (pdb, procedure); + g_object_unref (procedure); + + /* + * gimp-drawable-filter-set-visible + */ + procedure = gimp_procedure_new (drawable_filter_set_visible_invoker); + gimp_object_set_static_name (GIMP_OBJECT (procedure), + "gimp-drawable-filter-set-visible"); + gimp_procedure_set_static_help (procedure, + "Set the visibility of the specified filter.", + "This procedure sets the specified filter's visibility.\n" + "The drawable won't be immediately rendered. Use [method@Gimp.Drawable.update] to trigger an update.", + NULL); + gimp_procedure_set_static_attribution (procedure, + "Jehan", + "Jehan", + "2024"); + gimp_procedure_add_argument (procedure, + gimp_param_spec_drawable_filter ("filter", + "filter", + "The filter", + FALSE, + GIMP_PARAM_READWRITE)); + gimp_procedure_add_argument (procedure, + g_param_spec_boolean ("visible", + "visible", + "The new filter visibility", + FALSE, + GIMP_PARAM_READWRITE)); + gimp_pdb_register_procedure (pdb, procedure); + g_object_unref (procedure); + /* * gimp-drawable-filter-delete */ diff --git a/app/pdb/internal-procs.c b/app/pdb/internal-procs.c index 43e8051f1c..8202d4e781 100644 --- a/app/pdb/internal-procs.c +++ b/app/pdb/internal-procs.c @@ -30,7 +30,7 @@ #include "internal-procs.h" -/* 721 procedures registered total */ +/* 725 procedures registered total */ void internal_procs_init (GimpPDB *pdb) diff --git a/libgimp/gimp.def b/libgimp/gimp.def index a94a30d0eb..1a0a3a6759 100644 --- a/libgimp/gimp.def +++ b/libgimp/gimp.def @@ -214,9 +214,13 @@ EXPORTS gimp_drawable_filter_delete gimp_drawable_filter_get_by_id gimp_drawable_filter_get_id + gimp_drawable_filter_get_name + gimp_drawable_filter_get_operation_name gimp_drawable_filter_get_type + gimp_drawable_filter_get_visible gimp_drawable_filter_id_is_valid gimp_drawable_filter_is_valid + gimp_drawable_filter_set_visible gimp_drawable_foreground_extract gimp_drawable_free_shadow gimp_drawable_get_bpp diff --git a/libgimp/gimpdrawablefilter_pdb.c b/libgimp/gimpdrawablefilter_pdb.c index 915106ee40..2831128c42 100644 --- a/libgimp/gimpdrawablefilter_pdb.c +++ b/libgimp/gimpdrawablefilter_pdb.c @@ -73,6 +73,160 @@ gimp_drawable_filter_id_is_valid (gint filter_id) return valid; } +/** + * gimp_drawable_filter_get_name: + * @filter: The filter whose name you want. + * + * Get a drawable filter's name. + * + * This procedure returns the specified filter's name. + * Since it is not possible to set a drawable filter's name yet, this + * will be the operation's name. Eventually this filter's name will be + * a free form field so do not rely on this information for any + * processing. + * + * Returns: (transfer full): The filter's name. + * The returned value must be freed with g_free(). + * + * Since: 3.0 + **/ +gchar * +gimp_drawable_filter_get_name (GimpDrawableFilter *filter) +{ + GimpValueArray *args; + GimpValueArray *return_vals; + gchar *name = NULL; + + args = gimp_value_array_new_from_types (NULL, + GIMP_TYPE_DRAWABLE_FILTER, filter, + G_TYPE_NONE); + + return_vals = _gimp_pdb_run_procedure_array (gimp_get_pdb (), + "gimp-drawable-filter-get-name", + args); + gimp_value_array_unref (args); + + if (GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS) + name = GIMP_VALUES_DUP_STRING (return_vals, 1); + + gimp_value_array_unref (return_vals); + + return name; +} + +/** + * gimp_drawable_filter_get_operation_name: + * @filter: The filter whose operation name you want. + * + * Get a drawable filter's operation name. + * + * This procedure returns the specified filter's operation name. + * + * Returns: (transfer full): The filter's operation name. + * The returned value must be freed with g_free(). + * + * Since: 3.0 + **/ +gchar * +gimp_drawable_filter_get_operation_name (GimpDrawableFilter *filter) +{ + GimpValueArray *args; + GimpValueArray *return_vals; + gchar *name = NULL; + + args = gimp_value_array_new_from_types (NULL, + GIMP_TYPE_DRAWABLE_FILTER, filter, + G_TYPE_NONE); + + return_vals = _gimp_pdb_run_procedure_array (gimp_get_pdb (), + "gimp-drawable-filter-get-operation-name", + args); + gimp_value_array_unref (args); + + if (GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS) + name = GIMP_VALUES_DUP_STRING (return_vals, 1); + + gimp_value_array_unref (return_vals); + + return name; +} + +/** + * gimp_drawable_filter_get_visible: + * @filter: The filter. + * + * Get the visibility of the specified filter. + * + * This procedure returns the specified filter's visibility. + * + * Returns: The filter visibility. + * + * Since: 3.0 + **/ +gboolean +gimp_drawable_filter_get_visible (GimpDrawableFilter *filter) +{ + GimpValueArray *args; + GimpValueArray *return_vals; + gboolean visible = FALSE; + + args = gimp_value_array_new_from_types (NULL, + GIMP_TYPE_DRAWABLE_FILTER, filter, + G_TYPE_NONE); + + return_vals = _gimp_pdb_run_procedure_array (gimp_get_pdb (), + "gimp-drawable-filter-get-visible", + args); + gimp_value_array_unref (args); + + if (GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS) + visible = GIMP_VALUES_GET_BOOLEAN (return_vals, 1); + + gimp_value_array_unref (return_vals); + + return visible; +} + +/** + * gimp_drawable_filter_set_visible: + * @filter: The filter. + * @visible: The new filter visibility. + * + * Set the visibility of the specified filter. + * + * This procedure sets the specified filter's visibility. + * The drawable won't be immediately rendered. Use + * [method@Gimp.Drawable.update] to trigger an update. + * + * Returns: TRUE on success. + * + * Since: 3.0 + **/ +gboolean +gimp_drawable_filter_set_visible (GimpDrawableFilter *filter, + gboolean visible) +{ + GimpValueArray *args; + GimpValueArray *return_vals; + gboolean success = TRUE; + + args = gimp_value_array_new_from_types (NULL, + GIMP_TYPE_DRAWABLE_FILTER, filter, + G_TYPE_BOOLEAN, visible, + G_TYPE_NONE); + + return_vals = _gimp_pdb_run_procedure_array (gimp_get_pdb (), + "gimp-drawable-filter-set-visible", + 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_drawable_filter_delete: * @filter: The filter to delete. diff --git a/libgimp/gimpdrawablefilter_pdb.h b/libgimp/gimpdrawablefilter_pdb.h index 7369230af9..694c556c01 100644 --- a/libgimp/gimpdrawablefilter_pdb.h +++ b/libgimp/gimpdrawablefilter_pdb.h @@ -32,8 +32,13 @@ G_BEGIN_DECLS /* For information look into the C source or the html documentation */ -gboolean gimp_drawable_filter_id_is_valid (gint filter_id); -gboolean gimp_drawable_filter_delete (GimpDrawableFilter *filter); +gboolean gimp_drawable_filter_id_is_valid (gint filter_id); +gchar* gimp_drawable_filter_get_name (GimpDrawableFilter *filter); +gchar* gimp_drawable_filter_get_operation_name (GimpDrawableFilter *filter); +gboolean gimp_drawable_filter_get_visible (GimpDrawableFilter *filter); +gboolean gimp_drawable_filter_set_visible (GimpDrawableFilter *filter, + gboolean visible); +gboolean gimp_drawable_filter_delete (GimpDrawableFilter *filter); G_END_DECLS diff --git a/pdb/groups/drawable_filter.pdb b/pdb/groups/drawable_filter.pdb index fe1c721e4e..69a02c7bad 100644 --- a/pdb/groups/drawable_filter.pdb +++ b/pdb/groups/drawable_filter.pdb @@ -44,6 +44,122 @@ CODE ); } +sub drawable_filter_get_name { + $blurb = 'Get a drawable filter\'s name.'; + + $help = <<'HELP'; +This procedure returns the specified filter's name. + +Since it is not possible to set a drawable filter's name yet, this will +be the operation's name. Eventually this filter's name will be a free +form field so do not rely on this information for any processing. +HELP + + &jehan_pdb_misc('2024', '3.0'); + + @inargs = ( + { name => 'filter', type => 'filter', + desc => 'The filter whose name you want' } + ); + + @outargs = ( + { name => 'name', type => 'string', + desc => "The filter's name" } + ); + + %invoke = ( + code => <<'CODE' +{ + name = g_strdup (gimp_object_get_name (GIMP_OBJECT (filter))); +} +CODE + ); +} + +sub drawable_filter_get_operation_name { + $blurb = 'Get a drawable filter\'s operation name.'; + + $help = <<'HELP'; +This procedure returns the specified filter's operation name. +HELP + + &jehan_pdb_misc('2024', '3.0'); + + @inargs = ( + { name => 'filter', type => 'filter', + desc => 'The filter whose operation name you want' } + ); + + @outargs = ( + { name => 'name', type => 'string', + desc => "The filter's operation name" } + ); + + %invoke = ( + code => <<'CODE' +{ + GeglNode *node; + + node = gimp_drawable_filter_get_operation (filter); + name = g_strdup (gegl_node_get_operation (node)); +} +CODE + ); +} + +sub drawable_filter_get_visible { + $blurb = "Get the visibility of the specified filter."; + + $help = "This procedure returns the specified filter's visibility."; + + &jehan_pdb_misc('2024', '3.0'); + + @inargs = ( + { name => 'filter', type => 'filter', + desc => 'The filter' } + ); + + @outargs = ( + { name => 'visible', type => 'boolean', + desc => "The filter visibility" } + ); + + %invoke = ( + code => <<'CODE' +{ + visible = gimp_filter_get_active (GIMP_FILTER (filter)); +} +CODE + ); +} + +sub drawable_filter_set_visible { + $blurb = "Set the visibility of the specified filter."; + + $help = <<'HELP'; +This procedure sets the specified filter's visibility. + +The drawable won't be immediately rendered. Use [method@Gimp.Drawable.update] to trigger an update. +HELP + + &jehan_pdb_misc('2024', '3.0'); + + @inargs = ( + { name => 'filter', type => 'filter', + desc => 'The filter' }, + { name => 'visible', type => 'boolean', + desc => "The new filter visibility" } + ); + + %invoke = ( + code => <<'CODE' +{ + gimp_filter_set_active (GIMP_FILTER (filter), visible); +} +CODE + ); +} + sub drawable_filter_delete { $blurb = 'Delete a drawable filter.'; @@ -91,6 +207,10 @@ CODE "gimp-intl.h"); @procs = qw(drawable_filter_id_is_valid + drawable_filter_get_name + drawable_filter_get_operation_name + drawable_filter_get_visible + drawable_filter_set_visible drawable_filter_delete); %exports = (app => [@procs], lib => [@procs]);