nexmon – Blame information for rev 1

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