gio/gsimpleaction.c - third_party/glib - Git at Google

 /*
  * 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,
                   g_cclosure_marshal_VOID__VARIANT,
                   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,
                   g_cclosure_marshal_VOID__VARIANT,
                   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);
 }
	/*
	* 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,
	g_cclosure_marshal_VOID__VARIANT,
	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,
	g_cclosure_marshal_VOID__VARIANT,
	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);
	}