GI.Gio.Objects.SimpleAction

A SimpleAction is the obvious simple implementation of the Action interface. This is the easiest way to create an action for purposes of adding it to a SimpleActionGroup.

See also GtkAction.

Exported types

newtype SimpleAction

Memory-managed wrapper type.

Constructors

SimpleAction (ManagedPtr SimpleAction)

Instances

Eq SimpleAction

Defined in GI.Gio.Objects.SimpleAction

Methods

(==) :: SimpleAction -> SimpleAction -> Bool

(/=) :: SimpleAction -> SimpleAction -> Bool

GObject SimpleAction

Defined in GI.Gio.Objects.SimpleAction

Methods

gobjectType :: IO GType

IsGValue SimpleAction

Convert SimpleAction to and from GValue with toGValue and fromGValue.

Defined in GI.Gio.Objects.SimpleAction

Methods

toGValue :: SimpleAction -> IO GValue

fromGValue :: GValue -> IO SimpleAction

HasParentTypes SimpleAction

Defined in GI.Gio.Objects.SimpleAction

type ParentTypes SimpleAction

Defined in GI.Gio.Objects.SimpleAction

type ParentTypes SimpleAction = '[Object, Action]

class (GObject o, IsDescendantOf SimpleAction o) => IsSimpleAction o

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

Instances

(GObject o, IsDescendantOf SimpleAction o) => IsSimpleAction o

Defined in GI.Gio.Objects.SimpleAction

toSimpleAction :: (MonadIO m, IsSimpleAction o) => o -> m SimpleAction

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

noSimpleAction :: Maybe SimpleAction

A convenience alias for Nothing :: Maybe SimpleAction.

Methods

Overloaded methods

new

simpleActionNew

Arguments

:: (HasCallStack, MonadIO m)

=> Text

name: the name of the action

-> Maybe VariantType

parameterType: the type of parameter that will be passed to handlers for the activate signal, or Nothing for no parameter

-> m SimpleAction

Returns: a new SimpleAction

Creates a new action.

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

Since: 2.28

newStateful

simpleActionNewStateful

Arguments

:: (HasCallStack, MonadIO m)

=> Text

name: the name of the action

-> Maybe VariantType

parameterType: the type of the parameter that will be passed to handlers for the activate signal, or Nothing for no parameter

-> GVariant

state: the initial state of the action

-> m SimpleAction

Returns: a new SimpleAction

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

setEnabled

simpleActionSetEnabled

Arguments

:: (HasCallStack, MonadIO m, IsSimpleAction a)

=> a

simple: a SimpleAction

-> Bool

enabled: whether the action is enabled

-> m ()

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

setState

simpleActionSetState

Arguments

:: (HasCallStack, MonadIO m, IsSimpleAction a)

=> a

simple: a SimpleAction

-> GVariant

value: the new GVariant for the state

-> m ()

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

setStateHint

simpleActionSetStateHint

Arguments

:: (HasCallStack, MonadIO m, IsSimpleAction a)

=> a

simple: a SimpleAction

-> Maybe GVariant

stateHint: a GVariant representing the state hint

-> m ()

Sets the state hint for the action.

See actionGetStateHint for more information about action state hints.

Since: 2.44

Properties

enabled

If action is currently enabled.

If the action is disabled then calls to actionActivate and actionChangeState have no effect.

Since: 2.28

constructSimpleActionEnabled :: IsSimpleAction o => Bool -> IO (GValueConstruct o)

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

getSimpleActionEnabled :: (MonadIO m, IsSimpleAction o) => o -> m Bool

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

get simpleAction #enabled

setSimpleActionEnabled :: (MonadIO m, IsSimpleAction o) => o -> Bool -> m ()

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

set simpleAction [ #enabled := value ]

name

The name of the action. This is mostly meaningful for identifying the action once it has been added to a SimpleActionGroup.

Since: 2.28

constructSimpleActionName :: IsSimpleAction o => Text -> IO (GValueConstruct o)

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

getSimpleActionName :: (MonadIO m, IsSimpleAction o) => o -> m (Maybe Text)

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

get simpleAction #name

parameterType

The type of the parameter that must be given when activating the action.

Since: 2.28

constructSimpleActionParameterType :: IsSimpleAction o => VariantType -> IO (GValueConstruct o)

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

getSimpleActionParameterType :: (MonadIO m, IsSimpleAction o) => o -> m (Maybe VariantType)

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

get simpleAction #parameterType

state

The state of the action, or Nothing if the action is stateless.

Since: 2.28

constructSimpleActionState :: IsSimpleAction o => GVariant -> IO (GValueConstruct o)

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

getSimpleActionState :: (MonadIO m, IsSimpleAction o) => o -> m (Maybe GVariant)

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

get simpleAction #state

setSimpleActionState :: (MonadIO m, IsSimpleAction o) => o -> GVariant -> m ()

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

set simpleAction [ #state := value ]

stateType

The VariantType of the state that the action has, or Nothing if the action is stateless.

Since: 2.28

getSimpleActionStateType :: (MonadIO m, IsSimpleAction o) => o -> m (Maybe VariantType)

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

get simpleAction #stateType

Signals

activate

type C_SimpleActionActivateCallback = Ptr () -> Ptr GVariant -> Ptr () -> IO ()

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

type SimpleActionActivateCallback

Arguments

 = Maybe GVariant

parameter: the parameter to the activation, or Nothing if it has no parameter

-> IO ()

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

afterSimpleActionActivate :: (IsSimpleAction a, MonadIO m) => a -> SimpleActionActivateCallback -> m SignalHandlerId

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

genClosure_SimpleActionActivate :: MonadIO m => SimpleActionActivateCallback -> m (GClosure C_SimpleActionActivateCallback)

Wrap the callback into a GClosure.

mk_SimpleActionActivateCallback :: C_SimpleActionActivateCallback -> IO (FunPtr C_SimpleActionActivateCallback)

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

noSimpleActionActivateCallback :: Maybe SimpleActionActivateCallback

A convenience synonym for Nothing :: Maybe SimpleActionActivateCallback.

onSimpleActionActivate :: (IsSimpleAction a, MonadIO m) => a -> SimpleActionActivateCallback -> m SignalHandlerId

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_SimpleActionActivateCallback :: SimpleActionActivateCallback -> C_SimpleActionActivateCallback

Wrap a SimpleActionActivateCallback into a C_SimpleActionActivateCallback.

changeState

type C_SimpleActionChangeStateCallback = Ptr () -> Ptr GVariant -> Ptr () -> IO ()

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

type SimpleActionChangeStateCallback

Arguments

 = Maybe GVariant

value: the requested value for the state

-> IO ()

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

afterSimpleActionChangeState :: (IsSimpleAction a, MonadIO m) => a -> SimpleActionChangeStateCallback -> m SignalHandlerId

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

genClosure_SimpleActionChangeState :: MonadIO m => SimpleActionChangeStateCallback -> m (GClosure C_SimpleActionChangeStateCallback)

Wrap the callback into a GClosure.

mk_SimpleActionChangeStateCallback :: C_SimpleActionChangeStateCallback -> IO (FunPtr C_SimpleActionChangeStateCallback)

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

noSimpleActionChangeStateCallback :: Maybe SimpleActionChangeStateCallback

A convenience synonym for Nothing :: Maybe SimpleActionChangeStateCallback.

onSimpleActionChangeState :: (IsSimpleAction a, MonadIO m) => a -> SimpleActionChangeStateCallback -> m SignalHandlerId

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_SimpleActionChangeStateCallback :: SimpleActionChangeStateCallback -> C_SimpleActionChangeStateCallback

Wrap a SimpleActionChangeStateCallback into a C_SimpleActionChangeStateCallback.