Branch data Line data Source code
1 : : /*
2 : : * Copyright © 2013 Canonical Limited
3 : : *
4 : : * SPDX-License-Identifier: LGPL-2.1-or-later
5 : : *
6 : : * This library is free software; you can redistribute it and/or
7 : : * modify it under the terms of the GNU Lesser General Public
8 : : * License as published by the Free Software Foundation; either
9 : : * version 2.1 of the License, or (at your option) any later version.
10 : : *
11 : : * This library is distributed in the hope that it will be useful,
12 : : * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 : : * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 : : * Lesser General Public License for more details.
15 : : *
16 : : * You should have received a copy of the GNU Lesser General
17 : : * Public License along with this library; if not, see <http://www.gnu.org/licenses/>.
18 : : *
19 : : * Authors: Ryan Lortie <desrt@desrt.ca>
20 : : */
21 : :
22 : : #include "config.h"
23 : :
24 : : #include "gpropertyaction.h"
25 : :
26 : : #include "gsettings-mapping.h"
27 : : #include "gaction.h"
28 : : #include "glibintl.h"
29 : :
30 : : /**
31 : : * GPropertyAction:
32 : : *
33 : : * A `GPropertyAction` is a way to get a [iface@Gio.Action] with a state value
34 : : * reflecting and controlling the value of a [class@GObject.Object] property.
35 : : *
36 : : * The state of the action will correspond to the value of the property.
37 : : * Changing it will change the property (assuming the requested value
38 : : * matches the requirements as specified in the [type@GObject.ParamSpec]).
39 : : *
40 : : * Only the most common types are presently supported. Booleans are
41 : : * mapped to booleans, strings to strings, signed/unsigned integers to
42 : : * int32/uint32 and floats and doubles to doubles.
43 : : *
44 : : * If the property is an enum then the state will be string-typed and
45 : : * conversion will automatically be performed between the enum value and
46 : : * ‘nick’ string as per the [type@GObject.EnumValue] table.
47 : : *
48 : : * Flags types are not currently supported.
49 : : *
50 : : * Properties of object types, boxed types and pointer types are not
51 : : * supported and probably never will be.
52 : : *
53 : : * Properties of [type@GLib.Variant] types are not currently supported.
54 : : *
55 : : * If the property is boolean-valued then the action will have a `NULL`
56 : : * parameter type, and activating the action (with no parameter) will
57 : : * toggle the value of the property.
58 : : *
59 : : * In all other cases, the parameter type will correspond to the type of
60 : : * the property.
61 : : *
62 : : * The general idea here is to reduce the number of locations where a
63 : : * particular piece of state is kept (and therefore has to be synchronised
64 : : * between). `GPropertyAction` does not have a separate state that is kept
65 : : * in sync with the property value — its state is the property value.
66 : : *
67 : : * For example, it might be useful to create a [iface@Gio.Action] corresponding
68 : : * to the `visible-child-name` property of a [`GtkStack`](https://docs.gtk.org/gtk4/class.Stack.html)
69 : : * so that the current page can be switched from a menu. The active radio
70 : : * indication in the menu is then directly determined from the active page of
71 : : * the `GtkStack`.
72 : : *
73 : : * An anti-example would be binding the `active-id` property on a
74 : : * [`GtkComboBox`](https://docs.gtk.org/gtk4/class.ComboBox.html). This is
75 : : * because the state of the combo box itself is probably uninteresting and is
76 : : * actually being used to control something else.
77 : : *
78 : : * Another anti-example would be to bind to the `visible-child-name`
79 : : * property of a [`GtkStack`](https://docs.gtk.org/gtk4/class.Stack.html) if
80 : : * this value is actually stored in [class@Gio.Settings]. In that case, the
81 : : * real source of the value is* [class@Gio.Settings]. If you want
82 : : * a [iface@Gio.Action] to control a setting stored in [class@Gio.Settings],
83 : : * see [method@Gio.Settings.create_action] instead, and possibly combine its
84 : : * use with [method@Gio.Settings.bind].
85 : : *
86 : : * Since: 2.38
87 : : **/
88 : : struct _GPropertyAction
89 : : {
90 : : GObject parent_instance;
91 : :
92 : : gchar *name;
93 : : gpointer object;
94 : : GParamSpec *pspec;
95 : : const GVariantType *state_type;
96 : : gboolean invert_boolean;
97 : : };
98 : :
99 : : typedef GObjectClass GPropertyActionClass;
100 : :
101 : : static void g_property_action_iface_init (GActionInterface *iface);
102 : 289 : G_DEFINE_TYPE_WITH_CODE (GPropertyAction, g_property_action, G_TYPE_OBJECT,
103 : : G_IMPLEMENT_INTERFACE (G_TYPE_ACTION, g_property_action_iface_init))
104 : :
105 : : enum
106 : : {
107 : : PROP_NONE,
108 : : PROP_NAME,
109 : : PROP_PARAMETER_TYPE,
110 : : PROP_ENABLED,
111 : : PROP_STATE_TYPE,
112 : : PROP_STATE,
113 : : PROP_OBJECT,
114 : : PROP_PROPERTY_NAME,
115 : : PROP_INVERT_BOOLEAN
116 : : };
117 : :
118 : : static gboolean
119 : 0 : g_property_action_get_invert_boolean (GAction *action)
120 : : {
121 : 0 : GPropertyAction *paction = G_PROPERTY_ACTION (action);
122 : :
123 : 0 : return paction->invert_boolean;
124 : : }
125 : :
126 : : static const gchar *
127 : 23 : g_property_action_get_name (GAction *action)
128 : : {
129 : 23 : GPropertyAction *paction = G_PROPERTY_ACTION (action);
130 : :
131 : 23 : return paction->name;
132 : : }
133 : :
134 : : static const GVariantType *
135 : 1 : g_property_action_get_parameter_type (GAction *action)
136 : : {
137 : 1 : GPropertyAction *paction = G_PROPERTY_ACTION (action);
138 : :
139 : 1 : return paction->pspec->value_type == G_TYPE_BOOLEAN ? NULL : paction->state_type;
140 : : }
141 : :
142 : : static const GVariantType *
143 : 11 : g_property_action_get_state_type (GAction *action)
144 : : {
145 : 11 : GPropertyAction *paction = G_PROPERTY_ACTION (action);
146 : :
147 : 11 : return paction->state_type;
148 : : }
149 : :
150 : : static GVariant *
151 : 0 : g_property_action_get_state_hint (GAction *action)
152 : : {
153 : 0 : GPropertyAction *paction = G_PROPERTY_ACTION (action);
154 : :
155 : 0 : if (paction->pspec->value_type == G_TYPE_INT)
156 : : {
157 : 0 : GParamSpecInt *pspec = (GParamSpecInt *)paction->pspec;
158 : 0 : return g_variant_new ("(ii)", pspec->minimum, pspec->maximum);
159 : : }
160 : 0 : else if (paction->pspec->value_type == G_TYPE_UINT)
161 : : {
162 : 0 : GParamSpecUInt *pspec = (GParamSpecUInt *)paction->pspec;
163 : 0 : return g_variant_new ("(uu)", pspec->minimum, pspec->maximum);
164 : : }
165 : 0 : else if (paction->pspec->value_type == G_TYPE_FLOAT)
166 : : {
167 : 0 : GParamSpecFloat *pspec = (GParamSpecFloat *)paction->pspec;
168 : 0 : return g_variant_new ("(dd)", (double)pspec->minimum, (double)pspec->maximum);
169 : : }
170 : 0 : else if (paction->pspec->value_type == G_TYPE_DOUBLE)
171 : : {
172 : 0 : GParamSpecDouble *pspec = (GParamSpecDouble *)paction->pspec;
173 : 0 : return g_variant_new ("(dd)", pspec->minimum, pspec->maximum);
174 : : }
175 : :
176 : 0 : return NULL;
177 : : }
178 : :
179 : : static gboolean
180 : 1 : g_property_action_get_enabled (GAction *action)
181 : : {
182 : 1 : return TRUE;
183 : : }
184 : :
185 : : static void
186 : 8 : g_property_action_set_state (GPropertyAction *paction,
187 : : GVariant *variant)
188 : : {
189 : 8 : GValue value = G_VALUE_INIT;
190 : :
191 : 8 : g_value_init (&value, paction->pspec->value_type);
192 : 8 : g_settings_get_mapping (&value, variant, NULL);
193 : :
194 : 8 : if (paction->pspec->value_type == G_TYPE_BOOLEAN && paction->invert_boolean)
195 : 1 : g_value_set_boolean (&value, !g_value_get_boolean (&value));
196 : :
197 : 8 : g_object_set_property (paction->object, paction->pspec->name, &value);
198 : 8 : g_value_unset (&value);
199 : 8 : }
200 : :
201 : : static void
202 : 5 : g_property_action_change_state (GAction *action,
203 : : GVariant *value)
204 : : {
205 : 5 : GPropertyAction *paction = G_PROPERTY_ACTION (action);
206 : :
207 : 5 : g_return_if_fail (g_variant_is_of_type (value, paction->state_type));
208 : :
209 : 5 : g_property_action_set_state (paction, value);
210 : : }
211 : :
212 : : static GVariant *
213 : 40 : g_property_action_get_state (GAction *action)
214 : : {
215 : 40 : GPropertyAction *paction = G_PROPERTY_ACTION (action);
216 : 40 : GValue value = G_VALUE_INIT;
217 : : GVariant *result;
218 : :
219 : 40 : g_value_init (&value, paction->pspec->value_type);
220 : 40 : g_object_get_property (paction->object, paction->pspec->name, &value);
221 : :
222 : 40 : if (paction->pspec->value_type == G_TYPE_BOOLEAN && paction->invert_boolean)
223 : 9 : g_value_set_boolean (&value, !g_value_get_boolean (&value));
224 : :
225 : 40 : result = g_settings_set_mapping (&value, paction->state_type, NULL);
226 : 40 : g_value_unset (&value);
227 : :
228 : 40 : return g_variant_ref_sink (result);
229 : : }
230 : :
231 : : static void
232 : 7 : g_property_action_activate (GAction *action,
233 : : GVariant *parameter)
234 : : {
235 : 7 : GPropertyAction *paction = G_PROPERTY_ACTION (action);
236 : :
237 : 7 : if (paction->pspec->value_type == G_TYPE_BOOLEAN)
238 : : {
239 : : gboolean value;
240 : :
241 : 4 : g_return_if_fail (paction->pspec->value_type == G_TYPE_BOOLEAN && parameter == NULL);
242 : :
243 : 4 : g_object_get (paction->object, paction->pspec->name, &value, NULL);
244 : 4 : value = !value;
245 : 4 : g_object_set (paction->object, paction->pspec->name, value, NULL);
246 : : }
247 : : else
248 : : {
249 : 3 : g_return_if_fail (parameter != NULL && g_variant_is_of_type (parameter, paction->state_type));
250 : :
251 : 3 : g_property_action_set_state (paction, parameter);
252 : : }
253 : : }
254 : :
255 : : static const GVariantType *
256 : 6 : g_property_action_determine_type (GParamSpec *pspec)
257 : : {
258 : 6 : if (G_TYPE_IS_ENUM (pspec->value_type))
259 : 1 : return G_VARIANT_TYPE_STRING;
260 : :
261 : 5 : switch (pspec->value_type)
262 : : {
263 : 2 : case G_TYPE_BOOLEAN:
264 : 2 : return G_VARIANT_TYPE_BOOLEAN;
265 : :
266 : 0 : case G_TYPE_INT:
267 : 0 : return G_VARIANT_TYPE_INT32;
268 : :
269 : 1 : case G_TYPE_UINT:
270 : 1 : return G_VARIANT_TYPE_UINT32;
271 : :
272 : 0 : case G_TYPE_DOUBLE:
273 : : case G_TYPE_FLOAT:
274 : 0 : return G_VARIANT_TYPE_DOUBLE;
275 : :
276 : 1 : case G_TYPE_STRING:
277 : 1 : return G_VARIANT_TYPE_STRING;
278 : :
279 : 1 : default:
280 : 1 : g_critical ("Unable to use GPropertyAction with property '%s::%s' of type '%s'",
281 : : g_type_name (pspec->owner_type), pspec->name, g_type_name (pspec->value_type));
282 : 1 : return NULL;
283 : : }
284 : : }
285 : :
286 : : static void
287 : 17 : g_property_action_notify (GObject *object,
288 : : GParamSpec *pspec,
289 : : gpointer user_data)
290 : : {
291 : 17 : GPropertyAction *paction = user_data;
292 : :
293 : 17 : g_assert (object == paction->object);
294 : 17 : g_assert (pspec == paction->pspec);
295 : :
296 : 17 : g_object_notify (G_OBJECT (paction), "state");
297 : 17 : }
298 : :
299 : : static void
300 : 9 : g_property_action_set_property_name (GPropertyAction *paction,
301 : : const gchar *property_name)
302 : : {
303 : : GParamSpec *pspec;
304 : : gchar *detailed;
305 : :
306 : : /* In case somebody is constructing GPropertyAction without passing
307 : : * a property name
308 : : */
309 : 9 : if (G_UNLIKELY (property_name == NULL || property_name[0] == '\0'))
310 : : {
311 : 1 : g_critical ("Attempted to use an empty property name for GPropertyAction");
312 : 1 : return;
313 : : }
314 : :
315 : 8 : pspec = g_object_class_find_property (G_OBJECT_GET_CLASS (paction->object), property_name);
316 : :
317 : 8 : if (pspec == NULL)
318 : : {
319 : 1 : g_critical ("Attempted to use non-existent property '%s::%s' for GPropertyAction",
320 : : G_OBJECT_TYPE_NAME (paction->object), property_name);
321 : 1 : return;
322 : : }
323 : :
324 : 7 : if (~pspec->flags & G_PARAM_READABLE || ~pspec->flags & G_PARAM_WRITABLE || pspec->flags & G_PARAM_CONSTRUCT_ONLY)
325 : : {
326 : 1 : g_critical ("Property '%s::%s' used with GPropertyAction must be readable, writable, and not construct-only",
327 : : G_OBJECT_TYPE_NAME (paction->object), property_name);
328 : 1 : return;
329 : : }
330 : :
331 : 6 : paction->pspec = pspec;
332 : :
333 : 6 : detailed = g_strconcat ("notify::", paction->pspec->name, NULL);
334 : 6 : paction->state_type = g_property_action_determine_type (paction->pspec);
335 : 6 : g_signal_connect (paction->object, detailed, G_CALLBACK (g_property_action_notify), paction);
336 : 6 : g_free (detailed);
337 : : }
338 : :
339 : : static void
340 : 36 : g_property_action_set_property (GObject *object,
341 : : guint prop_id,
342 : : const GValue *value,
343 : : GParamSpec *pspec)
344 : : {
345 : 36 : GPropertyAction *paction = G_PROPERTY_ACTION (object);
346 : :
347 : 36 : switch (prop_id)
348 : : {
349 : 9 : case PROP_NAME:
350 : 9 : paction->name = g_value_dup_string (value);
351 : 9 : break;
352 : :
353 : 9 : case PROP_OBJECT:
354 : 9 : paction->object = g_value_dup_object (value);
355 : 9 : break;
356 : :
357 : 9 : case PROP_PROPERTY_NAME:
358 : 9 : g_property_action_set_property_name (paction, g_value_get_string (value));
359 : 9 : break;
360 : :
361 : 9 : case PROP_INVERT_BOOLEAN:
362 : 9 : paction->invert_boolean = g_value_get_boolean (value);
363 : 9 : break;
364 : :
365 : 0 : default:
366 : : g_assert_not_reached ();
367 : : }
368 : 36 : }
369 : :
370 : : static void
371 : 5 : g_property_action_get_property (GObject *object,
372 : : guint prop_id,
373 : : GValue *value,
374 : : GParamSpec *pspec)
375 : : {
376 : 5 : GAction *action = G_ACTION (object);
377 : :
378 : 5 : switch (prop_id)
379 : : {
380 : 1 : case PROP_NAME:
381 : 1 : g_value_set_string (value, g_property_action_get_name (action));
382 : 1 : break;
383 : :
384 : 1 : case PROP_PARAMETER_TYPE:
385 : 1 : g_value_set_boxed (value, g_property_action_get_parameter_type (action));
386 : 1 : break;
387 : :
388 : 1 : case PROP_ENABLED:
389 : 1 : g_value_set_boolean (value, g_property_action_get_enabled (action));
390 : 1 : break;
391 : :
392 : 1 : case PROP_STATE_TYPE:
393 : 1 : g_value_set_boxed (value, g_property_action_get_state_type (action));
394 : 1 : break;
395 : :
396 : 1 : case PROP_STATE:
397 : 1 : g_value_take_variant (value, g_property_action_get_state (action));
398 : 1 : break;
399 : :
400 : 0 : case PROP_INVERT_BOOLEAN:
401 : 0 : g_value_set_boolean (value, g_property_action_get_invert_boolean (action));
402 : 0 : break;
403 : :
404 : 0 : default:
405 : : g_assert_not_reached ();
406 : : }
407 : 5 : }
408 : :
409 : : static void
410 : 9 : g_property_action_dispose (GObject *object)
411 : : {
412 : 9 : GPropertyAction *paction = G_PROPERTY_ACTION (object);
413 : :
414 : 9 : if (paction->object != NULL)
415 : : {
416 : 8 : g_signal_handlers_disconnect_by_func (paction->object, g_property_action_notify, paction);
417 : 8 : g_clear_object (&paction->object);
418 : : }
419 : :
420 : 9 : G_OBJECT_CLASS (g_property_action_parent_class)->dispose (object);
421 : 9 : }
422 : :
423 : : static void
424 : 9 : g_property_action_finalize (GObject *object)
425 : : {
426 : 9 : GPropertyAction *paction = G_PROPERTY_ACTION (object);
427 : :
428 : 9 : g_free (paction->name);
429 : :
430 : 9 : G_OBJECT_CLASS (g_property_action_parent_class)
431 : 9 : ->finalize (object);
432 : 9 : }
433 : :
434 : : void
435 : 9 : g_property_action_init (GPropertyAction *property)
436 : : {
437 : 9 : }
438 : :
439 : : void
440 : 2 : g_property_action_iface_init (GActionInterface *iface)
441 : : {
442 : 2 : iface->get_name = g_property_action_get_name;
443 : 2 : iface->get_parameter_type = g_property_action_get_parameter_type;
444 : 2 : iface->get_state_type = g_property_action_get_state_type;
445 : 2 : iface->get_state_hint = g_property_action_get_state_hint;
446 : 2 : iface->get_enabled = g_property_action_get_enabled;
447 : 2 : iface->get_state = g_property_action_get_state;
448 : 2 : iface->change_state = g_property_action_change_state;
449 : 2 : iface->activate = g_property_action_activate;
450 : 2 : }
451 : :
452 : : void
453 : 2 : g_property_action_class_init (GPropertyActionClass *class)
454 : : {
455 : 2 : GObjectClass *object_class = G_OBJECT_CLASS (class);
456 : :
457 : 2 : object_class->set_property = g_property_action_set_property;
458 : 2 : object_class->get_property = g_property_action_get_property;
459 : 2 : object_class->dispose = g_property_action_dispose;
460 : 2 : object_class->finalize = g_property_action_finalize;
461 : :
462 : : /**
463 : : * GPropertyAction:name:
464 : : *
465 : : * The name of the action. This is mostly meaningful for identifying
466 : : * the action once it has been added to a #GActionMap.
467 : : *
468 : : * Since: 2.38
469 : : **/
470 : 2 : g_object_class_install_property (object_class, PROP_NAME,
471 : : g_param_spec_string ("name", NULL, NULL,
472 : : NULL,
473 : : G_PARAM_READWRITE |
474 : : G_PARAM_CONSTRUCT_ONLY |
475 : : G_PARAM_STATIC_STRINGS));
476 : :
477 : : /**
478 : : * GPropertyAction:parameter-type:
479 : : *
480 : : * The type of the parameter that must be given when activating the
481 : : * action.
482 : : *
483 : : * Since: 2.38
484 : : **/
485 : 2 : g_object_class_install_property (object_class, PROP_PARAMETER_TYPE,
486 : : g_param_spec_boxed ("parameter-type", NULL, NULL,
487 : : G_TYPE_VARIANT_TYPE,
488 : : G_PARAM_READABLE |
489 : : G_PARAM_STATIC_STRINGS));
490 : :
491 : : /**
492 : : * GPropertyAction:enabled:
493 : : *
494 : : * If @action is currently enabled.
495 : : *
496 : : * If the action is disabled then calls to g_action_activate() and
497 : : * g_action_change_state() have no effect.
498 : : *
499 : : * Since: 2.38
500 : : **/
501 : 2 : g_object_class_install_property (object_class, PROP_ENABLED,
502 : : g_param_spec_boolean ("enabled", NULL, NULL,
503 : : TRUE,
504 : : G_PARAM_READABLE |
505 : : G_PARAM_STATIC_STRINGS));
506 : :
507 : : /**
508 : : * GPropertyAction:state-type:
509 : : *
510 : : * The #GVariantType of the state that the action has, or %NULL if the
511 : : * action is stateless.
512 : : *
513 : : * Since: 2.38
514 : : **/
515 : 2 : g_object_class_install_property (object_class, PROP_STATE_TYPE,
516 : : g_param_spec_boxed ("state-type", NULL, NULL,
517 : : G_TYPE_VARIANT_TYPE,
518 : : G_PARAM_READABLE |
519 : : G_PARAM_STATIC_STRINGS));
520 : :
521 : : /**
522 : : * GPropertyAction:state:
523 : : *
524 : : * The state of the action, or %NULL if the action is stateless.
525 : : *
526 : : * Since: 2.38
527 : : **/
528 : 2 : g_object_class_install_property (object_class, PROP_STATE,
529 : : g_param_spec_variant ("state", NULL, NULL,
530 : : G_VARIANT_TYPE_ANY,
531 : : NULL,
532 : : G_PARAM_READABLE |
533 : : G_PARAM_STATIC_STRINGS));
534 : :
535 : : /**
536 : : * GPropertyAction:object:
537 : : *
538 : : * The object to wrap a property on.
539 : : *
540 : : * The object must be a non-%NULL #GObject with properties.
541 : : *
542 : : * Since: 2.38
543 : : **/
544 : 2 : g_object_class_install_property (object_class, PROP_OBJECT,
545 : : g_param_spec_object ("object", NULL, NULL,
546 : : G_TYPE_OBJECT,
547 : : G_PARAM_WRITABLE |
548 : : G_PARAM_CONSTRUCT_ONLY |
549 : : G_PARAM_STATIC_STRINGS));
550 : :
551 : : /**
552 : : * GPropertyAction:property-name:
553 : : *
554 : : * The name of the property to wrap on the object.
555 : : *
556 : : * The property must exist on the passed-in object and it must be
557 : : * readable and writable (and not construct-only).
558 : : *
559 : : * Since: 2.38
560 : : **/
561 : 2 : g_object_class_install_property (object_class, PROP_PROPERTY_NAME,
562 : : g_param_spec_string ("property-name", NULL, NULL,
563 : : NULL,
564 : : G_PARAM_WRITABLE |
565 : : G_PARAM_CONSTRUCT_ONLY |
566 : : G_PARAM_STATIC_STRINGS));
567 : :
568 : : /**
569 : : * GPropertyAction:invert-boolean:
570 : : *
571 : : * If %TRUE, the state of the action will be the negation of the
572 : : * property value, provided the property is boolean.
573 : : *
574 : : * Since: 2.46
575 : : */
576 : 2 : g_object_class_install_property (object_class, PROP_INVERT_BOOLEAN,
577 : : g_param_spec_boolean ("invert-boolean", NULL, NULL,
578 : : FALSE,
579 : : G_PARAM_READWRITE |
580 : : G_PARAM_CONSTRUCT_ONLY |
581 : : G_PARAM_STATIC_STRINGS));
582 : 2 : }
583 : :
584 : : /**
585 : : * g_property_action_new:
586 : : * @name: the name of the action to create
587 : : * @object: (type GObject.Object): the object that has the property
588 : : * to wrap
589 : : * @property_name: the name of the property
590 : : *
591 : : * Creates a #GAction corresponding to the value of property
592 : : * @property_name on @object.
593 : : *
594 : : * The property must be existent and readable and writable (and not
595 : : * construct-only).
596 : : *
597 : : * This function takes a reference on @object and doesn't release it
598 : : * until the action is destroyed.
599 : : *
600 : : * Returns: a new #GPropertyAction
601 : : *
602 : : * Since: 2.38
603 : : **/
604 : : GPropertyAction *
605 : 7 : g_property_action_new (const gchar *name,
606 : : gpointer object,
607 : : const gchar *property_name)
608 : : {
609 : 7 : g_return_val_if_fail (name != NULL, NULL);
610 : 7 : g_return_val_if_fail (G_IS_OBJECT (object), NULL);
611 : 7 : g_return_val_if_fail (property_name != NULL, NULL);
612 : :
613 : 7 : return g_object_new (G_TYPE_PROPERTY_ACTION,
614 : : "name", name,
615 : : "object", object,
616 : : "property-name", property_name,
617 : : NULL);
618 : : }
|
