2020-06-29 22:17:00 +00:00
|
|
|
|
|
2019-11-16 20:52:18 +00:00
|
|
|
|
/*
|
|
|
|
|
* Copyright © 2019 Benjamin Otte
|
|
|
|
|
*
|
|
|
|
|
* 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 2.1 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 <http://www.gnu.org/licenses/>.
|
|
|
|
|
*
|
|
|
|
|
* Authors: Benjamin Otte <otte@gnome.org>
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
#include "config.h"
|
|
|
|
|
|
|
|
|
|
#include "gtkexpression.h"
|
|
|
|
|
|
2021-02-04 19:18:28 +00:00
|
|
|
|
/* XXX: For g_memdup2() */
|
|
|
|
|
#include "gtkprivate.h"
|
|
|
|
|
|
2019-11-16 20:52:18 +00:00
|
|
|
|
#include <gobject/gvaluecollector.h>
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* SECTION:gtkexpression
|
|
|
|
|
* @Short_description: Expressions to values
|
|
|
|
|
* @Title: GtkExpression
|
|
|
|
|
*
|
2020-06-29 22:17:00 +00:00
|
|
|
|
* GtkExpression provides a way to describe references to values.
|
|
|
|
|
*
|
|
|
|
|
* An important aspect of expressions is that the value can be obtained
|
|
|
|
|
* from a source that is several steps away. For example, an expression
|
|
|
|
|
* may describe ‘the value of property A of @object1, which is itself the
|
|
|
|
|
* value of a property of @object2’. And @object1 may not even exist yet
|
|
|
|
|
* at the time that the expression is created. This is contrast to GObject
|
|
|
|
|
* property bindings, which can only create direct connections between
|
|
|
|
|
* the properties of two objects that must both exist for the duration
|
|
|
|
|
* of the binding.
|
2019-11-16 20:52:18 +00:00
|
|
|
|
*
|
2020-06-29 22:17:00 +00:00
|
|
|
|
* An expression needs to be "evaluated" to obtain the value that it currently
|
|
|
|
|
* refers to. An evaluation always happens in the context of a current object
|
|
|
|
|
* called `this` (it mirrors the behavior of object-oriented languages),
|
|
|
|
|
* which may or may not influence the result of the evaluation. Use
|
|
|
|
|
* gtk_expression_evaluate() for evaluating an expression.
|
2019-11-16 20:52:18 +00:00
|
|
|
|
*
|
|
|
|
|
* Various methods for defining expressions exist, from simple constants via
|
|
|
|
|
* gtk_constant_expression_new() to looking up properties in a #GObject (even
|
2020-06-29 22:17:00 +00:00
|
|
|
|
* recursively) via gtk_property_expression_new() or providing custom functions
|
|
|
|
|
* to transform and combine expressions via gtk_closure_expression_new().
|
|
|
|
|
*
|
|
|
|
|
* Here is an example of a complex expression:
|
|
|
|
|
* |[
|
2020-07-16 23:45:21 +00:00
|
|
|
|
* color_expr = gtk_property_expression_new (GTK_TYPE_LIST_ITEM,
|
|
|
|
|
* NULL, "item");
|
|
|
|
|
* expression = gtk_property_expression_new (GTK_TYPE_COLOR,
|
|
|
|
|
* color_expr, "name");
|
2020-06-29 22:17:00 +00:00
|
|
|
|
* ]|
|
2020-07-16 23:45:21 +00:00
|
|
|
|
*
|
2020-06-29 22:17:00 +00:00
|
|
|
|
* when evaluated with `this` being a GtkListItem, it will obtain the
|
|
|
|
|
* "item" property from the GtkListItem, and then obtain the "name" property
|
|
|
|
|
* from the resulting object (which is assumed to be of type GTK_TYPE_COLOR).
|
|
|
|
|
*
|
|
|
|
|
* A more concise way to describe this would be
|
|
|
|
|
* |[
|
2020-07-16 23:45:21 +00:00
|
|
|
|
* this->item->name
|
2020-06-29 22:17:00 +00:00
|
|
|
|
* ]|
|
|
|
|
|
*
|
|
|
|
|
* The most likely place where you will encounter expressions is in the context
|
|
|
|
|
* of list models and list widgets using them. For example, #GtkDropDown is
|
|
|
|
|
* evaluating a GtkExpression to obtain strings from the items in its model
|
|
|
|
|
* that it can then use to match against the contents of its search entry.
|
2020-07-16 23:45:21 +00:00
|
|
|
|
* #GtkStringFilter is using a GtkExpression for similar reasons.
|
2019-11-16 20:52:18 +00:00
|
|
|
|
*
|
|
|
|
|
* By default, expressions are not paying attention to changes and evaluation is
|
|
|
|
|
* just a snapshot of the current state at a given time. To get informed about
|
2020-06-01 20:07:53 +00:00
|
|
|
|
* changes, an expression needs to be "watched" via a #GtkExpressionWatch, which
|
2019-11-16 20:52:18 +00:00
|
|
|
|
* will cause a callback to be called whenever the value of the expression may
|
|
|
|
|
* have changed. gtk_expression_watch() starts watching an expression, and
|
|
|
|
|
* gtk_expression_watch_unwatch() stops.
|
|
|
|
|
*
|
2020-08-21 12:41:13 +00:00
|
|
|
|
* Watches can be created for automatically updating the property of an object,
|
2019-11-16 20:52:18 +00:00
|
|
|
|
* similar to GObject's #GBinding mechanism, by using gtk_expression_bind().
|
2019-11-18 03:35:36 +00:00
|
|
|
|
*
|
2020-06-01 20:17:34 +00:00
|
|
|
|
* # GtkExpression in GObject properties
|
|
|
|
|
*
|
|
|
|
|
* In order to use a #GtkExpression as a #GObject property, you must use the
|
|
|
|
|
* gtk_param_spec_expression() when creating a #GParamSpec to install in the
|
|
|
|
|
* #GObject class being defined; for instance:
|
|
|
|
|
*
|
|
|
|
|
* |[
|
|
|
|
|
* obj_props[PROP_EXPRESSION] =
|
|
|
|
|
* gtk_param_spec_expression ("expression",
|
|
|
|
|
* "Expression",
|
|
|
|
|
* "The expression used by the widget",
|
|
|
|
|
* G_PARAM_READWRITE |
|
|
|
|
|
* G_PARAM_STATIC_STRINGS |
|
|
|
|
|
* G_PARAM_EXPLICIT_NOTIFY);
|
|
|
|
|
* ]|
|
|
|
|
|
*
|
|
|
|
|
* When implementing the #GObjectClass.set_property() and #GObjectClass.get_property()
|
|
|
|
|
* virtual functions, you must use gtk_value_get_expression(), to retrieve the
|
|
|
|
|
* stored #GtkExpression from the #GValue container, and gtk_value_set_expression(),
|
|
|
|
|
* to store the #GtkExpression into the #GValue; for instance:
|
|
|
|
|
*
|
|
|
|
|
* |[
|
|
|
|
|
* // in set_property()...
|
|
|
|
|
* case PROP_EXPRESSION:
|
|
|
|
|
* foo_widget_set_expression (foo, gtk_value_get_expression (value));
|
|
|
|
|
* break;
|
|
|
|
|
*
|
|
|
|
|
* // in get_property()...
|
|
|
|
|
* case PROP_EXPRESSION:
|
|
|
|
|
* gtk_value_set_expression (value, foo->expression);
|
|
|
|
|
* break;
|
|
|
|
|
* ]|
|
|
|
|
|
*
|
2019-11-18 03:35:36 +00:00
|
|
|
|
* # GtkExpression in .ui files
|
|
|
|
|
*
|
|
|
|
|
* GtkBuilder has support for creating expressions. The syntax here can be used where
|
|
|
|
|
* a #GtkExpression object is needed like in a <property> tag for an expression
|
|
|
|
|
* property, or in a <binding> tag to bind a property to an expression.
|
|
|
|
|
*
|
|
|
|
|
* To create an property expression, use the <lookup> element. It can have a `type`
|
|
|
|
|
* attribute to specify the object type, and a `name` attribute to specify the property
|
|
|
|
|
* to look up. The content of <lookup> can either be an element specfiying the expression
|
|
|
|
|
* to use the object, or a string that specifies the name of the object to use.
|
2020-07-16 23:45:21 +00:00
|
|
|
|
*
|
2019-11-18 03:35:36 +00:00
|
|
|
|
* Example:
|
|
|
|
|
* |[
|
|
|
|
|
* <lookup name='search'>string_filter</lookup>
|
2020-07-16 23:45:21 +00:00
|
|
|
|
* ]|
|
2019-11-18 03:35:36 +00:00
|
|
|
|
*
|
|
|
|
|
* To create a constant expression, use the <constant> element. If the type attribute
|
|
|
|
|
* is specified, the element content is interpreted as a value of that type. Otherwise,
|
|
|
|
|
* it is assumed to be an object.
|
|
|
|
|
*
|
|
|
|
|
* Example:
|
|
|
|
|
* |[
|
|
|
|
|
* <constant>string_filter</constant>
|
|
|
|
|
* <constant type='gchararray'>Hello, world</constant>
|
|
|
|
|
* ]|
|
|
|
|
|
*
|
|
|
|
|
* To create a closure expression, use the <closure> element. The `type` and `function`
|
|
|
|
|
* attributes specify what function to use for the closure, the content of the element
|
|
|
|
|
* contains the expressions for the parameters.
|
2020-08-07 03:45:30 +00:00
|
|
|
|
*
|
2019-11-18 03:35:36 +00:00
|
|
|
|
* Example:
|
|
|
|
|
* |[
|
|
|
|
|
* <closure type='gchararray' function='combine_args_somehow'>
|
|
|
|
|
* <constant type='gchararray'>File size:</constant>
|
|
|
|
|
* <lookup type='GFile' name='size'>myfile</lookup>
|
|
|
|
|
* </closure>
|
|
|
|
|
* ]|
|
2019-11-16 20:52:18 +00:00
|
|
|
|
*/
|
2020-06-01 20:07:53 +00:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* GtkExpression: (ref-func gtk_expression_ref) (unref-func gtk_expression_unref) (set-value-func gtk_value_set_expression) (get-value-func gtk_value_get_expression)
|
|
|
|
|
*
|
|
|
|
|
* The `GtkExpression` structure contains only private data.
|
|
|
|
|
*/
|
|
|
|
|
|
2019-11-16 20:52:18 +00:00
|
|
|
|
typedef struct _GtkExpressionClass GtkExpressionClass;
|
2020-06-01 20:07:53 +00:00
|
|
|
|
typedef struct _GtkExpressionSubWatch GtkExpressionSubWatch;
|
|
|
|
|
typedef struct _GtkExpressionTypeInfo GtkExpressionTypeInfo;
|
2019-11-16 20:52:18 +00:00
|
|
|
|
|
|
|
|
|
struct _GtkExpression
|
|
|
|
|
{
|
2020-06-01 20:07:53 +00:00
|
|
|
|
GTypeInstance parent_instance;
|
|
|
|
|
|
|
|
|
|
gatomicrefcount ref_count;
|
|
|
|
|
|
2019-11-16 20:52:18 +00:00
|
|
|
|
GType value_type;
|
|
|
|
|
|
|
|
|
|
GtkExpression *owner;
|
|
|
|
|
};
|
|
|
|
|
|
2020-06-01 20:07:53 +00:00
|
|
|
|
struct _GtkExpressionClass
|
2019-11-21 04:53:56 +00:00
|
|
|
|
{
|
2020-06-01 20:07:53 +00:00
|
|
|
|
GTypeClass parent_class;
|
|
|
|
|
|
|
|
|
|
void (* finalize) (GtkExpression *expr);
|
|
|
|
|
gboolean (* is_static) (GtkExpression *expr);
|
|
|
|
|
gboolean (* evaluate) (GtkExpression *expr,
|
|
|
|
|
gpointer this,
|
|
|
|
|
GValue *value);
|
|
|
|
|
|
|
|
|
|
gsize (* watch_size) (GtkExpression *expr);
|
|
|
|
|
void (* watch) (GtkExpression *self,
|
|
|
|
|
GtkExpressionSubWatch *watch,
|
|
|
|
|
gpointer this_,
|
|
|
|
|
GtkExpressionNotify notify,
|
|
|
|
|
gpointer user_data);
|
|
|
|
|
void (* unwatch) (GtkExpression *self,
|
|
|
|
|
GtkExpressionSubWatch *watch);
|
2019-11-21 04:53:56 +00:00
|
|
|
|
};
|
|
|
|
|
|
2020-06-01 20:07:53 +00:00
|
|
|
|
struct _GtkExpressionTypeInfo
|
2019-11-16 20:52:18 +00:00
|
|
|
|
{
|
2020-06-01 20:07:53 +00:00
|
|
|
|
gsize instance_size;
|
2019-11-16 20:52:18 +00:00
|
|
|
|
|
2020-06-01 20:07:53 +00:00
|
|
|
|
void (* instance_init) (GtkExpression *expr);
|
2019-11-16 20:52:18 +00:00
|
|
|
|
void (* finalize) (GtkExpression *expr);
|
2019-11-21 04:53:56 +00:00
|
|
|
|
gboolean (* is_static) (GtkExpression *expr);
|
2019-11-16 20:52:18 +00:00
|
|
|
|
gboolean (* evaluate) (GtkExpression *expr,
|
|
|
|
|
gpointer this,
|
|
|
|
|
GValue *value);
|
2019-11-21 04:53:56 +00:00
|
|
|
|
|
|
|
|
|
gsize (* watch_size) (GtkExpression *expr);
|
|
|
|
|
void (* watch) (GtkExpression *self,
|
|
|
|
|
GtkExpressionSubWatch *watch,
|
|
|
|
|
gpointer this_,
|
|
|
|
|
GtkExpressionNotify notify,
|
|
|
|
|
gpointer user_data);
|
|
|
|
|
void (* unwatch) (GtkExpression *self,
|
|
|
|
|
GtkExpressionSubWatch *watch);
|
2019-11-16 20:52:18 +00:00
|
|
|
|
};
|
|
|
|
|
|
2020-06-01 20:07:53 +00:00
|
|
|
|
struct _GtkExpressionWatch
|
|
|
|
|
{
|
|
|
|
|
GtkExpression *expression;
|
|
|
|
|
GObject *this;
|
|
|
|
|
GDestroyNotify user_destroy;
|
|
|
|
|
GtkExpressionNotify notify;
|
|
|
|
|
gpointer user_data;
|
|
|
|
|
guchar sub[0];
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
#define GTK_EXPRESSION_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_EXPRESSION, GtkExpressionClass))
|
|
|
|
|
|
|
|
|
|
/*< private >
|
|
|
|
|
* GTK_DEFINE_EXPRESSION_TYPE:
|
|
|
|
|
* @TypeName: the type name, in camel case
|
|
|
|
|
* @type_name: the type name, in snake case
|
|
|
|
|
* @type_info: the address of the #GtkExpressionTypeInfo for the expression type
|
|
|
|
|
*
|
|
|
|
|
* Registers a new #GtkExpression subclass with the given @TypeName and @type_info.
|
|
|
|
|
*
|
|
|
|
|
* Similarly to %G_DEFINE_TYPE, this macro will generate a `get_type()`
|
|
|
|
|
* function that registers the event type.
|
|
|
|
|
*
|
|
|
|
|
* You can specify code to be run after the type registration; the #GType of
|
|
|
|
|
* the event is available in the `gtk_define_expression_type_id` variable.
|
|
|
|
|
*/
|
|
|
|
|
#define GTK_DEFINE_EXPRESSION_TYPE(TypeName, type_name, type_info) \
|
|
|
|
|
GType \
|
|
|
|
|
type_name ## _get_type (void) \
|
|
|
|
|
{ \
|
2020-11-19 03:58:09 +00:00
|
|
|
|
static gsize gtk_define_expression_type_id__volatile; \
|
2020-06-01 20:07:53 +00:00
|
|
|
|
if (g_once_init_enter (>k_define_expression_type_id__volatile)) \
|
|
|
|
|
{ \
|
|
|
|
|
GType gtk_define_expression_type_id = \
|
|
|
|
|
gtk_expression_type_register_static (g_intern_static_string (#TypeName), type_info); \
|
|
|
|
|
g_once_init_leave (>k_define_expression_type_id__volatile, gtk_define_expression_type_id); \
|
|
|
|
|
} \
|
|
|
|
|
return gtk_define_expression_type_id__volatile; \
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#define GTK_EXPRESSION_SUPER(expr) \
|
|
|
|
|
((GtkExpressionClass *) g_type_class_peek (g_type_parent (G_TYPE_FROM_INSTANCE (expr))))
|
|
|
|
|
|
|
|
|
|
/* {{{ GtkExpression internals */
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
value_expression_init (GValue *value)
|
|
|
|
|
{
|
|
|
|
|
value->data[0].v_pointer = NULL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
value_expression_free_value (GValue *value)
|
|
|
|
|
{
|
|
|
|
|
if (value->data[0].v_pointer != NULL)
|
|
|
|
|
gtk_expression_unref (value->data[0].v_pointer);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
value_expression_copy_value (const GValue *src,
|
|
|
|
|
GValue *dst)
|
|
|
|
|
{
|
|
|
|
|
if (src->data[0].v_pointer != NULL)
|
|
|
|
|
dst->data[0].v_pointer = gtk_expression_ref (src->data[0].v_pointer);
|
|
|
|
|
else
|
|
|
|
|
dst->data[0].v_pointer = NULL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static gpointer
|
|
|
|
|
value_expression_peek_pointer (const GValue *value)
|
|
|
|
|
{
|
|
|
|
|
return value->data[0].v_pointer;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static char *
|
|
|
|
|
value_expression_collect_value (GValue *value,
|
|
|
|
|
guint n_collect_values,
|
|
|
|
|
GTypeCValue *collect_values,
|
|
|
|
|
guint collect_flags)
|
|
|
|
|
{
|
|
|
|
|
GtkExpression *expression = collect_values[0].v_pointer;
|
|
|
|
|
|
|
|
|
|
if (expression == NULL)
|
|
|
|
|
{
|
|
|
|
|
value->data[0].v_pointer = NULL;
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (expression->parent_instance.g_class == NULL)
|
|
|
|
|
return g_strconcat ("invalid unclassed GtkExpression pointer for "
|
|
|
|
|
"value type '",
|
|
|
|
|
G_VALUE_TYPE_NAME (value),
|
|
|
|
|
"'",
|
|
|
|
|
NULL);
|
|
|
|
|
|
|
|
|
|
value->data[0].v_pointer = gtk_expression_ref (expression);
|
|
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
|
|
|
|
|
2020-07-24 18:40:36 +00:00
|
|
|
|
static char *
|
2020-06-01 20:07:53 +00:00
|
|
|
|
value_expression_lcopy_value (const GValue *value,
|
|
|
|
|
guint n_collect_values,
|
|
|
|
|
GTypeCValue *collect_values,
|
|
|
|
|
guint collect_flags)
|
|
|
|
|
{
|
|
|
|
|
GtkExpression **expression_p = collect_values[0].v_pointer;
|
|
|
|
|
|
|
|
|
|
if (expression_p == NULL)
|
|
|
|
|
return g_strconcat ("value location for '",
|
|
|
|
|
G_VALUE_TYPE_NAME (value),
|
|
|
|
|
"' passed as NULL",
|
|
|
|
|
NULL);
|
|
|
|
|
|
|
|
|
|
if (value->data[0].v_pointer == NULL)
|
|
|
|
|
*expression_p = NULL;
|
|
|
|
|
else if (collect_flags & G_VALUE_NOCOPY_CONTENTS)
|
|
|
|
|
*expression_p = value->data[0].v_pointer;
|
|
|
|
|
else
|
|
|
|
|
*expression_p = gtk_expression_ref (value->data[0].v_pointer);
|
|
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
|
|
|
|
|
2019-11-16 20:52:18 +00:00
|
|
|
|
/**
|
2020-06-01 20:07:53 +00:00
|
|
|
|
* gtk_value_set_expression:
|
|
|
|
|
* @value: a #GValue initialized with type %GTK_TYPE_EXPRESSION
|
|
|
|
|
* @expression: a #GtkExpression
|
2019-11-16 20:52:18 +00:00
|
|
|
|
*
|
2020-06-01 20:07:53 +00:00
|
|
|
|
* Stores the given #GtkExpression inside @value.
|
|
|
|
|
*
|
|
|
|
|
* The #GValue will acquire a reference to the @expression.
|
2019-11-16 20:52:18 +00:00
|
|
|
|
*/
|
2020-06-01 20:07:53 +00:00
|
|
|
|
void
|
|
|
|
|
gtk_value_set_expression (GValue *value,
|
|
|
|
|
GtkExpression *expression)
|
|
|
|
|
{
|
|
|
|
|
g_return_if_fail (G_VALUE_HOLDS (value, GTK_TYPE_EXPRESSION));
|
2019-11-16 20:52:18 +00:00
|
|
|
|
|
2020-06-01 20:07:53 +00:00
|
|
|
|
GtkExpression *old_expression = value->data[0].v_pointer;
|
2019-11-16 20:52:18 +00:00
|
|
|
|
|
2020-06-01 20:07:53 +00:00
|
|
|
|
if (expression != NULL)
|
|
|
|
|
{
|
|
|
|
|
g_return_if_fail (GTK_IS_EXPRESSION (expression));
|
|
|
|
|
|
|
|
|
|
value->data[0].v_pointer = gtk_expression_ref (expression);
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
value->data[0].v_pointer = NULL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (old_expression != NULL)
|
|
|
|
|
gtk_expression_unref (old_expression);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* gtk_value_take_expression:
|
|
|
|
|
* @value: a #GValue initialized with type %GTK_TYPE_EXPRESSION
|
|
|
|
|
* @expression: (transfer full) (nullable): a #GtkExpression
|
2019-11-16 20:52:18 +00:00
|
|
|
|
*
|
2020-06-01 20:07:53 +00:00
|
|
|
|
* Stores the given #GtkExpression inside @value.
|
|
|
|
|
*
|
|
|
|
|
* This function transfers the ownership of the @expression to the #GValue.
|
2019-11-16 20:52:18 +00:00
|
|
|
|
*/
|
2020-06-01 20:07:53 +00:00
|
|
|
|
void
|
|
|
|
|
gtk_value_take_expression (GValue *value,
|
|
|
|
|
GtkExpression *expression)
|
2019-11-16 20:52:18 +00:00
|
|
|
|
{
|
2020-06-01 20:07:53 +00:00
|
|
|
|
g_return_if_fail (G_VALUE_HOLDS (value, GTK_TYPE_EXPRESSION));
|
2019-11-16 20:52:18 +00:00
|
|
|
|
|
2020-06-01 20:07:53 +00:00
|
|
|
|
GtkExpression *old_expression = value->data[0].v_pointer;
|
2019-11-16 20:52:18 +00:00
|
|
|
|
|
2020-06-01 20:07:53 +00:00
|
|
|
|
if (expression != NULL)
|
|
|
|
|
{
|
|
|
|
|
g_return_if_fail (GTK_IS_EXPRESSION (expression));
|
2019-11-16 20:52:18 +00:00
|
|
|
|
|
2020-06-01 20:07:53 +00:00
|
|
|
|
value->data[0].v_pointer = expression;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
value->data[0].v_pointer = NULL;
|
|
|
|
|
}
|
2019-11-16 20:52:18 +00:00
|
|
|
|
|
2020-06-01 20:07:53 +00:00
|
|
|
|
if (old_expression != NULL)
|
|
|
|
|
gtk_expression_unref (old_expression);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* gtk_value_get_expression:
|
|
|
|
|
* @value: a #GValue initialized with type %GTK_TYPE_EXPRESSION
|
|
|
|
|
*
|
|
|
|
|
* Retrieves the #GtkExpression stored inside the given @value.
|
|
|
|
|
*
|
|
|
|
|
* Returns: (transfer none) (nullable): a #GtkExpression
|
|
|
|
|
*/
|
|
|
|
|
GtkExpression *
|
|
|
|
|
gtk_value_get_expression (const GValue *value)
|
|
|
|
|
{
|
|
|
|
|
g_return_val_if_fail (G_VALUE_HOLDS (value, GTK_TYPE_EXPRESSION), NULL);
|
|
|
|
|
|
|
|
|
|
return value->data[0].v_pointer;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* gtk_value_dup_expression:
|
|
|
|
|
* @value: a #GValue initialized with type %GTK_TYPE_EXPRESSION
|
|
|
|
|
*
|
|
|
|
|
* Retrieves the #GtkExpression stored inside the given @value, and acquires
|
|
|
|
|
* a reference to it.
|
|
|
|
|
*
|
|
|
|
|
* Returns: (transfer full) (nullable): a #GtkExpression
|
|
|
|
|
*/
|
|
|
|
|
GtkExpression *
|
|
|
|
|
gtk_value_dup_expression (const GValue *value)
|
|
|
|
|
{
|
|
|
|
|
g_return_val_if_fail (G_VALUE_HOLDS (value, GTK_TYPE_EXPRESSION), NULL);
|
|
|
|
|
|
|
|
|
|
if (value->data[0].v_pointer == NULL)
|
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
|
|
GtkExpression *expression = value->data[0].v_pointer;
|
|
|
|
|
|
|
|
|
|
return gtk_expression_ref (expression);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
param_expression_init (GParamSpec *pspec)
|
|
|
|
|
{
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
param_expression_set_default (GParamSpec *pspec,
|
|
|
|
|
GValue *value)
|
|
|
|
|
{
|
|
|
|
|
value->data[0].v_pointer = NULL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static gboolean
|
|
|
|
|
param_expression_validate (GParamSpec *pspec,
|
|
|
|
|
GValue *value)
|
|
|
|
|
{
|
|
|
|
|
GtkParamSpecExpression *espec = GTK_PARAM_SPEC_EXPRESSION (pspec);
|
|
|
|
|
GtkExpression *expr = value->data[0].v_pointer;
|
|
|
|
|
guint changed = 0;
|
|
|
|
|
|
|
|
|
|
if (expr != NULL &&
|
|
|
|
|
!g_value_type_compatible (G_TYPE_FROM_INSTANCE (expr), G_PARAM_SPEC_VALUE_TYPE (espec)))
|
|
|
|
|
{
|
|
|
|
|
gtk_expression_unref (expr);
|
|
|
|
|
value->data[0].v_pointer = NULL;
|
|
|
|
|
changed++;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return changed;
|
|
|
|
|
}
|
|
|
|
|
|
2020-07-24 13:54:49 +00:00
|
|
|
|
static int
|
2020-06-01 20:07:53 +00:00
|
|
|
|
param_expression_values_cmp (GParamSpec *pspec,
|
|
|
|
|
const GValue *value1,
|
|
|
|
|
const GValue *value2)
|
|
|
|
|
{
|
|
|
|
|
guint8 *p1 = value1->data[0].v_pointer;
|
|
|
|
|
guint8 *p2 = value2->data[0].v_pointer;
|
|
|
|
|
|
|
|
|
|
return p1 < p2 ? -1 : p1 > p2;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
GType
|
|
|
|
|
gtk_param_expression_get_type (void)
|
|
|
|
|
{
|
2020-11-19 03:58:09 +00:00
|
|
|
|
static gsize param_expression_type__volatile;
|
2020-06-01 20:07:53 +00:00
|
|
|
|
|
|
|
|
|
if (g_once_init_enter (¶m_expression_type__volatile))
|
|
|
|
|
{
|
|
|
|
|
const GParamSpecTypeInfo pspec_info = {
|
|
|
|
|
sizeof (GtkParamSpecExpression),
|
|
|
|
|
16,
|
|
|
|
|
param_expression_init,
|
|
|
|
|
GTK_TYPE_EXPRESSION,
|
|
|
|
|
NULL,
|
|
|
|
|
param_expression_set_default,
|
|
|
|
|
param_expression_validate,
|
|
|
|
|
param_expression_values_cmp,
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
GType param_expression_type =
|
|
|
|
|
g_param_type_register_static (g_intern_static_string ("GtkParamSpecExpression"),
|
|
|
|
|
&pspec_info);
|
|
|
|
|
|
|
|
|
|
g_once_init_leave (¶m_expression_type__volatile, param_expression_type);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return param_expression_type__volatile;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* gtk_param_spec_expression:
|
|
|
|
|
* @name: canonical name of the property
|
|
|
|
|
* @nick: a user-readable name for the property
|
|
|
|
|
* @blurb: a user-readable description of the property
|
|
|
|
|
* @flags: flags for the property
|
|
|
|
|
*
|
|
|
|
|
* Creates a new #GParamSpec instance for a property holding a #GtkExpression.
|
|
|
|
|
*
|
|
|
|
|
* See g_param_spec_internal() for details on the property strings.
|
|
|
|
|
*
|
|
|
|
|
* Returns: (transfer full): a newly created property specification
|
|
|
|
|
*/
|
|
|
|
|
GParamSpec *
|
|
|
|
|
gtk_param_spec_expression (const char *name,
|
|
|
|
|
const char *nick,
|
|
|
|
|
const char *blurb,
|
|
|
|
|
GParamFlags flags)
|
|
|
|
|
{
|
|
|
|
|
GParamSpec *pspec = g_param_spec_internal (GTK_TYPE_PARAM_SPEC_EXPRESSION,
|
|
|
|
|
name, nick, blurb,
|
|
|
|
|
flags);
|
|
|
|
|
|
|
|
|
|
pspec->value_type = GTK_TYPE_EXPRESSION;
|
|
|
|
|
|
|
|
|
|
return pspec;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* }}} */
|
|
|
|
|
|
|
|
|
|
/* {{{ GtkExpression internals */
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
gtk_expression_real_finalize (GtkExpression *self)
|
|
|
|
|
{
|
|
|
|
|
g_type_free_instance ((GTypeInstance *) self);
|
2019-11-16 20:52:18 +00:00
|
|
|
|
}
|
|
|
|
|
|
2019-11-21 04:53:56 +00:00
|
|
|
|
static gsize
|
2020-06-01 20:07:53 +00:00
|
|
|
|
gtk_expression_real_watch_size (GtkExpression *self)
|
2019-11-21 04:53:56 +00:00
|
|
|
|
{
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void
|
2020-06-01 20:07:53 +00:00
|
|
|
|
gtk_expression_real_watch (GtkExpression *self,
|
|
|
|
|
GtkExpressionSubWatch *watch,
|
|
|
|
|
gpointer this_,
|
|
|
|
|
GtkExpressionNotify notify,
|
|
|
|
|
gpointer user_data)
|
2019-11-21 04:53:56 +00:00
|
|
|
|
{
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void
|
2020-06-01 20:07:53 +00:00
|
|
|
|
gtk_expression_real_unwatch (GtkExpression *self,
|
|
|
|
|
GtkExpressionSubWatch *watch)
|
2019-11-21 04:53:56 +00:00
|
|
|
|
{
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static gsize
|
|
|
|
|
gtk_expression_watch_size (GtkExpression *self)
|
|
|
|
|
{
|
2020-06-01 20:07:53 +00:00
|
|
|
|
return GTK_EXPRESSION_GET_CLASS (self)->watch_size (self);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
gtk_expression_class_init (GtkExpressionClass *klass)
|
|
|
|
|
{
|
|
|
|
|
klass->finalize = gtk_expression_real_finalize;
|
|
|
|
|
klass->watch_size = gtk_expression_real_watch_size;
|
|
|
|
|
klass->watch = gtk_expression_real_watch;
|
|
|
|
|
klass->unwatch = gtk_expression_real_unwatch;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
gtk_expression_init (GtkExpression *self)
|
|
|
|
|
{
|
|
|
|
|
g_atomic_ref_count_init (&self->ref_count);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
GType
|
|
|
|
|
gtk_expression_get_type (void)
|
|
|
|
|
{
|
2020-11-19 03:58:09 +00:00
|
|
|
|
static gsize expression_type__volatile;
|
2020-06-01 20:07:53 +00:00
|
|
|
|
|
|
|
|
|
if (g_once_init_enter (&expression_type__volatile))
|
|
|
|
|
{
|
|
|
|
|
static const GTypeFundamentalInfo finfo = {
|
|
|
|
|
(G_TYPE_FLAG_CLASSED |
|
|
|
|
|
G_TYPE_FLAG_INSTANTIATABLE |
|
|
|
|
|
G_TYPE_FLAG_DERIVABLE |
|
|
|
|
|
G_TYPE_FLAG_DEEP_DERIVABLE),
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
static const GTypeValueTable value_table = {
|
|
|
|
|
value_expression_init,
|
|
|
|
|
value_expression_free_value,
|
|
|
|
|
value_expression_copy_value,
|
|
|
|
|
value_expression_peek_pointer,
|
|
|
|
|
"p",
|
|
|
|
|
value_expression_collect_value,
|
|
|
|
|
"p",
|
|
|
|
|
value_expression_lcopy_value,
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
const GTypeInfo event_info = {
|
|
|
|
|
/* Class */
|
|
|
|
|
sizeof (GtkExpressionClass),
|
|
|
|
|
(GBaseInitFunc) NULL,
|
|
|
|
|
(GBaseFinalizeFunc) NULL,
|
|
|
|
|
(GClassInitFunc) gtk_expression_class_init,
|
|
|
|
|
(GClassFinalizeFunc) NULL,
|
|
|
|
|
NULL,
|
|
|
|
|
|
|
|
|
|
/* Instance */
|
|
|
|
|
sizeof (GtkExpression),
|
|
|
|
|
0,
|
|
|
|
|
(GInstanceInitFunc) gtk_expression_init,
|
|
|
|
|
|
|
|
|
|
/* GValue */
|
|
|
|
|
&value_table,
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
GType expression_type =
|
|
|
|
|
g_type_register_fundamental (g_type_fundamental_next (),
|
|
|
|
|
g_intern_static_string ("GtkExpression"),
|
|
|
|
|
&event_info, &finfo,
|
|
|
|
|
G_TYPE_FLAG_ABSTRACT);
|
|
|
|
|
|
|
|
|
|
g_once_init_leave (&expression_type__volatile, expression_type);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return expression_type__volatile;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
gtk_expression_generic_class_init (gpointer g_class,
|
|
|
|
|
gpointer class_data)
|
|
|
|
|
{
|
|
|
|
|
GtkExpressionTypeInfo *info = class_data;
|
|
|
|
|
GtkExpressionClass *expression_class = g_class;
|
|
|
|
|
|
|
|
|
|
/* Mandatory */
|
|
|
|
|
expression_class->is_static = info->is_static;
|
|
|
|
|
expression_class->evaluate = info->evaluate;
|
|
|
|
|
|
|
|
|
|
/* Optional */
|
|
|
|
|
if (info->finalize != NULL)
|
|
|
|
|
expression_class->finalize = info->finalize;
|
|
|
|
|
if (info->watch_size != NULL)
|
|
|
|
|
expression_class->watch_size = info->watch_size;
|
|
|
|
|
if (info->watch != NULL)
|
|
|
|
|
expression_class->watch = info->watch;
|
|
|
|
|
if (info->unwatch != NULL)
|
|
|
|
|
expression_class->unwatch = info->unwatch;
|
|
|
|
|
|
|
|
|
|
g_free (info);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static GType
|
|
|
|
|
gtk_expression_type_register_static (const char *type_name,
|
|
|
|
|
const GtkExpressionTypeInfo *type_info)
|
|
|
|
|
{
|
|
|
|
|
GTypeInfo info;
|
|
|
|
|
|
|
|
|
|
info.class_size = sizeof (GtkExpressionClass);
|
|
|
|
|
info.base_init = NULL;
|
|
|
|
|
info.base_finalize = NULL;
|
|
|
|
|
info.class_init = gtk_expression_generic_class_init;
|
|
|
|
|
info.class_finalize = NULL;
|
2021-02-04 19:18:28 +00:00
|
|
|
|
info.class_data = g_memdup2 (type_info, sizeof (GtkExpressionTypeInfo));
|
2020-06-01 20:07:53 +00:00
|
|
|
|
|
|
|
|
|
info.instance_size = type_info->instance_size;
|
|
|
|
|
info.n_preallocs = 0;
|
|
|
|
|
info.instance_init = (GInstanceInitFunc) type_info->instance_init;
|
|
|
|
|
info.value_table = NULL;
|
|
|
|
|
|
|
|
|
|
return g_type_register_static (GTK_TYPE_EXPRESSION, type_name, &info, 0);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*< private >
|
|
|
|
|
* gtk_expression_alloc:
|
|
|
|
|
* @expression_type: the type of expression to create
|
|
|
|
|
* @value_type: the type of the value returned by this expression
|
|
|
|
|
*
|
|
|
|
|
* Returns: (transfer full): the newly created #GtkExpression
|
|
|
|
|
*/
|
|
|
|
|
static gpointer
|
|
|
|
|
gtk_expression_alloc (GType expression_type,
|
|
|
|
|
GType value_type)
|
|
|
|
|
{
|
|
|
|
|
GtkExpression *self;
|
|
|
|
|
|
|
|
|
|
self = (GtkExpression *) g_type_create_instance (expression_type);
|
|
|
|
|
|
|
|
|
|
self->value_type = value_type;
|
|
|
|
|
|
|
|
|
|
return self;
|
2019-11-21 04:53:56 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
gtk_expression_subwatch_init (GtkExpression *self,
|
|
|
|
|
GtkExpressionSubWatch *watch,
|
|
|
|
|
gpointer this,
|
|
|
|
|
GtkExpressionNotify notify,
|
|
|
|
|
gpointer user_data)
|
|
|
|
|
{
|
2020-06-01 20:07:53 +00:00
|
|
|
|
GTK_EXPRESSION_GET_CLASS (self)->watch (self, watch, this, notify, user_data);
|
2019-11-21 04:53:56 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
gtk_expression_subwatch_finish (GtkExpression *self,
|
|
|
|
|
GtkExpressionSubWatch *watch)
|
|
|
|
|
{
|
2020-06-01 20:07:53 +00:00
|
|
|
|
GTK_EXPRESSION_GET_CLASS (self)->unwatch (self, watch);
|
2019-11-21 04:53:56 +00:00
|
|
|
|
}
|
|
|
|
|
|
2020-06-01 20:07:53 +00:00
|
|
|
|
/* }}} */
|
|
|
|
|
|
|
|
|
|
/* {{{ GtkConstantExpression */
|
2019-11-16 20:52:18 +00:00
|
|
|
|
|
|
|
|
|
typedef struct _GtkConstantExpression GtkConstantExpression;
|
|
|
|
|
|
|
|
|
|
struct _GtkConstantExpression
|
|
|
|
|
{
|
|
|
|
|
GtkExpression parent;
|
|
|
|
|
|
|
|
|
|
GValue value;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
gtk_constant_expression_finalize (GtkExpression *expr)
|
|
|
|
|
{
|
|
|
|
|
GtkConstantExpression *self = (GtkConstantExpression *) expr;
|
|
|
|
|
|
|
|
|
|
g_value_unset (&self->value);
|
2020-06-01 20:07:53 +00:00
|
|
|
|
|
|
|
|
|
GTK_EXPRESSION_SUPER (expr)->finalize (expr);
|
2019-11-16 20:52:18 +00:00
|
|
|
|
}
|
|
|
|
|
|
2019-11-21 04:53:56 +00:00
|
|
|
|
static gboolean
|
|
|
|
|
gtk_constant_expression_is_static (GtkExpression *expr)
|
|
|
|
|
{
|
|
|
|
|
return TRUE;
|
|
|
|
|
}
|
|
|
|
|
|
2019-11-16 20:52:18 +00:00
|
|
|
|
static gboolean
|
|
|
|
|
gtk_constant_expression_evaluate (GtkExpression *expr,
|
|
|
|
|
gpointer this,
|
|
|
|
|
GValue *value)
|
|
|
|
|
{
|
|
|
|
|
GtkConstantExpression *self = (GtkConstantExpression *) expr;
|
|
|
|
|
|
|
|
|
|
g_value_init (value, G_VALUE_TYPE (&self->value));
|
|
|
|
|
g_value_copy (&self->value, value);
|
|
|
|
|
return TRUE;
|
|
|
|
|
}
|
|
|
|
|
|
2020-06-01 20:07:53 +00:00
|
|
|
|
static const GtkExpressionTypeInfo gtk_constant_expression_info =
|
2019-11-16 20:52:18 +00:00
|
|
|
|
{
|
|
|
|
|
sizeof (GtkConstantExpression),
|
2020-06-01 20:07:53 +00:00
|
|
|
|
NULL,
|
2019-11-16 20:52:18 +00:00
|
|
|
|
gtk_constant_expression_finalize,
|
2019-11-21 04:53:56 +00:00
|
|
|
|
gtk_constant_expression_is_static,
|
2019-11-16 20:52:18 +00:00
|
|
|
|
gtk_constant_expression_evaluate,
|
2020-06-01 20:07:53 +00:00
|
|
|
|
NULL,
|
|
|
|
|
NULL,
|
|
|
|
|
NULL,
|
2019-11-16 20:52:18 +00:00
|
|
|
|
};
|
|
|
|
|
|
2020-06-01 20:07:53 +00:00
|
|
|
|
GTK_DEFINE_EXPRESSION_TYPE (GtkConstantExpression,
|
|
|
|
|
gtk_constant_expression,
|
|
|
|
|
>k_constant_expression_info)
|
|
|
|
|
|
2019-11-16 20:52:18 +00:00
|
|
|
|
/**
|
|
|
|
|
* gtk_constant_expression_new:
|
|
|
|
|
* @value_type: The type of the object
|
|
|
|
|
* @...: arguments to create the object from
|
|
|
|
|
*
|
|
|
|
|
* Creates a GtkExpression that evaluates to the
|
|
|
|
|
* object given by the arguments.
|
|
|
|
|
*
|
|
|
|
|
* Returns: a new #GtkExpression
|
|
|
|
|
*/
|
|
|
|
|
GtkExpression *
|
|
|
|
|
gtk_constant_expression_new (GType value_type,
|
|
|
|
|
...)
|
|
|
|
|
{
|
|
|
|
|
GValue value = G_VALUE_INIT;
|
|
|
|
|
GtkExpression *result;
|
|
|
|
|
va_list args;
|
|
|
|
|
char *error;
|
|
|
|
|
|
|
|
|
|
va_start (args, value_type);
|
|
|
|
|
G_VALUE_COLLECT_INIT (&value, value_type,
|
|
|
|
|
args, G_VALUE_NOCOPY_CONTENTS,
|
|
|
|
|
&error);
|
|
|
|
|
if (error)
|
|
|
|
|
{
|
|
|
|
|
g_critical ("%s: %s", G_STRLOC, error);
|
|
|
|
|
g_free (error);
|
|
|
|
|
/* we purposely leak the value here, it might not be
|
|
|
|
|
* in a sane state if an error condition occurred
|
|
|
|
|
*/
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
result = gtk_constant_expression_new_for_value (&value);
|
|
|
|
|
|
|
|
|
|
g_value_unset (&value);
|
|
|
|
|
va_end (args);
|
|
|
|
|
|
|
|
|
|
return result;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* gtk_constant_expression_new_for_value:
|
|
|
|
|
* @value: a #GValue
|
|
|
|
|
*
|
|
|
|
|
* Creates an expression that always evaluates to the given @value.
|
|
|
|
|
*
|
|
|
|
|
* Returns: a new #GtkExpression
|
|
|
|
|
**/
|
|
|
|
|
GtkExpression *
|
|
|
|
|
gtk_constant_expression_new_for_value (const GValue *value)
|
|
|
|
|
{
|
2020-06-01 20:07:53 +00:00
|
|
|
|
GtkExpression *result;
|
|
|
|
|
GtkConstantExpression *self;
|
2019-11-16 20:52:18 +00:00
|
|
|
|
|
|
|
|
|
g_return_val_if_fail (G_IS_VALUE (value), NULL);
|
|
|
|
|
|
2020-06-01 20:07:53 +00:00
|
|
|
|
result = gtk_expression_alloc (GTK_TYPE_CONSTANT_EXPRESSION, G_VALUE_TYPE (value));
|
|
|
|
|
self = (GtkConstantExpression *) result;
|
2019-11-16 20:52:18 +00:00
|
|
|
|
|
2020-06-01 20:07:53 +00:00
|
|
|
|
g_value_init (&self->value, G_VALUE_TYPE (value));
|
|
|
|
|
g_value_copy (value, &self->value);
|
2019-11-16 20:52:18 +00:00
|
|
|
|
|
2020-06-01 20:07:53 +00:00
|
|
|
|
return result;
|
2019-11-16 20:52:18 +00:00
|
|
|
|
}
|
|
|
|
|
|
2020-07-14 00:19:07 +00:00
|
|
|
|
/**
|
|
|
|
|
* gtk_constant_expression_get_value:
|
2020-07-18 10:29:29 +00:00
|
|
|
|
* @expression: (type GtkConstantExpression): a constant #GtkExpression
|
2020-07-14 00:19:07 +00:00
|
|
|
|
*
|
|
|
|
|
* Gets the value that a constant expression evaluates to.
|
|
|
|
|
*
|
|
|
|
|
* Returns: (transfer none): the value
|
|
|
|
|
*/
|
|
|
|
|
const GValue *
|
|
|
|
|
gtk_constant_expression_get_value (GtkExpression *expression)
|
|
|
|
|
{
|
|
|
|
|
GtkConstantExpression *self = (GtkConstantExpression *) expression;
|
|
|
|
|
|
|
|
|
|
g_return_val_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (expression, GTK_TYPE_CONSTANT_EXPRESSION), NULL);
|
|
|
|
|
|
|
|
|
|
return &self->value;
|
|
|
|
|
}
|
|
|
|
|
|
2020-06-01 20:07:53 +00:00
|
|
|
|
/* }}} */
|
|
|
|
|
|
|
|
|
|
/* {{{ GtkObjectExpression */
|
2019-11-26 17:59:34 +00:00
|
|
|
|
|
|
|
|
|
typedef struct _GtkObjectExpression GtkObjectExpression;
|
2019-11-21 04:53:56 +00:00
|
|
|
|
typedef struct _GtkObjectExpressionWatch GtkObjectExpressionWatch;
|
2019-11-26 17:59:34 +00:00
|
|
|
|
|
|
|
|
|
struct _GtkObjectExpression
|
|
|
|
|
{
|
|
|
|
|
GtkExpression parent;
|
|
|
|
|
|
|
|
|
|
GObject *object;
|
2019-11-21 04:53:56 +00:00
|
|
|
|
GSList *watches;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
struct _GtkObjectExpressionWatch
|
|
|
|
|
{
|
|
|
|
|
GtkExpressionNotify notify;
|
|
|
|
|
gpointer user_data;
|
2019-11-26 17:59:34 +00:00
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
gtk_object_expression_weak_ref_cb (gpointer data,
|
|
|
|
|
GObject *object)
|
|
|
|
|
{
|
|
|
|
|
GtkObjectExpression *self = (GtkObjectExpression *) data;
|
2019-11-21 04:53:56 +00:00
|
|
|
|
GSList *l;
|
2019-11-26 17:59:34 +00:00
|
|
|
|
|
|
|
|
|
self->object = NULL;
|
2019-11-21 04:53:56 +00:00
|
|
|
|
|
|
|
|
|
for (l = self->watches; l; l = l->next)
|
|
|
|
|
{
|
|
|
|
|
GtkObjectExpressionWatch *owatch = l->data;
|
|
|
|
|
|
|
|
|
|
owatch->notify (owatch->user_data);
|
|
|
|
|
}
|
2019-11-26 17:59:34 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
gtk_object_expression_finalize (GtkExpression *expr)
|
|
|
|
|
{
|
|
|
|
|
GtkObjectExpression *self = (GtkObjectExpression *) expr;
|
|
|
|
|
|
|
|
|
|
if (self->object)
|
|
|
|
|
g_object_weak_unref (self->object, gtk_object_expression_weak_ref_cb, self);
|
2019-11-21 04:53:56 +00:00
|
|
|
|
|
|
|
|
|
g_assert (self->watches == NULL);
|
2020-06-01 20:07:53 +00:00
|
|
|
|
|
|
|
|
|
GTK_EXPRESSION_SUPER (expr)->finalize (expr);
|
2019-11-21 04:53:56 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static gboolean
|
|
|
|
|
gtk_object_expression_is_static (GtkExpression *expr)
|
|
|
|
|
{
|
|
|
|
|
return FALSE;
|
2019-11-26 17:59:34 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static gboolean
|
|
|
|
|
gtk_object_expression_evaluate (GtkExpression *expr,
|
|
|
|
|
gpointer this,
|
|
|
|
|
GValue *value)
|
|
|
|
|
{
|
|
|
|
|
GtkObjectExpression *self = (GtkObjectExpression *) expr;
|
|
|
|
|
|
|
|
|
|
if (self->object == NULL)
|
|
|
|
|
return FALSE;
|
|
|
|
|
|
|
|
|
|
g_value_init (value, gtk_expression_get_value_type (expr));
|
|
|
|
|
g_value_set_object (value, self->object);
|
|
|
|
|
return TRUE;
|
|
|
|
|
}
|
|
|
|
|
|
2019-11-21 04:53:56 +00:00
|
|
|
|
static gsize
|
|
|
|
|
gtk_object_expression_watch_size (GtkExpression *expr)
|
|
|
|
|
{
|
|
|
|
|
return sizeof (GtkObjectExpressionWatch);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
gtk_object_expression_watch (GtkExpression *expr,
|
|
|
|
|
GtkExpressionSubWatch *watch,
|
|
|
|
|
gpointer this_,
|
|
|
|
|
GtkExpressionNotify notify,
|
|
|
|
|
gpointer user_data)
|
|
|
|
|
{
|
|
|
|
|
GtkObjectExpression *self = (GtkObjectExpression *) expr;
|
|
|
|
|
GtkObjectExpressionWatch *owatch = (GtkObjectExpressionWatch *) watch;
|
|
|
|
|
|
|
|
|
|
owatch->notify = notify;
|
|
|
|
|
owatch->user_data = user_data;
|
|
|
|
|
self->watches = g_slist_prepend (self->watches, owatch);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
gtk_object_expression_unwatch (GtkExpression *expr,
|
|
|
|
|
GtkExpressionSubWatch *watch)
|
|
|
|
|
{
|
|
|
|
|
GtkObjectExpression *self = (GtkObjectExpression *) expr;
|
|
|
|
|
|
|
|
|
|
self->watches = g_slist_remove (self->watches, watch);
|
|
|
|
|
}
|
|
|
|
|
|
2020-06-01 20:07:53 +00:00
|
|
|
|
static const GtkExpressionTypeInfo gtk_object_expression_info =
|
2019-11-26 17:59:34 +00:00
|
|
|
|
{
|
|
|
|
|
sizeof (GtkObjectExpression),
|
2020-06-01 20:07:53 +00:00
|
|
|
|
NULL,
|
2019-11-26 17:59:34 +00:00
|
|
|
|
gtk_object_expression_finalize,
|
2019-11-21 04:53:56 +00:00
|
|
|
|
gtk_object_expression_is_static,
|
|
|
|
|
gtk_object_expression_evaluate,
|
|
|
|
|
gtk_object_expression_watch_size,
|
|
|
|
|
gtk_object_expression_watch,
|
|
|
|
|
gtk_object_expression_unwatch
|
2019-11-26 17:59:34 +00:00
|
|
|
|
};
|
|
|
|
|
|
2020-06-01 20:07:53 +00:00
|
|
|
|
GTK_DEFINE_EXPRESSION_TYPE (GtkObjectExpression,
|
|
|
|
|
gtk_object_expression,
|
|
|
|
|
>k_object_expression_info)
|
|
|
|
|
|
2019-11-26 17:59:34 +00:00
|
|
|
|
/**
|
|
|
|
|
* gtk_object_expression_new:
|
|
|
|
|
* @object: (transfer none): object to watch
|
|
|
|
|
*
|
|
|
|
|
* Creates an expression evaluating to the given @object with a weak reference.
|
|
|
|
|
* Once the @object is disposed, it will fail to evaluate.
|
|
|
|
|
* This expression is meant to break reference cycles.
|
|
|
|
|
*
|
|
|
|
|
* If you want to keep a reference to @object, use gtk_constant_expression_new().
|
|
|
|
|
*
|
|
|
|
|
* Returns: a new #GtkExpression
|
|
|
|
|
**/
|
|
|
|
|
GtkExpression *
|
|
|
|
|
gtk_object_expression_new (GObject *object)
|
|
|
|
|
{
|
2020-06-01 20:07:53 +00:00
|
|
|
|
GtkExpression *result;
|
|
|
|
|
GtkObjectExpression *self;
|
2019-11-26 17:59:34 +00:00
|
|
|
|
|
|
|
|
|
g_return_val_if_fail (G_IS_OBJECT (object), NULL);
|
|
|
|
|
|
2020-06-01 20:07:53 +00:00
|
|
|
|
result = gtk_expression_alloc (GTK_TYPE_OBJECT_EXPRESSION, G_OBJECT_TYPE (object));
|
|
|
|
|
self = (GtkObjectExpression *) result;
|
2019-11-26 17:59:34 +00:00
|
|
|
|
|
2020-06-01 20:07:53 +00:00
|
|
|
|
self->object = object;
|
|
|
|
|
g_object_weak_ref (object, gtk_object_expression_weak_ref_cb, self);
|
2019-11-26 17:59:34 +00:00
|
|
|
|
|
2020-06-01 20:07:53 +00:00
|
|
|
|
return result;
|
2019-11-26 17:59:34 +00:00
|
|
|
|
}
|
|
|
|
|
|
2020-07-14 00:19:07 +00:00
|
|
|
|
/**
|
|
|
|
|
* gtk_object_expression_get_object:
|
2020-07-18 10:29:29 +00:00
|
|
|
|
* @expression: (type GtkObjectExpression): an object #GtkExpression
|
2020-07-14 00:19:07 +00:00
|
|
|
|
*
|
|
|
|
|
* Gets the object that the expression evaluates to.
|
|
|
|
|
*
|
2020-10-17 13:17:56 +00:00
|
|
|
|
* Returns: (transfer none) (nullable): the object, or %NULL
|
2020-07-14 00:19:07 +00:00
|
|
|
|
*/
|
|
|
|
|
GObject *
|
|
|
|
|
gtk_object_expression_get_object (GtkExpression *expression)
|
|
|
|
|
{
|
|
|
|
|
GtkObjectExpression *self = (GtkObjectExpression *) expression;
|
|
|
|
|
|
|
|
|
|
g_return_val_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (expression, GTK_TYPE_OBJECT_EXPRESSION), NULL);
|
|
|
|
|
|
|
|
|
|
return self->object;
|
|
|
|
|
}
|
|
|
|
|
|
2020-06-01 20:07:53 +00:00
|
|
|
|
/* }}} */
|
|
|
|
|
|
|
|
|
|
/* {{{ GtkPropertyExpression */
|
2019-11-16 20:52:18 +00:00
|
|
|
|
|
|
|
|
|
typedef struct _GtkPropertyExpression GtkPropertyExpression;
|
|
|
|
|
|
|
|
|
|
struct _GtkPropertyExpression
|
|
|
|
|
{
|
|
|
|
|
GtkExpression parent;
|
|
|
|
|
|
|
|
|
|
GtkExpression *expr;
|
|
|
|
|
|
|
|
|
|
GParamSpec *pspec;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
gtk_property_expression_finalize (GtkExpression *expr)
|
|
|
|
|
{
|
|
|
|
|
GtkPropertyExpression *self = (GtkPropertyExpression *) expr;
|
|
|
|
|
|
|
|
|
|
g_clear_pointer (&self->expr, gtk_expression_unref);
|
2020-06-01 20:07:53 +00:00
|
|
|
|
|
|
|
|
|
GTK_EXPRESSION_SUPER (expr)->finalize (expr);
|
2019-11-16 20:52:18 +00:00
|
|
|
|
}
|
|
|
|
|
|
2019-11-21 04:53:56 +00:00
|
|
|
|
static gboolean
|
|
|
|
|
gtk_property_expression_is_static (GtkExpression *expr)
|
|
|
|
|
{
|
|
|
|
|
return FALSE;
|
|
|
|
|
}
|
|
|
|
|
|
2019-11-16 20:52:18 +00:00
|
|
|
|
static GObject *
|
|
|
|
|
gtk_property_expression_get_object (GtkPropertyExpression *self,
|
|
|
|
|
gpointer this)
|
|
|
|
|
{
|
|
|
|
|
GValue expr_value = G_VALUE_INIT;
|
|
|
|
|
GObject *object;
|
|
|
|
|
|
|
|
|
|
if (self->expr == NULL)
|
|
|
|
|
{
|
|
|
|
|
if (this)
|
|
|
|
|
return g_object_ref (this);
|
|
|
|
|
else
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (!gtk_expression_evaluate (self->expr, this, &expr_value))
|
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
|
|
if (!G_VALUE_HOLDS_OBJECT (&expr_value))
|
|
|
|
|
{
|
|
|
|
|
g_value_unset (&expr_value);
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
object = g_value_dup_object (&expr_value);
|
|
|
|
|
g_value_unset (&expr_value);
|
2019-11-21 04:53:56 +00:00
|
|
|
|
if (object == NULL)
|
|
|
|
|
return NULL;
|
2019-11-16 20:52:18 +00:00
|
|
|
|
|
|
|
|
|
if (!G_TYPE_CHECK_INSTANCE_TYPE (object, self->pspec->owner_type))
|
|
|
|
|
{
|
|
|
|
|
g_object_unref (object);
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return object;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static gboolean
|
|
|
|
|
gtk_property_expression_evaluate (GtkExpression *expr,
|
|
|
|
|
gpointer this,
|
|
|
|
|
GValue *value)
|
|
|
|
|
{
|
|
|
|
|
GtkPropertyExpression *self = (GtkPropertyExpression *) expr;
|
|
|
|
|
GObject *object;
|
|
|
|
|
|
|
|
|
|
object = gtk_property_expression_get_object (self, this);
|
|
|
|
|
if (object == NULL)
|
|
|
|
|
return FALSE;
|
|
|
|
|
|
|
|
|
|
g_object_get_property (object, self->pspec->name, value);
|
|
|
|
|
g_object_unref (object);
|
|
|
|
|
return TRUE;
|
|
|
|
|
}
|
|
|
|
|
|
2019-11-21 04:53:56 +00:00
|
|
|
|
typedef struct _GtkPropertyExpressionWatch GtkPropertyExpressionWatch;
|
|
|
|
|
|
|
|
|
|
struct _GtkPropertyExpressionWatch
|
|
|
|
|
{
|
|
|
|
|
GtkExpressionNotify notify;
|
|
|
|
|
gpointer user_data;
|
|
|
|
|
|
|
|
|
|
GtkPropertyExpression *expr;
|
|
|
|
|
gpointer this;
|
|
|
|
|
GClosure *closure;
|
|
|
|
|
guchar sub[0];
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
gtk_property_expression_watch_destroy_closure (GtkPropertyExpressionWatch *pwatch)
|
|
|
|
|
{
|
|
|
|
|
if (pwatch->closure == NULL)
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
g_closure_invalidate (pwatch->closure);
|
|
|
|
|
g_closure_unref (pwatch->closure);
|
|
|
|
|
pwatch->closure = NULL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
gtk_property_expression_watch_notify_cb (GObject *object,
|
|
|
|
|
GParamSpec *pspec,
|
|
|
|
|
GtkPropertyExpressionWatch *pwatch)
|
|
|
|
|
{
|
|
|
|
|
pwatch->notify (pwatch->user_data);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
gtk_property_expression_watch_create_closure (GtkPropertyExpressionWatch *pwatch)
|
|
|
|
|
{
|
|
|
|
|
GObject *object;
|
|
|
|
|
|
|
|
|
|
object = gtk_property_expression_get_object (pwatch->expr, pwatch->this);
|
|
|
|
|
if (object == NULL)
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
pwatch->closure = g_cclosure_new (G_CALLBACK (gtk_property_expression_watch_notify_cb), pwatch, NULL);
|
|
|
|
|
if (!g_signal_connect_closure_by_id (object,
|
|
|
|
|
g_signal_lookup ("notify", G_OBJECT_TYPE (object)),
|
|
|
|
|
g_quark_from_string (pwatch->expr->pspec->name),
|
|
|
|
|
g_closure_ref (pwatch->closure),
|
|
|
|
|
FALSE))
|
|
|
|
|
{
|
|
|
|
|
g_assert_not_reached ();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
g_object_unref (object);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
gtk_property_expression_watch_expr_notify_cb (gpointer data)
|
|
|
|
|
{
|
|
|
|
|
GtkPropertyExpressionWatch *pwatch = data;
|
|
|
|
|
|
|
|
|
|
gtk_property_expression_watch_destroy_closure (pwatch);
|
|
|
|
|
gtk_property_expression_watch_create_closure (pwatch);
|
|
|
|
|
pwatch->notify (pwatch->user_data);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static gsize
|
|
|
|
|
gtk_property_expression_watch_size (GtkExpression *expr)
|
|
|
|
|
{
|
|
|
|
|
GtkPropertyExpression *self = (GtkPropertyExpression *) expr;
|
|
|
|
|
gsize result;
|
|
|
|
|
|
|
|
|
|
result = sizeof (GtkPropertyExpressionWatch);
|
|
|
|
|
if (self->expr)
|
|
|
|
|
result += gtk_expression_watch_size (self->expr);
|
|
|
|
|
|
|
|
|
|
return result;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
gtk_property_expression_watch (GtkExpression *expr,
|
|
|
|
|
GtkExpressionSubWatch *watch,
|
|
|
|
|
gpointer this_,
|
|
|
|
|
GtkExpressionNotify notify,
|
|
|
|
|
gpointer user_data)
|
|
|
|
|
{
|
|
|
|
|
GtkPropertyExpressionWatch *pwatch = (GtkPropertyExpressionWatch *) watch;
|
|
|
|
|
GtkPropertyExpression *self = (GtkPropertyExpression *) expr;
|
|
|
|
|
|
|
|
|
|
pwatch->notify = notify;
|
|
|
|
|
pwatch->user_data = user_data;
|
|
|
|
|
pwatch->expr = self;
|
|
|
|
|
pwatch->this = this_;
|
|
|
|
|
if (self->expr && !gtk_expression_is_static (self->expr))
|
|
|
|
|
{
|
|
|
|
|
gtk_expression_subwatch_init (self->expr,
|
|
|
|
|
(GtkExpressionSubWatch *) pwatch->sub,
|
|
|
|
|
this_,
|
|
|
|
|
gtk_property_expression_watch_expr_notify_cb,
|
|
|
|
|
pwatch);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
gtk_property_expression_watch_create_closure (pwatch);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
gtk_property_expression_unwatch (GtkExpression *expr,
|
|
|
|
|
GtkExpressionSubWatch *watch)
|
|
|
|
|
{
|
|
|
|
|
GtkPropertyExpressionWatch *pwatch = (GtkPropertyExpressionWatch *) watch;
|
|
|
|
|
GtkPropertyExpression *self = (GtkPropertyExpression *) expr;
|
|
|
|
|
|
|
|
|
|
gtk_property_expression_watch_destroy_closure (pwatch);
|
|
|
|
|
|
|
|
|
|
if (self->expr && !gtk_expression_is_static (self->expr))
|
|
|
|
|
gtk_expression_subwatch_finish (self->expr, (GtkExpressionSubWatch *) pwatch->sub);
|
|
|
|
|
}
|
|
|
|
|
|
2020-06-01 20:07:53 +00:00
|
|
|
|
static const GtkExpressionTypeInfo gtk_property_expression_info =
|
2019-11-16 20:52:18 +00:00
|
|
|
|
{
|
|
|
|
|
sizeof (GtkPropertyExpression),
|
2020-06-01 20:07:53 +00:00
|
|
|
|
NULL,
|
2019-11-16 20:52:18 +00:00
|
|
|
|
gtk_property_expression_finalize,
|
2019-11-21 04:53:56 +00:00
|
|
|
|
gtk_property_expression_is_static,
|
2019-11-16 20:52:18 +00:00
|
|
|
|
gtk_property_expression_evaluate,
|
2019-11-21 04:53:56 +00:00
|
|
|
|
gtk_property_expression_watch_size,
|
|
|
|
|
gtk_property_expression_watch,
|
|
|
|
|
gtk_property_expression_unwatch
|
2019-11-16 20:52:18 +00:00
|
|
|
|
};
|
|
|
|
|
|
2020-06-01 20:07:53 +00:00
|
|
|
|
GTK_DEFINE_EXPRESSION_TYPE (GtkPropertyExpression,
|
|
|
|
|
gtk_property_expression,
|
|
|
|
|
>k_property_expression_info)
|
|
|
|
|
|
2019-11-16 20:52:18 +00:00
|
|
|
|
/**
|
|
|
|
|
* gtk_property_expression_new:
|
|
|
|
|
* @this_type: The type to expect for the this type
|
|
|
|
|
* @expression: (nullable) (transfer full): Expression to
|
|
|
|
|
* evaluate to get the object to query or %NULL to
|
|
|
|
|
* query the `this` object
|
|
|
|
|
* @property_name: name of the property
|
|
|
|
|
*
|
|
|
|
|
* Creates an expression that looks up a property via the
|
|
|
|
|
* given @expression or the `this` argument when @expression
|
|
|
|
|
* is %NULL.
|
|
|
|
|
*
|
|
|
|
|
* If the resulting object conforms to @this_type, its property
|
|
|
|
|
* named @property_name will be queried.
|
|
|
|
|
* Otherwise, this expression's evaluation will fail.
|
|
|
|
|
*
|
|
|
|
|
* The given @this_type must have a property with @property_name.
|
|
|
|
|
*
|
|
|
|
|
* Returns: a new #GtkExpression
|
|
|
|
|
**/
|
|
|
|
|
GtkExpression *
|
|
|
|
|
gtk_property_expression_new (GType this_type,
|
|
|
|
|
GtkExpression *expression,
|
|
|
|
|
const char *property_name)
|
|
|
|
|
{
|
|
|
|
|
GParamSpec *pspec;
|
|
|
|
|
|
2020-10-31 02:24:53 +00:00
|
|
|
|
if (g_type_fundamental (this_type) == G_TYPE_OBJECT)
|
2019-11-16 20:52:18 +00:00
|
|
|
|
{
|
2019-11-21 04:53:56 +00:00
|
|
|
|
GObjectClass *class = g_type_class_ref (this_type);
|
|
|
|
|
pspec = g_object_class_find_property (class, property_name);
|
|
|
|
|
g_type_class_unref (class);
|
2019-11-16 20:52:18 +00:00
|
|
|
|
}
|
2020-10-31 02:24:53 +00:00
|
|
|
|
else if (g_type_fundamental (this_type) == G_TYPE_INTERFACE)
|
2019-11-16 20:52:18 +00:00
|
|
|
|
{
|
2019-11-21 04:53:56 +00:00
|
|
|
|
GTypeInterface *iface = g_type_default_interface_ref (this_type);
|
|
|
|
|
pspec = g_object_interface_find_property (iface, property_name);
|
|
|
|
|
g_type_default_interface_unref (iface);
|
2019-11-16 20:52:18 +00:00
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
g_critical ("Type `%s` does not support properties", g_type_name (this_type));
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (pspec == NULL)
|
|
|
|
|
{
|
|
|
|
|
g_critical ("Type `%s` does not have a property named `%s`", g_type_name (this_type), property_name);
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return gtk_property_expression_new_for_pspec (expression, pspec);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* gtk_property_expression_new_for_pspec:
|
|
|
|
|
* @expression: (nullable) (transfer full): Expression to
|
|
|
|
|
* evaluate to get the object to query or %NULL to
|
|
|
|
|
* query the `this` object
|
|
|
|
|
* @pspec: the #GParamSpec for the property to query
|
|
|
|
|
*
|
|
|
|
|
* Creates an expression that looks up a property via the
|
|
|
|
|
* given @expression or the `this` argument when @expression
|
|
|
|
|
* is %NULL.
|
|
|
|
|
*
|
|
|
|
|
* If the resulting object conforms to @this_type, its
|
|
|
|
|
* property specified by @pspec will be queried.
|
|
|
|
|
* Otherwise, this expression's evaluation will fail.
|
|
|
|
|
*
|
|
|
|
|
* Returns: a new #GtkExpression
|
|
|
|
|
**/
|
|
|
|
|
GtkExpression *
|
|
|
|
|
gtk_property_expression_new_for_pspec (GtkExpression *expression,
|
|
|
|
|
GParamSpec *pspec)
|
|
|
|
|
{
|
2020-06-01 20:07:53 +00:00
|
|
|
|
GtkExpression *result;
|
|
|
|
|
GtkPropertyExpression *self;
|
2019-11-16 20:52:18 +00:00
|
|
|
|
|
2020-06-01 20:07:53 +00:00
|
|
|
|
result = gtk_expression_alloc (GTK_TYPE_PROPERTY_EXPRESSION, pspec->value_type);
|
|
|
|
|
self = (GtkPropertyExpression *) result;
|
2019-11-16 20:52:18 +00:00
|
|
|
|
|
2020-06-01 20:07:53 +00:00
|
|
|
|
self->pspec = pspec;
|
|
|
|
|
self->expr = expression;
|
2019-11-16 20:52:18 +00:00
|
|
|
|
|
2020-06-01 20:07:53 +00:00
|
|
|
|
return result;
|
2019-11-16 20:52:18 +00:00
|
|
|
|
}
|
|
|
|
|
|
2020-07-14 00:19:07 +00:00
|
|
|
|
/**
|
|
|
|
|
* gtk_property_expression_get_expression:
|
2020-07-18 10:29:29 +00:00
|
|
|
|
* @expression: (type GtkPropertyExpression): a property #GtkExpression
|
2020-07-14 00:19:07 +00:00
|
|
|
|
*
|
|
|
|
|
* Gets the expression specifying the object of
|
|
|
|
|
* a property expression.
|
|
|
|
|
*
|
|
|
|
|
* Returns: (transfer none): the object expression
|
|
|
|
|
*/
|
|
|
|
|
GtkExpression *
|
|
|
|
|
gtk_property_expression_get_expression (GtkExpression *expression)
|
|
|
|
|
{
|
|
|
|
|
GtkPropertyExpression *self = (GtkPropertyExpression *) expression;
|
|
|
|
|
|
|
|
|
|
g_return_val_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (expression, GTK_TYPE_PROPERTY_EXPRESSION), NULL);
|
|
|
|
|
|
|
|
|
|
return self->expr;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* gtk_property_expression_get_pspec:
|
2020-07-18 10:29:29 +00:00
|
|
|
|
* @expression: (type GtkPropertyExpression): a property #GtkExpression
|
2020-07-14 00:19:07 +00:00
|
|
|
|
*
|
|
|
|
|
* Gets the #GParamSpec specifying the property of
|
|
|
|
|
* a property expression.
|
|
|
|
|
*
|
|
|
|
|
* Returns: (transfer none): the #GParamSpec
|
|
|
|
|
*/
|
|
|
|
|
GParamSpec *
|
|
|
|
|
gtk_property_expression_get_pspec (GtkExpression *expression)
|
|
|
|
|
{
|
|
|
|
|
GtkPropertyExpression *self = (GtkPropertyExpression *) expression;
|
|
|
|
|
|
|
|
|
|
g_return_val_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (expression, GTK_TYPE_PROPERTY_EXPRESSION), NULL);
|
|
|
|
|
|
|
|
|
|
return self->pspec;
|
|
|
|
|
}
|
|
|
|
|
|
2020-06-01 20:07:53 +00:00
|
|
|
|
/* }}} */
|
|
|
|
|
|
|
|
|
|
/* {{{ GtkClosureExpression */
|
2019-11-16 20:52:18 +00:00
|
|
|
|
|
|
|
|
|
typedef struct _GtkClosureExpression GtkClosureExpression;
|
|
|
|
|
|
|
|
|
|
struct _GtkClosureExpression
|
|
|
|
|
{
|
|
|
|
|
GtkExpression parent;
|
|
|
|
|
|
|
|
|
|
GClosure *closure;
|
|
|
|
|
guint n_params;
|
|
|
|
|
GtkExpression **params;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
gtk_closure_expression_finalize (GtkExpression *expr)
|
|
|
|
|
{
|
|
|
|
|
GtkClosureExpression *self = (GtkClosureExpression *) expr;
|
|
|
|
|
guint i;
|
|
|
|
|
|
|
|
|
|
for (i = 0; i < self->n_params; i++)
|
|
|
|
|
{
|
|
|
|
|
gtk_expression_unref (self->params[i]);
|
|
|
|
|
}
|
|
|
|
|
g_free (self->params);
|
|
|
|
|
|
|
|
|
|
g_closure_unref (self->closure);
|
2020-06-01 20:07:53 +00:00
|
|
|
|
|
|
|
|
|
GTK_EXPRESSION_SUPER (expr)->finalize (expr);
|
2019-11-16 20:52:18 +00:00
|
|
|
|
}
|
|
|
|
|
|
2019-11-21 04:53:56 +00:00
|
|
|
|
static gboolean
|
|
|
|
|
gtk_closure_expression_is_static (GtkExpression *expr)
|
|
|
|
|
{
|
|
|
|
|
GtkClosureExpression *self = (GtkClosureExpression *) expr;
|
|
|
|
|
guint i;
|
|
|
|
|
|
|
|
|
|
for (i = 0; i < self->n_params; i++)
|
|
|
|
|
{
|
|
|
|
|
if (!gtk_expression_is_static (self->params[i]))
|
|
|
|
|
return FALSE;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return TRUE;
|
|
|
|
|
}
|
|
|
|
|
|
2019-11-16 20:52:18 +00:00
|
|
|
|
static gboolean
|
|
|
|
|
gtk_closure_expression_evaluate (GtkExpression *expr,
|
|
|
|
|
gpointer this,
|
|
|
|
|
GValue *value)
|
|
|
|
|
{
|
|
|
|
|
GtkClosureExpression *self = (GtkClosureExpression *) expr;
|
|
|
|
|
GValue *instance_and_params;
|
|
|
|
|
gboolean result = TRUE;
|
|
|
|
|
guint i;
|
|
|
|
|
|
|
|
|
|
instance_and_params = g_alloca (sizeof (GValue) * (self->n_params + 1));
|
|
|
|
|
memset (instance_and_params, 0, sizeof (GValue) * (self->n_params + 1));
|
|
|
|
|
|
|
|
|
|
for (i = 0; i < self->n_params; i++)
|
|
|
|
|
{
|
|
|
|
|
if (!gtk_expression_evaluate (self->params[i], this, &instance_and_params[i + 1]))
|
|
|
|
|
{
|
|
|
|
|
result = FALSE;
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
if (this)
|
|
|
|
|
g_value_init_from_instance (instance_and_params, this);
|
|
|
|
|
else
|
|
|
|
|
g_value_init (instance_and_params, G_TYPE_OBJECT);
|
|
|
|
|
|
|
|
|
|
g_value_init (value, expr->value_type);
|
|
|
|
|
g_closure_invoke (self->closure,
|
|
|
|
|
value,
|
|
|
|
|
self->n_params + 1,
|
|
|
|
|
instance_and_params,
|
|
|
|
|
NULL);
|
|
|
|
|
|
|
|
|
|
out:
|
|
|
|
|
for (i = 0; i < self->n_params + 1; i++)
|
|
|
|
|
g_value_unset (&instance_and_params[i]);
|
|
|
|
|
|
|
|
|
|
return result;
|
|
|
|
|
}
|
|
|
|
|
|
2019-11-21 04:53:56 +00:00
|
|
|
|
typedef struct _GtkClosureExpressionWatch GtkClosureExpressionWatch;
|
|
|
|
|
struct _GtkClosureExpressionWatch
|
|
|
|
|
{
|
|
|
|
|
GtkExpressionNotify notify;
|
|
|
|
|
gpointer user_data;
|
|
|
|
|
|
|
|
|
|
guchar sub[0];
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
gtk_closure_expression_watch_notify_cb (gpointer data)
|
|
|
|
|
{
|
|
|
|
|
GtkClosureExpressionWatch *cwatch = data;
|
|
|
|
|
|
|
|
|
|
cwatch->notify (cwatch->user_data);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static gsize
|
|
|
|
|
gtk_closure_expression_watch_size (GtkExpression *expr)
|
|
|
|
|
{
|
|
|
|
|
GtkClosureExpression *self = (GtkClosureExpression *) expr;
|
|
|
|
|
gsize size;
|
|
|
|
|
guint i;
|
|
|
|
|
|
|
|
|
|
size = sizeof (GtkClosureExpressionWatch);
|
|
|
|
|
|
|
|
|
|
for (i = 0; i < self->n_params; i++)
|
|
|
|
|
{
|
|
|
|
|
if (gtk_expression_is_static (self->params[i]))
|
|
|
|
|
continue;
|
|
|
|
|
|
|
|
|
|
size += gtk_expression_watch_size (self->params[i]);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return size;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
gtk_closure_expression_watch (GtkExpression *expr,
|
|
|
|
|
GtkExpressionSubWatch *watch,
|
|
|
|
|
gpointer this_,
|
|
|
|
|
GtkExpressionNotify notify,
|
|
|
|
|
gpointer user_data)
|
|
|
|
|
{
|
|
|
|
|
GtkClosureExpressionWatch *cwatch = (GtkClosureExpressionWatch *) watch;
|
|
|
|
|
GtkClosureExpression *self = (GtkClosureExpression *) expr;
|
|
|
|
|
guchar *sub;
|
|
|
|
|
guint i;
|
|
|
|
|
|
|
|
|
|
cwatch->notify = notify;
|
|
|
|
|
cwatch->user_data = user_data;
|
|
|
|
|
|
|
|
|
|
sub = cwatch->sub;
|
|
|
|
|
for (i = 0; i < self->n_params; i++)
|
|
|
|
|
{
|
|
|
|
|
if (gtk_expression_is_static (self->params[i]))
|
|
|
|
|
continue;
|
|
|
|
|
|
|
|
|
|
gtk_expression_subwatch_init (self->params[i],
|
|
|
|
|
(GtkExpressionSubWatch *) sub,
|
|
|
|
|
this_,
|
|
|
|
|
gtk_closure_expression_watch_notify_cb,
|
|
|
|
|
watch);
|
|
|
|
|
sub += gtk_expression_watch_size (self->params[i]);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
gtk_closure_expression_unwatch (GtkExpression *expr,
|
|
|
|
|
GtkExpressionSubWatch *watch)
|
|
|
|
|
{
|
|
|
|
|
GtkClosureExpressionWatch *cwatch = (GtkClosureExpressionWatch *) watch;
|
|
|
|
|
GtkClosureExpression *self = (GtkClosureExpression *) expr;
|
|
|
|
|
guchar *sub;
|
|
|
|
|
guint i;
|
|
|
|
|
|
|
|
|
|
sub = cwatch->sub;
|
|
|
|
|
for (i = 0; i < self->n_params; i++)
|
|
|
|
|
{
|
|
|
|
|
if (gtk_expression_is_static (self->params[i]))
|
|
|
|
|
continue;
|
|
|
|
|
|
|
|
|
|
gtk_expression_subwatch_finish (self->params[i],
|
|
|
|
|
(GtkExpressionSubWatch *) sub);
|
|
|
|
|
sub += gtk_expression_watch_size (self->params[i]);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2020-06-01 20:07:53 +00:00
|
|
|
|
static const GtkExpressionTypeInfo gtk_closure_expression_info =
|
2019-11-16 20:52:18 +00:00
|
|
|
|
{
|
|
|
|
|
sizeof (GtkClosureExpression),
|
2020-06-01 20:07:53 +00:00
|
|
|
|
NULL,
|
2019-11-16 20:52:18 +00:00
|
|
|
|
gtk_closure_expression_finalize,
|
2019-11-21 04:53:56 +00:00
|
|
|
|
gtk_closure_expression_is_static,
|
2019-11-16 20:52:18 +00:00
|
|
|
|
gtk_closure_expression_evaluate,
|
2019-11-21 04:53:56 +00:00
|
|
|
|
gtk_closure_expression_watch_size,
|
|
|
|
|
gtk_closure_expression_watch,
|
|
|
|
|
gtk_closure_expression_unwatch
|
2019-11-16 20:52:18 +00:00
|
|
|
|
};
|
|
|
|
|
|
2020-06-01 20:07:53 +00:00
|
|
|
|
GTK_DEFINE_EXPRESSION_TYPE (GtkClosureExpression,
|
|
|
|
|
gtk_closure_expression,
|
|
|
|
|
>k_closure_expression_info)
|
|
|
|
|
|
2019-11-16 20:52:18 +00:00
|
|
|
|
/**
|
|
|
|
|
* gtk_closure_expression_new:
|
2019-11-21 04:53:56 +00:00
|
|
|
|
* @value_type: the type of the value that this expression evaluates to
|
2019-11-16 20:52:18 +00:00
|
|
|
|
* @closure: closure to call when evaluating this expression. If closure is floating, it is adopted
|
|
|
|
|
* @n_params: the number of params needed for evaluating @closure
|
2020-09-14 16:00:23 +00:00
|
|
|
|
* @params: (nullable) (array length=n_params) (transfer full): expressions for each parameter
|
2019-11-16 20:52:18 +00:00
|
|
|
|
*
|
|
|
|
|
* Creates a GtkExpression that calls @closure when it is evaluated.
|
|
|
|
|
* @closure is called with the @this object and the results of evaluating
|
|
|
|
|
* the @params expressions.
|
|
|
|
|
*
|
|
|
|
|
* Returns: a new #GtkExpression
|
|
|
|
|
*/
|
|
|
|
|
GtkExpression *
|
|
|
|
|
gtk_closure_expression_new (GType value_type,
|
|
|
|
|
GClosure *closure,
|
|
|
|
|
guint n_params,
|
|
|
|
|
GtkExpression **params)
|
|
|
|
|
{
|
2020-06-01 20:07:53 +00:00
|
|
|
|
GtkExpression *result;
|
|
|
|
|
GtkClosureExpression *self;
|
2019-11-16 20:52:18 +00:00
|
|
|
|
guint i;
|
|
|
|
|
|
|
|
|
|
g_return_val_if_fail (closure != NULL, NULL);
|
|
|
|
|
g_return_val_if_fail (n_params == 0 || params != NULL, NULL);
|
|
|
|
|
|
2020-06-01 20:07:53 +00:00
|
|
|
|
result = gtk_expression_alloc (GTK_TYPE_CLOSURE_EXPRESSION, value_type);
|
|
|
|
|
self = (GtkClosureExpression *) result;
|
2019-11-16 20:52:18 +00:00
|
|
|
|
|
2020-06-01 20:07:53 +00:00
|
|
|
|
self->closure = g_closure_ref (closure);
|
2019-11-16 20:52:18 +00:00
|
|
|
|
g_closure_sink (closure);
|
|
|
|
|
if (G_CLOSURE_NEEDS_MARSHAL (closure))
|
|
|
|
|
g_closure_set_marshal (closure, g_cclosure_marshal_generic);
|
|
|
|
|
|
2020-06-01 20:07:53 +00:00
|
|
|
|
self->n_params = n_params;
|
|
|
|
|
self->params = g_new (GtkExpression *, n_params);
|
2019-11-16 20:52:18 +00:00
|
|
|
|
for (i = 0; i < n_params; i++)
|
2020-06-01 20:07:53 +00:00
|
|
|
|
self->params[i] = params[i];
|
2019-11-16 20:52:18 +00:00
|
|
|
|
|
2020-06-01 20:07:53 +00:00
|
|
|
|
return result;
|
2019-11-16 20:52:18 +00:00
|
|
|
|
}
|
|
|
|
|
|
2020-06-01 20:07:53 +00:00
|
|
|
|
/* }}} */
|
|
|
|
|
|
|
|
|
|
/* {{{ GtkCClosureExpression */
|
|
|
|
|
|
|
|
|
|
typedef struct _GtkCClosureExpression GtkCClosureExpression;
|
|
|
|
|
|
|
|
|
|
struct _GtkCClosureExpression
|
|
|
|
|
{
|
|
|
|
|
GtkClosureExpression parent;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
static const GtkExpressionTypeInfo gtk_cclosure_expression_info =
|
|
|
|
|
{
|
|
|
|
|
sizeof (GtkClosureExpression),
|
|
|
|
|
NULL,
|
|
|
|
|
gtk_closure_expression_finalize,
|
|
|
|
|
gtk_closure_expression_is_static,
|
|
|
|
|
gtk_closure_expression_evaluate,
|
|
|
|
|
gtk_closure_expression_watch_size,
|
|
|
|
|
gtk_closure_expression_watch,
|
|
|
|
|
gtk_closure_expression_unwatch
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
GTK_DEFINE_EXPRESSION_TYPE (GtkCClosureExpression,
|
|
|
|
|
gtk_cclosure_expression,
|
|
|
|
|
>k_cclosure_expression_info)
|
|
|
|
|
|
2019-11-16 20:52:18 +00:00
|
|
|
|
/**
|
|
|
|
|
* gtk_cclosure_expression_new:
|
2019-11-21 04:53:56 +00:00
|
|
|
|
* @value_type: the type of the value that this expression evaluates to
|
2020-06-30 11:11:21 +00:00
|
|
|
|
* @marshal: (scope call) (nullable): marshaller used for creating a closure
|
2019-11-16 20:52:18 +00:00
|
|
|
|
* @n_params: the number of params needed for evaluating @closure
|
|
|
|
|
* @params: (array length=n_params) (transfer full): expressions for each parameter
|
2020-05-31 14:10:27 +00:00
|
|
|
|
* @callback_func: (scope notified) (closure user_data) (destroy user_destroy): callback used for creating a closure
|
2020-06-30 11:11:21 +00:00
|
|
|
|
* @user_data: (nullable): user data used for creating a closure
|
|
|
|
|
* @user_destroy: (nullable): destroy notify for @user_data
|
2019-11-16 20:52:18 +00:00
|
|
|
|
*
|
|
|
|
|
* This function is a variant of gtk_closure_expression_new() that
|
2020-08-05 01:17:49 +00:00
|
|
|
|
* creates a #GClosure by calling g_cclosure_new() with the given
|
2019-11-16 20:52:18 +00:00
|
|
|
|
* @callback_func, @user_data and @user_destroy.
|
|
|
|
|
*
|
|
|
|
|
* Returns: a new #GtkExpression
|
|
|
|
|
*/
|
|
|
|
|
GtkExpression *
|
|
|
|
|
gtk_cclosure_expression_new (GType value_type,
|
|
|
|
|
GClosureMarshal marshal,
|
|
|
|
|
guint n_params,
|
|
|
|
|
GtkExpression **params,
|
|
|
|
|
GCallback callback_func,
|
|
|
|
|
gpointer user_data,
|
|
|
|
|
GClosureNotify user_destroy)
|
|
|
|
|
{
|
2020-06-01 20:07:53 +00:00
|
|
|
|
GtkExpression *result;
|
|
|
|
|
GtkClosureExpression *self;
|
2019-11-16 20:52:18 +00:00
|
|
|
|
GClosure *closure;
|
2020-06-01 20:07:53 +00:00
|
|
|
|
guint i;
|
|
|
|
|
|
|
|
|
|
g_return_val_if_fail (callback_func != NULL, NULL);
|
|
|
|
|
g_return_val_if_fail (n_params == 0 || params != NULL, NULL);
|
|
|
|
|
|
|
|
|
|
result = gtk_expression_alloc (GTK_TYPE_CCLOSURE_EXPRESSION, value_type);
|
|
|
|
|
self = (GtkClosureExpression *) result;
|
2019-11-16 20:52:18 +00:00
|
|
|
|
|
|
|
|
|
closure = g_cclosure_new (callback_func, user_data, user_destroy);
|
|
|
|
|
if (marshal)
|
|
|
|
|
g_closure_set_marshal (closure, marshal);
|
|
|
|
|
|
2020-06-01 20:07:53 +00:00
|
|
|
|
self->closure = g_closure_ref (closure);
|
|
|
|
|
g_closure_sink (closure);
|
|
|
|
|
if (G_CLOSURE_NEEDS_MARSHAL (closure))
|
|
|
|
|
g_closure_set_marshal (closure, g_cclosure_marshal_generic);
|
2019-11-16 20:52:18 +00:00
|
|
|
|
|
2020-06-01 20:07:53 +00:00
|
|
|
|
self->n_params = n_params;
|
|
|
|
|
self->params = g_new (GtkExpression *, n_params);
|
|
|
|
|
for (i = 0; i < n_params; i++)
|
|
|
|
|
self->params[i] = params[i];
|
2019-11-16 20:52:18 +00:00
|
|
|
|
|
2020-06-01 20:07:53 +00:00
|
|
|
|
return result;
|
2019-11-16 20:52:18 +00:00
|
|
|
|
}
|
|
|
|
|
|
2020-06-01 20:07:53 +00:00
|
|
|
|
/* }}} */
|
|
|
|
|
|
|
|
|
|
/* {{{ GtkExpression public API */
|
|
|
|
|
|
2019-11-16 20:52:18 +00:00
|
|
|
|
/**
|
|
|
|
|
* gtk_expression_ref:
|
|
|
|
|
* @self: (allow-none): a #GtkExpression
|
|
|
|
|
*
|
|
|
|
|
* Acquires a reference on the given #GtkExpression.
|
|
|
|
|
*
|
|
|
|
|
* Returns: (transfer none): the #GtkExpression with an additional reference
|
|
|
|
|
*/
|
|
|
|
|
GtkExpression *
|
|
|
|
|
gtk_expression_ref (GtkExpression *self)
|
|
|
|
|
{
|
2020-06-01 20:07:53 +00:00
|
|
|
|
g_return_val_if_fail (GTK_IS_EXPRESSION (self), NULL);
|
|
|
|
|
|
|
|
|
|
g_atomic_ref_count_inc (&self->ref_count);
|
|
|
|
|
|
|
|
|
|
return self;
|
2019-11-16 20:52:18 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* gtk_expression_unref:
|
|
|
|
|
* @self: (allow-none): a #GtkExpression
|
|
|
|
|
*
|
|
|
|
|
* Releases a reference on the given #GtkExpression.
|
|
|
|
|
*
|
|
|
|
|
* If the reference was the last, the resources associated to the @self are
|
|
|
|
|
* freed.
|
|
|
|
|
*/
|
|
|
|
|
void
|
|
|
|
|
gtk_expression_unref (GtkExpression *self)
|
|
|
|
|
{
|
2020-06-01 20:07:53 +00:00
|
|
|
|
g_return_if_fail (GTK_IS_EXPRESSION (self));
|
|
|
|
|
|
|
|
|
|
if (g_atomic_ref_count_dec (&self->ref_count))
|
|
|
|
|
GTK_EXPRESSION_GET_CLASS (self)->finalize (self);
|
2019-11-16 20:52:18 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* gtk_expression_get_value_type:
|
|
|
|
|
* @self: a #GtkExpression
|
|
|
|
|
*
|
|
|
|
|
* Gets the #GType that this expression evaluates to. This type
|
|
|
|
|
* is constant and will not change over the lifetime of this expression.
|
|
|
|
|
*
|
|
|
|
|
* Returns: The type returned from gtk_expression_evaluate()
|
|
|
|
|
**/
|
|
|
|
|
GType
|
|
|
|
|
gtk_expression_get_value_type (GtkExpression *self)
|
|
|
|
|
{
|
|
|
|
|
g_return_val_if_fail (GTK_IS_EXPRESSION (self), G_TYPE_INVALID);
|
|
|
|
|
|
|
|
|
|
return self->value_type;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* gtk_expression_evaluate:
|
|
|
|
|
* @self: a #GtkExpression
|
|
|
|
|
* @this_: (transfer none) (type GObject) (nullable): the this argument for the evaluation
|
|
|
|
|
* @value: an empty #GValue
|
|
|
|
|
*
|
|
|
|
|
* Evaluates the given expression and on success stores the result
|
|
|
|
|
* in @value. The #GType of @value will be the type given by
|
|
|
|
|
* gtk_expression_get_value_type().
|
|
|
|
|
*
|
|
|
|
|
* It is possible that expressions cannot be evaluated - for example
|
|
|
|
|
* when the expression references objects that have been destroyed or
|
|
|
|
|
* set to %NULL. In that case @value will remain empty and %FALSE
|
|
|
|
|
* will be returned.
|
|
|
|
|
*
|
|
|
|
|
* Returns: %TRUE if the expression could be evaluated
|
|
|
|
|
**/
|
|
|
|
|
gboolean
|
|
|
|
|
gtk_expression_evaluate (GtkExpression *self,
|
|
|
|
|
gpointer this_,
|
|
|
|
|
GValue *value)
|
|
|
|
|
{
|
|
|
|
|
g_return_val_if_fail (GTK_IS_EXPRESSION (self), FALSE);
|
|
|
|
|
g_return_val_if_fail (this_ == NULL || G_IS_OBJECT (this_), FALSE);
|
|
|
|
|
g_return_val_if_fail (value != NULL, FALSE);
|
|
|
|
|
|
2020-06-01 20:07:53 +00:00
|
|
|
|
return GTK_EXPRESSION_GET_CLASS (self)->evaluate (self, this_, value);
|
2019-11-16 20:52:18 +00:00
|
|
|
|
}
|
|
|
|
|
|
2019-11-21 04:53:56 +00:00
|
|
|
|
/**
|
|
|
|
|
* gtk_expression_is_static:
|
|
|
|
|
* @self: a #GtkExpression
|
|
|
|
|
*
|
|
|
|
|
* Checks if the expression is static.
|
|
|
|
|
*
|
|
|
|
|
* A static expression will never change its result when
|
|
|
|
|
* gtk_expression_evaluate() is called on it with the same arguments.
|
|
|
|
|
*
|
|
|
|
|
* That means a call to gtk_expression_watch() is not necessary because
|
|
|
|
|
* it will never trigger a notify.
|
|
|
|
|
*
|
|
|
|
|
* Returns: %TRUE if the expression is static
|
|
|
|
|
**/
|
|
|
|
|
gboolean
|
|
|
|
|
gtk_expression_is_static (GtkExpression *self)
|
|
|
|
|
{
|
2020-06-01 20:07:53 +00:00
|
|
|
|
g_return_val_if_fail (GTK_IS_EXPRESSION (self), FALSE);
|
|
|
|
|
|
|
|
|
|
return GTK_EXPRESSION_GET_CLASS (self)->is_static (self);
|
2019-11-21 04:53:56 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static gboolean
|
|
|
|
|
gtk_expression_watch_is_watching (GtkExpressionWatch *watch)
|
|
|
|
|
{
|
|
|
|
|
return watch->expression != NULL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
gtk_expression_watch_this_cb (gpointer data,
|
|
|
|
|
GObject *this)
|
|
|
|
|
{
|
|
|
|
|
GtkExpressionWatch *watch = data;
|
|
|
|
|
|
|
|
|
|
watch->this = NULL;
|
|
|
|
|
|
|
|
|
|
watch->notify (watch->user_data);
|
|
|
|
|
gtk_expression_watch_unwatch (watch);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
gtk_expression_watch_cb (gpointer data)
|
|
|
|
|
{
|
|
|
|
|
GtkExpressionWatch *watch = data;
|
|
|
|
|
|
|
|
|
|
if (!gtk_expression_watch_is_watching (watch))
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
watch->notify (watch->user_data);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* gtk_expression_watch:
|
|
|
|
|
* @self: a #GtkExpression
|
2020-06-01 20:07:53 +00:00
|
|
|
|
* @this_: (transfer none) (type GObject) (nullable): the `this` argument to
|
2019-11-21 04:53:56 +00:00
|
|
|
|
* watch
|
|
|
|
|
* @notify: (closure user_data): callback to invoke when the
|
|
|
|
|
* expression changes
|
|
|
|
|
* @user_data: user data to pass to @notify callback
|
|
|
|
|
* @user_destroy: destroy notify for @user_data
|
|
|
|
|
*
|
|
|
|
|
* Installs a watch for the given @expression that calls the @notify function
|
|
|
|
|
* whenever the evaluation of @self may have changed.
|
|
|
|
|
*
|
|
|
|
|
* GTK cannot guarantee that the evaluation did indeed change when the @notify
|
|
|
|
|
* gets invoked, but it guarantees the opposite: When it did in fact change,
|
|
|
|
|
* the @notify will be invoked.
|
|
|
|
|
*
|
|
|
|
|
* Returns: (transfer none): The newly installed watch. Note that the only
|
|
|
|
|
* reference held to the watch will be released when the watch is unwatched
|
|
|
|
|
* which can happen automatically, and not just via
|
|
|
|
|
* gtk_expression_watch_unwatch(). You should call gtk_expression_watch_ref()
|
|
|
|
|
* if you want to keep the watch around.
|
|
|
|
|
**/
|
|
|
|
|
GtkExpressionWatch *
|
|
|
|
|
gtk_expression_watch (GtkExpression *self,
|
|
|
|
|
gpointer this_,
|
|
|
|
|
GtkExpressionNotify notify,
|
|
|
|
|
gpointer user_data,
|
|
|
|
|
GDestroyNotify user_destroy)
|
|
|
|
|
{
|
|
|
|
|
GtkExpressionWatch *watch;
|
|
|
|
|
|
|
|
|
|
g_return_val_if_fail (self != NULL, NULL);
|
|
|
|
|
g_return_val_if_fail (this_ == NULL || G_IS_OBJECT (this_), NULL);
|
|
|
|
|
g_return_val_if_fail (notify != NULL, NULL);
|
|
|
|
|
|
|
|
|
|
watch = g_atomic_rc_box_alloc0 (sizeof (GtkExpressionWatch) + gtk_expression_watch_size (self));
|
|
|
|
|
|
|
|
|
|
watch->expression = gtk_expression_ref (self);
|
|
|
|
|
watch->this = this_;
|
|
|
|
|
if (this_)
|
|
|
|
|
g_object_weak_ref (this_, gtk_expression_watch_this_cb, watch);
|
|
|
|
|
watch->notify = notify;
|
|
|
|
|
watch->user_data = user_data;
|
|
|
|
|
watch->user_destroy = user_destroy;
|
|
|
|
|
|
|
|
|
|
gtk_expression_subwatch_init (self,
|
|
|
|
|
(GtkExpressionSubWatch *) watch->sub,
|
|
|
|
|
this_,
|
|
|
|
|
gtk_expression_watch_cb,
|
|
|
|
|
watch);
|
|
|
|
|
|
|
|
|
|
return watch;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* gtk_expression_watch_ref:
|
|
|
|
|
* @watch: (allow-none): a #GtkExpressionWatch
|
|
|
|
|
*
|
|
|
|
|
* Acquires a reference on the given #GtkExpressionWatch.
|
|
|
|
|
*
|
|
|
|
|
* Returns: (transfer none): the #GtkExpression with an additional reference
|
|
|
|
|
*/
|
|
|
|
|
GtkExpressionWatch *
|
|
|
|
|
gtk_expression_watch_ref (GtkExpressionWatch *watch)
|
|
|
|
|
{
|
|
|
|
|
return g_atomic_rc_box_acquire (watch);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
gtk_expression_watch_finalize (gpointer data)
|
|
|
|
|
{
|
|
|
|
|
GtkExpressionWatch *watch = data;
|
|
|
|
|
|
|
|
|
|
g_assert (!gtk_expression_watch_is_watching (watch));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* gtk_expression_watch_unref:
|
|
|
|
|
* @watch: (allow-none): a #GtkExpressionWatch
|
|
|
|
|
*
|
|
|
|
|
* Releases a reference on the given #GtkExpressionWatch.
|
|
|
|
|
*
|
|
|
|
|
* If the reference was the last, the resources associated to @self are
|
|
|
|
|
* freed.
|
|
|
|
|
*/
|
|
|
|
|
void
|
|
|
|
|
gtk_expression_watch_unref (GtkExpressionWatch *watch)
|
|
|
|
|
{
|
|
|
|
|
g_atomic_rc_box_release_full (watch, gtk_expression_watch_finalize);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* gtk_expression_watch_unwatch:
|
|
|
|
|
* @watch: (transfer none): watch to release
|
|
|
|
|
*
|
|
|
|
|
* Stops watching an expression that was established via gtk_expression_watch().
|
|
|
|
|
**/
|
|
|
|
|
void
|
|
|
|
|
gtk_expression_watch_unwatch (GtkExpressionWatch *watch)
|
|
|
|
|
{
|
|
|
|
|
if (!gtk_expression_watch_is_watching (watch))
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
gtk_expression_subwatch_finish (watch->expression, (GtkExpressionSubWatch *) watch->sub);
|
|
|
|
|
|
|
|
|
|
if (watch->this)
|
|
|
|
|
g_object_weak_unref (watch->this, gtk_expression_watch_this_cb, watch);
|
|
|
|
|
|
|
|
|
|
if (watch->user_destroy)
|
|
|
|
|
watch->user_destroy (watch->user_data);
|
|
|
|
|
|
|
|
|
|
g_clear_pointer (&watch->expression, gtk_expression_unref);
|
|
|
|
|
|
|
|
|
|
gtk_expression_watch_unref (watch);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* gtk_expression_watch_evaluate:
|
|
|
|
|
* @watch: a #GtkExpressionWatch
|
|
|
|
|
* @value: an empty #GValue to be set
|
|
|
|
|
*
|
|
|
|
|
* Evaluates the watched expression and on success stores the result
|
|
|
|
|
* in @value.
|
|
|
|
|
*
|
|
|
|
|
* This is equivalent to calling gtk_expression_evaluate() with the
|
|
|
|
|
* expression and this pointer originally used to create @watch.
|
|
|
|
|
*
|
|
|
|
|
* Returns: %TRUE if the expression could be evaluated and @value was set
|
|
|
|
|
**/
|
|
|
|
|
gboolean
|
|
|
|
|
gtk_expression_watch_evaluate (GtkExpressionWatch *watch,
|
|
|
|
|
GValue *value)
|
|
|
|
|
{
|
|
|
|
|
g_return_val_if_fail (watch != NULL, FALSE);
|
|
|
|
|
|
|
|
|
|
if (!gtk_expression_watch_is_watching (watch))
|
|
|
|
|
return FALSE;
|
|
|
|
|
|
|
|
|
|
return gtk_expression_evaluate (watch->expression, watch->this, value);
|
|
|
|
|
}
|
|
|
|
|
|
2019-11-24 07:05:41 +00:00
|
|
|
|
typedef struct {
|
|
|
|
|
GtkExpressionWatch *watch;
|
2019-11-28 01:32:12 +00:00
|
|
|
|
GObject *target;
|
2019-11-24 07:05:41 +00:00
|
|
|
|
GParamSpec *pspec;
|
|
|
|
|
} GtkExpressionBind;
|
|
|
|
|
|
2019-11-26 02:57:40 +00:00
|
|
|
|
static void
|
|
|
|
|
invalidate_binds (gpointer unused,
|
|
|
|
|
GObject *object)
|
|
|
|
|
{
|
|
|
|
|
GSList *l, *binds;
|
|
|
|
|
|
|
|
|
|
binds = g_object_get_data (object, "gtk-expression-binds");
|
|
|
|
|
for (l = binds; l; l = l->next)
|
|
|
|
|
{
|
|
|
|
|
GtkExpressionBind *bind = l->data;
|
|
|
|
|
|
2019-11-28 01:32:12 +00:00
|
|
|
|
/* This guarantees we neither try to update bindings
|
|
|
|
|
* (which would wreck havoc because the object is
|
|
|
|
|
* dispose()ing itself) nor try to destroy bindings
|
|
|
|
|
* anymore, so destruction can be done in free_binds().
|
|
|
|
|
*/
|
|
|
|
|
bind->target = NULL;
|
2019-11-26 02:57:40 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2019-11-24 07:05:41 +00:00
|
|
|
|
static void
|
|
|
|
|
free_binds (gpointer data)
|
|
|
|
|
{
|
|
|
|
|
GSList *l;
|
|
|
|
|
|
|
|
|
|
for (l = data; l; l = l->next)
|
|
|
|
|
{
|
|
|
|
|
GtkExpressionBind *bind = l->data;
|
|
|
|
|
|
2019-11-28 01:32:12 +00:00
|
|
|
|
g_assert (bind->target == NULL);
|
|
|
|
|
if (bind->watch)
|
|
|
|
|
gtk_expression_watch_unwatch (bind->watch);
|
|
|
|
|
g_slice_free (GtkExpressionBind, bind);
|
2019-11-24 07:05:41 +00:00
|
|
|
|
}
|
|
|
|
|
g_slist_free (data);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
gtk_expression_bind_free (gpointer data)
|
|
|
|
|
{
|
|
|
|
|
GtkExpressionBind *bind = data;
|
|
|
|
|
|
2019-11-28 01:32:12 +00:00
|
|
|
|
if (bind->target)
|
2019-11-24 07:05:41 +00:00
|
|
|
|
{
|
|
|
|
|
GSList *binds;
|
2019-11-28 01:32:12 +00:00
|
|
|
|
binds = g_object_steal_data (bind->target, "gtk-expression-binds");
|
2019-11-24 07:05:41 +00:00
|
|
|
|
binds = g_slist_remove (binds, bind);
|
|
|
|
|
if (binds)
|
2019-11-28 01:32:12 +00:00
|
|
|
|
g_object_set_data_full (bind->target, "gtk-expression-binds", binds, free_binds);
|
2019-11-26 02:57:40 +00:00
|
|
|
|
else
|
2019-11-28 01:32:12 +00:00
|
|
|
|
g_object_weak_unref (bind->target, invalidate_binds, NULL);
|
2019-11-24 07:05:41 +00:00
|
|
|
|
|
2019-11-28 01:32:12 +00:00
|
|
|
|
g_slice_free (GtkExpressionBind, bind);
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
/* If a bind gets unwatched after invalidate_binds() but
|
|
|
|
|
* before free_binds(), we end up here. This can happen if
|
|
|
|
|
* the bind was watching itself or if the target's dispose()
|
|
|
|
|
* function freed the object that was watched.
|
|
|
|
|
* We make sure we don't destroy the binding or free_binds() will do
|
|
|
|
|
* bad stuff, but we clear the watch, so free_binds() won't try to
|
|
|
|
|
* unwatch() it.
|
|
|
|
|
*/
|
|
|
|
|
bind->watch = NULL;
|
|
|
|
|
}
|
2019-11-24 07:05:41 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
gtk_expression_bind_notify (gpointer data)
|
|
|
|
|
{
|
|
|
|
|
GValue value = G_VALUE_INIT;
|
|
|
|
|
GtkExpressionBind *bind = data;
|
|
|
|
|
|
2019-11-28 01:32:12 +00:00
|
|
|
|
if (bind->target == NULL)
|
2019-11-26 02:57:40 +00:00
|
|
|
|
return;
|
|
|
|
|
|
2019-11-28 01:32:12 +00:00
|
|
|
|
if (!gtk_expression_watch_evaluate (bind->watch, &value))
|
2019-11-24 07:05:41 +00:00
|
|
|
|
return;
|
|
|
|
|
|
2019-11-28 01:32:12 +00:00
|
|
|
|
g_object_set_property (bind->target, bind->pspec->name, &value);
|
2019-11-24 07:05:41 +00:00
|
|
|
|
g_value_unset (&value);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* gtk_expression_bind:
|
|
|
|
|
* @self: (transfer full): a #GtkExpression
|
2019-11-28 01:32:12 +00:00
|
|
|
|
* @target: (transfer none) (type GObject): the target object to bind to
|
|
|
|
|
* @property: name of the property on @target to bind to
|
2020-06-28 12:39:17 +00:00
|
|
|
|
* @this_: (transfer none) (type GObject) (nullable): the this argument for
|
2019-11-28 01:32:12 +00:00
|
|
|
|
* the evaluation of @self
|
2019-11-24 07:05:41 +00:00
|
|
|
|
*
|
2019-11-28 01:32:12 +00:00
|
|
|
|
* Bind @target's property named @property to @self.
|
2019-11-24 07:05:41 +00:00
|
|
|
|
*
|
|
|
|
|
* The value that @self evaluates to is set via g_object_set() on
|
2019-11-28 01:32:12 +00:00
|
|
|
|
* @target. This is repeated whenever @self changes to ensure that
|
2019-11-24 07:05:41 +00:00
|
|
|
|
* the object's property stays synchronized with @self.
|
|
|
|
|
*
|
2019-11-28 01:32:12 +00:00
|
|
|
|
* If @self's evaluation fails, @target's @property is not updated.
|
2019-11-24 07:05:41 +00:00
|
|
|
|
* You can ensure that this doesn't happen by using a fallback
|
|
|
|
|
* expression.
|
|
|
|
|
*
|
|
|
|
|
* Note that this function takes ownership of @self. If you want
|
|
|
|
|
* to keep it around, you should gtk_expression_ref() it beforehand.
|
|
|
|
|
*
|
|
|
|
|
* Returns: (transfer none): a #GtkExpressionWatch
|
|
|
|
|
**/
|
|
|
|
|
GtkExpressionWatch *
|
|
|
|
|
gtk_expression_bind (GtkExpression *self,
|
2019-11-28 01:32:12 +00:00
|
|
|
|
gpointer target,
|
|
|
|
|
const char *property,
|
|
|
|
|
gpointer this_)
|
2019-11-24 07:05:41 +00:00
|
|
|
|
{
|
|
|
|
|
GtkExpressionBind *bind;
|
|
|
|
|
GParamSpec *pspec;
|
|
|
|
|
GSList *binds;
|
|
|
|
|
|
|
|
|
|
g_return_val_if_fail (GTK_IS_EXPRESSION (self), NULL);
|
2019-11-28 01:32:12 +00:00
|
|
|
|
g_return_val_if_fail (G_IS_OBJECT (target), NULL);
|
2019-11-24 07:05:41 +00:00
|
|
|
|
g_return_val_if_fail (property != NULL, NULL);
|
2020-06-28 12:40:11 +00:00
|
|
|
|
g_return_val_if_fail (this_ == NULL || G_IS_OBJECT (this_), NULL);
|
|
|
|
|
|
2019-11-28 01:32:12 +00:00
|
|
|
|
pspec = g_object_class_find_property (G_OBJECT_GET_CLASS (target), property);
|
2019-11-24 07:05:41 +00:00
|
|
|
|
if (G_UNLIKELY (pspec == NULL))
|
|
|
|
|
{
|
|
|
|
|
g_critical ("%s: Class '%s' has no property named '%s'",
|
2019-11-28 01:32:12 +00:00
|
|
|
|
G_STRFUNC, G_OBJECT_TYPE_NAME (target), property);
|
2019-11-24 07:05:41 +00:00
|
|
|
|
return NULL;
|
|
|
|
|
}
|
|
|
|
|
if (G_UNLIKELY ((pspec->flags & (G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY)) != G_PARAM_WRITABLE))
|
|
|
|
|
{
|
|
|
|
|
g_critical ("%s: property '%s' of class '%s' is not writable",
|
2019-11-28 01:32:12 +00:00
|
|
|
|
G_STRFUNC, pspec->name, G_OBJECT_TYPE_NAME (target));
|
2019-11-24 07:05:41 +00:00
|
|
|
|
return NULL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
bind = g_slice_new0 (GtkExpressionBind);
|
2019-11-28 01:32:12 +00:00
|
|
|
|
binds = g_object_steal_data (target, "gtk-expression-binds");
|
2019-11-26 02:57:40 +00:00
|
|
|
|
if (binds == NULL)
|
2019-11-28 01:32:12 +00:00
|
|
|
|
g_object_weak_ref (target, invalidate_binds, NULL);
|
|
|
|
|
bind->target = target;
|
2019-11-24 07:05:41 +00:00
|
|
|
|
bind->pspec = pspec;
|
|
|
|
|
bind->watch = gtk_expression_watch (self,
|
2019-11-28 01:32:12 +00:00
|
|
|
|
this_,
|
2019-11-24 07:05:41 +00:00
|
|
|
|
gtk_expression_bind_notify,
|
|
|
|
|
bind,
|
|
|
|
|
gtk_expression_bind_free);
|
|
|
|
|
binds = g_slist_prepend (binds, bind);
|
2019-11-28 01:32:12 +00:00
|
|
|
|
g_object_set_data_full (target, "gtk-expression-binds", binds, free_binds);
|
2019-11-24 07:05:41 +00:00
|
|
|
|
|
|
|
|
|
gtk_expression_unref (self);
|
|
|
|
|
|
|
|
|
|
gtk_expression_bind_notify (bind);
|
|
|
|
|
|
|
|
|
|
return bind->watch;
|
|
|
|
|
}
|
2020-06-01 20:07:53 +00:00
|
|
|
|
|
|
|
|
|
/* }}} */
|