| /* |
| * Copyright © 2010 Codethink Limited |
| * |
| * 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: Ryan Lortie <desrt@desrt.ca> |
| */ |
| |
| #include "config.h" |
| |
| #include "gsimpleaction.h" |
| |
| #include "gaction.h" |
| #include "glibintl.h" |
| |
| /** |
| * SECTION:gsimpleaction |
| * @title: GSimpleAction |
| * @short_description: A simple GAction implementation |
| * @include: gio/gio.h |
| * |
| * A #GSimpleAction is the obvious simple implementation of the #GAction |
| * interface. This is the easiest way to create an action for purposes of |
| * adding it to a #GSimpleActionGroup. |
| * |
| * See also #GtkAction. |
| */ |
| |
| /** |
| * GSimpleAction: |
| * |
| * #GSimpleAction is an opaque data structure and can only be accessed |
| * using the following functions. |
| **/ |
| |
| struct _GSimpleAction |
| { |
| GObject parent_instance; |
| |
| gchar *name; |
| GVariantType *parameter_type; |
| gboolean enabled; |
| GVariant *state; |
| GVariant *state_hint; |
| gboolean state_set_already; |
| }; |
| |
| typedef GObjectClass GSimpleActionClass; |
| |
| static void g_simple_action_iface_init (GActionInterface *iface); |
| G_DEFINE_TYPE_WITH_CODE (GSimpleAction, g_simple_action, G_TYPE_OBJECT, |
| G_IMPLEMENT_INTERFACE (G_TYPE_ACTION, g_simple_action_iface_init)) |
| |
| enum |
| { |
| PROP_NONE, |
| PROP_NAME, |
| PROP_PARAMETER_TYPE, |
| PROP_ENABLED, |
| PROP_STATE_TYPE, |
| PROP_STATE |
| }; |
| |
| enum |
| { |
| SIGNAL_CHANGE_STATE, |
| SIGNAL_ACTIVATE, |
| NR_SIGNALS |
| }; |
| |
| static guint g_simple_action_signals[NR_SIGNALS]; |
| |
| static const gchar * |
| g_simple_action_get_name (GAction *action) |
| { |
| GSimpleAction *simple = G_SIMPLE_ACTION (action); |
| |
| return simple->name; |
| } |
| |
| static const GVariantType * |
| g_simple_action_get_parameter_type (GAction *action) |
| { |
| GSimpleAction *simple = G_SIMPLE_ACTION (action); |
| |
| return simple->parameter_type; |
| } |
| |
| static const GVariantType * |
| g_simple_action_get_state_type (GAction *action) |
| { |
| GSimpleAction *simple = G_SIMPLE_ACTION (action); |
| |
| if (simple->state != NULL) |
| return g_variant_get_type (simple->state); |
| else |
| return NULL; |
| } |
| |
| static GVariant * |
| g_simple_action_get_state_hint (GAction *action) |
| { |
| GSimpleAction *simple = G_SIMPLE_ACTION (action); |
| |
| if (simple->state_hint != NULL) |
| return g_variant_ref (simple->state_hint); |
| else |
| return NULL; |
| } |
| |
| static gboolean |
| g_simple_action_get_enabled (GAction *action) |
| { |
| GSimpleAction *simple = G_SIMPLE_ACTION (action); |
| |
| return simple->enabled; |
| } |
| |
| static void |
| g_simple_action_change_state (GAction *action, |
| GVariant *value) |
| { |
| GSimpleAction *simple = G_SIMPLE_ACTION (action); |
| |
| /* If the user connected a signal handler then they are responsible |
| * for handling state changes. |
| */ |
| if (g_signal_has_handler_pending (action, g_simple_action_signals[SIGNAL_CHANGE_STATE], 0, TRUE)) |
| g_signal_emit (action, g_simple_action_signals[SIGNAL_CHANGE_STATE], 0, value); |
| |
| /* If not, then the default behaviour is to just set the state. */ |
| else |
| g_simple_action_set_state (simple, value); |
| } |
| |
| /** |
| * g_simple_action_set_state: |
| * @simple: a #GSimpleAction |
| * @value: the new #GVariant for the state |
| * |
| * Sets the state of the action. |
| * |
| * This directly updates the 'state' property to the given value. |
| * |
| * This should only be called by the implementor of the action. Users |
| * of the action should not attempt to directly modify the 'state' |
| * property. Instead, they should call g_action_change_state() to |
| * request the change. |
| * |
| * If the @value GVariant is floating, it is consumed. |
| * |
| * Since: 2.30 |
| **/ |
| void |
| g_simple_action_set_state (GSimpleAction *simple, |
| GVariant *value) |
| { |
| g_return_if_fail (G_IS_SIMPLE_ACTION (simple)); |
| g_return_if_fail (value != NULL); |
| |
| { |
| const GVariantType *state_type; |
| |
| state_type = simple->state ? |
| g_variant_get_type (simple->state) : NULL; |
| g_return_if_fail (state_type != NULL); |
| g_return_if_fail (g_variant_is_of_type (value, state_type)); |
| } |
| |
| g_variant_ref_sink (value); |
| |
| if (!simple->state || !g_variant_equal (simple->state, value)) |
| { |
| if (simple->state) |
| g_variant_unref (simple->state); |
| |
| simple->state = g_variant_ref (value); |
| |
| g_object_notify (G_OBJECT (simple), "state"); |
| } |
| |
| g_variant_unref (value); |
| } |
| |
| static GVariant * |
| g_simple_action_get_state (GAction *action) |
| { |
| GSimpleAction *simple = G_SIMPLE_ACTION (action); |
| |
| return simple->state ? g_variant_ref (simple->state) : NULL; |
| } |
| |
| static void |
| g_simple_action_activate (GAction *action, |
| GVariant *parameter) |
| { |
| GSimpleAction *simple = G_SIMPLE_ACTION (action); |
| |
| g_return_if_fail (simple->parameter_type == NULL ? |
| parameter == NULL : |
| (parameter != NULL && |
| g_variant_is_of_type (parameter, |
| simple->parameter_type))); |
| |
| if (parameter != NULL) |
| g_variant_ref_sink (parameter); |
| |
| if (simple->enabled) |
| { |
| /* If the user connected a signal handler then they are responsible |
| * for handling activation. |
| */ |
| if (g_signal_has_handler_pending (action, g_simple_action_signals[SIGNAL_ACTIVATE], 0, TRUE)) |
| g_signal_emit (action, g_simple_action_signals[SIGNAL_ACTIVATE], 0, parameter); |
| |
| /* If not, do some reasonable defaults for stateful actions. */ |
| else if (simple->state) |
| { |
| /* If we have no parameter and this is a boolean action, toggle. */ |
| if (parameter == NULL && g_variant_is_of_type (simple->state, G_VARIANT_TYPE_BOOLEAN)) |
| { |
| gboolean was_enabled = g_variant_get_boolean (simple->state); |
| g_simple_action_change_state (action, g_variant_new_boolean (!was_enabled)); |
| } |
| |
| /* else, if the parameter and state type are the same, do a change-state */ |
| else if (g_variant_is_of_type (simple->state, g_variant_get_type (parameter))) |
| g_simple_action_change_state (action, parameter); |
| } |
| } |
| |
| if (parameter != NULL) |
| g_variant_unref (parameter); |
| } |
| |
| static void |
| g_simple_action_set_property (GObject *object, |
| guint prop_id, |
| const GValue *value, |
| GParamSpec *pspec) |
| { |
| GSimpleAction *action = G_SIMPLE_ACTION (object); |
| |
| switch (prop_id) |
| { |
| case PROP_NAME: |
| action->name = g_strdup (g_value_get_string (value)); |
| break; |
| |
| case PROP_PARAMETER_TYPE: |
| action->parameter_type = g_value_dup_boxed (value); |
| break; |
| |
| case PROP_ENABLED: |
| action->enabled = g_value_get_boolean (value); |
| break; |
| |
| case PROP_STATE: |
| /* The first time we see this (during construct) we should just |
| * take the state as it was handed to us. |
| * |
| * After that, we should make sure we go through the same checks |
| * as the C API. |
| */ |
| if (!action->state_set_already) |
| { |
| action->state = g_value_dup_variant (value); |
| action->state_set_already = TRUE; |
| } |
| else |
| g_simple_action_set_state (action, g_value_get_variant (value)); |
| |
| break; |
| |
| default: |
| g_assert_not_reached (); |
| } |
| } |
| |
| static void |
| g_simple_action_get_property (GObject *object, |
| guint prop_id, |
| GValue *value, |
| GParamSpec *pspec) |
| { |
| GAction *action = G_ACTION (object); |
| |
| switch (prop_id) |
| { |
| case PROP_NAME: |
| g_value_set_string (value, g_simple_action_get_name (action)); |
| break; |
| |
| case PROP_PARAMETER_TYPE: |
| g_value_set_boxed (value, g_simple_action_get_parameter_type (action)); |
| break; |
| |
| case PROP_ENABLED: |
| g_value_set_boolean (value, g_simple_action_get_enabled (action)); |
| break; |
| |
| case PROP_STATE_TYPE: |
| g_value_set_boxed (value, g_simple_action_get_state_type (action)); |
| break; |
| |
| case PROP_STATE: |
| g_value_take_variant (value, g_simple_action_get_state (action)); |
| break; |
| |
| default: |
| g_assert_not_reached (); |
| } |
| } |
| |
| static void |
| g_simple_action_finalize (GObject *object) |
| { |
| GSimpleAction *simple = G_SIMPLE_ACTION (object); |
| |
| g_free (simple->name); |
| if (simple->parameter_type) |
| g_variant_type_free (simple->parameter_type); |
| if (simple->state) |
| g_variant_unref (simple->state); |
| if (simple->state_hint) |
| g_variant_unref (simple->state_hint); |
| |
| G_OBJECT_CLASS (g_simple_action_parent_class) |
| ->finalize (object); |
| } |
| |
| void |
| g_simple_action_init (GSimpleAction *simple) |
| { |
| simple->enabled = TRUE; |
| } |
| |
| void |
| g_simple_action_iface_init (GActionInterface *iface) |
| { |
| iface->get_name = g_simple_action_get_name; |
| iface->get_parameter_type = g_simple_action_get_parameter_type; |
| iface->get_state_type = g_simple_action_get_state_type; |
| iface->get_state_hint = g_simple_action_get_state_hint; |
| iface->get_enabled = g_simple_action_get_enabled; |
| iface->get_state = g_simple_action_get_state; |
| iface->change_state = g_simple_action_change_state; |
| iface->activate = g_simple_action_activate; |
| } |
| |
| void |
| g_simple_action_class_init (GSimpleActionClass *class) |
| { |
| GObjectClass *object_class = G_OBJECT_CLASS (class); |
| |
| object_class->set_property = g_simple_action_set_property; |
| object_class->get_property = g_simple_action_get_property; |
| object_class->finalize = g_simple_action_finalize; |
| |
| /** |
| * GSimpleAction::activate: |
| * @simple: the #GSimpleAction |
| * @parameter: (nullable): the parameter to the activation, or %NULL if it has |
| * no parameter |
| * |
| * Indicates that the action was just activated. |
| * |
| * @parameter will always be of the expected type, i.e. the parameter type |
| * specified when the action was created. If an incorrect type is given when |
| * activating the action, this signal is not emitted. |
| * |
| * Since GLib 2.40, if no handler is connected to this signal then the |
| * default behaviour for boolean-stated actions with a %NULL parameter |
| * type is to toggle them via the #GSimpleAction::change-state signal. |
| * For stateful actions where the state type is equal to the parameter |
| * type, the default is to forward them directly to |
| * #GSimpleAction::change-state. This should allow almost all users |
| * of #GSimpleAction to connect only one handler or the other. |
| * |
| * Since: 2.28 |
| */ |
| g_simple_action_signals[SIGNAL_ACTIVATE] = |
| g_signal_new (I_("activate"), |
| G_TYPE_SIMPLE_ACTION, |
| G_SIGNAL_RUN_LAST | G_SIGNAL_MUST_COLLECT, |
| 0, NULL, NULL, |
| NULL, |
| G_TYPE_NONE, 1, |
| G_TYPE_VARIANT); |
| |
| /** |
| * GSimpleAction::change-state: |
| * @simple: the #GSimpleAction |
| * @value: (nullable): the requested value for the state |
| * |
| * Indicates that the action just received a request to change its |
| * state. |
| * |
| * @value will always be of the correct state type, i.e. the type of the |
| * initial state passed to g_simple_action_new_stateful(). If an incorrect |
| * type is given when requesting to change the state, this signal is not |
| * emitted. |
| * |
| * If no handler is connected to this signal then the default |
| * behaviour is to call g_simple_action_set_state() to set the state |
| * to the requested value. If you connect a signal handler then no |
| * default action is taken. If the state should change then you must |
| * call g_simple_action_set_state() from the handler. |
| * |
| * An example of a 'change-state' handler: |
| * |[<!-- language="C" --> |
| * static void |
| * change_volume_state (GSimpleAction *action, |
| * GVariant *value, |
| * gpointer user_data) |
| * { |
| * gint requested; |
| * |
| * requested = g_variant_get_int32 (value); |
| * |
| * // Volume only goes from 0 to 10 |
| * if (0 <= requested && requested <= 10) |
| * g_simple_action_set_state (action, value); |
| * } |
| * ]| |
| * |
| * The handler need not set the state to the requested value. |
| * It could set it to any value at all, or take some other action. |
| * |
| * Since: 2.30 |
| */ |
| g_simple_action_signals[SIGNAL_CHANGE_STATE] = |
| g_signal_new (I_("change-state"), |
| G_TYPE_SIMPLE_ACTION, |
| G_SIGNAL_RUN_LAST | G_SIGNAL_MUST_COLLECT, |
| 0, NULL, NULL, |
| NULL, |
| G_TYPE_NONE, 1, |
| G_TYPE_VARIANT); |
| |
| /** |
| * GSimpleAction:name: |
| * |
| * The name of the action. This is mostly meaningful for identifying |
| * the action once it has been added to a #GSimpleActionGroup. |
| * |
| * Since: 2.28 |
| **/ |
| g_object_class_install_property (object_class, PROP_NAME, |
| g_param_spec_string ("name", |
| P_("Action Name"), |
| P_("The name used to invoke the action"), |
| NULL, |
| G_PARAM_READWRITE | |
| G_PARAM_CONSTRUCT_ONLY | |
| G_PARAM_STATIC_STRINGS)); |
| |
| /** |
| * GSimpleAction:parameter-type: |
| * |
| * The type of the parameter that must be given when activating the |
| * action. |
| * |
| * Since: 2.28 |
| **/ |
| g_object_class_install_property (object_class, PROP_PARAMETER_TYPE, |
| g_param_spec_boxed ("parameter-type", |
| P_("Parameter Type"), |
| P_("The type of GVariant passed to activate()"), |
| G_TYPE_VARIANT_TYPE, |
| G_PARAM_READWRITE | |
| G_PARAM_CONSTRUCT_ONLY | |
| G_PARAM_STATIC_STRINGS)); |
| |
| /** |
| * GSimpleAction:enabled: |
| * |
| * If @action is currently enabled. |
| * |
| * If the action is disabled then calls to g_action_activate() and |
| * g_action_change_state() have no effect. |
| * |
| * Since: 2.28 |
| **/ |
| g_object_class_install_property (object_class, PROP_ENABLED, |
| g_param_spec_boolean ("enabled", |
| P_("Enabled"), |
| P_("If the action can be activated"), |
| TRUE, |
| G_PARAM_READWRITE | |
| G_PARAM_STATIC_STRINGS)); |
| |
| /** |
| * GSimpleAction:state-type: |
| * |
| * The #GVariantType of the state that the action has, or %NULL if the |
| * action is stateless. |
| * |
| * Since: 2.28 |
| **/ |
| g_object_class_install_property (object_class, PROP_STATE_TYPE, |
| g_param_spec_boxed ("state-type", |
| P_("State Type"), |
| P_("The type of the state kept by the action"), |
| G_TYPE_VARIANT_TYPE, |
| G_PARAM_READABLE | |
| G_PARAM_STATIC_STRINGS)); |
| |
| /** |
| * GSimpleAction:state: |
| * |
| * The state of the action, or %NULL if the action is stateless. |
| * |
| * Since: 2.28 |
| **/ |
| g_object_class_install_property (object_class, PROP_STATE, |
| g_param_spec_variant ("state", |
| P_("State"), |
| P_("The state the action is in"), |
| G_VARIANT_TYPE_ANY, |
| NULL, |
| G_PARAM_READWRITE | G_PARAM_CONSTRUCT | |
| G_PARAM_STATIC_STRINGS)); |
| } |
| |
| /** |
| * g_simple_action_set_enabled: |
| * @simple: a #GSimpleAction |
| * @enabled: whether the action is enabled |
| * |
| * Sets the action as enabled or not. |
| * |
| * An action must be enabled in order to be activated or in order to |
| * have its state changed from outside callers. |
| * |
| * This should only be called by the implementor of the action. Users |
| * of the action should not attempt to modify its enabled flag. |
| * |
| * Since: 2.28 |
| **/ |
| void |
| g_simple_action_set_enabled (GSimpleAction *simple, |
| gboolean enabled) |
| { |
| g_return_if_fail (G_IS_SIMPLE_ACTION (simple)); |
| |
| enabled = !!enabled; |
| |
| if (simple->enabled != enabled) |
| { |
| simple->enabled = enabled; |
| g_object_notify (G_OBJECT (simple), "enabled"); |
| } |
| } |
| |
| /** |
| * g_simple_action_set_state_hint: |
| * @simple: a #GSimpleAction |
| * @state_hint: (nullable): a #GVariant representing the state hint |
| * |
| * Sets the state hint for the action. |
| * |
| * See g_action_get_state_hint() for more information about |
| * action state hints. |
| * |
| * Since: 2.44 |
| **/ |
| void |
| g_simple_action_set_state_hint (GSimpleAction *simple, |
| GVariant *state_hint) |
| { |
| g_return_if_fail (G_IS_SIMPLE_ACTION (simple)); |
| |
| if (simple->state_hint != NULL) |
| { |
| g_variant_unref (simple->state_hint); |
| simple->state_hint = NULL; |
| } |
| |
| if (state_hint != NULL) |
| simple->state_hint = g_variant_ref (state_hint); |
| } |
| |
| /** |
| * g_simple_action_new: |
| * @name: the name of the action |
| * @parameter_type: (nullable): the type of parameter that will be passed to |
| * handlers for the #GSimpleAction::activate signal, or %NULL for no parameter |
| * |
| * Creates a new action. |
| * |
| * The created action is stateless. See g_simple_action_new_stateful() to create |
| * an action that has state. |
| * |
| * Returns: a new #GSimpleAction |
| * |
| * Since: 2.28 |
| **/ |
| GSimpleAction * |
| g_simple_action_new (const gchar *name, |
| const GVariantType *parameter_type) |
| { |
| g_return_val_if_fail (name != NULL, NULL); |
| |
| return g_object_new (G_TYPE_SIMPLE_ACTION, |
| "name", name, |
| "parameter-type", parameter_type, |
| NULL); |
| } |
| |
| /** |
| * g_simple_action_new_stateful: |
| * @name: the name of the action |
| * @parameter_type: (nullable): the type of the parameter that will be passed to |
| * handlers for the #GSimpleAction::activate signal, or %NULL for no parameter |
| * @state: the initial state of the action |
| * |
| * Creates a new stateful action. |
| * |
| * All future state values must have the same #GVariantType as the initial |
| * @state. |
| * |
| * If the @state #GVariant is floating, it is consumed. |
| * |
| * Returns: a new #GSimpleAction |
| * |
| * Since: 2.28 |
| **/ |
| GSimpleAction * |
| g_simple_action_new_stateful (const gchar *name, |
| const GVariantType *parameter_type, |
| GVariant *state) |
| { |
| return g_object_new (G_TYPE_SIMPLE_ACTION, |
| "name", name, |
| "parameter-type", parameter_type, |
| "state", state, |
| NULL); |
| } |
