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

Constructors

SimpleAction (ManagedPtr SimpleAction)

Instances

GObject SimpleAction

Methods

gobjectType :: SimpleAction -> IO GType

IsObject SimpleAction

IsSimpleAction SimpleAction

IsAction SimpleAction

class GObject o => IsSimpleAction o

Instances

(GObject a, UnknownAncestorError Constraint SimpleAction a) => IsSimpleAction a

IsSimpleAction SimpleAction

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

noSimpleAction :: Maybe SimpleAction

Methods

new

simpleActionNew

Arguments

:: (HasCallStack, MonadIO m)

=> Text

name: the name of the action

-> Maybe VariantType

parameterType: the type of parameter to the activate function

-> m SimpleAction

Returns: a new SimpleAction

Creates a new action.

The created action is stateless. See simpleActionNewStateful.

Since: 2.28

newStateful

simpleActionNewStateful

Arguments

:: (HasCallStack, MonadIO m)

=> Text

name: the name of the action

-> Maybe VariantType

parameterType: the type of the parameter to the activate function

-> GVariant

state: the initial state of the action

-> m SimpleAction

Returns: a new SimpleAction

Creates a new stateful action.

state is the initial state of the 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

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

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

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

name

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

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

parameterType

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

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

state

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

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

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

stateType

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

Signals

activate

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

type SimpleActionActivateCallback = Maybe GVariant -> IO ()

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

genClosure_SimpleActionActivate :: SimpleActionActivateCallback -> IO Closure

mk_SimpleActionActivateCallback :: C_SimpleActionActivateCallback -> IO (FunPtr C_SimpleActionActivateCallback)

noSimpleActionActivateCallback :: Maybe SimpleActionActivateCallback

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

wrap_SimpleActionActivateCallback :: SimpleActionActivateCallback -> Ptr () -> Ptr GVariant -> Ptr () -> IO ()

changeState

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

type SimpleActionChangeStateCallback = Maybe GVariant -> IO ()

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

genClosure_SimpleActionChangeState :: SimpleActionChangeStateCallback -> IO Closure

mk_SimpleActionChangeStateCallback :: C_SimpleActionChangeStateCallback -> IO (FunPtr C_SimpleActionChangeStateCallback)

noSimpleActionChangeStateCallback :: Maybe SimpleActionChangeStateCallback

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

wrap_SimpleActionChangeStateCallback :: SimpleActionChangeStateCallback -> Ptr () -> Ptr GVariant -> Ptr () -> IO ()