Memory-managed wrapper type.

Type class for types which can be safely cast to SimpleAction, for instance with toSimpleAction.

Cast to SimpleAction, for types for which this is known to be safe. For general casts, use castTo.

A convenience alias for Nothing :: Maybe SimpleAction.

Creates a new action.

The created action is stateless. See simpleActionNewStateful to create an action that has state.

Since: 2.28

Creates a new stateful action.

All future state values must have the same VariantType as the initial state.

If the state GVariant is floating, it is consumed.

Since: 2.28

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

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 actionChangeState to request the change.

If the value GVariant is floating, it is consumed.

Since: 2.30

Sets the state hint for the action.

See actionGetStateHint for more information about action state hints.

Since: 2.44

Construct a GValueConstruct with valid value for the “enabled” property. This is rarely needed directly, but it is used by new.

Get the value of the “enabled” property. When overloading is enabled, this is equivalent to

get simpleAction #enabled

Set the value of the “enabled” property. When overloading is enabled, this is equivalent to

set simpleAction [ #enabled := value ]

Construct a GValueConstruct with valid value for the “name” property. This is rarely needed directly, but it is used by new.

Get the value of the “name” property. When overloading is enabled, this is equivalent to

get simpleAction #name

Construct a GValueConstruct with valid value for the “parameter-type” property. This is rarely needed directly, but it is used by new.

Get the value of the “parameter-type” property. When overloading is enabled, this is equivalent to

get simpleAction #parameterType

Construct a GValueConstruct with valid value for the “state” property. This is rarely needed directly, but it is used by new.

Get the value of the “state” property. When overloading is enabled, this is equivalent to

get simpleAction #state

Set the value of the “state” property. When overloading is enabled, this is equivalent to

set simpleAction [ #state := value ]

Get the value of the “state-type” property. When overloading is enabled, this is equivalent to

get simpleAction #stateType

Type for the callback on the (unwrapped) C side.

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 Nothing parameter type is to toggle them via the changeState signal. For stateful actions where the state type is equal to the parameter type, the default is to forward them directly to changeState. This should allow almost all users of SimpleAction to connect only one handler or the other.

Since: 2.28

Connect a signal handler for the activate signal, to be run after the default handler. When overloading is enabled, this is equivalent to

after simpleAction #activate callback

Wrap the callback into a GClosure.

Generate a function pointer callable from C code, from a C_SimpleActionActivateCallback.

A convenience synonym for Nothing :: Maybe SimpleActionActivateCallback.

Connect a signal handler for the activate signal, to be run before the default handler. When overloading is enabled, this is equivalent to

on simpleAction #activate callback

Wrap a SimpleActionActivateCallback into a C_SimpleActionActivateCallback.

Type for the callback on the (unwrapped) C side.

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 simpleActionNewStateful. 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 simpleActionSetState 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 simpleActionSetState from the handler.

An example of a 'change-state' handler:

C code

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

Connect a signal handler for the changeState signal, to be run after the default handler. When overloading is enabled, this is equivalent to

after simpleAction #changeState callback

Wrap the callback into a GClosure.

Generate a function pointer callable from C code, from a C_SimpleActionChangeStateCallback.

A convenience synonym for Nothing :: Maybe SimpleActionChangeStateCallback.

Connect a signal handler for the changeState signal, to be run before the default handler. When overloading is enabled, this is equivalent to

on simpleAction #changeState callback

Wrap a SimpleActionChangeStateCallback into a C_SimpleActionChangeStateCallback.