procyberian/gimp
2
0
Fork 0
mirror of https://gitlab.gnome.org/GNOME/gimp.git synced 2025-07-04 01:43:24 +00:00
Code Issues 1 Projects 1 Releases Packages Wiki Activity Actions
gimp/libgimp/gimpdrawablefilter.c

384 lines
10 KiB
C
Raw Normal View History

app, libgimp, pdb: passing GimpDrawableFilter across the wire. A few functions were added, but the main one is gimp_drawable_get_filters() to request the list of filters applied non-destructively on a drawable. We can't do much with these for the time being, but this will come. WIP.
2024-11-25 04:38:39 +09:00
/* LIBGIMP - The GIMP Library
* Copyright (C) 1995-2000 Peter Mattis and Spencer Kimball
*
* gimpdrawablefilter.c
* Copyright (C) 2024 Jehan
*
* 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/>.
*/
#include "config.h"
#include "gimp.h"
#include "libgimpbase/gimpwire.h" /* FIXME kill this include */
#include "gimpplugin-private.h"
enum
{
PROP_0,
PROP_ID,
N_PROPS
};
struct _GimpDrawableFilter
{
app, libgimp, pdb: new GimpDrawableFilterConfig class. This is mostly an empty shell whose goal is to serve as base class for specific dynamically generated per-operation subclasses, which will have properties mimicking the arguments of the GEGL operation. Most of the fundamental type args will just use the base GLib param spec types instead of GEGL ones. As a special case, the GeglParamEnum arguments are transformed into GimpChoice param specs on libgimp side. The reason is that most of the time, enum types are created within the scope of an operation code only and cannot be properly reconstructed over the wire. I could just transform these into an int type (which is mostly what is done in GEGL right now when running an op with such arg), but GimpChoice allow much nicer string-type args, which make much more semantic code. This class was initially created for plug-ins, but it would work very well to run GEGL ops on drawables. So let's do it. Finally add a gimp_drawable_filter_get_config() to request the current config of a filter. Note that right now, we can't do much with this config object other than observing an operation args and default values. Being able to update a filter's settings will come up in further commits.
2024-11-28 01:07:23 +09:00
GObject parent_instance;
gint id;
app, libgimp, pdb: new gimp_drawable_filter_(g|s)et_blend_mode() and gimp_drawable_filter_(g|s)et_opacity(). Similarly to the config arguments, the set functions are not directly calling core. Instead they are queuing changes until gimp_drawable_filter_update() is run.
2024-12-04 23:09:02 +09:00
gdouble opacity;
GimpLayerMode blend_mode;
GimpLayerColorSpace blend_space;
GimpLayerCompositeMode composite_mode;
GimpLayerColorSpace composite_space;
app, libgimp, pdb: new GimpDrawableFilterConfig class. This is mostly an empty shell whose goal is to serve as base class for specific dynamically generated per-operation subclasses, which will have properties mimicking the arguments of the GEGL operation. Most of the fundamental type args will just use the base GLib param spec types instead of GEGL ones. As a special case, the GeglParamEnum arguments are transformed into GimpChoice param specs on libgimp side. The reason is that most of the time, enum types are created within the scope of an operation code only and cannot be properly reconstructed over the wire. I could just transform these into an int type (which is mostly what is done in GEGL right now when running an op with such arg), but GimpChoice allow much nicer string-type args, which make much more semantic code. This class was initially created for plug-ins, but it would work very well to run GEGL ops on drawables. So let's do it. Finally add a gimp_drawable_filter_get_config() to request the current config of a filter. Note that right now, we can't do much with this config object other than observing an operation args and default values. Being able to update a filter's settings will come up in further commits.
2024-11-28 01:07:23 +09:00
GimpDrawableFilterConfig *config;
app, libgimp, pdb: passing GimpDrawableFilter across the wire. A few functions were added, but the main one is gimp_drawable_get_filters() to request the list of filters applied non-destructively on a drawable. We can't do much with these for the time being, but this will come. WIP.
2024-11-25 04:38:39 +09:00
};
app, libgimp, pdb: new GimpDrawableFilterConfig class. This is mostly an empty shell whose goal is to serve as base class for specific dynamically generated per-operation subclasses, which will have properties mimicking the arguments of the GEGL operation. Most of the fundamental type args will just use the base GLib param spec types instead of GEGL ones. As a special case, the GeglParamEnum arguments are transformed into GimpChoice param specs on libgimp side. The reason is that most of the time, enum types are created within the scope of an operation code only and cannot be properly reconstructed over the wire. I could just transform these into an int type (which is mostly what is done in GEGL right now when running an op with such arg), but GimpChoice allow much nicer string-type args, which make much more semantic code. This class was initially created for plug-ins, but it would work very well to run GEGL ops on drawables. So let's do it. Finally add a gimp_drawable_filter_get_config() to request the current config of a filter. Note that right now, we can't do much with this config object other than observing an operation args and default values. Being able to update a filter's settings will come up in further commits.
2024-11-28 01:07:23 +09:00
static void gimp_drawable_filter_finalize (GObject *object);
app, libgimp, pdb: passing GimpDrawableFilter across the wire. A few functions were added, but the main one is gimp_drawable_get_filters() to request the list of filters applied non-destructively on a drawable. We can't do much with these for the time being, but this will come. WIP.
2024-11-25 04:38:39 +09:00
static void gimp_drawable_filter_set_property (GObject *object,
guint property_id,
const GValue *value,
GParamSpec *pspec);
static void gimp_drawable_filter_get_property (GObject *object,
guint property_id,
GValue *value,
GParamSpec *pspec);
G_DEFINE_TYPE (GimpDrawableFilter, gimp_drawable_filter, G_TYPE_OBJECT)
#define parent_class gimp_drawable_filter_parent_class
static GParamSpec *props[N_PROPS] = { NULL, };
static void
gimp_drawable_filter_class_init (GimpDrawableFilterClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
app, libgimp, pdb: new GimpDrawableFilterConfig class. This is mostly an empty shell whose goal is to serve as base class for specific dynamically generated per-operation subclasses, which will have properties mimicking the arguments of the GEGL operation. Most of the fundamental type args will just use the base GLib param spec types instead of GEGL ones. As a special case, the GeglParamEnum arguments are transformed into GimpChoice param specs on libgimp side. The reason is that most of the time, enum types are created within the scope of an operation code only and cannot be properly reconstructed over the wire. I could just transform these into an int type (which is mostly what is done in GEGL right now when running an op with such arg), but GimpChoice allow much nicer string-type args, which make much more semantic code. This class was initially created for plug-ins, but it would work very well to run GEGL ops on drawables. So let's do it. Finally add a gimp_drawable_filter_get_config() to request the current config of a filter. Note that right now, we can't do much with this config object other than observing an operation args and default values. Being able to update a filter's settings will come up in further commits.
2024-11-28 01:07:23 +09:00
object_class->finalize = gimp_drawable_filter_finalize;
app, libgimp, pdb: passing GimpDrawableFilter across the wire. A few functions were added, but the main one is gimp_drawable_get_filters() to request the list of filters applied non-destructively on a drawable. We can't do much with these for the time being, but this will come. WIP.
2024-11-25 04:38:39 +09:00
object_class->set_property = gimp_drawable_filter_set_property;
object_class->get_property = gimp_drawable_filter_get_property;
props[PROP_ID] =
g_param_spec_int ("id",
"The drawable_filter id",
"The drawable_filter id for internal use",
0, G_MAXINT32, 0,
GIMP_PARAM_READWRITE |
G_PARAM_CONSTRUCT_ONLY);
g_object_class_install_properties (object_class, N_PROPS, props);
}
static void
gimp_drawable_filter_init (GimpDrawableFilter *drawable_filter)
{
app, libgimp, pdb: new GimpDrawableFilterConfig class. This is mostly an empty shell whose goal is to serve as base class for specific dynamically generated per-operation subclasses, which will have properties mimicking the arguments of the GEGL operation. Most of the fundamental type args will just use the base GLib param spec types instead of GEGL ones. As a special case, the GeglParamEnum arguments are transformed into GimpChoice param specs on libgimp side. The reason is that most of the time, enum types are created within the scope of an operation code only and cannot be properly reconstructed over the wire. I could just transform these into an int type (which is mostly what is done in GEGL right now when running an op with such arg), but GimpChoice allow much nicer string-type args, which make much more semantic code. This class was initially created for plug-ins, but it would work very well to run GEGL ops on drawables. So let's do it. Finally add a gimp_drawable_filter_get_config() to request the current config of a filter. Note that right now, we can't do much with this config object other than observing an operation args and default values. Being able to update a filter's settings will come up in further commits.
2024-11-28 01:07:23 +09:00
drawable_filter->config = NULL;
app, libgimp, pdb: new gimp_drawable_filter_(g|s)et_blend_mode() and gimp_drawable_filter_(g|s)et_opacity(). Similarly to the config arguments, the set functions are not directly calling core. Instead they are queuing changes until gimp_drawable_filter_update() is run.
2024-12-04 23:09:02 +09:00
drawable_filter->opacity = 1.0;
app, libgimp, pdb: make GIMP_LAYER_MODE_REPLACE PDB-visible. This is the actual default blend mode for filters so now that we have API to set filters, this mode must be settable.
2024-12-06 14:46:27 +09:00
drawable_filter->blend_mode = GIMP_LAYER_MODE_REPLACE;
app, libgimp, pdb: new gimp_drawable_filter_(g|s)et_blend_mode() and gimp_drawable_filter_(g|s)et_opacity(). Similarly to the config arguments, the set functions are not directly calling core. Instead they are queuing changes until gimp_drawable_filter_update() is run.
2024-12-04 23:09:02 +09:00
drawable_filter->blend_space = GIMP_LAYER_COLOR_SPACE_AUTO;
drawable_filter->composite_mode = GIMP_LAYER_COMPOSITE_AUTO;
drawable_filter->composite_space = GIMP_LAYER_COLOR_SPACE_AUTO;
app, libgimp, pdb: new GimpDrawableFilterConfig class. This is mostly an empty shell whose goal is to serve as base class for specific dynamically generated per-operation subclasses, which will have properties mimicking the arguments of the GEGL operation. Most of the fundamental type args will just use the base GLib param spec types instead of GEGL ones. As a special case, the GeglParamEnum arguments are transformed into GimpChoice param specs on libgimp side. The reason is that most of the time, enum types are created within the scope of an operation code only and cannot be properly reconstructed over the wire. I could just transform these into an int type (which is mostly what is done in GEGL right now when running an op with such arg), but GimpChoice allow much nicer string-type args, which make much more semantic code. This class was initially created for plug-ins, but it would work very well to run GEGL ops on drawables. So let's do it. Finally add a gimp_drawable_filter_get_config() to request the current config of a filter. Note that right now, we can't do much with this config object other than observing an operation args and default values. Being able to update a filter's settings will come up in further commits.
2024-11-28 01:07:23 +09:00
}
static void
gimp_drawable_filter_finalize (GObject *object)
{
GimpDrawableFilter *filter = GIMP_DRAWABLE_FILTER (object);
g_clear_object (&filter->config);
G_OBJECT_CLASS (parent_class)->finalize (object);
app, libgimp, pdb: passing GimpDrawableFilter across the wire. A few functions were added, but the main one is gimp_drawable_get_filters() to request the list of filters applied non-destructively on a drawable. We can't do much with these for the time being, but this will come. WIP.
2024-11-25 04:38:39 +09:00
}
static void
gimp_drawable_filter_set_property (GObject *object,
guint property_id,
const GValue *value,
GParamSpec *pspec)
{
GimpDrawableFilter *drawable_filter = GIMP_DRAWABLE_FILTER (object);
switch (property_id)
{
case PROP_ID:
drawable_filter->id = g_value_get_int (value);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
break;
}
}
static void
gimp_drawable_filter_get_property (GObject *object,
guint property_id,
GValue *value,
GParamSpec *pspec)
{
GimpDrawableFilter *drawable_filter = GIMP_DRAWABLE_FILTER (object);
switch (property_id)
{
case PROP_ID:
g_value_set_int (value, drawable_filter->id);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
break;
}
}
/* Public API */
/**
* gimp_drawable_filter_get_id:
* @filter: The [class@Gimp.Drawable]'s filter.
*
* Returns: the drawable's filter ID.
*
* Since: 3.0
**/
gint32
gimp_drawable_filter_get_id (GimpDrawableFilter *filter)
{
return filter ? filter->id : -1;
}
/**
* gimp_drawable_filter_get_by_id:
* @filter_id: The %GimpDrawableFilter id.
*
* Returns: (nullable) (transfer none): a #GimpDrawableFilter for @filter_id or
* %NULL if @filter_id does not represent a valid drawable's filter.
* The object belongs to libgimp and you must not modify
* or unref it.
*
* Since: 3.0
**/
GimpDrawableFilter *
gimp_drawable_filter_get_by_id (gint32 filter_id)
{
if (filter_id > 0)
{
GimpPlugIn *plug_in = gimp_get_plug_in ();
return _gimp_plug_in_get_filter (plug_in, filter_id);
}
return NULL;
}
/**
* gimp_drawable_filter_is_valid:
* @filter: The drawable's filter to check.
*
* Returns TRUE if the @drawable_filter is valid.
*
* This procedure checks if the given filter is valid and refers to an
* existing %GimpDrawableFilter.
*
* Returns: Whether @drawable_filter is valid.
*
* Since: 3.0
**/
gboolean
gimp_drawable_filter_is_valid (GimpDrawableFilter *filter)
{
return gimp_drawable_filter_id_is_valid (gimp_drawable_filter_get_id (filter));
}
app, libgimp, pdb: new GimpDrawableFilterConfig class. This is mostly an empty shell whose goal is to serve as base class for specific dynamically generated per-operation subclasses, which will have properties mimicking the arguments of the GEGL operation. Most of the fundamental type args will just use the base GLib param spec types instead of GEGL ones. As a special case, the GeglParamEnum arguments are transformed into GimpChoice param specs on libgimp side. The reason is that most of the time, enum types are created within the scope of an operation code only and cannot be properly reconstructed over the wire. I could just transform these into an int type (which is mostly what is done in GEGL right now when running an op with such arg), but GimpChoice allow much nicer string-type args, which make much more semantic code. This class was initially created for plug-ins, but it would work very well to run GEGL ops on drawables. So let's do it. Finally add a gimp_drawable_filter_get_config() to request the current config of a filter. Note that right now, we can't do much with this config object other than observing an operation args and default values. Being able to update a filter's settings will come up in further commits.
2024-11-28 01:07:23 +09:00
app, libgimp, pdb: new gimp_drawable_filter_(g|s)et_blend_mode() and gimp_drawable_filter_(g|s)et_opacity(). Similarly to the config arguments, the set functions are not directly calling core. Instead they are queuing changes until gimp_drawable_filter_update() is run.
2024-12-04 23:09:02 +09:00
/**
* gimp_drawable_filter_set_opacity:
* @filter: The drawable's filter.
* @opacity: the opacity.
*
* This procedure sets the opacity of @filter on a range from 0.0
* (transparent) to 1.0 (opaque).
*
* The change is not synced immediately with the core application.
* Use [method@Gimp.Drawable.update] to trigger an actual update.
*
* Since: 3.0
**/
void
gimp_drawable_filter_set_opacity (GimpDrawableFilter *filter,
gdouble opacity)
{
g_return_if_fail (GIMP_IS_DRAWABLE_FILTER (filter));
g_return_if_fail (opacity >= 0.0 && opacity <= 1.0);
filter->opacity = opacity;
}
/**
* gimp_drawable_filter_set_blend_mode:
* @filter: The drawable's filter.
* @mode: blend mode.
*
* This procedure sets the blend mode of @filter.
*
* The change is not synced immediately with the core application.
* Use [method@Gimp.Drawable.update] to trigger an actual update.
*
* Since: 3.0
**/
void
gimp_drawable_filter_set_blend_mode (GimpDrawableFilter *filter,
GimpLayerMode mode)
{
g_return_if_fail (GIMP_IS_DRAWABLE_FILTER (filter));
filter->blend_mode = mode;
}
app, libgimp, pdb: new GimpDrawableFilterConfig class. This is mostly an empty shell whose goal is to serve as base class for specific dynamically generated per-operation subclasses, which will have properties mimicking the arguments of the GEGL operation. Most of the fundamental type args will just use the base GLib param spec types instead of GEGL ones. As a special case, the GeglParamEnum arguments are transformed into GimpChoice param specs on libgimp side. The reason is that most of the time, enum types are created within the scope of an operation code only and cannot be properly reconstructed over the wire. I could just transform these into an int type (which is mostly what is done in GEGL right now when running an op with such arg), but GimpChoice allow much nicer string-type args, which make much more semantic code. This class was initially created for plug-ins, but it would work very well to run GEGL ops on drawables. So let's do it. Finally add a gimp_drawable_filter_get_config() to request the current config of a filter. Note that right now, we can't do much with this config object other than observing an operation args and default values. Being able to update a filter's settings will come up in further commits.
2024-11-28 01:07:23 +09:00
/**
* gimp_drawable_filter_get_config:
* @filter: A drawable filter.
*
* Get the #GimpConfig with properties that match @filter's arguments.
*
* Returns: (transfer none): The new #GimpConfig.
*
app, libgimp, pdb: new gimp_drawable_filter_(g|s)et_blend_mode() and gimp_drawable_filter_(g|s)et_opacity(). Similarly to the config arguments, the set functions are not directly calling core. Instead they are queuing changes until gimp_drawable_filter_update() is run.
2024-12-04 23:09:02 +09:00
* Changes to @config's properties are not synced immediately with the
* core application. Use [method@Gimp.Drawable.update] to trigger an
* actual update.
*
app, libgimp, pdb: new GimpDrawableFilterConfig class. This is mostly an empty shell whose goal is to serve as base class for specific dynamically generated per-operation subclasses, which will have properties mimicking the arguments of the GEGL operation. Most of the fundamental type args will just use the base GLib param spec types instead of GEGL ones. As a special case, the GeglParamEnum arguments are transformed into GimpChoice param specs on libgimp side. The reason is that most of the time, enum types are created within the scope of an operation code only and cannot be properly reconstructed over the wire. I could just transform these into an int type (which is mostly what is done in GEGL right now when running an op with such arg), but GimpChoice allow much nicer string-type args, which make much more semantic code. This class was initially created for plug-ins, but it would work very well to run GEGL ops on drawables. So let's do it. Finally add a gimp_drawable_filter_get_config() to request the current config of a filter. Note that right now, we can't do much with this config object other than observing an operation args and default values. Being able to update a filter's settings will come up in further commits.
2024-11-28 01:07:23 +09:00
* Since: 3.0
**/
GimpDrawableFilterConfig *
gimp_drawable_filter_get_config (GimpDrawableFilter *filter)
{
gchar *config_type_name;
gchar *op_name;
gchar *canonical_name;
GType config_type;
gint n_args;
g_return_val_if_fail (GIMP_IS_DRAWABLE_FILTER (filter), NULL);
if (filter->config)
return filter->config;
op_name = gimp_drawable_filter_get_operation_name (filter);
canonical_name = gimp_canonicalize_identifier (op_name);
config_type_name = g_strdup_printf ("GimpDrawableFilterConfig-%s", canonical_name);
config_type = g_type_from_name (config_type_name);
n_args = _gimp_drawable_filter_get_number_arguments (op_name);
if (! config_type)
{
GParamSpec **config_args;
config_args = g_new0 (GParamSpec *, n_args);
for (gint i = 0; i < n_args; i++)
{
GParamSpec *pspec;
pspec = _gimp_drawable_filter_get_argument (op_name, i);
config_args[i] = pspec;
}
config_type = gimp_config_type_register (GIMP_TYPE_DRAWABLE_FILTER_CONFIG,
config_type_name, config_args, n_args);
g_free (config_args);
}
g_free (op_name);
g_free (canonical_name);
filter->config = g_object_new (config_type, NULL);
return filter->config;
}
app, libgimp, pdb: new gimp_drawable_filter_update() public API. It is now possible to sync the GimpDrawableFilterConfig with core. Another (simpler on usage) possibility could have been to sync automatically when a property is updated. But considering that some filters can be quite slow to render (especially in real-life usage when working on possibly very big files), and especially that on bindings with no variable args, scripts will likely have to edit properties one by one, it could make editing multiple properties very slow. Therefore the chosen solution is that editing properties stay local on libgimp and all changed properties are synced with core at once (with a frozen render until the end for single computation) when calling gimp_drawable_filter_update().
2024-11-29 17:37:23 +09:00
app, libgimp, pdb: new gimp_drawable_filter_(g|s)et_blend_mode() and gimp_drawable_filter_(g|s)et_opacity(). Similarly to the config arguments, the set functions are not directly calling core. Instead they are queuing changes until gimp_drawable_filter_update() is run.
2024-12-04 23:09:02 +09:00
/**
* gimp_drawable_filter_update:
* @filter: A drawable filter.
*
* Syncs the #GimpConfig with properties that match @filter's arguments.
* This procedure updates the settings of the specified filter all at
* once, including the arguments of the [class@Gimp.DrawableFilterConfig]
* obtained with [method@Gimp.DrawableFilter.get_config] as well as the
* blend mode and opacity.
*
* In particular, if the image is displayed, rendering will be frozen
* and will happen only once for all changed settings.
*
* Since: 3.0
**/
app, libgimp, pdb: new gimp_drawable_filter_update() public API. It is now possible to sync the GimpDrawableFilterConfig with core. Another (simpler on usage) possibility could have been to sync automatically when a property is updated. But considering that some filters can be quite slow to render (especially in real-life usage when working on possibly very big files), and especially that on bindings with no variable args, scripts will likely have to edit properties one by one, it could make editing multiple properties very slow. Therefore the chosen solution is that editing properties stay local on libgimp and all changed properties are synced with core at once (with a frozen render until the end for single computation) when calling gimp_drawable_filter_update().
2024-11-29 17:37:23 +09:00
void
gimp_drawable_filter_update (GimpDrawableFilter *filter)
{
GStrvBuilder *builder = g_strv_builder_new ();
GimpValueArray *values = NULL;
GStrv propnames;
if (filter->config)
{
GObjectClass *klass;
GParamSpec **pspecs;
guint n_pspecs;
klass = G_OBJECT_GET_CLASS (filter->config);
pspecs = g_object_class_list_properties (klass, &n_pspecs);
values = gimp_value_array_new (n_pspecs);
for (guint i = 0; i < n_pspecs; i++)
{
GParamSpec *pspec = pspecs[i];
GValue value = G_VALUE_INIT;
g_value_init (&value, pspec->value_type);
g_object_get_property (G_OBJECT (filter->config), pspec->name, &value);
if (g_param_value_defaults (pspec, &value))
{
g_value_unset (&value);
continue;
}
g_strv_builder_add (builder, pspec->name);
gimp_value_array_append (values, &value);
g_value_unset (&value);
}
g_free (pspecs);
}
propnames = g_strv_builder_end (builder);
app, libgimp, pdb: new gimp_drawable_filter_(g|s)et_blend_mode() and gimp_drawable_filter_(g|s)et_opacity(). Similarly to the config arguments, the set functions are not directly calling core. Instead they are queuing changes until gimp_drawable_filter_update() is run.
2024-12-04 23:09:02 +09:00
_gimp_drawable_filter_update (filter, (const gchar **) propnames, values,
filter->opacity,
filter->blend_mode, filter->blend_space,
filter->composite_mode, filter->composite_space);
app, libgimp, pdb: new gimp_drawable_filter_update() public API. It is now possible to sync the GimpDrawableFilterConfig with core. Another (simpler on usage) possibility could have been to sync automatically when a property is updated. But considering that some filters can be quite slow to render (especially in real-life usage when working on possibly very big files), and especially that on bindings with no variable args, scripts will likely have to edit properties one by one, it could make editing multiple properties very slow. Therefore the chosen solution is that editing properties stay local on libgimp and all changed properties are synced with core at once (with a frozen render until the end for single computation) when calling gimp_drawable_filter_update().
2024-11-29 17:37:23 +09:00
g_strfreev (propnames);
g_strv_builder_unref (builder);
gimp_value_array_unref (values);
}
Reference in a new issue Copy permalink