Action.hs


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

'GI.Gio.Interfaces.Action.Action' represents a single named action.

The main interface to an action is that it can be activated with
'GI.Gio.Interfaces.Action.actionActivate'.  This results in the \'activate\' signal being
emitted.  An activation has a 'GVariant' parameter (which may be
'Nothing').  The correct type for the parameter is determined by a static
parameter type (which is given at construction time).

An action may optionally have a state, in which case the state may be
set with 'GI.Gio.Interfaces.Action.actionChangeState'.  This call takes a 'GVariant'.  The
correct type for the state is determined by a static state type
(which is given at construction time).

The state may have a hint associated with it, specifying its valid
range.

'GI.Gio.Interfaces.Action.Action' is merely the interface to the concept of an action, as
described above.  Various implementations of actions exist, including
'GI.Gio.Objects.SimpleAction.SimpleAction'.

In all cases, the implementing class is responsible for storing the
name of the action, the parameter type, the enabled state, the
optional state type and the state and emitting the appropriate
signals when these change.  The implementor is responsible for filtering
calls to 'GI.Gio.Interfaces.Action.actionActivate' and 'GI.Gio.Interfaces.Action.actionChangeState' for type
safety and for the state being enabled.

Probably the only useful thing to do with a 'GI.Gio.Interfaces.Action.Action' is to put it
inside of a 'GI.Gio.Objects.SimpleActionGroup.SimpleActionGroup'.
-}

#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \
       && !defined(__HADDOCK_VERSION__))

module GI.Gio.Interfaces.Action
    ( 

-- * Exported types
    Action(..)                              ,
    noAction                                ,
    IsAction                                ,
    toAction                                ,


 -- * Methods
-- ** activate #method:activate#

#if ENABLE_OVERLOADING
    ActionActivateMethodInfo                ,
#endif
    actionActivate                          ,


-- ** changeState #method:changeState#

#if ENABLE_OVERLOADING
    ActionChangeStateMethodInfo             ,
#endif
    actionChangeState                       ,


-- ** getEnabled #method:getEnabled#

#if ENABLE_OVERLOADING
    ActionGetEnabledMethodInfo              ,
#endif
    actionGetEnabled                        ,


-- ** getName #method:getName#

#if ENABLE_OVERLOADING
    ActionGetNameMethodInfo                 ,
#endif
    actionGetName                           ,


-- ** getParameterType #method:getParameterType#

#if ENABLE_OVERLOADING
    ActionGetParameterTypeMethodInfo        ,
#endif
    actionGetParameterType                  ,


-- ** getState #method:getState#

#if ENABLE_OVERLOADING
    ActionGetStateMethodInfo                ,
#endif
    actionGetState                          ,


-- ** getStateHint #method:getStateHint#

#if ENABLE_OVERLOADING
    ActionGetStateHintMethodInfo            ,
#endif
    actionGetStateHint                      ,


-- ** getStateType #method:getStateType#

#if ENABLE_OVERLOADING
    ActionGetStateTypeMethodInfo            ,
#endif
    actionGetStateType                      ,


-- ** nameIsValid #method:nameIsValid#

    actionNameIsValid                       ,


-- ** parseDetailedName #method:parseDetailedName#

    actionParseDetailedName                 ,


-- ** printDetailedName #method:printDetailedName#

    actionPrintDetailedName                 ,




 -- * 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
    ActionEnabledPropertyInfo               ,
#endif
#if ENABLE_OVERLOADING
    actionEnabled                           ,
#endif
    getActionEnabled                        ,


-- ** 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.Interfaces.ActionGroup.ActionGroup'. It is immutable.

/Since: 2.28/
-}
#if ENABLE_OVERLOADING
    ActionNamePropertyInfo                  ,
#endif
#if ENABLE_OVERLOADING
    actionName                              ,
#endif
    getActionName                           ,


-- ** parameterType #attr:parameterType#
{- | The type of the parameter that must be given when activating the
action. This is immutable, and may be 'Nothing' if no parameter is needed when
activating the action.

/Since: 2.28/
-}
#if ENABLE_OVERLOADING
    ActionParameterTypePropertyInfo         ,
#endif
#if ENABLE_OVERLOADING
    actionParameterType                     ,
#endif
    getActionParameterType                  ,


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

/Since: 2.28/
-}
#if ENABLE_OVERLOADING
    ActionStatePropertyInfo                 ,
#endif
#if ENABLE_OVERLOADING
    actionState                             ,
#endif
    getActionState                          ,


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

/Since: 2.28/
-}
#if ENABLE_OVERLOADING
    ActionStateTypePropertyInfo             ,
#endif
#if ENABLE_OVERLOADING
    actionStateType                         ,
#endif
    getActionStateType                      ,




    ) 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.GClosure as B.GClosure
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.GI.Base.Properties as B.Properties
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 GHC.OverloadedLabels as OL

import qualified GI.GLib.Structs.VariantType as GLib.VariantType
import qualified GI.GObject.Objects.Object as GObject.Object

-- interface Action 
-- | Memory-managed wrapper type.
newtype Action = Action (ManagedPtr Action)
-- | A convenience alias for `Nothing` :: `Maybe` `Action`.
noAction :: Maybe Action
noAction = Nothing

#if ENABLE_OVERLOADING
type instance O.SignalList Action = ActionSignalList
type ActionSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)])

#endif

foreign import ccall "g_action_get_type"
    c_g_action_get_type :: IO GType

instance GObject Action where
    gobjectType = c_g_action_get_type
    

-- | Type class for types which can be safely cast to `Action`, for instance with `toAction`.
class (GObject o, O.IsDescendantOf Action o) => IsAction o
instance (GObject o, O.IsDescendantOf Action o) => IsAction o

instance O.HasParentTypes Action
type instance O.ParentTypes Action = '[GObject.Object.Object]

-- | Cast to `Action`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`.
toAction :: (MonadIO m, IsAction o) => o -> m Action
toAction = liftIO . unsafeCastTo Action

-- VVV Prop "enabled"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable]
   -- Nullable: (Just False,Nothing)

{- |
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' action #enabled
@
-}
getActionEnabled :: (MonadIO m, IsAction o) => o -> m Bool
getActionEnabled obj = liftIO $ B.Properties.getObjectPropertyBool obj "enabled"

#if ENABLE_OVERLOADING
data ActionEnabledPropertyInfo
instance AttrInfo ActionEnabledPropertyInfo where
    type AttrAllowedOps ActionEnabledPropertyInfo = '[ 'AttrGet]
    type AttrSetTypeConstraint ActionEnabledPropertyInfo = (~) ()
    type AttrBaseTypeConstraint ActionEnabledPropertyInfo = IsAction
    type AttrGetType ActionEnabledPropertyInfo = Bool
    type AttrLabel ActionEnabledPropertyInfo = "enabled"
    type AttrOrigin ActionEnabledPropertyInfo = Action
    attrGet _ = getActionEnabled
    attrSet _ = undefined
    attrConstruct _ = undefined
    attrClear _ = undefined
#endif

-- VVV Prop "name"
   -- Type: TBasicType TUTF8
   -- Flags: [PropertyReadable]
   -- Nullable: (Just False,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' action #name
@
-}
getActionName :: (MonadIO m, IsAction o) => o -> m T.Text
getActionName obj = liftIO $ checkUnexpectedNothing "getActionName" $ B.Properties.getObjectPropertyString obj "name"

#if ENABLE_OVERLOADING
data ActionNamePropertyInfo
instance AttrInfo ActionNamePropertyInfo where
    type AttrAllowedOps ActionNamePropertyInfo = '[ 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint ActionNamePropertyInfo = (~) ()
    type AttrBaseTypeConstraint ActionNamePropertyInfo = IsAction
    type AttrGetType ActionNamePropertyInfo = T.Text
    type AttrLabel ActionNamePropertyInfo = "name"
    type AttrOrigin ActionNamePropertyInfo = Action
    attrGet _ = getActionName
    attrSet _ = undefined
    attrConstruct _ = undefined
    attrClear _ = undefined
#endif

-- VVV Prop "parameter-type"
   -- Type: TInterface (Name {namespace = "GLib", name = "VariantType"})
   -- Flags: [PropertyReadable]
   -- Nullable: (Just True,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' action #parameterType
@
-}
getActionParameterType :: (MonadIO m, IsAction o) => o -> m (Maybe GLib.VariantType.VariantType)
getActionParameterType obj = liftIO $ B.Properties.getObjectPropertyBoxed obj "parameter-type" GLib.VariantType.VariantType

#if ENABLE_OVERLOADING
data ActionParameterTypePropertyInfo
instance AttrInfo ActionParameterTypePropertyInfo where
    type AttrAllowedOps ActionParameterTypePropertyInfo = '[ 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint ActionParameterTypePropertyInfo = (~) ()
    type AttrBaseTypeConstraint ActionParameterTypePropertyInfo = IsAction
    type AttrGetType ActionParameterTypePropertyInfo = (Maybe GLib.VariantType.VariantType)
    type AttrLabel ActionParameterTypePropertyInfo = "parameter-type"
    type AttrOrigin ActionParameterTypePropertyInfo = Action
    attrGet _ = getActionParameterType
    attrSet _ = undefined
    attrConstruct _ = undefined
    attrClear _ = undefined
#endif

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

{- |
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' action #state
@
-}
getActionState :: (MonadIO m, IsAction o) => o -> m (Maybe GVariant)
getActionState obj = liftIO $ B.Properties.getObjectPropertyVariant obj "state"

#if ENABLE_OVERLOADING
data ActionStatePropertyInfo
instance AttrInfo ActionStatePropertyInfo where
    type AttrAllowedOps ActionStatePropertyInfo = '[ 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint ActionStatePropertyInfo = (~) ()
    type AttrBaseTypeConstraint ActionStatePropertyInfo = IsAction
    type AttrGetType ActionStatePropertyInfo = (Maybe GVariant)
    type AttrLabel ActionStatePropertyInfo = "state"
    type AttrOrigin ActionStatePropertyInfo = Action
    attrGet _ = getActionState
    attrSet _ = undefined
    attrConstruct _ = undefined
    attrClear _ = undefined
#endif

-- VVV Prop "state-type"
   -- Type: TInterface (Name {namespace = "GLib", name = "VariantType"})
   -- Flags: [PropertyReadable]
   -- Nullable: (Just True,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' action #stateType
@
-}
getActionStateType :: (MonadIO m, IsAction o) => o -> m (Maybe GLib.VariantType.VariantType)
getActionStateType obj = liftIO $ B.Properties.getObjectPropertyBoxed obj "state-type" GLib.VariantType.VariantType

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

#if ENABLE_OVERLOADING
instance O.HasAttributeList Action
type instance O.AttributeList Action = ActionAttributeList
type ActionAttributeList = ('[ '("enabled", ActionEnabledPropertyInfo), '("name", ActionNamePropertyInfo), '("parameterType", ActionParameterTypePropertyInfo), '("state", ActionStatePropertyInfo), '("stateType", ActionStateTypePropertyInfo)] :: [(Symbol, *)])
#endif

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

actionName :: AttrLabelProxy "name"
actionName = AttrLabelProxy

actionParameterType :: AttrLabelProxy "parameterType"
actionParameterType = AttrLabelProxy

actionState :: AttrLabelProxy "state"
actionState = AttrLabelProxy

actionStateType :: AttrLabelProxy "stateType"
actionStateType = AttrLabelProxy

#endif

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

instance (info ~ ResolveActionMethod t Action, O.MethodInfo info Action p) => OL.IsLabel t (Action -> 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

-- method Action::activate
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "action", argType = TInterface (Name {namespace = "Gio", name = "Action"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GAction", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "parameter", argType = TVariant, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the parameter to the activation", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "g_action_activate" g_action_activate :: 
    Ptr Action ->                           -- action : TInterface (Name {namespace = "Gio", name = "Action"})
    Ptr GVariant ->                         -- parameter : TVariant
    IO ()

{- |
Activates the action.

/@parameter@/ must be the correct type of parameter for the action (ie:
the parameter type given at construction time).  If the parameter
type was 'Nothing' then /@parameter@/ must also be 'Nothing'.

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

/Since: 2.28/
-}
actionActivate ::
    (B.CallStack.HasCallStack, MonadIO m, IsAction a) =>
    a
    {- ^ /@action@/: a 'GI.Gio.Interfaces.Action.Action' -}
    -> Maybe (GVariant)
    {- ^ /@parameter@/: the parameter to the activation -}
    -> m ()
actionActivate action parameter = liftIO $ do
    action' <- unsafeManagedPtrCastPtr action
    maybeParameter <- case parameter of
        Nothing -> return nullPtr
        Just jParameter -> do
            jParameter' <- unsafeManagedPtrGetPtr jParameter
            return jParameter'
    g_action_activate action' maybeParameter
    touchManagedPtr action
    whenJust parameter touchManagedPtr
    return ()

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

#endif

-- method Action::change_state
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "action", argType = TInterface (Name {namespace = "Gio", name = "Action"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GAction", 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 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_action_change_state" g_action_change_state :: 
    Ptr Action ->                           -- action : TInterface (Name {namespace = "Gio", name = "Action"})
    Ptr GVariant ->                         -- value : TVariant
    IO ()

{- |
Request for the state of /@action@/ to be changed to /@value@/.

The action must be stateful and /@value@/ must be of the correct type.
See 'GI.Gio.Interfaces.Action.actionGetStateType'.

This call merely requests a change.  The action may refuse to change
its state or may change its state to something other than /@value@/.
See 'GI.Gio.Interfaces.Action.actionGetStateHint'.

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

/Since: 2.30/
-}
actionChangeState ::
    (B.CallStack.HasCallStack, MonadIO m, IsAction a) =>
    a
    {- ^ /@action@/: a 'GI.Gio.Interfaces.Action.Action' -}
    -> GVariant
    {- ^ /@value@/: the new state -}
    -> m ()
actionChangeState action value = liftIO $ do
    action' <- unsafeManagedPtrCastPtr action
    value' <- unsafeManagedPtrGetPtr value
    g_action_change_state action' value'
    touchManagedPtr action
    touchManagedPtr value
    return ()

#if ENABLE_OVERLOADING
data ActionChangeStateMethodInfo
instance (signature ~ (GVariant -> m ()), MonadIO m, IsAction a) => O.MethodInfo ActionChangeStateMethodInfo a signature where
    overloadedMethod _ = actionChangeState

#endif

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

foreign import ccall "g_action_get_enabled" g_action_get_enabled :: 
    Ptr Action ->                           -- action : TInterface (Name {namespace = "Gio", name = "Action"})
    IO CInt

{- |
Checks if /@action@/ is currently enabled.

An action must be enabled in order to be activated or in order to
have its state changed from outside callers.

/Since: 2.28/
-}
actionGetEnabled ::
    (B.CallStack.HasCallStack, MonadIO m, IsAction a) =>
    a
    {- ^ /@action@/: a 'GI.Gio.Interfaces.Action.Action' -}
    -> m Bool
    {- ^ __Returns:__ whether the action is enabled -}
actionGetEnabled action = liftIO $ do
    action' <- unsafeManagedPtrCastPtr action
    result <- g_action_get_enabled action'
    let result' = (/= 0) result
    touchManagedPtr action
    return result'

#if ENABLE_OVERLOADING
data ActionGetEnabledMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsAction a) => O.MethodInfo ActionGetEnabledMethodInfo a signature where
    overloadedMethod _ = actionGetEnabled

#endif

-- method Action::get_name
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "action", argType = TInterface (Name {namespace = "Gio", name = "Action"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GAction", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TUTF8)
-- throws : False
-- Skip return : False

foreign import ccall "g_action_get_name" g_action_get_name :: 
    Ptr Action ->                           -- action : TInterface (Name {namespace = "Gio", name = "Action"})
    IO CString

{- |
Queries the name of /@action@/.

/Since: 2.28/
-}
actionGetName ::
    (B.CallStack.HasCallStack, MonadIO m, IsAction a) =>
    a
    {- ^ /@action@/: a 'GI.Gio.Interfaces.Action.Action' -}
    -> m T.Text
    {- ^ __Returns:__ the name of the action -}
actionGetName action = liftIO $ do
    action' <- unsafeManagedPtrCastPtr action
    result <- g_action_get_name action'
    checkUnexpectedReturnNULL "actionGetName" result
    result' <- cstringToText result
    touchManagedPtr action
    return result'

#if ENABLE_OVERLOADING
data ActionGetNameMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsAction a) => O.MethodInfo ActionGetNameMethodInfo a signature where
    overloadedMethod _ = actionGetName

#endif

-- method Action::get_parameter_type
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "action", argType = TInterface (Name {namespace = "Gio", name = "Action"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GAction", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "GLib", name = "VariantType"}))
-- throws : False
-- Skip return : False

foreign import ccall "g_action_get_parameter_type" g_action_get_parameter_type :: 
    Ptr Action ->                           -- action : TInterface (Name {namespace = "Gio", name = "Action"})
    IO (Ptr GLib.VariantType.VariantType)

{- |
Queries the type of the parameter that must be given when activating
/@action@/.

When activating the action using 'GI.Gio.Interfaces.Action.actionActivate', the 'GVariant'
given to that function must be of the type returned by this function.

In the case that this function returns 'Nothing', you must not give any
'GVariant', but 'Nothing' instead.

/Since: 2.28/
-}
actionGetParameterType ::
    (B.CallStack.HasCallStack, MonadIO m, IsAction a) =>
    a
    {- ^ /@action@/: a 'GI.Gio.Interfaces.Action.Action' -}
    -> m (Maybe GLib.VariantType.VariantType)
    {- ^ __Returns:__ the parameter type -}
actionGetParameterType action = liftIO $ do
    action' <- unsafeManagedPtrCastPtr action
    result <- g_action_get_parameter_type action'
    maybeResult <- convertIfNonNull result $ \result' -> do
        result'' <- (newBoxed GLib.VariantType.VariantType) result'
        return result''
    touchManagedPtr action
    return maybeResult

#if ENABLE_OVERLOADING
data ActionGetParameterTypeMethodInfo
instance (signature ~ (m (Maybe GLib.VariantType.VariantType)), MonadIO m, IsAction a) => O.MethodInfo ActionGetParameterTypeMethodInfo a signature where
    overloadedMethod _ = actionGetParameterType

#endif

-- method Action::get_state
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "action", argType = TInterface (Name {namespace = "Gio", name = "Action"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GAction", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just TVariant
-- throws : False
-- Skip return : False

foreign import ccall "g_action_get_state" g_action_get_state :: 
    Ptr Action ->                           -- action : TInterface (Name {namespace = "Gio", name = "Action"})
    IO (Ptr GVariant)

{- |
Queries the current state of /@action@/.

If the action is not stateful then 'Nothing' will be returned.  If the
action is stateful then the type of the return value is the type
given by 'GI.Gio.Interfaces.Action.actionGetStateType'.

The return value (if non-'Nothing') should be freed with
'GI.GLib.Structs.Variant.variantUnref' when it is no longer required.

/Since: 2.28/
-}
actionGetState ::
    (B.CallStack.HasCallStack, MonadIO m, IsAction a) =>
    a
    {- ^ /@action@/: a 'GI.Gio.Interfaces.Action.Action' -}
    -> m GVariant
    {- ^ __Returns:__ the current state of the action -}
actionGetState action = liftIO $ do
    action' <- unsafeManagedPtrCastPtr action
    result <- g_action_get_state action'
    checkUnexpectedReturnNULL "actionGetState" result
    result' <- B.GVariant.wrapGVariantPtr result
    touchManagedPtr action
    return result'

#if ENABLE_OVERLOADING
data ActionGetStateMethodInfo
instance (signature ~ (m GVariant), MonadIO m, IsAction a) => O.MethodInfo ActionGetStateMethodInfo a signature where
    overloadedMethod _ = actionGetState

#endif

-- method Action::get_state_hint
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "action", argType = TInterface (Name {namespace = "Gio", name = "Action"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GAction", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just TVariant
-- throws : False
-- Skip return : False

foreign import ccall "g_action_get_state_hint" g_action_get_state_hint :: 
    Ptr Action ->                           -- action : TInterface (Name {namespace = "Gio", name = "Action"})
    IO (Ptr GVariant)

{- |
Requests a hint about the valid range of values for the state of
/@action@/.

If 'Nothing' is returned it either means that the action is not stateful
or that there is no hint about the valid range of values for the
state of the action.

If a 'GVariant' array is returned then each item in the array is a
possible value for the state.  If a 'GVariant' pair (ie: two-tuple) is
returned then the tuple specifies the inclusive lower and upper bound
of valid values for the state.

In any case, the information is merely a hint.  It may be possible to
have a state value outside of the hinted range and setting a value
within the range may fail.

The return value (if non-'Nothing') should be freed with
'GI.GLib.Structs.Variant.variantUnref' when it is no longer required.

/Since: 2.28/
-}
actionGetStateHint ::
    (B.CallStack.HasCallStack, MonadIO m, IsAction a) =>
    a
    {- ^ /@action@/: a 'GI.Gio.Interfaces.Action.Action' -}
    -> m (Maybe GVariant)
    {- ^ __Returns:__ the state range hint -}
actionGetStateHint action = liftIO $ do
    action' <- unsafeManagedPtrCastPtr action
    result <- g_action_get_state_hint action'
    maybeResult <- convertIfNonNull result $ \result' -> do
        result'' <- B.GVariant.wrapGVariantPtr result'
        return result''
    touchManagedPtr action
    return maybeResult

#if ENABLE_OVERLOADING
data ActionGetStateHintMethodInfo
instance (signature ~ (m (Maybe GVariant)), MonadIO m, IsAction a) => O.MethodInfo ActionGetStateHintMethodInfo a signature where
    overloadedMethod _ = actionGetStateHint

#endif

-- method Action::get_state_type
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "action", argType = TInterface (Name {namespace = "Gio", name = "Action"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GAction", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "GLib", name = "VariantType"}))
-- throws : False
-- Skip return : False

foreign import ccall "g_action_get_state_type" g_action_get_state_type :: 
    Ptr Action ->                           -- action : TInterface (Name {namespace = "Gio", name = "Action"})
    IO (Ptr GLib.VariantType.VariantType)

{- |
Queries the type of the state of /@action@/.

If the action is stateful (e.g. created with
'GI.Gio.Objects.SimpleAction.simpleActionNewStateful') then this function returns the
'GI.GLib.Structs.VariantType.VariantType' of the state.  This is the type of the initial value
given as the state. All calls to 'GI.Gio.Interfaces.Action.actionChangeState' must give a
'GVariant' of this type and 'GI.Gio.Interfaces.Action.actionGetState' will return a
'GVariant' of the same type.

If the action is not stateful (e.g. created with 'GI.Gio.Objects.SimpleAction.simpleActionNew')
then this function will return 'Nothing'. In that case, 'GI.Gio.Interfaces.Action.actionGetState'
will return 'Nothing' and you must not call 'GI.Gio.Interfaces.Action.actionChangeState'.

/Since: 2.28/
-}
actionGetStateType ::
    (B.CallStack.HasCallStack, MonadIO m, IsAction a) =>
    a
    {- ^ /@action@/: a 'GI.Gio.Interfaces.Action.Action' -}
    -> m (Maybe GLib.VariantType.VariantType)
    {- ^ __Returns:__ the state type, if the action is stateful -}
actionGetStateType action = liftIO $ do
    action' <- unsafeManagedPtrCastPtr action
    result <- g_action_get_state_type action'
    maybeResult <- convertIfNonNull result $ \result' -> do
        result'' <- (newBoxed GLib.VariantType.VariantType) result'
        return result''
    touchManagedPtr action
    return maybeResult

#if ENABLE_OVERLOADING
data ActionGetStateTypeMethodInfo
instance (signature ~ (m (Maybe GLib.VariantType.VariantType)), MonadIO m, IsAction a) => O.MethodInfo ActionGetStateTypeMethodInfo a signature where
    overloadedMethod _ = actionGetStateType

#endif

-- method Action::name_is_valid
-- method type : MemberFunction
-- Args : [Arg {argCName = "action_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an potential action name", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "g_action_name_is_valid" g_action_name_is_valid :: 
    CString ->                              -- action_name : TBasicType TUTF8
    IO CInt

{- |
Checks if /@actionName@/ is valid.

/@actionName@/ is valid if it consists only of alphanumeric characters,
plus \'-\' and \'.\'.  The empty string is not a valid action name.

It is an error to call this function with a non-utf8 /@actionName@/.
/@actionName@/ must not be 'Nothing'.

/Since: 2.38/
-}
actionNameIsValid ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    T.Text
    {- ^ /@actionName@/: an potential action name -}
    -> m Bool
    {- ^ __Returns:__ 'True' if /@actionName@/ is valid -}
actionNameIsValid actionName = liftIO $ do
    actionName' <- textToCString actionName
    result <- g_action_name_is_valid actionName'
    let result' = (/= 0) result
    freeMem actionName'
    return result'

#if ENABLE_OVERLOADING
#endif

-- method Action::parse_detailed_name
-- method type : MemberFunction
-- Args : [Arg {argCName = "detailed_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a detailed action name", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "action_name", argType = TBasicType TUTF8, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the action name", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "target_value", argType = TVariant, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the target value, or %NULL for no target", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : True
-- Skip return : False

foreign import ccall "g_action_parse_detailed_name" g_action_parse_detailed_name :: 
    CString ->                              -- detailed_name : TBasicType TUTF8
    Ptr CString ->                          -- action_name : TBasicType TUTF8
    Ptr (Ptr GVariant) ->                   -- target_value : TVariant
    Ptr (Ptr GError) ->                     -- error
    IO CInt

{- |
Parses a detailed action name into its separate name and target
components.

Detailed action names can have three formats.

The first format is used to represent an action name with no target
value and consists of just an action name containing no whitespace
nor the characters \':\', \'(\' or \')\'.  For example: \"app.action\".

The second format is used to represent an action with a target value
that is a non-empty string consisting only of alphanumerics, plus \'-\'
and \'.\'.  In that case, the action name and target value are
separated by a double colon (\"::\").  For example:
\"app.action::target\".

The third format is used to represent an action with any type of
target value, including strings.  The target value follows the action
name, surrounded in parens.  For example: \"app.action(42)\".  The
target value is parsed using 'GI.GLib.Functions.variantParse'.  If a tuple-typed
value is desired, it must be specified in the same way, resulting in
two sets of parens, for example: \"app.action((1,2,3))\".  A string
target can be specified this way as well: \"app.action(\'target\')\".
For strings, this third format must be used if * target value is
empty or contains characters other than alphanumerics, \'-\' and \'.\'.

/Since: 2.38/
-}
actionParseDetailedName ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    T.Text
    {- ^ /@detailedName@/: a detailed action name -}
    -> m ((T.Text, GVariant))
    {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -}
actionParseDetailedName detailedName = liftIO $ do
    detailedName' <- textToCString detailedName
    actionName <- allocMem :: IO (Ptr CString)
    targetValue <- allocMem :: IO (Ptr (Ptr GVariant))
    onException (do
        _ <- propagateGError $ g_action_parse_detailed_name detailedName' actionName targetValue
        actionName' <- peek actionName
        actionName'' <- cstringToText actionName'
        freeMem actionName'
        targetValue' <- peek targetValue
        targetValue'' <- B.GVariant.wrapGVariantPtr targetValue'
        freeMem detailedName'
        freeMem actionName
        freeMem targetValue
        return (actionName'', targetValue'')
     ) (do
        freeMem detailedName'
        freeMem actionName
        freeMem targetValue
     )

#if ENABLE_OVERLOADING
#endif

-- method Action::print_detailed_name
-- method type : MemberFunction
-- Args : [Arg {argCName = "action_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a valid action name", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "target_value", argType = TVariant, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GVariant target value, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TUTF8)
-- throws : False
-- Skip return : False

foreign import ccall "g_action_print_detailed_name" g_action_print_detailed_name :: 
    CString ->                              -- action_name : TBasicType TUTF8
    Ptr GVariant ->                         -- target_value : TVariant
    IO CString

{- |
Formats a detailed action name from /@actionName@/ and /@targetValue@/.

It is an error to call this function with an invalid action name.

This function is the opposite of 'GI.Gio.Functions.actionParseDetailedName'.
It will produce a string that can be parsed back to the /@actionName@/
and /@targetValue@/ by that function.

See that function for the types of strings that will be printed by
this function.

/Since: 2.38/
-}
actionPrintDetailedName ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    T.Text
    {- ^ /@actionName@/: a valid action name -}
    -> Maybe (GVariant)
    {- ^ /@targetValue@/: a 'GVariant' target value, or 'Nothing' -}
    -> m T.Text
    {- ^ __Returns:__ a detailed format string -}
actionPrintDetailedName actionName targetValue = liftIO $ do
    actionName' <- textToCString actionName
    maybeTargetValue <- case targetValue of
        Nothing -> return nullPtr
        Just jTargetValue -> do
            jTargetValue' <- unsafeManagedPtrGetPtr jTargetValue
            return jTargetValue'
    result <- g_action_print_detailed_name actionName' maybeTargetValue
    checkUnexpectedReturnNULL "actionPrintDetailedName" result
    result' <- cstringToText result
    freeMem result
    whenJust targetValue touchManagedPtr
    freeMem actionName'
    return result'

#if ENABLE_OVERLOADING
#endif