{- |
Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
License    : LGPL-2.1
Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)

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

See also @/GtkAction/@.
-}

#define ENABLE_OVERLOADING \
       (!defined(__HADDOCK_VERSION__))

module GI.Gio.Objects.SimpleAction
    ( 

-- * Exported types
    SimpleAction(..)                        ,
    IsSimpleAction                          ,
    toSimpleAction                          ,
    noSimpleAction                          ,


 -- * Methods
-- ** new #method:new#

    simpleActionNew                         ,


-- ** newStateful #method:newStateful#

    simpleActionNewStateful                 ,


-- ** setEnabled #method:setEnabled#

#if ENABLE_OVERLOADING
    SimpleActionSetEnabledMethodInfo        ,
#endif
    simpleActionSetEnabled                  ,


-- ** setState #method:setState#

#if ENABLE_OVERLOADING
    SimpleActionSetStateMethodInfo          ,
#endif
    simpleActionSetState                    ,


-- ** setStateHint #method:setStateHint#

#if ENABLE_OVERLOADING
    SimpleActionSetStateHintMethodInfo      ,
#endif
    simpleActionSetStateHint                ,




 -- * Properties
-- ** enabled #attr:enabled#
{- | If /@action@/ is currently enabled.

If the action is disabled then calls to 'GI.Gio.Interfaces.Action.actionActivate' and
'GI.Gio.Interfaces.Action.actionChangeState' have no effect.

/Since: 2.28/
-}
#if ENABLE_OVERLOADING
    SimpleActionEnabledPropertyInfo         ,
#endif
    constructSimpleActionEnabled            ,
    getSimpleActionEnabled                  ,
    setSimpleActionEnabled                  ,
#if ENABLE_OVERLOADING
    simpleActionEnabled                     ,
#endif


-- ** name #attr:name#
{- | The name of the action. This is mostly meaningful for identifying
the action once it has been added to a 'GI.Gio.Objects.SimpleActionGroup.SimpleActionGroup'.

/Since: 2.28/
-}
#if ENABLE_OVERLOADING
    SimpleActionNamePropertyInfo            ,
#endif
    constructSimpleActionName               ,
    getSimpleActionName                     ,
#if ENABLE_OVERLOADING
    simpleActionName                        ,
#endif


-- ** parameterType #attr:parameterType#
{- | The type of the parameter that must be given when activating the
action.

/Since: 2.28/
-}
#if ENABLE_OVERLOADING
    SimpleActionParameterTypePropertyInfo   ,
#endif
    constructSimpleActionParameterType      ,
    getSimpleActionParameterType            ,
#if ENABLE_OVERLOADING
    simpleActionParameterType               ,
#endif


-- ** state #attr:state#
{- | The state of the action, or 'Nothing' if the action is stateless.

/Since: 2.28/
-}
#if ENABLE_OVERLOADING
    SimpleActionStatePropertyInfo           ,
#endif
    constructSimpleActionState              ,
    getSimpleActionState                    ,
    setSimpleActionState                    ,
#if ENABLE_OVERLOADING
    simpleActionState                       ,
#endif


-- ** stateType #attr:stateType#
{- | The 'GI.GLib.Structs.VariantType.VariantType' of the state that the action has, or 'Nothing' if the
action is stateless.

/Since: 2.28/
-}
#if ENABLE_OVERLOADING
    SimpleActionStateTypePropertyInfo       ,
#endif
    getSimpleActionStateType                ,
#if ENABLE_OVERLOADING
    simpleActionStateType                   ,
#endif




 -- * Signals
-- ** activate #signal:activate#

    C_SimpleActionActivateCallback          ,
    SimpleActionActivateCallback            ,
#if ENABLE_OVERLOADING
    SimpleActionActivateSignalInfo          ,
#endif
    afterSimpleActionActivate               ,
    genClosure_SimpleActionActivate         ,
    mk_SimpleActionActivateCallback         ,
    noSimpleActionActivateCallback          ,
    onSimpleActionActivate                  ,
    wrap_SimpleActionActivateCallback       ,


-- ** changeState #signal:changeState#

    C_SimpleActionChangeStateCallback       ,
    SimpleActionChangeStateCallback         ,
#if ENABLE_OVERLOADING
    SimpleActionChangeStateSignalInfo       ,
#endif
    afterSimpleActionChangeState            ,
    genClosure_SimpleActionChangeState      ,
    mk_SimpleActionChangeStateCallback      ,
    noSimpleActionChangeStateCallback       ,
    onSimpleActionChangeState               ,
    wrap_SimpleActionChangeStateCallback    ,




    ) where

import Data.GI.Base.ShortPrelude
import qualified Data.GI.Base.ShortPrelude as SP
import qualified Data.GI.Base.Overloading as O
import qualified Prelude as P

import qualified Data.GI.Base.Attributes as GI.Attributes
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP

import qualified GI.GLib.Structs.VariantType as GLib.VariantType
import qualified GI.GObject.Objects.Object as GObject.Object
import {-# SOURCE #-} qualified GI.Gio.Interfaces.Action as Gio.Action

-- | Memory-managed wrapper type.
newtype SimpleAction = SimpleAction (ManagedPtr SimpleAction)
foreign import ccall "g_simple_action_get_type"
    c_g_simple_action_get_type :: IO GType

instance GObject SimpleAction where
    gobjectType :: SimpleAction -> IO GType
gobjectType _ = IO GType
c_g_simple_action_get_type
    

-- | Type class for types which can be safely cast to `SimpleAction`, for instance with `toSimpleAction`.
class GObject o => IsSimpleAction o
#if MIN_VERSION_base(4,9,0)
instance {-# OVERLAPPABLE #-} (GObject a, O.UnknownAncestorError SimpleAction a) =>
    IsSimpleAction a
#endif
instance IsSimpleAction SimpleAction
instance GObject.Object.IsObject SimpleAction
instance Gio.Action.IsAction SimpleAction

-- | Cast to `SimpleAction`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`.
toSimpleAction :: (MonadIO m, IsSimpleAction o) => o -> m SimpleAction
toSimpleAction :: o -> m SimpleAction
toSimpleAction = IO SimpleAction -> m SimpleAction
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SimpleAction -> m SimpleAction)
-> (o -> IO SimpleAction) -> o -> m SimpleAction
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ManagedPtr SimpleAction -> SimpleAction) -> o -> IO SimpleAction
forall o o'.
(HasCallStack, GObject o, GObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
unsafeCastTo ManagedPtr SimpleAction -> SimpleAction
SimpleAction

-- | A convenience alias for `Nothing` :: `Maybe` `SimpleAction`.
noSimpleAction :: Maybe SimpleAction
noSimpleAction :: Maybe SimpleAction
noSimpleAction = Maybe SimpleAction
forall a. Maybe a
Nothing

#if ENABLE_OVERLOADING
type family ResolveSimpleActionMethod (t :: Symbol) (o :: *) :: * where
    ResolveSimpleActionMethod "activate" o = Gio.Action.ActionActivateMethodInfo
    ResolveSimpleActionMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveSimpleActionMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveSimpleActionMethod "changeState" o = Gio.Action.ActionChangeStateMethodInfo
    ResolveSimpleActionMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveSimpleActionMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveSimpleActionMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
    ResolveSimpleActionMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveSimpleActionMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveSimpleActionMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveSimpleActionMethod "ref" o = GObject.Object.ObjectRefMethodInfo
    ResolveSimpleActionMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveSimpleActionMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveSimpleActionMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveSimpleActionMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveSimpleActionMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveSimpleActionMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
    ResolveSimpleActionMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveSimpleActionMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveSimpleActionMethod "getEnabled" o = Gio.Action.ActionGetEnabledMethodInfo
    ResolveSimpleActionMethod "getName" o = Gio.Action.ActionGetNameMethodInfo
    ResolveSimpleActionMethod "getParameterType" o = Gio.Action.ActionGetParameterTypeMethodInfo
    ResolveSimpleActionMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveSimpleActionMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveSimpleActionMethod "getState" o = Gio.Action.ActionGetStateMethodInfo
    ResolveSimpleActionMethod "getStateHint" o = Gio.Action.ActionGetStateHintMethodInfo
    ResolveSimpleActionMethod "getStateType" o = Gio.Action.ActionGetStateTypeMethodInfo
    ResolveSimpleActionMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveSimpleActionMethod "setEnabled" o = SimpleActionSetEnabledMethodInfo
    ResolveSimpleActionMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveSimpleActionMethod "setState" o = SimpleActionSetStateMethodInfo
    ResolveSimpleActionMethod "setStateHint" o = SimpleActionSetStateHintMethodInfo
    ResolveSimpleActionMethod l o = O.MethodResolutionFailed l o

instance (info ~ ResolveSimpleActionMethod t SimpleAction, O.MethodInfo info SimpleAction p) => O.IsLabelProxy t (SimpleAction -> p) where
    fromLabelProxy _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)

#if MIN_VERSION_base(4,9,0)
instance (info ~ ResolveSimpleActionMethod t SimpleAction, O.MethodInfo info SimpleAction p) => O.IsLabel t (SimpleAction -> p) where
#if MIN_VERSION_base(4,10,0)
    fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
#else
    fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
#endif
#endif

#endif

-- signal SimpleAction::activate
{- |
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 'GI.Gio.Objects.SimpleAction.SimpleAction'::@/change-state/@ signal.
For stateful actions where the state type is equal to the parameter
type, the default is to forward them directly to
'GI.Gio.Objects.SimpleAction.SimpleAction'::@/change-state/@.  This should allow almost all users
of 'GI.Gio.Objects.SimpleAction.SimpleAction' to connect only one handler or the other.

/Since: 2.28/
-}
type SimpleActionActivateCallback =
    Maybe GVariant
    {- ^ /@parameter@/: the parameter to the activation, or 'Nothing' if it has
  no parameter -}
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `SimpleActionActivateCallback`@.
noSimpleActionActivateCallback :: Maybe SimpleActionActivateCallback
noSimpleActionActivateCallback :: Maybe SimpleActionActivateCallback
noSimpleActionActivateCallback = Maybe SimpleActionActivateCallback
forall a. Maybe a
Nothing

-- | Type for the callback on the (unwrapped) C side.
type C_SimpleActionActivateCallback =
    Ptr () ->                               -- object
    Ptr GVariant ->
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_SimpleActionActivateCallback`.
foreign import ccall "wrapper"
    mk_SimpleActionActivateCallback :: C_SimpleActionActivateCallback -> IO (FunPtr C_SimpleActionActivateCallback)

-- | Wrap the callback into a `Closure`.
genClosure_SimpleActionActivate :: SimpleActionActivateCallback -> IO Closure
genClosure_SimpleActionActivate :: SimpleActionActivateCallback -> IO Closure
genClosure_SimpleActionActivate cb :: SimpleActionActivateCallback
cb = do
    let cb' :: C_SimpleActionActivateCallback
cb' = SimpleActionActivateCallback -> C_SimpleActionActivateCallback
wrap_SimpleActionActivateCallback SimpleActionActivateCallback
cb
    C_SimpleActionActivateCallback
-> IO (FunPtr C_SimpleActionActivateCallback)
mk_SimpleActionActivateCallback C_SimpleActionActivateCallback
cb' IO (FunPtr C_SimpleActionActivateCallback)
-> (FunPtr C_SimpleActionActivateCallback -> IO Closure)
-> IO Closure
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_SimpleActionActivateCallback -> IO Closure
forall a. FunPtr a -> IO Closure
newCClosure


-- | Wrap a `SimpleActionActivateCallback` into a `C_SimpleActionActivateCallback`.
wrap_SimpleActionActivateCallback ::
    SimpleActionActivateCallback ->
    C_SimpleActionActivateCallback
wrap_SimpleActionActivateCallback :: SimpleActionActivateCallback -> C_SimpleActionActivateCallback
wrap_SimpleActionActivateCallback _cb :: SimpleActionActivateCallback
_cb _ parameter :: Ptr GVariant
parameter _ = do
    Maybe GVariant
maybeParameter <-
        if Ptr GVariant
parameter Ptr GVariant -> Ptr GVariant -> Bool
forall a. Eq a => a -> a -> Bool
== Ptr GVariant
forall a. Ptr a
nullPtr
        then Maybe GVariant -> IO (Maybe GVariant)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe GVariant
forall a. Maybe a
Nothing
        else do
            GVariant
parameter' <- Ptr GVariant -> IO GVariant
B.GVariant.newGVariantFromPtr Ptr GVariant
parameter
            Maybe GVariant -> IO (Maybe GVariant)
forall (m :: * -> *) a. Monad m => a -> m a
return (Maybe GVariant -> IO (Maybe GVariant))
-> Maybe GVariant -> IO (Maybe GVariant)
forall a b. (a -> b) -> a -> b
$ GVariant -> Maybe GVariant
forall a. a -> Maybe a
Just GVariant
parameter'
    SimpleActionActivateCallback
_cb  Maybe GVariant
maybeParameter


{- |
Connect a signal handler for the “@activate@” signal, to be run before the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.on' simpleAction #activate callback
@
-}
onSimpleActionActivate :: (IsSimpleAction a, MonadIO m) => a -> SimpleActionActivateCallback -> m SignalHandlerId
onSimpleActionActivate :: a -> SimpleActionActivateCallback -> m SignalHandlerId
onSimpleActionActivate obj :: a
obj cb :: SimpleActionActivateCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_SimpleActionActivateCallback
cb' = SimpleActionActivateCallback -> C_SimpleActionActivateCallback
wrap_SimpleActionActivateCallback SimpleActionActivateCallback
cb
    FunPtr C_SimpleActionActivateCallback
cb'' <- C_SimpleActionActivateCallback
-> IO (FunPtr C_SimpleActionActivateCallback)
mk_SimpleActionActivateCallback C_SimpleActionActivateCallback
cb'
    a
-> String
-> FunPtr C_SimpleActionActivateCallback
-> SignalConnectMode
-> IO SignalHandlerId
forall o a.
GObject o =>
o -> String -> FunPtr a -> SignalConnectMode -> IO SignalHandlerId
connectSignalFunPtr a
obj "activate" FunPtr C_SimpleActionActivateCallback
cb'' SignalConnectMode
SignalConnectBefore

{- |
Connect a signal handler for the “@activate@” signal, to be run after the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.after' simpleAction #activate callback
@
-}
afterSimpleActionActivate :: (IsSimpleAction a, MonadIO m) => a -> SimpleActionActivateCallback -> m SignalHandlerId
afterSimpleActionActivate :: a -> SimpleActionActivateCallback -> m SignalHandlerId
afterSimpleActionActivate obj :: a
obj cb :: SimpleActionActivateCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_SimpleActionActivateCallback
cb' = SimpleActionActivateCallback -> C_SimpleActionActivateCallback
wrap_SimpleActionActivateCallback SimpleActionActivateCallback
cb
    FunPtr C_SimpleActionActivateCallback
cb'' <- C_SimpleActionActivateCallback
-> IO (FunPtr C_SimpleActionActivateCallback)
mk_SimpleActionActivateCallback C_SimpleActionActivateCallback
cb'
    a
-> String
-> FunPtr C_SimpleActionActivateCallback
-> SignalConnectMode
-> IO SignalHandlerId
forall o a.
GObject o =>
o -> String -> FunPtr a -> SignalConnectMode -> IO SignalHandlerId
connectSignalFunPtr a
obj "activate" FunPtr C_SimpleActionActivateCallback
cb'' SignalConnectMode
SignalConnectAfter


-- signal SimpleAction::change-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 'GI.Gio.Objects.SimpleAction.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 'GI.Gio.Objects.SimpleAction.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 'GI.Gio.Objects.SimpleAction.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/
-}
type SimpleActionChangeStateCallback =
    Maybe GVariant
    {- ^ /@value@/: the requested value for the state -}
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `SimpleActionChangeStateCallback`@.
noSimpleActionChangeStateCallback :: Maybe SimpleActionChangeStateCallback
noSimpleActionChangeStateCallback :: Maybe SimpleActionActivateCallback
noSimpleActionChangeStateCallback = Maybe SimpleActionActivateCallback
forall a. Maybe a
Nothing

-- | Type for the callback on the (unwrapped) C side.
type C_SimpleActionChangeStateCallback =
    Ptr () ->                               -- object
    Ptr GVariant ->
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_SimpleActionChangeStateCallback`.
foreign import ccall "wrapper"
    mk_SimpleActionChangeStateCallback :: C_SimpleActionChangeStateCallback -> IO (FunPtr C_SimpleActionChangeStateCallback)

-- | Wrap the callback into a `Closure`.
genClosure_SimpleActionChangeState :: SimpleActionChangeStateCallback -> IO Closure
genClosure_SimpleActionChangeState :: SimpleActionActivateCallback -> IO Closure
genClosure_SimpleActionChangeState cb :: SimpleActionActivateCallback
cb = do
    let cb' :: C_SimpleActionActivateCallback
cb' = SimpleActionActivateCallback -> C_SimpleActionActivateCallback
wrap_SimpleActionChangeStateCallback SimpleActionActivateCallback
cb
    C_SimpleActionActivateCallback
-> IO (FunPtr C_SimpleActionActivateCallback)
mk_SimpleActionChangeStateCallback C_SimpleActionActivateCallback
cb' IO (FunPtr C_SimpleActionActivateCallback)
-> (FunPtr C_SimpleActionActivateCallback -> IO Closure)
-> IO Closure
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_SimpleActionActivateCallback -> IO Closure
forall a. FunPtr a -> IO Closure
newCClosure


-- | Wrap a `SimpleActionChangeStateCallback` into a `C_SimpleActionChangeStateCallback`.
wrap_SimpleActionChangeStateCallback ::
    SimpleActionChangeStateCallback ->
    C_SimpleActionChangeStateCallback
wrap_SimpleActionChangeStateCallback :: SimpleActionActivateCallback -> C_SimpleActionActivateCallback
wrap_SimpleActionChangeStateCallback _cb :: SimpleActionActivateCallback
_cb _ value :: Ptr GVariant
value _ = do
    Maybe GVariant
maybeValue <-
        if Ptr GVariant
value Ptr GVariant -> Ptr GVariant -> Bool
forall a. Eq a => a -> a -> Bool
== Ptr GVariant
forall a. Ptr a
nullPtr
        then Maybe GVariant -> IO (Maybe GVariant)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe GVariant
forall a. Maybe a
Nothing
        else do
            GVariant
value' <- Ptr GVariant -> IO GVariant
B.GVariant.newGVariantFromPtr Ptr GVariant
value
            Maybe GVariant -> IO (Maybe GVariant)
forall (m :: * -> *) a. Monad m => a -> m a
return (Maybe GVariant -> IO (Maybe GVariant))
-> Maybe GVariant -> IO (Maybe GVariant)
forall a b. (a -> b) -> a -> b
$ GVariant -> Maybe GVariant
forall a. a -> Maybe a
Just GVariant
value'
    SimpleActionActivateCallback
_cb  Maybe GVariant
maybeValue


{- |
Connect a signal handler for the “@change-state@” signal, to be run before the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.on' simpleAction #changeState callback
@
-}
onSimpleActionChangeState :: (IsSimpleAction a, MonadIO m) => a -> SimpleActionChangeStateCallback -> m SignalHandlerId
onSimpleActionChangeState :: a -> SimpleActionActivateCallback -> m SignalHandlerId
onSimpleActionChangeState obj :: a
obj cb :: SimpleActionActivateCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_SimpleActionActivateCallback
cb' = SimpleActionActivateCallback -> C_SimpleActionActivateCallback
wrap_SimpleActionChangeStateCallback SimpleActionActivateCallback
cb
    FunPtr C_SimpleActionActivateCallback
cb'' <- C_SimpleActionActivateCallback
-> IO (FunPtr C_SimpleActionActivateCallback)
mk_SimpleActionChangeStateCallback C_SimpleActionActivateCallback
cb'
    a
-> String
-> FunPtr C_SimpleActionActivateCallback
-> SignalConnectMode
-> IO SignalHandlerId
forall o a.
GObject o =>
o -> String -> FunPtr a -> SignalConnectMode -> IO SignalHandlerId
connectSignalFunPtr a
obj "change-state" FunPtr C_SimpleActionActivateCallback
cb'' SignalConnectMode
SignalConnectBefore

{- |
Connect a signal handler for the “@change-state@” signal, to be run after the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.after' simpleAction #changeState callback
@
-}
afterSimpleActionChangeState :: (IsSimpleAction a, MonadIO m) => a -> SimpleActionChangeStateCallback -> m SignalHandlerId
afterSimpleActionChangeState :: a -> SimpleActionActivateCallback -> m SignalHandlerId
afterSimpleActionChangeState obj :: a
obj cb :: SimpleActionActivateCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_SimpleActionActivateCallback
cb' = SimpleActionActivateCallback -> C_SimpleActionActivateCallback
wrap_SimpleActionChangeStateCallback SimpleActionActivateCallback
cb
    FunPtr C_SimpleActionActivateCallback
cb'' <- C_SimpleActionActivateCallback
-> IO (FunPtr C_SimpleActionActivateCallback)
mk_SimpleActionChangeStateCallback C_SimpleActionActivateCallback
cb'
    a
-> String
-> FunPtr C_SimpleActionActivateCallback
-> SignalConnectMode
-> IO SignalHandlerId
forall o a.
GObject o =>
o -> String -> FunPtr a -> SignalConnectMode -> IO SignalHandlerId
connectSignalFunPtr a
obj "change-state" FunPtr C_SimpleActionActivateCallback
cb'' SignalConnectMode
SignalConnectAfter


--- XXX Duplicated object with different types:
  --- Name {namespace = "Gio", name = "SimpleAction"} -> Property {propName = "enabled", propType = TBasicType TBoolean, propFlags = [PropertyReadable,PropertyWritable], propReadNullable = Nothing, propWriteNullable = Nothing, propTransfer = TransferNothing, propDoc = Documentation {rawDocText = Just "If @action is currently enabled.\n\nIf the action is disabled then calls to g_action_activate() and\ng_action_change_state() have no effect.", sinceVersion = Just "2.28"}, propDeprecated = Nothing}
  --- Name {namespace = "Gio", name = "Action"} -> Property {propName = "enabled", propType = TBasicType TBoolean, propFlags = [PropertyReadable], propReadNullable = Nothing, propWriteNullable = Nothing, propTransfer = TransferNothing, propDoc = Documentation {rawDocText = Just "If @action is currently enabled.\n\nIf the action is disabled then calls to g_action_activate() and\ng_action_change_state() have no effect.", sinceVersion = Just "2.28"}, propDeprecated = Nothing}
--- XXX Duplicated object with different types:
  --- Name {namespace = "Gio", name = "SimpleAction"} -> Property {propName = "name", propType = TBasicType TUTF8, propFlags = [PropertyReadable,PropertyWritable,PropertyConstructOnly], propReadNullable = Nothing, propWriteNullable = Nothing, propTransfer = TransferNothing, propDoc = Documentation {rawDocText = Just "The name of the action. This is mostly meaningful for identifying\nthe action once it has been added to a #GSimpleActionGroup.", sinceVersion = Just "2.28"}, propDeprecated = Nothing}
  --- Name {namespace = "Gio", name = "Action"} -> Property {propName = "name", propType = TBasicType TUTF8, propFlags = [PropertyReadable], propReadNullable = Nothing, propWriteNullable = Nothing, propTransfer = TransferNothing, propDoc = Documentation {rawDocText = Just "The name of the action.  This is mostly meaningful for identifying\nthe action once it has been added to a #GActionGroup. It is immutable.", sinceVersion = Just "2.28"}, propDeprecated = Nothing}
--- XXX Duplicated object with different types:
  --- Name {namespace = "Gio", name = "SimpleAction"} -> Property {propName = "parameter-type", propType = TInterface (Name {namespace = "GLib", name = "VariantType"}), propFlags = [PropertyReadable,PropertyWritable,PropertyConstructOnly], propReadNullable = Nothing, propWriteNullable = Nothing, propTransfer = TransferNothing, propDoc = Documentation {rawDocText = Just "The type of the parameter that must be given when activating the\naction.", sinceVersion = Just "2.28"}, propDeprecated = Nothing}
  --- Name {namespace = "Gio", name = "Action"} -> Property {propName = "parameter-type", propType = TInterface (Name {namespace = "GLib", name = "VariantType"}), propFlags = [PropertyReadable], propReadNullable = Nothing, propWriteNullable = Nothing, propTransfer = TransferNothing, propDoc = Documentation {rawDocText = Just "The type of the parameter that must be given when activating the\naction. This is immutable, and may be %NULL if no parameter is needed when\nactivating the action.", sinceVersion = Just "2.28"}, propDeprecated = Nothing}
--- XXX Duplicated object with different types:
  --- Name {namespace = "Gio", name = "SimpleAction"} -> Property {propName = "state", propType = TVariant, propFlags = [PropertyReadable,PropertyWritable,PropertyConstruct], propReadNullable = Nothing, propWriteNullable = Nothing, propTransfer = TransferNothing, propDoc = Documentation {rawDocText = Just "The state of the action, or %NULL if the action is stateless.", sinceVersion = Just "2.28"}, propDeprecated = Nothing}
  --- Name {namespace = "Gio", name = "Action"} -> Property {propName = "state", propType = TVariant, propFlags = [PropertyReadable], propReadNullable = Nothing, propWriteNullable = Nothing, propTransfer = TransferNothing, propDoc = Documentation {rawDocText = Just "The state of the action, or %NULL if the action is stateless.", sinceVersion = Just "2.28"}, propDeprecated = Nothing}
--- XXX Duplicated object with different types:
  --- Name {namespace = "Gio", name = "SimpleAction"} -> Property {propName = "state-type", propType = TInterface (Name {namespace = "GLib", name = "VariantType"}), propFlags = [PropertyReadable], propReadNullable = Nothing, propWriteNullable = Nothing, propTransfer = TransferNothing, propDoc = Documentation {rawDocText = Just "The #GVariantType of the state that the action has, or %NULL if the\naction is stateless.", sinceVersion = Just "2.28"}, propDeprecated = Nothing}
  --- Name {namespace = "Gio", name = "Action"} -> Property {propName = "state-type", propType = TInterface (Name {namespace = "GLib", name = "VariantType"}), propFlags = [PropertyReadable], propReadNullable = Nothing, propWriteNullable = Nothing, propTransfer = TransferNothing, propDoc = Documentation {rawDocText = Just "The #GVariantType of the state that the action has, or %NULL if the\naction is stateless. This is immutable.", sinceVersion = Just "2.28"}, propDeprecated = Nothing}
-- VVV Prop "enabled"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Nothing,Just False)

{- |
Get the value of the “@enabled@” property.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.get' simpleAction #enabled
@
-}
getSimpleActionEnabled :: (MonadIO m, IsSimpleAction o) => o -> m Bool
getSimpleActionEnabled :: o -> m Bool
getSimpleActionEnabled obj :: o
obj = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Bool
forall a. GObject a => a -> String -> IO Bool
getObjectPropertyBool o
obj "enabled"

{- |
Set the value of the “@enabled@” property.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.set' simpleAction [ #enabled 'Data.GI.Base.Attributes.:=' value ]
@
-}
setSimpleActionEnabled :: (MonadIO m, IsSimpleAction o) => o -> Bool -> m ()
setSimpleActionEnabled :: o -> Bool -> m ()
setSimpleActionEnabled obj :: o
obj val :: Bool
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ o -> String -> Bool -> IO ()
forall a. GObject a => a -> String -> Bool -> IO ()
setObjectPropertyBool o
obj "enabled" Bool
val

{- |
Construct a `GValueConstruct` with valid value for the “@enabled@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
-}
constructSimpleActionEnabled :: (IsSimpleAction o) => Bool -> IO (GValueConstruct o)
constructSimpleActionEnabled :: Bool -> IO (GValueConstruct o)
constructSimpleActionEnabled val :: Bool
val = String -> Bool -> IO (GValueConstruct o)
forall o. String -> Bool -> IO (GValueConstruct o)
constructObjectPropertyBool "enabled" Bool
val

#if ENABLE_OVERLOADING
data SimpleActionEnabledPropertyInfo
instance AttrInfo SimpleActionEnabledPropertyInfo where
    type AttrAllowedOps SimpleActionEnabledPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint SimpleActionEnabledPropertyInfo = (~) Bool
    type AttrBaseTypeConstraint SimpleActionEnabledPropertyInfo = IsSimpleAction
    type AttrGetType SimpleActionEnabledPropertyInfo = Bool
    type AttrLabel SimpleActionEnabledPropertyInfo = "enabled"
    type AttrOrigin SimpleActionEnabledPropertyInfo = SimpleAction
    attrGet _ = getSimpleActionEnabled
    attrSet _ = setSimpleActionEnabled
    attrConstruct _ = constructSimpleActionEnabled
    attrClear _ = undefined
#endif

-- VVV Prop "name"
   -- Type: TBasicType TUTF8
   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]
   -- Nullable: (Nothing,Nothing)

{- |
Get the value of the “@name@” property.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.get' simpleAction #name
@
-}
getSimpleActionName :: (MonadIO m, IsSimpleAction o) => o -> m (Maybe T.Text)
getSimpleActionName :: o -> m (Maybe Text)
getSimpleActionName obj :: o
obj = IO (Maybe Text) -> m (Maybe Text)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ o -> String -> IO (Maybe Text)
forall a. GObject a => a -> String -> IO (Maybe Text)
getObjectPropertyString o
obj "name"

{- |
Construct a `GValueConstruct` with valid value for the “@name@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
-}
constructSimpleActionName :: (IsSimpleAction o) => T.Text -> IO (GValueConstruct o)
constructSimpleActionName :: Text -> IO (GValueConstruct o)
constructSimpleActionName val :: Text
val = String -> Maybe Text -> IO (GValueConstruct o)
forall o. String -> Maybe Text -> IO (GValueConstruct o)
constructObjectPropertyString "name" (Text -> Maybe Text
forall a. a -> Maybe a
Just Text
val)

#if ENABLE_OVERLOADING
data SimpleActionNamePropertyInfo
instance AttrInfo SimpleActionNamePropertyInfo where
    type AttrAllowedOps SimpleActionNamePropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint SimpleActionNamePropertyInfo = (~) T.Text
    type AttrBaseTypeConstraint SimpleActionNamePropertyInfo = IsSimpleAction
    type AttrGetType SimpleActionNamePropertyInfo = (Maybe T.Text)
    type AttrLabel SimpleActionNamePropertyInfo = "name"
    type AttrOrigin SimpleActionNamePropertyInfo = SimpleAction
    attrGet _ = getSimpleActionName
    attrSet _ = undefined
    attrConstruct _ = constructSimpleActionName
    attrClear _ = undefined
#endif

-- VVV Prop "parameter-type"
   -- Type: TInterface (Name {namespace = "GLib", name = "VariantType"})
   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]
   -- Nullable: (Nothing,Nothing)

{- |
Get the value of the “@parameter-type@” property.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.get' simpleAction #parameterType
@
-}
getSimpleActionParameterType :: (MonadIO m, IsSimpleAction o) => o -> m (Maybe GLib.VariantType.VariantType)
getSimpleActionParameterType :: o -> m (Maybe VariantType)
getSimpleActionParameterType obj :: o
obj = IO (Maybe VariantType) -> m (Maybe VariantType)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe VariantType) -> m (Maybe VariantType))
-> IO (Maybe VariantType) -> m (Maybe VariantType)
forall a b. (a -> b) -> a -> b
$ o
-> String
-> (ManagedPtr VariantType -> VariantType)
-> IO (Maybe VariantType)
forall a b.
(GObject a, BoxedObject b) =>
a -> String -> (ManagedPtr b -> b) -> IO (Maybe b)
getObjectPropertyBoxed o
obj "parameter-type" ManagedPtr VariantType -> VariantType
GLib.VariantType.VariantType

{- |
Construct a `GValueConstruct` with valid value for the “@parameter-type@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
-}
constructSimpleActionParameterType :: (IsSimpleAction o) => GLib.VariantType.VariantType -> IO (GValueConstruct o)
constructSimpleActionParameterType :: VariantType -> IO (GValueConstruct o)
constructSimpleActionParameterType val :: VariantType
val = String -> Maybe VariantType -> IO (GValueConstruct o)
forall a o.
BoxedObject a =>
String -> Maybe a -> IO (GValueConstruct o)
constructObjectPropertyBoxed "parameter-type" (VariantType -> Maybe VariantType
forall a. a -> Maybe a
Just VariantType
val)

#if ENABLE_OVERLOADING
data SimpleActionParameterTypePropertyInfo
instance AttrInfo SimpleActionParameterTypePropertyInfo where
    type AttrAllowedOps SimpleActionParameterTypePropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint SimpleActionParameterTypePropertyInfo = (~) GLib.VariantType.VariantType
    type AttrBaseTypeConstraint SimpleActionParameterTypePropertyInfo = IsSimpleAction
    type AttrGetType SimpleActionParameterTypePropertyInfo = (Maybe GLib.VariantType.VariantType)
    type AttrLabel SimpleActionParameterTypePropertyInfo = "parameter-type"
    type AttrOrigin SimpleActionParameterTypePropertyInfo = SimpleAction
    attrGet _ = getSimpleActionParameterType
    attrSet _ = undefined
    attrConstruct _ = constructSimpleActionParameterType
    attrClear _ = undefined
#endif

-- VVV Prop "state"
   -- Type: TVariant
   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct]
   -- Nullable: (Nothing,Just False)

{- |
Get the value of the “@state@” property.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.get' simpleAction #state
@
-}
getSimpleActionState :: (MonadIO m, IsSimpleAction o) => o -> m (Maybe GVariant)
getSimpleActionState :: o -> m (Maybe GVariant)
getSimpleActionState obj :: o
obj = IO (Maybe GVariant) -> m (Maybe GVariant)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe GVariant) -> m (Maybe GVariant))
-> IO (Maybe GVariant) -> m (Maybe GVariant)
forall a b. (a -> b) -> a -> b
$ o -> String -> IO (Maybe GVariant)
forall a. GObject a => a -> String -> IO (Maybe GVariant)
getObjectPropertyVariant o
obj "state"

{- |
Set the value of the “@state@” property.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.set' simpleAction [ #state 'Data.GI.Base.Attributes.:=' value ]
@
-}
setSimpleActionState :: (MonadIO m, IsSimpleAction o) => o -> GVariant -> m ()
setSimpleActionState :: o -> GVariant -> m ()
setSimpleActionState obj :: o
obj val :: GVariant
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ o -> String -> SimpleActionActivateCallback
forall a. GObject a => a -> String -> SimpleActionActivateCallback
setObjectPropertyVariant o
obj "state" (GVariant -> Maybe GVariant
forall a. a -> Maybe a
Just GVariant
val)

{- |
Construct a `GValueConstruct` with valid value for the “@state@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
-}
constructSimpleActionState :: (IsSimpleAction o) => GVariant -> IO (GValueConstruct o)
constructSimpleActionState :: GVariant -> IO (GValueConstruct o)
constructSimpleActionState val :: GVariant
val = String -> Maybe GVariant -> IO (GValueConstruct o)
forall o. String -> Maybe GVariant -> IO (GValueConstruct o)
constructObjectPropertyVariant "state" (GVariant -> Maybe GVariant
forall a. a -> Maybe a
Just GVariant
val)

#if ENABLE_OVERLOADING
data SimpleActionStatePropertyInfo
instance AttrInfo SimpleActionStatePropertyInfo where
    type AttrAllowedOps SimpleActionStatePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint SimpleActionStatePropertyInfo = (~) GVariant
    type AttrBaseTypeConstraint SimpleActionStatePropertyInfo = IsSimpleAction
    type AttrGetType SimpleActionStatePropertyInfo = (Maybe GVariant)
    type AttrLabel SimpleActionStatePropertyInfo = "state"
    type AttrOrigin SimpleActionStatePropertyInfo = SimpleAction
    attrGet _ = getSimpleActionState
    attrSet _ = setSimpleActionState
    attrConstruct _ = constructSimpleActionState
    attrClear _ = undefined
#endif

-- VVV Prop "state-type"
   -- Type: TInterface (Name {namespace = "GLib", name = "VariantType"})
   -- Flags: [PropertyReadable]
   -- Nullable: (Nothing,Nothing)

{- |
Get the value of the “@state-type@” property.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.get' simpleAction #stateType
@
-}
getSimpleActionStateType :: (MonadIO m, IsSimpleAction o) => o -> m (Maybe GLib.VariantType.VariantType)
getSimpleActionStateType :: o -> m (Maybe VariantType)
getSimpleActionStateType obj :: o
obj = IO (Maybe VariantType) -> m (Maybe VariantType)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe VariantType) -> m (Maybe VariantType))
-> IO (Maybe VariantType) -> m (Maybe VariantType)
forall a b. (a -> b) -> a -> b
$ o
-> String
-> (ManagedPtr VariantType -> VariantType)
-> IO (Maybe VariantType)
forall a b.
(GObject a, BoxedObject b) =>
a -> String -> (ManagedPtr b -> b) -> IO (Maybe b)
getObjectPropertyBoxed o
obj "state-type" ManagedPtr VariantType -> VariantType
GLib.VariantType.VariantType

#if ENABLE_OVERLOADING
data SimpleActionStateTypePropertyInfo
instance AttrInfo SimpleActionStateTypePropertyInfo where
    type AttrAllowedOps SimpleActionStateTypePropertyInfo = '[ 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint SimpleActionStateTypePropertyInfo = (~) ()
    type AttrBaseTypeConstraint SimpleActionStateTypePropertyInfo = IsSimpleAction
    type AttrGetType SimpleActionStateTypePropertyInfo = (Maybe GLib.VariantType.VariantType)
    type AttrLabel SimpleActionStateTypePropertyInfo = "state-type"
    type AttrOrigin SimpleActionStateTypePropertyInfo = SimpleAction
    attrGet _ = getSimpleActionStateType
    attrSet _ = undefined
    attrConstruct _ = undefined
    attrClear _ = undefined
#endif

#if ENABLE_OVERLOADING
instance O.HasAttributeList SimpleAction
type instance O.AttributeList SimpleAction = SimpleActionAttributeList
type SimpleActionAttributeList = ('[ '("enabled", SimpleActionEnabledPropertyInfo), '("name", SimpleActionNamePropertyInfo), '("parameterType", SimpleActionParameterTypePropertyInfo), '("state", SimpleActionStatePropertyInfo), '("stateType", SimpleActionStateTypePropertyInfo)] :: [(Symbol, *)])
#endif

#if ENABLE_OVERLOADING
simpleActionEnabled :: AttrLabelProxy "enabled"
simpleActionEnabled = AttrLabelProxy

simpleActionName :: AttrLabelProxy "name"
simpleActionName = AttrLabelProxy

simpleActionParameterType :: AttrLabelProxy "parameterType"
simpleActionParameterType = AttrLabelProxy

simpleActionState :: AttrLabelProxy "state"
simpleActionState = AttrLabelProxy

simpleActionStateType :: AttrLabelProxy "stateType"
simpleActionStateType = AttrLabelProxy

#endif

#if ENABLE_OVERLOADING
data SimpleActionActivateSignalInfo
instance SignalInfo SimpleActionActivateSignalInfo where
    type HaskellCallbackType SimpleActionActivateSignalInfo = SimpleActionActivateCallback
    connectSignal _ obj cb connectMode = do
        let cb' = wrap_SimpleActionActivateCallback cb
        cb'' <- mk_SimpleActionActivateCallback cb'
        connectSignalFunPtr obj "activate" cb'' connectMode

data SimpleActionChangeStateSignalInfo
instance SignalInfo SimpleActionChangeStateSignalInfo where
    type HaskellCallbackType SimpleActionChangeStateSignalInfo = SimpleActionChangeStateCallback
    connectSignal _ obj cb connectMode = do
        let cb' = wrap_SimpleActionChangeStateCallback cb
        cb'' <- mk_SimpleActionChangeStateCallback cb'
        connectSignalFunPtr obj "change-state" cb'' connectMode

type instance O.SignalList SimpleAction = SimpleActionSignalList
type SimpleActionSignalList = ('[ '("activate", SimpleActionActivateSignalInfo), '("changeState", SimpleActionChangeStateSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)])

#endif

-- method SimpleAction::new
-- method type : Constructor
-- Args : [Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the name of the action", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "parameter_type", argType = TInterface (Name {namespace = "GLib", name = "VariantType"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the type of parameter that will be passed to\n  handlers for the #GSimpleAction::activate signal, or %NULL for no parameter", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gio", name = "SimpleAction"}))
-- throws : False
-- Skip return : False

foreign import ccall "g_simple_action_new" g_simple_action_new :: 
    CString ->                              -- name : TBasicType TUTF8
    Ptr GLib.VariantType.VariantType ->     -- parameter_type : TInterface (Name {namespace = "GLib", name = "VariantType"})
    IO (Ptr SimpleAction)

{- |
Creates a new action.

The created action is stateless. See 'GI.Gio.Objects.SimpleAction.simpleActionNewStateful' to create
an action that has state.

/Since: 2.28/
-}
simpleActionNew ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    T.Text
    {- ^ /@name@/: the name of the action -}
    -> Maybe (GLib.VariantType.VariantType)
    {- ^ /@parameterType@/: the type of parameter that will be passed to
  handlers for the 'GI.Gio.Objects.SimpleAction.SimpleAction'::@/activate/@ signal, or 'Nothing' for no parameter -}
    -> m SimpleAction
    {- ^ __Returns:__ a new 'GI.Gio.Objects.SimpleAction.SimpleAction' -}
simpleActionNew :: Text -> Maybe VariantType -> m SimpleAction
simpleActionNew name :: Text
name parameterType :: Maybe VariantType
parameterType = IO SimpleAction -> m SimpleAction
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SimpleAction -> m SimpleAction)
-> IO SimpleAction -> m SimpleAction
forall a b. (a -> b) -> a -> b
$ do
    CString
name' <- Text -> IO CString
textToCString Text
name
    Ptr VariantType
maybeParameterType <- case Maybe VariantType
parameterType of
        Nothing -> Ptr VariantType -> IO (Ptr VariantType)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr VariantType
forall a. Ptr a
nullPtr
        Just jParameterType :: VariantType
jParameterType -> do
            Ptr VariantType
jParameterType' <- VariantType -> IO (Ptr VariantType)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr VariantType
jParameterType
            Ptr VariantType -> IO (Ptr VariantType)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr VariantType
jParameterType'
    Ptr SimpleAction
result <- CString -> Ptr VariantType -> IO (Ptr SimpleAction)
g_simple_action_new CString
name' Ptr VariantType
maybeParameterType
    Text -> Ptr SimpleAction -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "simpleActionNew" Ptr SimpleAction
result
    SimpleAction
result' <- ((ManagedPtr SimpleAction -> SimpleAction)
-> Ptr SimpleAction -> IO SimpleAction
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr SimpleAction -> SimpleAction
SimpleAction) Ptr SimpleAction
result
    Maybe VariantType -> (VariantType -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe VariantType
parameterType VariantType -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
name'
    SimpleAction -> IO SimpleAction
forall (m :: * -> *) a. Monad m => a -> m a
return SimpleAction
result'

#if ENABLE_OVERLOADING
#endif

-- method SimpleAction::new_stateful
-- method type : Constructor
-- Args : [Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the name of the action", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "parameter_type", argType = TInterface (Name {namespace = "GLib", name = "VariantType"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the type of the parameter that will be passed to\n  handlers for the #GSimpleAction::activate signal, or %NULL for no parameter", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "state", argType = TVariant, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the initial state of the action", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gio", name = "SimpleAction"}))
-- throws : False
-- Skip return : False

foreign import ccall "g_simple_action_new_stateful" g_simple_action_new_stateful :: 
    CString ->                              -- name : TBasicType TUTF8
    Ptr GLib.VariantType.VariantType ->     -- parameter_type : TInterface (Name {namespace = "GLib", name = "VariantType"})
    Ptr GVariant ->                         -- state : TVariant
    IO (Ptr SimpleAction)

{- |
Creates a new stateful action.

All future state values must have the same 'GI.GLib.Structs.VariantType.VariantType' as the initial
/@state@/.

If the /@state@/ 'GVariant' is floating, it is consumed.

/Since: 2.28/
-}
simpleActionNewStateful ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    T.Text
    {- ^ /@name@/: the name of the action -}
    -> Maybe (GLib.VariantType.VariantType)
    {- ^ /@parameterType@/: the type of the parameter that will be passed to
  handlers for the 'GI.Gio.Objects.SimpleAction.SimpleAction'::@/activate/@ signal, or 'Nothing' for no parameter -}
    -> GVariant
    {- ^ /@state@/: the initial state of the action -}
    -> m SimpleAction
    {- ^ __Returns:__ a new 'GI.Gio.Objects.SimpleAction.SimpleAction' -}
simpleActionNewStateful :: Text -> Maybe VariantType -> GVariant -> m SimpleAction
simpleActionNewStateful name :: Text
name parameterType :: Maybe VariantType
parameterType state :: GVariant
state = IO SimpleAction -> m SimpleAction
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SimpleAction -> m SimpleAction)
-> IO SimpleAction -> m SimpleAction
forall a b. (a -> b) -> a -> b
$ do
    CString
name' <- Text -> IO CString
textToCString Text
name
    Ptr VariantType
maybeParameterType <- case Maybe VariantType
parameterType of
        Nothing -> Ptr VariantType -> IO (Ptr VariantType)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr VariantType
forall a. Ptr a
nullPtr
        Just jParameterType :: VariantType
jParameterType -> do
            Ptr VariantType
jParameterType' <- VariantType -> IO (Ptr VariantType)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr VariantType
jParameterType
            Ptr VariantType -> IO (Ptr VariantType)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr VariantType
jParameterType'
    Ptr GVariant
state' <- GVariant -> IO (Ptr GVariant)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr GVariant
state
    Ptr SimpleAction
result <- CString -> Ptr VariantType -> Ptr GVariant -> IO (Ptr SimpleAction)
g_simple_action_new_stateful CString
name' Ptr VariantType
maybeParameterType Ptr GVariant
state'
    Text -> Ptr SimpleAction -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "simpleActionNewStateful" Ptr SimpleAction
result
    SimpleAction
result' <- ((ManagedPtr SimpleAction -> SimpleAction)
-> Ptr SimpleAction -> IO SimpleAction
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr SimpleAction -> SimpleAction
SimpleAction) Ptr SimpleAction
result
    Maybe VariantType -> (VariantType -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe VariantType
parameterType VariantType -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
    GVariant -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr GVariant
state
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
name'
    SimpleAction -> IO SimpleAction
forall (m :: * -> *) a. Monad m => a -> m a
return SimpleAction
result'

#if ENABLE_OVERLOADING
#endif

-- method SimpleAction::set_enabled
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "simple", argType = TInterface (Name {namespace = "Gio", name = "SimpleAction"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GSimpleAction", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "enabled", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "whether the action is enabled", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "g_simple_action_set_enabled" g_simple_action_set_enabled :: 
    Ptr SimpleAction ->                     -- simple : TInterface (Name {namespace = "Gio", name = "SimpleAction"})
    CInt ->                                 -- enabled : TBasicType TBoolean
    IO ()

{- |
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/
-}
simpleActionSetEnabled ::
    (B.CallStack.HasCallStack, MonadIO m, IsSimpleAction a) =>
    a
    {- ^ /@simple@/: a 'GI.Gio.Objects.SimpleAction.SimpleAction' -}
    -> Bool
    {- ^ /@enabled@/: whether the action is enabled -}
    -> m ()
simpleActionSetEnabled :: a -> Bool -> m ()
simpleActionSetEnabled simple :: a
simple enabled :: Bool
enabled = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr SimpleAction
simple' <- a -> IO (Ptr SimpleAction)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
simple
    let enabled' :: CInt
enabled' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
enabled
    Ptr SimpleAction -> CInt -> IO ()
g_simple_action_set_enabled Ptr SimpleAction
simple' CInt
enabled'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
simple
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if ENABLE_OVERLOADING
data SimpleActionSetEnabledMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsSimpleAction a) => O.MethodInfo SimpleActionSetEnabledMethodInfo a signature where
    overloadedMethod _ = simpleActionSetEnabled

#endif

-- method SimpleAction::set_state
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "simple", argType = TInterface (Name {namespace = "Gio", name = "SimpleAction"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GSimpleAction", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TVariant, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the new #GVariant for the state", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "g_simple_action_set_state" g_simple_action_set_state :: 
    Ptr SimpleAction ->                     -- simple : TInterface (Name {namespace = "Gio", name = "SimpleAction"})
    Ptr GVariant ->                         -- value : TVariant
    IO ()

{- |
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 'GI.Gio.Interfaces.Action.actionChangeState' to
request the change.

If the /@value@/ GVariant is floating, it is consumed.

/Since: 2.30/
-}
simpleActionSetState ::
    (B.CallStack.HasCallStack, MonadIO m, IsSimpleAction a) =>
    a
    {- ^ /@simple@/: a 'GI.Gio.Objects.SimpleAction.SimpleAction' -}
    -> GVariant
    {- ^ /@value@/: the new 'GVariant' for the state -}
    -> m ()
simpleActionSetState :: a -> GVariant -> m ()
simpleActionSetState simple :: a
simple value :: GVariant
value = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr SimpleAction
simple' <- a -> IO (Ptr SimpleAction)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
simple
    Ptr GVariant
value' <- GVariant -> IO (Ptr GVariant)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr GVariant
value
    Ptr SimpleAction -> Ptr GVariant -> IO ()
g_simple_action_set_state Ptr SimpleAction
simple' Ptr GVariant
value'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
simple
    GVariant -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr GVariant
value
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if ENABLE_OVERLOADING
data SimpleActionSetStateMethodInfo
instance (signature ~ (GVariant -> m ()), MonadIO m, IsSimpleAction a) => O.MethodInfo SimpleActionSetStateMethodInfo a signature where
    overloadedMethod _ = simpleActionSetState

#endif

-- method SimpleAction::set_state_hint
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "simple", argType = TInterface (Name {namespace = "Gio", name = "SimpleAction"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GSimpleAction", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "state_hint", argType = TVariant, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GVariant representing the state hint", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "g_simple_action_set_state_hint" g_simple_action_set_state_hint :: 
    Ptr SimpleAction ->                     -- simple : TInterface (Name {namespace = "Gio", name = "SimpleAction"})
    Ptr GVariant ->                         -- state_hint : TVariant
    IO ()

{- |
Sets the state hint for the action.

See 'GI.Gio.Interfaces.Action.actionGetStateHint' for more information about
action state hints.

/Since: 2.44/
-}
simpleActionSetStateHint ::
    (B.CallStack.HasCallStack, MonadIO m, IsSimpleAction a) =>
    a
    {- ^ /@simple@/: a 'GI.Gio.Objects.SimpleAction.SimpleAction' -}
    -> Maybe (GVariant)
    {- ^ /@stateHint@/: a 'GVariant' representing the state hint -}
    -> m ()
simpleActionSetStateHint :: a -> Maybe GVariant -> m ()
simpleActionSetStateHint simple :: a
simple stateHint :: Maybe GVariant
stateHint = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr SimpleAction
simple' <- a -> IO (Ptr SimpleAction)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
simple
    Ptr GVariant
maybeStateHint <- case Maybe GVariant
stateHint of
        Nothing -> Ptr GVariant -> IO (Ptr GVariant)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr GVariant
forall a. Ptr a
nullPtr
        Just jStateHint :: GVariant
jStateHint -> do
            Ptr GVariant
jStateHint' <- GVariant -> IO (Ptr GVariant)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr GVariant
jStateHint
            Ptr GVariant -> IO (Ptr GVariant)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr GVariant
jStateHint'
    Ptr SimpleAction -> Ptr GVariant -> IO ()
g_simple_action_set_state_hint Ptr SimpleAction
simple' Ptr GVariant
maybeStateHint
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
simple
    Maybe GVariant -> (GVariant -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe GVariant
stateHint GVariant -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if ENABLE_OVERLOADING
data SimpleActionSetStateHintMethodInfo
instance (signature ~ (Maybe (GVariant) -> m ()), MonadIO m, IsSimpleAction a) => O.MethodInfo SimpleActionSetStateHintMethodInfo a signature where
    overloadedMethod _ = simpleActionSetStateHint

#endif