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
|
|
|
|
#include "gtkprivate.h"
|
|
|
|
|
|
2019-11-16 20:52:18 +00:00
|
|
|
|
#include <gobject/gvaluecollector.h>
|
|
|
|
|
|
|
|
|
|
/**
|
2021-02-28 18:08:39 +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)
|
2019-11-16 20:52:18 +00:00
|
|
|
|
*
|
2021-02-28 18:08:39 +00:00
|
|
|
|
* `GtkExpression` provides a way to describe references to values.
|
2020-06-29 22:17:00 +00:00
|
|
|
|
*
|
|
|
|
|
* An important aspect of expressions is that the value can be obtained
|
|
|
|
|
* from a source that is several steps away. For example, an expression
|
2021-02-22 17:35:39 +00:00
|
|
|
|
* 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`
|
2020-06-29 22:17:00 +00:00
|
|
|
|
* 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
|
2021-02-22 17:35:39 +00:00
|
|
|
|
* [method@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
|
2021-02-22 17:35:39 +00:00
|
|
|
|
* [ctor@Gtk.ConstantExpression.new] to looking up properties in a `GObject`
|
|
|
|
|
* (even recursively) via [ctor@Gtk.PropertyExpression.new] or providing
|
|
|
|
|
* custom functions to transform and combine expressions via
|
|
|
|
|
* [ctor@Gtk.ClosureExpression.new].
|
2020-06-29 22:17:00 +00:00
|
|
|
|
*
|
|
|
|
|
* Here is an example of a complex expression:
|
2021-02-22 17:35:39 +00:00
|
|
|
|
*
|
|
|
|
|
* ```c
|
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");
|
2021-02-22 17:35:39 +00:00
|
|
|
|
* ```
|
2020-07-16 23:45:21 +00:00
|
|
|
|
*
|
2021-02-22 17:35:39 +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`).
|
2020-06-29 22:17:00 +00:00
|
|
|
|
*
|
|
|
|
|
* A more concise way to describe this would be
|
2021-02-22 17:35:39 +00:00
|
|
|
|
*
|
|
|
|
|
* ```
|
2020-07-16 23:45:21 +00:00
|
|
|
|
* this->item->name
|
2021-02-22 17:35:39 +00:00
|
|
|
|
* ```
|
2020-06-29 22:17:00 +00:00
|
|
|
|
*
|
|
|
|
|
* The most likely place where you will encounter expressions is in the context
|
2021-02-22 17:35:39 +00:00
|
|
|
|
* of list models and list widgets using them. For example, `GtkDropDown` is
|
|
|
|
|
* evaluating a `GtkExpression` to obtain strings from the items in its model
|
2020-06-29 22:17:00 +00:00
|
|
|
|
* that it can then use to match against the contents of its search entry.
|
2021-02-22 17:35:39 +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
|
2021-02-22 17:35:39 +00:00
|
|
|
|
* changes, an expression needs to be "watched" via a [struct@Gtk.ExpressionWatch],
|
|
|
|
|
* which will cause a callback to be called whenever the value of the expression may
|
|
|
|
|
* have changed; [method@Gtk.Expression.watch] starts watching an expression, and
|
|
|
|
|
* [method@Gtk.ExpressionWatch.unwatch] stops.
|
2019-11-16 20:52:18 +00:00
|
|
|
|
*
|
2020-08-21 12:41:13 +00:00
|
|
|
|
* Watches can be created for automatically updating the property of an object,
|
2021-02-22 17:35:39 +00:00
|
|
|
|
* similar to GObject's `GBinding` mechanism, by using [method@Gtk.Expression.bind].
|
2019-11-18 03:35:36 +00:00
|
|
|
|
*
|
2021-02-22 17:35:39 +00:00
|
|
|
|
* ## GtkExpression in GObject properties
|
2020-06-01 20:17:34 +00:00
|
|
|
|
*
|
2021-02-22 17:35:39 +00:00
|
|
|
|
* In order to use a `GtkExpression` as a `GObject` property, you must use the
|
|
|
|
|
* [id@gtk_param_spec_expression] when creating a `GParamSpec` to install in the
|
|
|
|
|
* `GObject` class being defined; for instance:
|
2020-06-01 20:17:34 +00:00
|
|
|
|
*
|
2021-02-22 17:35:39 +00:00
|
|
|
|
* ```c
|
2021-02-28 18:08:39 +00:00
|
|
|
|
* 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);
|
2021-02-22 17:35:39 +00:00
|
|
|
|
* ```
|
2020-06-01 20:17:34 +00:00
|
|
|
|
*
|
2021-02-22 17:35:39 +00:00
|
|
|
|
* When implementing the `GObjectClass.set_property` and `GObjectClass.get_property`
|
|
|
|
|
* virtual functions, you must use [id@gtk_value_get_expression], to retrieve the
|
|
|
|
|
* stored `GtkExpression` from the `GValue` container, and [id@gtk_value_set_expression],
|
|
|
|
|
* to store the `GtkExpression` into the `GValue`; for instance:
|
2020-06-01 20:17:34 +00:00
|
|
|
|
*
|
2021-02-22 17:35:39 +00:00
|
|
|
|
* ```c
|
2020-06-01 20:17:34 +00:00
|
|
|
|
* // 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;
|
2021-02-22 17:35:39 +00:00
|
|
|
|
* ```
|
2020-06-01 20:17:34 +00:00
|
|
|
|
*
|
2021-02-22 17:35:39 +00:00
|
|
|
|
* ## GtkExpression in .ui files
|
2019-11-18 03:35:36 +00:00
|
|
|
|
*
|
2021-02-22 17:35:39 +00:00
|
|
|
|
* `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
|
2021-12-12 14:03:11 +00:00
|
|
|
|
* property, or in a `<binding name="property">` tag to bind a property to an expression.
|
2019-11-18 03:35:36 +00:00
|
|
|
|
*
|
2022-04-18 06:20:19 +00:00
|
|
|
|
* To create a property expression, use the `<lookup>` element. It can have a `type`
|
2019-11-18 03:35:36 +00:00
|
|
|
|
* attribute to specify the object type, and a `name` attribute to specify the property
|
2021-02-22 17:35:39 +00:00
|
|
|
|
* to look up. The content of `<lookup>` can either be an element specfiying the expression
|
2019-11-18 03:35:36 +00:00
|
|
|
|
* 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:
|
2021-02-22 17:35:39 +00:00
|
|
|
|
*
|
|
|
|
|
* ```xml
|
2019-11-18 03:35:36 +00:00
|
|
|
|
* <lookup name='search'>string_filter</lookup>
|
2021-02-22 17:35:39 +00:00
|
|
|
|
* ```
|
2019-11-18 03:35:36 +00:00
|
|
|
|
*
|
2021-02-22 17:35:39 +00:00
|
|
|
|
* To create a constant expression, use the `<constant>` element. If the type attribute
|
2019-11-18 03:35:36 +00:00
|
|
|
|
* is specified, the element content is interpreted as a value of that type. Otherwise,
|
2021-02-22 17:35:39 +00:00
|
|
|
|
* it is assumed to be an object. For instance:
|
2019-11-18 03:35:36 +00:00
|
|
|
|
*
|
2021-02-22 17:35:39 +00:00
|
|
|
|
* ```xml
|
2019-11-18 03:35:36 +00:00
|
|
|
|
* <constant>string_filter</constant>
|
|
|
|
|
* <constant type='gchararray'>Hello, world</constant>
|
2021-02-22 17:35:39 +00:00
|
|
|
|
* ```
|
2019-11-18 03:35:36 +00:00
|
|
|
|
*
|
2021-02-22 17:35:39 +00:00
|
|
|
|
* To create a closure expression, use the `<closure>` element. The `type` and `function`
|
2019-11-18 03:35:36 +00:00
|
|
|
|
* attributes specify what function to use for the closure, the content of the element
|
2021-02-22 17:35:39 +00:00
|
|
|
|
* contains the expressions for the parameters. For instance:
|
2020-08-07 03:45:30 +00:00
|
|
|
|
*
|
2021-02-22 17:35:39 +00:00
|
|
|
|
* ```xml
|
2019-11-18 03:35:36 +00:00
|
|
|
|
* <closure type='gchararray' function='combine_args_somehow'>
|
|
|
|
|
* <constant type='gchararray'>File size:</constant>
|
|
|
|
|
* <lookup type='GFile' name='size'>myfile</lookup>
|
|
|
|
|
* </closure>
|
2021-02-22 17:35:39 +00:00
|
|
|
|
* ```
|
2019-11-16 20:52:18 +00:00
|
|
|
|
*/
|
2020-06-01 20:07:53 +00:00
|
|
|
|
|
|
|
|
|
|
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
|
|
|
|
};
|
|
|
|
|
|
2021-02-22 17:35:39 +00:00
|
|
|
|
/**
|
|
|
|
|
* GtkExpressionWatch:
|
|
|
|
|
*
|
2021-02-28 18:08:39 +00:00
|
|
|
|
* An opaque structure representing a watched `GtkExpression`.
|
2021-02-22 17:35:39 +00:00
|
|
|
|
*
|
|
|
|
|
* The contents of `GtkExpressionWatch` should only be accessed through the
|
|
|
|
|
* provided API.
|
|
|
|
|
*/
|
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];
|
|
|
|
|
};
|
|
|
|
|
|
2021-02-22 18:23:36 +00:00
|
|
|
|
G_DEFINE_BOXED_TYPE (GtkExpressionWatch, gtk_expression_watch,
|
|
|
|
|
gtk_expression_watch_ref,
|
|
|
|
|
gtk_expression_watch_unref)
|
|
|
|
|
|
2020-06-01 20:07:53 +00:00
|
|
|
|
#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
|
2021-05-20 13:17:04 +00:00
|
|
|
|
* @type_info: the address of the `GtkExpressionTypeInfo` for the expression type
|
2020-06-01 20:07:53 +00:00
|
|
|
|
*
|
2021-05-20 13:17:04 +00:00
|
|
|
|
* Registers a new `GtkExpression` subclass with the given @TypeName and @type_info.
|
2020-06-01 20:07:53 +00:00
|
|
|
|
*
|
|
|
|
|
* Similarly to %G_DEFINE_TYPE, this macro will generate a `get_type()`
|
|
|
|
|
* function that registers the event type.
|
|
|
|
|
*
|
2021-05-20 13:17:04 +00:00
|
|
|
|
* You can specify code to be run after the type registration; the `GType` of
|
2020-06-01 20:07:53 +00:00
|
|
|
|
* 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:
|
2021-02-22 17:35:39 +00:00
|
|
|
|
* @value: a `GValue` initialized with type `GTK_TYPE_EXPRESSION`
|
|
|
|
|
* @expression: a `GtkExpression`
|
2019-11-16 20:52:18 +00:00
|
|
|
|
*
|
2021-02-22 17:35:39 +00:00
|
|
|
|
* Stores the given `GtkExpression` inside `value`.
|
2020-06-01 20:07:53 +00:00
|
|
|
|
*
|
2021-02-22 17:35:39 +00:00
|
|
|
|
* 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:
|
2021-02-22 17:35:39 +00:00
|
|
|
|
* @value: a `GValue` initialized with type `GTK_TYPE_EXPRESSION`
|
|
|
|
|
* @expression: (transfer full) (nullable): a `GtkExpression`
|
2019-11-16 20:52:18 +00:00
|
|
|
|
*
|
2021-02-22 17:35:39 +00:00
|
|
|
|
* Stores the given `GtkExpression` inside `value`.
|
2020-06-01 20:07:53 +00:00
|
|
|
|
*
|
2021-02-22 17:35:39 +00:00
|
|
|
|
* 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:
|
2021-02-22 17:35:39 +00:00
|
|
|
|
* @value: a `GValue` initialized with type `GTK_TYPE_EXPRESSION`
|
2020-06-01 20:07:53 +00:00
|
|
|
|
*
|
2021-02-22 17:35:39 +00:00
|
|
|
|
* Retrieves the `GtkExpression` stored inside the given `value`.
|
2020-06-01 20:07:53 +00:00
|
|
|
|
*
|
2021-02-22 17:35:39 +00:00
|
|
|
|
* Returns: (transfer none) (nullable): a `GtkExpression`
|
2020-06-01 20:07:53 +00:00
|
|
|
|
*/
|
|
|
|
|
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:
|
2021-02-22 17:35:39 +00:00
|
|
|
|
* @value: a `GValue` initialized with type `GTK_TYPE_EXPRESSION`
|
2020-06-01 20:07:53 +00:00
|
|
|
|
*
|
2021-02-22 17:35:39 +00:00
|
|
|
|
* Retrieves the `GtkExpression` stored inside the given `value`, and acquires
|
2020-06-01 20:07:53 +00:00
|
|
|
|
* a reference to it.
|
|
|
|
|
*
|
2021-02-22 17:35:39 +00:00
|
|
|
|
* Returns: (transfer full) (nullable): a `GtkExpression`
|
2020-06-01 20:07:53 +00:00
|
|
|
|
*/
|
|
|
|
|
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
|
|
|
|
|
*
|
2021-02-22 17:35:39 +00:00
|
|
|
|
* Creates a new `GParamSpec` instance for a property holding a `GtkExpression`.
|
2020-06-01 20:07:53 +00:00
|
|
|
|
*
|
2021-02-22 17:35:39 +00:00
|
|
|
|
* See `g_param_spec_internal()` for details on the property strings.
|
2020-06-01 20:07:53 +00:00
|
|
|
|
*
|
|
|
|
|
* 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
|
|
|
|
|
*
|
2021-02-22 17:35:39 +00:00
|
|
|
|
* Returns: (transfer full): the newly created `GtkExpression`
|
2020-06-01 20:07:53 +00:00
|
|
|
|
*/
|
|
|
|
|
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
|
|
|
|
|
2021-02-22 17:35:39 +00:00
|
|
|
|
/**
|
|
|
|
|
* GtkConstantExpression:
|
|
|
|
|
*
|
|
|
|
|
* A constant value in a `GtkExpression`.
|
|
|
|
|
*/
|
2019-11-16 20:52:18 +00:00
|
|
|
|
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
|
|
|
|
|
*
|
2021-02-22 17:35:39 +00:00
|
|
|
|
* Creates a `GtkExpression` that evaluates to the
|
2019-11-16 20:52:18 +00:00
|
|
|
|
* object given by the arguments.
|
|
|
|
|
*
|
2021-02-22 17:35:39 +00:00
|
|
|
|
* Returns: (transfer full) (type GtkConstantExpression): a new `GtkExpression`
|
2019-11-16 20:52:18 +00:00
|
|
|
|
*/
|
|
|
|
|
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;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
2021-02-22 17:35:39 +00:00
|
|
|
|
* gtk_constant_expression_new_for_value: (constructor)
|
|
|
|
|
* @value: a `GValue`
|
2019-11-16 20:52:18 +00:00
|
|
|
|
*
|
2021-02-22 17:35:39 +00:00
|
|
|
|
* Creates an expression that always evaluates to the given `value`.
|
2019-11-16 20:52:18 +00:00
|
|
|
|
*
|
2021-02-22 17:35:39 +00:00
|
|
|
|
* Returns: (transfer full) (type GtkConstantExpression): a new `GtkExpression`
|
2019-11-16 20:52:18 +00:00
|
|
|
|
**/
|
|
|
|
|
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:
|
2021-02-22 17:35:39 +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
|
|
|
|
|
2019-11-21 04:53:56 +00:00
|
|
|
|
typedef struct _GtkObjectExpressionWatch GtkObjectExpressionWatch;
|
2019-11-26 17:59:34 +00:00
|
|
|
|
|
2021-02-22 17:35:39 +00:00
|
|
|
|
/**
|
|
|
|
|
* GtkObjectExpression:
|
|
|
|
|
*
|
|
|
|
|
* A `GObject` value in a `GtkExpression`.
|
|
|
|
|
*/
|
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
|
|
|
|
/**
|
2021-02-22 17:35:39 +00:00
|
|
|
|
* gtk_object_expression_new: (constructor)
|
2019-11-26 17:59:34 +00:00
|
|
|
|
* @object: (transfer none): object to watch
|
|
|
|
|
*
|
2021-02-22 17:35:39 +00:00
|
|
|
|
* Creates an expression evaluating to the given `object` with a weak reference.
|
|
|
|
|
*
|
|
|
|
|
* Once the `object` is disposed, it will fail to evaluate.
|
|
|
|
|
*
|
2019-11-26 17:59:34 +00:00
|
|
|
|
* This expression is meant to break reference cycles.
|
|
|
|
|
*
|
2021-02-22 17:35:39 +00:00
|
|
|
|
* If you want to keep a reference to `object`, use [ctor@Gtk.ConstantExpression.new].
|
2019-11-26 17:59:34 +00:00
|
|
|
|
*
|
2021-02-22 17:35:39 +00:00
|
|
|
|
* Returns: (type GtkObjectExpression) (transfer full): a new `GtkExpression`
|
2019-11-26 17:59:34 +00:00
|
|
|
|
**/
|
|
|
|
|
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:
|
2021-02-22 17:35:39 +00:00
|
|
|
|
* @expression: (type GtkObjectExpression): an object `GtkExpression`
|
2020-07-14 00:19:07 +00:00
|
|
|
|
*
|
|
|
|
|
* Gets the object that the expression evaluates to.
|
|
|
|
|
*
|
2021-02-22 17:35:39 +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
|
|
|
|
|
2021-02-22 17:35:39 +00:00
|
|
|
|
/**
|
|
|
|
|
* GtkPropertyExpression:
|
|
|
|
|
*
|
|
|
|
|
* A `GObject` property value in a `GtkExpression`.
|
|
|
|
|
*/
|
2019-11-16 20:52:18 +00:00
|
|
|
|
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
|
|
|
|
/**
|
2021-02-22 17:35:39 +00:00
|
|
|
|
* gtk_property_expression_new: (constructor)
|
2019-11-16 20:52:18 +00:00
|
|
|
|
* @this_type: The type to expect for the this type
|
|
|
|
|
* @expression: (nullable) (transfer full): Expression to
|
2021-02-22 17:35:39 +00:00
|
|
|
|
* evaluate to get the object to query or `NULL` to
|
|
|
|
|
* query the `this` object
|
2019-11-16 20:52:18 +00:00
|
|
|
|
* @property_name: name of the property
|
|
|
|
|
*
|
2021-05-22 21:24:55 +00:00
|
|
|
|
* Creates an expression that looks up a property.
|
|
|
|
|
*
|
|
|
|
|
* The object to use is found by evaluating the `expression`,
|
|
|
|
|
* or using the `this` argument when `expression` is `NULL`.
|
2019-11-16 20:52:18 +00:00
|
|
|
|
*
|
2021-02-22 17:35:39 +00:00
|
|
|
|
* If the resulting object conforms to `this_type`, its property named
|
|
|
|
|
* `property_name` will be queried. Otherwise, this expression's
|
|
|
|
|
* evaluation will fail.
|
2019-11-16 20:52:18 +00:00
|
|
|
|
*
|
2021-02-22 17:35:39 +00:00
|
|
|
|
* The given `this_type` must have a property with `property_name`.
|
2019-11-16 20:52:18 +00:00
|
|
|
|
*
|
2021-02-22 17:35:39 +00:00
|
|
|
|
* Returns: (type GtkPropertyExpression) (transfer full): a new `GtkExpression`
|
2019-11-16 20:52:18 +00:00
|
|
|
|
**/
|
|
|
|
|
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);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
2021-02-22 17:35:39 +00:00
|
|
|
|
* gtk_property_expression_new_for_pspec: (constructor)
|
2019-11-16 20:52:18 +00:00
|
|
|
|
* @expression: (nullable) (transfer full): Expression to
|
2021-02-22 17:35:39 +00:00
|
|
|
|
* evaluate to get the object to query or `NULL` to
|
|
|
|
|
* query the `this` object
|
|
|
|
|
* @pspec: the `GParamSpec` for the property to query
|
2019-11-16 20:52:18 +00:00
|
|
|
|
*
|
2021-05-22 21:24:55 +00:00
|
|
|
|
* Creates an expression that looks up a property.
|
|
|
|
|
*
|
|
|
|
|
* The object to use is found by evaluating the `expression`,
|
|
|
|
|
* or using the `this` argument when `expression` is `NULL`.
|
2019-11-16 20:52:18 +00:00
|
|
|
|
*
|
2021-02-22 17:35:39 +00:00
|
|
|
|
* If the resulting object conforms to `this_type`, its
|
|
|
|
|
* property specified by `pspec` will be queried.
|
2019-11-16 20:52:18 +00:00
|
|
|
|
* Otherwise, this expression's evaluation will fail.
|
|
|
|
|
*
|
2021-02-22 17:35:39 +00:00
|
|
|
|
* Returns: (type GtkPropertyExpression) (transfer full): a new `GtkExpression`
|
2019-11-16 20:52:18 +00:00
|
|
|
|
**/
|
|
|
|
|
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:
|
2021-02-22 17:35:39 +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.
|
|
|
|
|
*
|
2021-12-30 16:52:53 +00:00
|
|
|
|
* Returns: (transfer none) (nullable): the object expression
|
2020-07-14 00:19:07 +00:00
|
|
|
|
*/
|
|
|
|
|
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:
|
2021-02-22 17:35:39 +00:00
|
|
|
|
* @expression: (type GtkPropertyExpression): a property `GtkExpression`
|
2020-07-14 00:19:07 +00:00
|
|
|
|
*
|
2021-02-22 17:35:39 +00:00
|
|
|
|
* Gets the `GParamSpec` specifying the property of
|
2020-07-14 00:19:07 +00:00
|
|
|
|
* a property expression.
|
|
|
|
|
*
|
2021-02-22 17:35:39 +00:00
|
|
|
|
* Returns: (transfer none): the `GParamSpec` for the property
|
2020-07-14 00:19:07 +00:00
|
|
|
|
*/
|
|
|
|
|
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
|
|
|
|
|
2021-02-22 17:35:39 +00:00
|
|
|
|
/**
|
|
|
|
|
* GtkClosureExpression:
|
|
|
|
|
*
|
|
|
|
|
* An expression using a custom `GClosure` to compute the value from
|
|
|
|
|
* its parameters.
|
|
|
|
|
*/
|
2019-11-16 20:52:18 +00:00
|
|
|
|
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
|
|
|
|
/**
|
2021-02-22 17:35:39 +00:00
|
|
|
|
* gtk_closure_expression_new: (constructor)
|
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
|
2021-02-22 17:35:39 +00:00
|
|
|
|
* @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
|
|
|
|
*
|
2021-02-22 17:35:39 +00:00
|
|
|
|
* Creates a `GtkExpression` that calls `closure` when it is evaluated.
|
2021-05-22 21:24:55 +00:00
|
|
|
|
*
|
2021-02-22 17:35:39 +00:00
|
|
|
|
* `closure` is called with the `this` object and the results of evaluating
|
|
|
|
|
* the `params` expressions.
|
2019-11-16 20:52:18 +00:00
|
|
|
|
*
|
2021-02-22 17:35:39 +00:00
|
|
|
|
* Returns: (transfer full) (type GtkClosureExpression): a new `GtkExpression`
|
2019-11-16 20:52:18 +00:00
|
|
|
|
*/
|
|
|
|
|
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 */
|
|
|
|
|
|
2021-02-22 17:35:39 +00:00
|
|
|
|
/**
|
|
|
|
|
* GtkCClosureExpression:
|
|
|
|
|
*
|
2021-02-28 18:08:39 +00:00
|
|
|
|
* A variant of `GtkClosureExpression` using a C closure.
|
2021-02-22 17:35:39 +00:00
|
|
|
|
*/
|
2020-06-01 20:07:53 +00:00
|
|
|
|
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
|
|
|
|
/**
|
2021-02-22 17:35:39 +00:00
|
|
|
|
* gtk_cclosure_expression_new: (constructor)
|
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
|
|
|
|
*
|
2021-05-22 21:24:55 +00:00
|
|
|
|
* Creates a `GtkExpression` that calls `callback_func` when it is evaluated.
|
|
|
|
|
*
|
2021-02-22 17:35:39 +00:00
|
|
|
|
* This function is a variant of [ctor@Gtk.ClosureExpression.new] that
|
2021-05-22 21:24:55 +00:00
|
|
|
|
* creates a `GClosure` by calling g_cclosure_new() with the given
|
2021-02-22 17:35:39 +00:00
|
|
|
|
* `callback_func`, `user_data` and `user_destroy`.
|
2019-11-16 20:52:18 +00:00
|
|
|
|
*
|
2021-02-22 17:35:39 +00:00
|
|
|
|
* Returns: (transfer full) (type GtkCClosureExpression): a new `GtkExpression`
|
2019-11-16 20:52:18 +00:00
|
|
|
|
*/
|
|
|
|
|
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:
|
2021-02-22 17:35:39 +00:00
|
|
|
|
* @self: a `GtkExpression`
|
2019-11-16 20:52:18 +00:00
|
|
|
|
*
|
2021-02-22 17:35:39 +00:00
|
|
|
|
* Acquires a reference on the given `GtkExpression`.
|
2019-11-16 20:52:18 +00:00
|
|
|
|
*
|
2021-02-22 17:35:39 +00:00
|
|
|
|
* Returns: (transfer full): the `GtkExpression` with an additional reference
|
2019-11-16 20:52:18 +00:00
|
|
|
|
*/
|
|
|
|
|
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:
|
2021-02-22 17:35:39 +00:00
|
|
|
|
* @self: (transfer full): a `GtkExpression`
|
2019-11-16 20:52:18 +00:00
|
|
|
|
*
|
2021-02-22 17:35:39 +00:00
|
|
|
|
* Releases a reference on the given `GtkExpression`.
|
2019-11-16 20:52:18 +00:00
|
|
|
|
*
|
2021-02-22 17:35:39 +00:00
|
|
|
|
* If the reference was the last, the resources associated to the `self` are
|
2019-11-16 20:52:18 +00:00
|
|
|
|
* 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:
|
2021-02-22 17:35:39 +00:00
|
|
|
|
* @self: a `GtkExpression`
|
2019-11-16 20:52:18 +00:00
|
|
|
|
*
|
2021-02-28 18:08:39 +00:00
|
|
|
|
* Gets the `GType` that this expression evaluates to.
|
|
|
|
|
*
|
|
|
|
|
* This type is constant and will not change over the lifetime
|
|
|
|
|
* of this expression.
|
2019-11-16 20:52:18 +00:00
|
|
|
|
*
|
2021-02-22 17:35:39 +00:00
|
|
|
|
* Returns: The type returned from [method@Gtk.Expression.evaluate]
|
2021-02-28 18:08:39 +00:00
|
|
|
|
*/
|
2019-11-16 20:52:18 +00:00
|
|
|
|
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:
|
2021-02-22 17:35:39 +00:00
|
|
|
|
* @self: a `GtkExpression`
|
2019-11-16 20:52:18 +00:00
|
|
|
|
* @this_: (transfer none) (type GObject) (nullable): the this argument for the evaluation
|
2021-02-22 17:35:39 +00:00
|
|
|
|
* @value: an empty `GValue`
|
2019-11-16 20:52:18 +00:00
|
|
|
|
*
|
|
|
|
|
* Evaluates the given expression and on success stores the result
|
2021-02-22 17:35:39 +00:00
|
|
|
|
* in @value.
|
|
|
|
|
*
|
|
|
|
|
* The `GType` of `value` will be the type given by
|
|
|
|
|
* [method@Gtk.Expression.get_value_type].
|
2019-11-16 20:52:18 +00:00
|
|
|
|
*
|
|
|
|
|
* It is possible that expressions cannot be evaluated - for example
|
|
|
|
|
* when the expression references objects that have been destroyed or
|
2021-02-22 17:35:39 +00:00
|
|
|
|
* set to `NULL`. In that case `value` will remain empty and `FALSE`
|
2019-11-16 20:52:18 +00:00
|
|
|
|
* will be returned.
|
|
|
|
|
*
|
2021-02-22 17:35:39 +00:00
|
|
|
|
* Returns: `TRUE` if the expression could be evaluated
|
2019-11-16 20:52:18 +00:00
|
|
|
|
**/
|
|
|
|
|
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:
|
2021-02-22 17:35:39 +00:00
|
|
|
|
* @self: a `GtkExpression`
|
2019-11-21 04:53:56 +00:00
|
|
|
|
*
|
|
|
|
|
* Checks if the expression is static.
|
|
|
|
|
*
|
2021-02-28 18:08:39 +00:00
|
|
|
|
* A static expression will never change its result when
|
2021-02-22 17:35:39 +00:00
|
|
|
|
* [method@Gtk.Expression.evaluate] is called on it with the same arguments.
|
2019-11-21 04:53:56 +00:00
|
|
|
|
*
|
2021-02-22 17:35:39 +00:00
|
|
|
|
* That means a call to [method@Gtk.Expression.watch] is not necessary because
|
2019-11-21 04:53:56 +00:00
|
|
|
|
* it will never trigger a notify.
|
|
|
|
|
*
|
2021-02-22 17:35:39 +00:00
|
|
|
|
* Returns: `TRUE` if the expression is static
|
2019-11-21 04:53:56 +00:00
|
|
|
|
**/
|
|
|
|
|
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:
|
2021-02-22 17:35:39 +00:00
|
|
|
|
* @self: a `GtkExpression`
|
2020-06-01 20:07:53 +00:00
|
|
|
|
* @this_: (transfer none) (type GObject) (nullable): the `this` argument to
|
2021-05-18 21:05:26 +00:00
|
|
|
|
* watch
|
|
|
|
|
* @notify: (closure user_data): callback to invoke when the expression changes
|
2021-02-22 17:35:39 +00:00
|
|
|
|
* @user_data: user data to pass to the `notify` callback
|
|
|
|
|
* @user_destroy: destroy notify for `user_data`
|
2019-11-21 04:53:56 +00:00
|
|
|
|
*
|
2021-05-22 21:24:55 +00:00
|
|
|
|
* Watch the given `expression` for changes.
|
|
|
|
|
*
|
|
|
|
|
* The @notify function will be called whenever the evaluation of `self`
|
|
|
|
|
* may have changed.
|
2019-11-21 04:53:56 +00:00
|
|
|
|
*
|
|
|
|
|
* 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,
|
2021-05-22 21:24:55 +00:00
|
|
|
|
* the @notify will be invoked.
|
2019-11-21 04:53:56 +00:00
|
|
|
|
*
|
|
|
|
|
* Returns: (transfer none): The newly installed watch. Note that the only
|
2021-02-22 17:35:39 +00:00
|
|
|
|
* reference held to the watch will be released when the watch is unwatched
|
|
|
|
|
* which can happen automatically, and not just via
|
|
|
|
|
* [method@Gtk.ExpressionWatch.unwatch]. You should call [method@Gtk.ExpressionWatch.ref]
|
|
|
|
|
* if you want to keep the watch around.
|
2019-11-21 04:53:56 +00:00
|
|
|
|
**/
|
|
|
|
|
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:
|
2021-02-22 17:35:39 +00:00
|
|
|
|
* @watch: a `GtkExpressionWatch`
|
2019-11-21 04:53:56 +00:00
|
|
|
|
*
|
2021-02-22 17:35:39 +00:00
|
|
|
|
* Acquires a reference on the given `GtkExpressionWatch`.
|
2019-11-21 04:53:56 +00:00
|
|
|
|
*
|
2021-02-22 17:35:39 +00:00
|
|
|
|
* Returns: (transfer full): the `GtkExpressionWatch` with an additional reference
|
2019-11-21 04:53:56 +00:00
|
|
|
|
*/
|
|
|
|
|
GtkExpressionWatch *
|
|
|
|
|
gtk_expression_watch_ref (GtkExpressionWatch *watch)
|
|
|
|
|
{
|
|
|
|
|
return g_atomic_rc_box_acquire (watch);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
gtk_expression_watch_finalize (gpointer data)
|
|
|
|
|
{
|
2021-04-13 00:55:01 +00:00
|
|
|
|
GtkExpressionWatch *watch G_GNUC_UNUSED = data;
|
2019-11-21 04:53:56 +00:00
|
|
|
|
|
2021-04-13 00:55:01 +00:00
|
|
|
|
g_assert (!gtk_expression_watch_is_watching (data));
|
2019-11-21 04:53:56 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* gtk_expression_watch_unref:
|
2021-02-22 17:35:39 +00:00
|
|
|
|
* @watch: (transfer full): a `GtkExpressionWatch`
|
2019-11-21 04:53:56 +00:00
|
|
|
|
*
|
2021-02-22 17:35:39 +00:00
|
|
|
|
* Releases a reference on the given `GtkExpressionWatch`.
|
2019-11-21 04:53:56 +00:00
|
|
|
|
*
|
2021-02-22 17:35:39 +00:00
|
|
|
|
* If the reference was the last, the resources associated to `self` are
|
2019-11-21 04:53:56 +00:00
|
|
|
|
* 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
|
|
|
|
|
*
|
2021-02-28 18:08:39 +00:00
|
|
|
|
* Stops watching an expression.
|
|
|
|
|
*
|
|
|
|
|
* See [method@Gtk.Expression.watch] for how the watch
|
|
|
|
|
* was established.
|
|
|
|
|
*/
|
2019-11-21 04:53:56 +00:00
|
|
|
|
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:
|
2021-02-22 17:35:39 +00:00
|
|
|
|
* @watch: a `GtkExpressionWatch`
|
|
|
|
|
* @value: an empty `GValue` to be set
|
2019-11-21 04:53:56 +00:00
|
|
|
|
*
|
|
|
|
|
* Evaluates the watched expression and on success stores the result
|
2021-02-22 17:35:39 +00:00
|
|
|
|
* in `value`.
|
2019-11-21 04:53:56 +00:00
|
|
|
|
*
|
2021-02-22 17:35:39 +00:00
|
|
|
|
* This is equivalent to calling [method@Gtk.Expression.evaluate] with the
|
|
|
|
|
* expression and this pointer originally used to create `watch`.
|
2019-11-21 04:53:56 +00:00
|
|
|
|
*
|
2021-02-22 17:35:39 +00:00
|
|
|
|
* Returns: `TRUE` if the expression could be evaluated and `value` was set
|
2019-11-21 04:53:56 +00:00
|
|
|
|
**/
|
|
|
|
|
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:
|
2021-02-22 17:35:39 +00:00
|
|
|
|
* @self: (transfer full): a `GtkExpression`
|
2019-11-28 01:32:12 +00:00
|
|
|
|
* @target: (transfer none) (type GObject): the target object to bind to
|
2021-02-22 17:35:39 +00:00
|
|
|
|
* @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
|
2021-05-18 21:05:26 +00:00
|
|
|
|
* the evaluation of `self`
|
2019-11-24 07:05:41 +00:00
|
|
|
|
*
|
2021-02-22 17:35:39 +00:00
|
|
|
|
* Bind `target`'s property named `property` to `self`.
|
2019-11-24 07:05:41 +00:00
|
|
|
|
*
|
2021-02-22 17:35:39 +00:00
|
|
|
|
* The value that `self` evaluates to is set via `g_object_set()` on
|
|
|
|
|
* `target`. This is repeated whenever `self` changes to ensure that
|
|
|
|
|
* the object's property stays synchronized with `self`.
|
2019-11-24 07:05:41 +00:00
|
|
|
|
*
|
2021-02-22 17:35:39 +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.
|
|
|
|
|
*
|
2021-02-22 17:35:39 +00:00
|
|
|
|
* Note that this function takes ownership of `self`. If you want
|
|
|
|
|
* to keep it around, you should [method@Gtk.Expression.ref] it beforehand.
|
2019-11-24 07:05:41 +00:00
|
|
|
|
*
|
2021-02-22 17:35:39 +00:00
|
|
|
|
* Returns: (transfer none): a `GtkExpressionWatch`
|
2019-11-24 07:05:41 +00:00
|
|
|
|
**/
|
|
|
|
|
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
|
|
|
|
|
|
|
|
|
/* }}} */
|