{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- This struct defines a single action.  It is for use with
-- 'GI.Gio.Interfaces.ActionMap.actionMapAddActionEntries'.
-- 
-- The order of the items in the structure are intended to reflect
-- frequency of use.  It is permissible to use an incomplete initialiser
-- in order to leave some of the later values as @NULL@.  All values
-- after /@name@/ are optional.  Additional optional fields may be added in
-- the future.
-- 
-- See 'GI.Gio.Interfaces.ActionMap.actionMapAddActionEntries' for an example.

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

module GI.Gio.Structs.ActionEntry
    ( 

-- * Exported types
    ActionEntry(..)                         ,
    newZeroActionEntry                      ,


 -- * Methods

#if defined(ENABLE_OVERLOADING)
    ResolveActionEntryMethod                ,
#endif



 -- * Properties


-- ** activate #attr:activate#
-- | the callback to connect to the \"activate\" signal of the action.
--   Since GLib 2.40, this can be @NULL@ for stateful actions, in which case
--   the default handler is used. For boolean-stated actions with no
--   parameter, this is a toggle. For other state types (and parameter type
--   equal to the state type) this will be a function that just calls
--   /@changeState@/ (which you should provide).

#if defined(ENABLE_OVERLOADING)
    actionEntry_activate                    ,
#endif
    clearActionEntryActivate                ,
    getActionEntryActivate                  ,
    setActionEntryActivate                  ,


-- ** changeState #attr:changeState#
-- | the callback to connect to the \"change-state\" signal of the
--   action.  All stateful actions should provide a handler here; stateless
--   actions should not.

#if defined(ENABLE_OVERLOADING)
    actionEntry_changeState                 ,
#endif
    clearActionEntryChangeState             ,
    getActionEntryChangeState               ,
    setActionEntryChangeState               ,


-- ** name #attr:name#
-- | the name of the action

#if defined(ENABLE_OVERLOADING)
    actionEntry_name                        ,
#endif
    clearActionEntryName                    ,
    getActionEntryName                      ,
    setActionEntryName                      ,


-- ** parameterType #attr:parameterType#
-- | the type of the parameter that must be passed to the
--   activate function for this action, given as a single GVariant type string
--   (or @NULL@ for no parameter)

#if defined(ENABLE_OVERLOADING)
    actionEntry_parameterType               ,
#endif
    clearActionEntryParameterType           ,
    getActionEntryParameterType             ,
    setActionEntryParameterType             ,


-- ** state #attr:state#
-- | the initial state for this action, given in
--   <http://developer.gnome.org/gio/stable/gvariant-text-format.html GVariant text format>.  The state is parsed
--   with no extra type information, so type tags must be added to the string
--   if they are necessary.  Stateless actions should give @NULL@ here.

#if defined(ENABLE_OVERLOADING)
    actionEntry_state                       ,
#endif
    clearActionEntryState                   ,
    getActionEntryState                     ,
    setActionEntryState                     ,




    ) 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.BasicTypes as B.Types
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GArray as B.GArray
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GHashTable as B.GHT
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.GI.Base.Signals as B.Signals
import qualified Control.Monad.IO.Class as MIO
import qualified Data.Coerce as Coerce
import qualified Data.Text as T
import qualified Data.Kind as DK
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 GHC.Records as R
import qualified Data.Word as DW
import qualified Data.Int as DI
import qualified System.Posix.Types as SPT
import qualified Foreign.C.Types as FCT

-- Workaround for https://gitlab.haskell.org/ghc/ghc/-/issues/23392
#if MIN_VERSION_base(4,18,0)
import qualified GI.Gio.Callbacks as Gio.Callbacks

#else
import qualified GI.Gio.Callbacks as Gio.Callbacks

#endif

-- | Memory-managed wrapper type.
newtype ActionEntry = ActionEntry (SP.ManagedPtr ActionEntry)
    deriving (ActionEntry -> ActionEntry -> Bool
(ActionEntry -> ActionEntry -> Bool)
-> (ActionEntry -> ActionEntry -> Bool) -> Eq ActionEntry
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ActionEntry -> ActionEntry -> Bool
== :: ActionEntry -> ActionEntry -> Bool
$c/= :: ActionEntry -> ActionEntry -> Bool
/= :: ActionEntry -> ActionEntry -> Bool
Eq)

instance SP.ManagedPtrNewtype ActionEntry where
    toManagedPtr :: ActionEntry -> ManagedPtr ActionEntry
toManagedPtr (ActionEntry ManagedPtr ActionEntry
p) = ManagedPtr ActionEntry
p

instance BoxedPtr ActionEntry where
    boxedPtrCopy :: ActionEntry -> IO ActionEntry
boxedPtrCopy = \ActionEntry
p -> ActionEntry
-> (Ptr ActionEntry -> IO ActionEntry) -> IO ActionEntry
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr ActionEntry
p (Int -> Ptr ActionEntry -> IO (Ptr ActionEntry)
forall a. (HasCallStack, CallocPtr a) => Int -> Ptr a -> IO (Ptr a)
copyBytes Int
64 (Ptr ActionEntry -> IO (Ptr ActionEntry))
-> (Ptr ActionEntry -> IO ActionEntry)
-> Ptr ActionEntry
-> IO ActionEntry
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (ManagedPtr ActionEntry -> ActionEntry)
-> Ptr ActionEntry -> IO ActionEntry
forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
B.ManagedPtr.wrapPtr ManagedPtr ActionEntry -> ActionEntry
ActionEntry)
    boxedPtrFree :: ActionEntry -> IO ()
boxedPtrFree = \ActionEntry
x -> ActionEntry -> (Ptr ActionEntry -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
SP.withManagedPtr ActionEntry
x Ptr ActionEntry -> IO ()
forall a. Ptr a -> IO ()
SP.freeMem
instance CallocPtr ActionEntry where
    boxedPtrCalloc :: IO (Ptr ActionEntry)
boxedPtrCalloc = Int -> IO (Ptr ActionEntry)
forall a. Int -> IO (Ptr a)
callocBytes Int
64


-- | Construct a t'ActionEntry' struct initialized to zero.
newZeroActionEntry :: MonadIO m => m ActionEntry
newZeroActionEntry :: forall (m :: * -> *). MonadIO m => m ActionEntry
newZeroActionEntry = IO ActionEntry -> m ActionEntry
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO ActionEntry -> m ActionEntry)
-> IO ActionEntry -> m ActionEntry
forall a b. (a -> b) -> a -> b
$ IO (Ptr ActionEntry)
forall a. CallocPtr a => IO (Ptr a)
boxedPtrCalloc IO (Ptr ActionEntry)
-> (Ptr ActionEntry -> IO ActionEntry) -> IO ActionEntry
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (ManagedPtr ActionEntry -> ActionEntry)
-> Ptr ActionEntry -> IO ActionEntry
forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapPtr ManagedPtr ActionEntry -> ActionEntry
ActionEntry

instance tag ~ 'AttrSet => Constructible ActionEntry tag where
    new :: forall (m :: * -> *).
MonadIO m =>
(ManagedPtr ActionEntry -> ActionEntry)
-> [AttrOp ActionEntry tag] -> m ActionEntry
new ManagedPtr ActionEntry -> ActionEntry
_ [AttrOp ActionEntry tag]
attrs = do
        o <- m ActionEntry
forall (m :: * -> *). MonadIO m => m ActionEntry
newZeroActionEntry
        GI.Attributes.set o attrs
        return o


-- | Get the value of the “@name@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' actionEntry #name
-- @
getActionEntryName :: MonadIO m => ActionEntry -> m (Maybe T.Text)
getActionEntryName :: forall (m :: * -> *). MonadIO m => ActionEntry -> m (Maybe Text)
getActionEntryName ActionEntry
s = IO (Maybe Text) -> m (Maybe Text)
forall a. IO a -> m a
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
$ ActionEntry
-> (Ptr ActionEntry -> IO (Maybe Text)) -> IO (Maybe Text)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ActionEntry
s ((Ptr ActionEntry -> IO (Maybe Text)) -> IO (Maybe Text))
-> (Ptr ActionEntry -> IO (Maybe Text)) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \Ptr ActionEntry
ptr -> do
    val <- Ptr CString -> IO CString
forall a. Storable a => Ptr a -> IO a
peek (Ptr ActionEntry
ptr Ptr ActionEntry -> Int -> Ptr CString
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0) :: IO CString
    result <- SP.convertIfNonNull val $ \CString
val' -> do
        val'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
val'
        return val''
    return result

-- | Set the value of the “@name@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' actionEntry [ #name 'Data.GI.Base.Attributes.:=' value ]
-- @
setActionEntryName :: MonadIO m => ActionEntry -> CString -> m ()
setActionEntryName :: forall (m :: * -> *). MonadIO m => ActionEntry -> CString -> m ()
setActionEntryName ActionEntry
s CString
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ ActionEntry -> (Ptr ActionEntry -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ActionEntry
s ((Ptr ActionEntry -> IO ()) -> IO ())
-> (Ptr ActionEntry -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr ActionEntry
ptr -> do
    Ptr CString -> CString -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ActionEntry
ptr Ptr ActionEntry -> Int -> Ptr CString
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0) (CString
val :: CString)

-- | Set the value of the “@name@” field to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #name
-- @
clearActionEntryName :: MonadIO m => ActionEntry -> m ()
clearActionEntryName :: forall (m :: * -> *). MonadIO m => ActionEntry -> m ()
clearActionEntryName ActionEntry
s = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ ActionEntry -> (Ptr ActionEntry -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ActionEntry
s ((Ptr ActionEntry -> IO ()) -> IO ())
-> (Ptr ActionEntry -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr ActionEntry
ptr -> do
    Ptr CString -> CString -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ActionEntry
ptr Ptr ActionEntry -> Int -> Ptr CString
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0) (CString
forall a. Ptr a
FP.nullPtr :: CString)

#if defined(ENABLE_OVERLOADING)
data ActionEntryNameFieldInfo
instance AttrInfo ActionEntryNameFieldInfo where
    type AttrBaseTypeConstraint ActionEntryNameFieldInfo = (~) ActionEntry
    type AttrAllowedOps ActionEntryNameFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint ActionEntryNameFieldInfo = (~) CString
    type AttrTransferTypeConstraint ActionEntryNameFieldInfo = (~)CString
    type AttrTransferType ActionEntryNameFieldInfo = CString
    type AttrGetType ActionEntryNameFieldInfo = Maybe T.Text
    type AttrLabel ActionEntryNameFieldInfo = "name"
    type AttrOrigin ActionEntryNameFieldInfo = ActionEntry
    attrGet :: forall o.
AttrBaseTypeConstraint ActionEntryNameFieldInfo o =>
o -> IO (AttrGetType ActionEntryNameFieldInfo)
attrGet = o -> IO (AttrGetType ActionEntryNameFieldInfo)
ActionEntry -> IO (Maybe Text)
forall (m :: * -> *). MonadIO m => ActionEntry -> m (Maybe Text)
getActionEntryName
    attrSet :: forall o b.
(AttrBaseTypeConstraint ActionEntryNameFieldInfo o,
 AttrSetTypeConstraint ActionEntryNameFieldInfo b) =>
o -> b -> IO ()
attrSet = o -> b -> IO ()
ActionEntry -> CString -> IO ()
forall (m :: * -> *). MonadIO m => ActionEntry -> CString -> m ()
setActionEntryName
    attrConstruct :: forall o b.
(AttrBaseTypeConstraint ActionEntryNameFieldInfo o,
 AttrSetTypeConstraint ActionEntryNameFieldInfo b) =>
b -> IO (GValueConstruct o)
attrConstruct = b -> IO (GValueConstruct o)
forall a. HasCallStack => a
undefined
    attrClear :: forall o.
AttrBaseTypeConstraint ActionEntryNameFieldInfo o =>
o -> IO ()
attrClear = o -> IO ()
ActionEntry -> IO ()
forall (m :: * -> *). MonadIO m => ActionEntry -> m ()
clearActionEntryName
    attrTransfer :: forall o b.
(AttrBaseTypeConstraint ActionEntryNameFieldInfo o,
 AttrTransferTypeConstraint ActionEntryNameFieldInfo b) =>
Proxy o -> b -> IO (AttrTransferType ActionEntryNameFieldInfo)
attrTransfer Proxy o
_ b
v = do
        b -> IO b
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return b
v
    dbgAttrInfo :: Maybe ResolvedSymbolInfo
dbgAttrInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
        resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.Gio.Structs.ActionEntry.name"
        , resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-gio-2.0.38/docs/GI-Gio-Structs-ActionEntry.html#g:attr:name"
        })

actionEntry_name :: AttrLabelProxy "name"
actionEntry_name :: AttrLabelProxy "name"
actionEntry_name = AttrLabelProxy "name"
forall (a :: Symbol). AttrLabelProxy a
AttrLabelProxy

#endif


-- | Get the value of the “@activate@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' actionEntry #activate
-- @
getActionEntryActivate :: MonadIO m => ActionEntry -> m (Maybe Gio.Callbacks.ActionEntryActivateFieldCallback_WithClosures)
getActionEntryActivate :: forall (m :: * -> *).
MonadIO m =>
ActionEntry
-> m (Maybe ActionEntryActivateFieldCallback_WithClosures)
getActionEntryActivate ActionEntry
s = IO (Maybe ActionEntryActivateFieldCallback_WithClosures)
-> m (Maybe ActionEntryActivateFieldCallback_WithClosures)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe ActionEntryActivateFieldCallback_WithClosures)
 -> m (Maybe ActionEntryActivateFieldCallback_WithClosures))
-> IO (Maybe ActionEntryActivateFieldCallback_WithClosures)
-> m (Maybe ActionEntryActivateFieldCallback_WithClosures)
forall a b. (a -> b) -> a -> b
$ ActionEntry
-> (Ptr ActionEntry
    -> IO (Maybe ActionEntryActivateFieldCallback_WithClosures))
-> IO (Maybe ActionEntryActivateFieldCallback_WithClosures)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ActionEntry
s ((Ptr ActionEntry
  -> IO (Maybe ActionEntryActivateFieldCallback_WithClosures))
 -> IO (Maybe ActionEntryActivateFieldCallback_WithClosures))
-> (Ptr ActionEntry
    -> IO (Maybe ActionEntryActivateFieldCallback_WithClosures))
-> IO (Maybe ActionEntryActivateFieldCallback_WithClosures)
forall a b. (a -> b) -> a -> b
$ \Ptr ActionEntry
ptr -> do
    val <- Ptr (FunPtr C_ActionEntryActivateFieldCallback)
-> IO (FunPtr C_ActionEntryActivateFieldCallback)
forall a. Storable a => Ptr a -> IO a
peek (Ptr ActionEntry
ptr Ptr ActionEntry
-> Int -> Ptr (FunPtr C_ActionEntryActivateFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
8) :: IO (FunPtr Gio.Callbacks.C_ActionEntryActivateFieldCallback)
    result <- SP.convertFunPtrIfNonNull val $ \FunPtr C_ActionEntryActivateFieldCallback
val' -> do
        let val'' :: ActionEntryActivateFieldCallback_WithClosures
val'' = FunPtr C_ActionEntryActivateFieldCallback
-> ActionEntryActivateFieldCallback_WithClosures
forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSimpleAction a) =>
FunPtr C_ActionEntryActivateFieldCallback
-> a -> Maybe GVariant -> Ptr () -> m ()
Gio.Callbacks.dynamic_ActionEntryActivateFieldCallback FunPtr C_ActionEntryActivateFieldCallback
val'
        ActionEntryActivateFieldCallback_WithClosures
-> IO ActionEntryActivateFieldCallback_WithClosures
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ActionEntryActivateFieldCallback_WithClosures
val''
    return result

-- | Set the value of the “@activate@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' actionEntry [ #activate 'Data.GI.Base.Attributes.:=' value ]
-- @
setActionEntryActivate :: MonadIO m => ActionEntry -> FunPtr Gio.Callbacks.C_ActionEntryActivateFieldCallback -> m ()
setActionEntryActivate :: forall (m :: * -> *).
MonadIO m =>
ActionEntry -> FunPtr C_ActionEntryActivateFieldCallback -> m ()
setActionEntryActivate ActionEntry
s FunPtr C_ActionEntryActivateFieldCallback
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ ActionEntry -> (Ptr ActionEntry -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ActionEntry
s ((Ptr ActionEntry -> IO ()) -> IO ())
-> (Ptr ActionEntry -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr ActionEntry
ptr -> do
    Ptr (FunPtr C_ActionEntryActivateFieldCallback)
-> FunPtr C_ActionEntryActivateFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ActionEntry
ptr Ptr ActionEntry
-> Int -> Ptr (FunPtr C_ActionEntryActivateFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
8) (FunPtr C_ActionEntryActivateFieldCallback
val :: FunPtr Gio.Callbacks.C_ActionEntryActivateFieldCallback)

-- | Set the value of the “@activate@” field to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #activate
-- @
clearActionEntryActivate :: MonadIO m => ActionEntry -> m ()
clearActionEntryActivate :: forall (m :: * -> *). MonadIO m => ActionEntry -> m ()
clearActionEntryActivate ActionEntry
s = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ ActionEntry -> (Ptr ActionEntry -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ActionEntry
s ((Ptr ActionEntry -> IO ()) -> IO ())
-> (Ptr ActionEntry -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr ActionEntry
ptr -> do
    Ptr (FunPtr C_ActionEntryActivateFieldCallback)
-> FunPtr C_ActionEntryActivateFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ActionEntry
ptr Ptr ActionEntry
-> Int -> Ptr (FunPtr C_ActionEntryActivateFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
8) (FunPtr C_ActionEntryActivateFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gio.Callbacks.C_ActionEntryActivateFieldCallback)

#if defined(ENABLE_OVERLOADING)
data ActionEntryActivateFieldInfo
instance AttrInfo ActionEntryActivateFieldInfo where
    type AttrBaseTypeConstraint ActionEntryActivateFieldInfo = (~) ActionEntry
    type AttrAllowedOps ActionEntryActivateFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint ActionEntryActivateFieldInfo = (~) (FunPtr Gio.Callbacks.C_ActionEntryActivateFieldCallback)
    type AttrTransferTypeConstraint ActionEntryActivateFieldInfo = (~)Gio.Callbacks.ActionEntryActivateFieldCallback_WithClosures
    type AttrTransferType ActionEntryActivateFieldInfo = (FunPtr Gio.Callbacks.C_ActionEntryActivateFieldCallback)
    type AttrGetType ActionEntryActivateFieldInfo = Maybe Gio.Callbacks.ActionEntryActivateFieldCallback_WithClosures
    type AttrLabel ActionEntryActivateFieldInfo = "activate"
    type AttrOrigin ActionEntryActivateFieldInfo = ActionEntry
    attrGet :: forall o.
AttrBaseTypeConstraint ActionEntryActivateFieldInfo o =>
o -> IO (AttrGetType ActionEntryActivateFieldInfo)
attrGet = o -> IO (AttrGetType ActionEntryActivateFieldInfo)
ActionEntry
-> IO (Maybe ActionEntryActivateFieldCallback_WithClosures)
forall (m :: * -> *).
MonadIO m =>
ActionEntry
-> m (Maybe ActionEntryActivateFieldCallback_WithClosures)
getActionEntryActivate
    attrSet :: forall o b.
(AttrBaseTypeConstraint ActionEntryActivateFieldInfo o,
 AttrSetTypeConstraint ActionEntryActivateFieldInfo b) =>
o -> b -> IO ()
attrSet = o -> b -> IO ()
ActionEntry -> FunPtr C_ActionEntryActivateFieldCallback -> IO ()
forall (m :: * -> *).
MonadIO m =>
ActionEntry -> FunPtr C_ActionEntryActivateFieldCallback -> m ()
setActionEntryActivate
    attrConstruct :: forall o b.
(AttrBaseTypeConstraint ActionEntryActivateFieldInfo o,
 AttrSetTypeConstraint ActionEntryActivateFieldInfo b) =>
b -> IO (GValueConstruct o)
attrConstruct = b -> IO (GValueConstruct o)
forall a. HasCallStack => a
undefined
    attrClear :: forall o.
AttrBaseTypeConstraint ActionEntryActivateFieldInfo o =>
o -> IO ()
attrClear = o -> IO ()
ActionEntry -> IO ()
forall (m :: * -> *). MonadIO m => ActionEntry -> m ()
clearActionEntryActivate
    attrTransfer :: forall o b.
(AttrBaseTypeConstraint ActionEntryActivateFieldInfo o,
 AttrTransferTypeConstraint ActionEntryActivateFieldInfo b) =>
Proxy o -> b -> IO (AttrTransferType ActionEntryActivateFieldInfo)
attrTransfer Proxy o
_ b
v = do
        C_ActionEntryActivateFieldCallback
-> IO (FunPtr C_ActionEntryActivateFieldCallback)
Gio.Callbacks.mk_ActionEntryActivateFieldCallback (Maybe (Ptr (FunPtr C_ActionEntryActivateFieldCallback))
-> ActionEntryActivateFieldCallback_WithClosures
-> C_ActionEntryActivateFieldCallback
Gio.Callbacks.wrap_ActionEntryActivateFieldCallback Maybe (Ptr (FunPtr C_ActionEntryActivateFieldCallback))
forall a. Maybe a
Nothing b
ActionEntryActivateFieldCallback_WithClosures
v)
    dbgAttrInfo :: Maybe ResolvedSymbolInfo
dbgAttrInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
        resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.Gio.Structs.ActionEntry.activate"
        , resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-gio-2.0.38/docs/GI-Gio-Structs-ActionEntry.html#g:attr:activate"
        })

actionEntry_activate :: AttrLabelProxy "activate"
actionEntry_activate :: AttrLabelProxy "activate"
actionEntry_activate = AttrLabelProxy "activate"
forall (a :: Symbol). AttrLabelProxy a
AttrLabelProxy

#endif


-- | Get the value of the “@parameter_type@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' actionEntry #parameterType
-- @
getActionEntryParameterType :: MonadIO m => ActionEntry -> m (Maybe T.Text)
getActionEntryParameterType :: forall (m :: * -> *). MonadIO m => ActionEntry -> m (Maybe Text)
getActionEntryParameterType ActionEntry
s = IO (Maybe Text) -> m (Maybe Text)
forall a. IO a -> m a
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
$ ActionEntry
-> (Ptr ActionEntry -> IO (Maybe Text)) -> IO (Maybe Text)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ActionEntry
s ((Ptr ActionEntry -> IO (Maybe Text)) -> IO (Maybe Text))
-> (Ptr ActionEntry -> IO (Maybe Text)) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \Ptr ActionEntry
ptr -> do
    val <- Ptr CString -> IO CString
forall a. Storable a => Ptr a -> IO a
peek (Ptr ActionEntry
ptr Ptr ActionEntry -> Int -> Ptr CString
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
16) :: IO CString
    result <- SP.convertIfNonNull val $ \CString
val' -> do
        val'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
val'
        return val''
    return result

-- | Set the value of the “@parameter_type@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' actionEntry [ #parameterType 'Data.GI.Base.Attributes.:=' value ]
-- @
setActionEntryParameterType :: MonadIO m => ActionEntry -> CString -> m ()
setActionEntryParameterType :: forall (m :: * -> *). MonadIO m => ActionEntry -> CString -> m ()
setActionEntryParameterType ActionEntry
s CString
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ ActionEntry -> (Ptr ActionEntry -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ActionEntry
s ((Ptr ActionEntry -> IO ()) -> IO ())
-> (Ptr ActionEntry -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr ActionEntry
ptr -> do
    Ptr CString -> CString -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ActionEntry
ptr Ptr ActionEntry -> Int -> Ptr CString
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
16) (CString
val :: CString)

-- | Set the value of the “@parameter_type@” field to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #parameterType
-- @
clearActionEntryParameterType :: MonadIO m => ActionEntry -> m ()
clearActionEntryParameterType :: forall (m :: * -> *). MonadIO m => ActionEntry -> m ()
clearActionEntryParameterType ActionEntry
s = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ ActionEntry -> (Ptr ActionEntry -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ActionEntry
s ((Ptr ActionEntry -> IO ()) -> IO ())
-> (Ptr ActionEntry -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr ActionEntry
ptr -> do
    Ptr CString -> CString -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ActionEntry
ptr Ptr ActionEntry -> Int -> Ptr CString
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
16) (CString
forall a. Ptr a
FP.nullPtr :: CString)

#if defined(ENABLE_OVERLOADING)
data ActionEntryParameterTypeFieldInfo
instance AttrInfo ActionEntryParameterTypeFieldInfo where
    type AttrBaseTypeConstraint ActionEntryParameterTypeFieldInfo = (~) ActionEntry
    type AttrAllowedOps ActionEntryParameterTypeFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint ActionEntryParameterTypeFieldInfo = (~) CString
    type AttrTransferTypeConstraint ActionEntryParameterTypeFieldInfo = (~)CString
    type AttrTransferType ActionEntryParameterTypeFieldInfo = CString
    type AttrGetType ActionEntryParameterTypeFieldInfo = Maybe T.Text
    type AttrLabel ActionEntryParameterTypeFieldInfo = "parameter_type"
    type AttrOrigin ActionEntryParameterTypeFieldInfo = ActionEntry
    attrGet :: forall o.
AttrBaseTypeConstraint ActionEntryParameterTypeFieldInfo o =>
o -> IO (AttrGetType ActionEntryParameterTypeFieldInfo)
attrGet = o -> IO (AttrGetType ActionEntryParameterTypeFieldInfo)
ActionEntry -> IO (Maybe Text)
forall (m :: * -> *). MonadIO m => ActionEntry -> m (Maybe Text)
getActionEntryParameterType
    attrSet :: forall o b.
(AttrBaseTypeConstraint ActionEntryParameterTypeFieldInfo o,
 AttrSetTypeConstraint ActionEntryParameterTypeFieldInfo b) =>
o -> b -> IO ()
attrSet = o -> b -> IO ()
ActionEntry -> CString -> IO ()
forall (m :: * -> *). MonadIO m => ActionEntry -> CString -> m ()
setActionEntryParameterType
    attrConstruct :: forall o b.
(AttrBaseTypeConstraint ActionEntryParameterTypeFieldInfo o,
 AttrSetTypeConstraint ActionEntryParameterTypeFieldInfo b) =>
b -> IO (GValueConstruct o)
attrConstruct = b -> IO (GValueConstruct o)
forall a. HasCallStack => a
undefined
    attrClear :: forall o.
AttrBaseTypeConstraint ActionEntryParameterTypeFieldInfo o =>
o -> IO ()
attrClear = o -> IO ()
ActionEntry -> IO ()
forall (m :: * -> *). MonadIO m => ActionEntry -> m ()
clearActionEntryParameterType
    attrTransfer :: forall o b.
(AttrBaseTypeConstraint ActionEntryParameterTypeFieldInfo o,
 AttrTransferTypeConstraint ActionEntryParameterTypeFieldInfo b) =>
Proxy o
-> b -> IO (AttrTransferType ActionEntryParameterTypeFieldInfo)
attrTransfer Proxy o
_ b
v = do
        b -> IO b
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return b
v
    dbgAttrInfo :: Maybe ResolvedSymbolInfo
dbgAttrInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
        resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.Gio.Structs.ActionEntry.parameterType"
        , resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-gio-2.0.38/docs/GI-Gio-Structs-ActionEntry.html#g:attr:parameterType"
        })

actionEntry_parameterType :: AttrLabelProxy "parameterType"
actionEntry_parameterType :: AttrLabelProxy "parameterType"
actionEntry_parameterType = AttrLabelProxy "parameterType"
forall (a :: Symbol). AttrLabelProxy a
AttrLabelProxy

#endif


-- | Get the value of the “@state@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' actionEntry #state
-- @
getActionEntryState :: MonadIO m => ActionEntry -> m (Maybe T.Text)
getActionEntryState :: forall (m :: * -> *). MonadIO m => ActionEntry -> m (Maybe Text)
getActionEntryState ActionEntry
s = IO (Maybe Text) -> m (Maybe Text)
forall a. IO a -> m a
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
$ ActionEntry
-> (Ptr ActionEntry -> IO (Maybe Text)) -> IO (Maybe Text)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ActionEntry
s ((Ptr ActionEntry -> IO (Maybe Text)) -> IO (Maybe Text))
-> (Ptr ActionEntry -> IO (Maybe Text)) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \Ptr ActionEntry
ptr -> do
    val <- Ptr CString -> IO CString
forall a. Storable a => Ptr a -> IO a
peek (Ptr ActionEntry
ptr Ptr ActionEntry -> Int -> Ptr CString
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
24) :: IO CString
    result <- SP.convertIfNonNull val $ \CString
val' -> do
        val'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
val'
        return val''
    return result

-- | Set the value of the “@state@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' actionEntry [ #state 'Data.GI.Base.Attributes.:=' value ]
-- @
setActionEntryState :: MonadIO m => ActionEntry -> CString -> m ()
setActionEntryState :: forall (m :: * -> *). MonadIO m => ActionEntry -> CString -> m ()
setActionEntryState ActionEntry
s CString
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ ActionEntry -> (Ptr ActionEntry -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ActionEntry
s ((Ptr ActionEntry -> IO ()) -> IO ())
-> (Ptr ActionEntry -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr ActionEntry
ptr -> do
    Ptr CString -> CString -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ActionEntry
ptr Ptr ActionEntry -> Int -> Ptr CString
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
24) (CString
val :: CString)

-- | Set the value of the “@state@” field to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #state
-- @
clearActionEntryState :: MonadIO m => ActionEntry -> m ()
clearActionEntryState :: forall (m :: * -> *). MonadIO m => ActionEntry -> m ()
clearActionEntryState ActionEntry
s = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ ActionEntry -> (Ptr ActionEntry -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ActionEntry
s ((Ptr ActionEntry -> IO ()) -> IO ())
-> (Ptr ActionEntry -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr ActionEntry
ptr -> do
    Ptr CString -> CString -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ActionEntry
ptr Ptr ActionEntry -> Int -> Ptr CString
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
24) (CString
forall a. Ptr a
FP.nullPtr :: CString)

#if defined(ENABLE_OVERLOADING)
data ActionEntryStateFieldInfo
instance AttrInfo ActionEntryStateFieldInfo where
    type AttrBaseTypeConstraint ActionEntryStateFieldInfo = (~) ActionEntry
    type AttrAllowedOps ActionEntryStateFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint ActionEntryStateFieldInfo = (~) CString
    type AttrTransferTypeConstraint ActionEntryStateFieldInfo = (~)CString
    type AttrTransferType ActionEntryStateFieldInfo = CString
    type AttrGetType ActionEntryStateFieldInfo = Maybe T.Text
    type AttrLabel ActionEntryStateFieldInfo = "state"
    type AttrOrigin ActionEntryStateFieldInfo = ActionEntry
    attrGet :: forall o.
AttrBaseTypeConstraint ActionEntryStateFieldInfo o =>
o -> IO (AttrGetType ActionEntryStateFieldInfo)
attrGet = o -> IO (AttrGetType ActionEntryStateFieldInfo)
ActionEntry -> IO (Maybe Text)
forall (m :: * -> *). MonadIO m => ActionEntry -> m (Maybe Text)
getActionEntryState
    attrSet :: forall o b.
(AttrBaseTypeConstraint ActionEntryStateFieldInfo o,
 AttrSetTypeConstraint ActionEntryStateFieldInfo b) =>
o -> b -> IO ()
attrSet = o -> b -> IO ()
ActionEntry -> CString -> IO ()
forall (m :: * -> *). MonadIO m => ActionEntry -> CString -> m ()
setActionEntryState
    attrConstruct :: forall o b.
(AttrBaseTypeConstraint ActionEntryStateFieldInfo o,
 AttrSetTypeConstraint ActionEntryStateFieldInfo b) =>
b -> IO (GValueConstruct o)
attrConstruct = b -> IO (GValueConstruct o)
forall a. HasCallStack => a
undefined
    attrClear :: forall o.
AttrBaseTypeConstraint ActionEntryStateFieldInfo o =>
o -> IO ()
attrClear = o -> IO ()
ActionEntry -> IO ()
forall (m :: * -> *). MonadIO m => ActionEntry -> m ()
clearActionEntryState
    attrTransfer :: forall o b.
(AttrBaseTypeConstraint ActionEntryStateFieldInfo o,
 AttrTransferTypeConstraint ActionEntryStateFieldInfo b) =>
Proxy o -> b -> IO (AttrTransferType ActionEntryStateFieldInfo)
attrTransfer Proxy o
_ b
v = do
        b -> IO b
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return b
v
    dbgAttrInfo :: Maybe ResolvedSymbolInfo
dbgAttrInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
        resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.Gio.Structs.ActionEntry.state"
        , resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-gio-2.0.38/docs/GI-Gio-Structs-ActionEntry.html#g:attr:state"
        })

actionEntry_state :: AttrLabelProxy "state"
actionEntry_state :: AttrLabelProxy "state"
actionEntry_state = AttrLabelProxy "state"
forall (a :: Symbol). AttrLabelProxy a
AttrLabelProxy

#endif


-- | Get the value of the “@change_state@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' actionEntry #changeState
-- @
getActionEntryChangeState :: MonadIO m => ActionEntry -> m (Maybe Gio.Callbacks.ActionEntryChangeStateFieldCallback_WithClosures)
getActionEntryChangeState :: forall (m :: * -> *).
MonadIO m =>
ActionEntry
-> m (Maybe ActionEntryChangeStateFieldCallback_WithClosures)
getActionEntryChangeState ActionEntry
s = IO (Maybe ActionEntryChangeStateFieldCallback_WithClosures)
-> m (Maybe ActionEntryChangeStateFieldCallback_WithClosures)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe ActionEntryChangeStateFieldCallback_WithClosures)
 -> m (Maybe ActionEntryChangeStateFieldCallback_WithClosures))
-> IO (Maybe ActionEntryChangeStateFieldCallback_WithClosures)
-> m (Maybe ActionEntryChangeStateFieldCallback_WithClosures)
forall a b. (a -> b) -> a -> b
$ ActionEntry
-> (Ptr ActionEntry
    -> IO (Maybe ActionEntryChangeStateFieldCallback_WithClosures))
-> IO (Maybe ActionEntryChangeStateFieldCallback_WithClosures)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ActionEntry
s ((Ptr ActionEntry
  -> IO (Maybe ActionEntryChangeStateFieldCallback_WithClosures))
 -> IO (Maybe ActionEntryChangeStateFieldCallback_WithClosures))
-> (Ptr ActionEntry
    -> IO (Maybe ActionEntryChangeStateFieldCallback_WithClosures))
-> IO (Maybe ActionEntryChangeStateFieldCallback_WithClosures)
forall a b. (a -> b) -> a -> b
$ \Ptr ActionEntry
ptr -> do
    val <- Ptr (FunPtr C_ActionEntryActivateFieldCallback)
-> IO (FunPtr C_ActionEntryActivateFieldCallback)
forall a. Storable a => Ptr a -> IO a
peek (Ptr ActionEntry
ptr Ptr ActionEntry
-> Int -> Ptr (FunPtr C_ActionEntryActivateFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
32) :: IO (FunPtr Gio.Callbacks.C_ActionEntryChangeStateFieldCallback)
    result <- SP.convertFunPtrIfNonNull val $ \FunPtr C_ActionEntryActivateFieldCallback
val' -> do
        let val'' :: ActionEntryChangeStateFieldCallback_WithClosures
val'' = FunPtr C_ActionEntryActivateFieldCallback
-> ActionEntryChangeStateFieldCallback_WithClosures
forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSimpleAction a) =>
FunPtr C_ActionEntryActivateFieldCallback
-> a -> GVariant -> Ptr () -> m ()
Gio.Callbacks.dynamic_ActionEntryChangeStateFieldCallback FunPtr C_ActionEntryActivateFieldCallback
val'
        ActionEntryChangeStateFieldCallback_WithClosures
-> IO ActionEntryChangeStateFieldCallback_WithClosures
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ActionEntryChangeStateFieldCallback_WithClosures
val''
    return result

-- | Set the value of the “@change_state@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' actionEntry [ #changeState 'Data.GI.Base.Attributes.:=' value ]
-- @
setActionEntryChangeState :: MonadIO m => ActionEntry -> FunPtr Gio.Callbacks.C_ActionEntryChangeStateFieldCallback -> m ()
setActionEntryChangeState :: forall (m :: * -> *).
MonadIO m =>
ActionEntry -> FunPtr C_ActionEntryActivateFieldCallback -> m ()
setActionEntryChangeState ActionEntry
s FunPtr C_ActionEntryActivateFieldCallback
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ ActionEntry -> (Ptr ActionEntry -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ActionEntry
s ((Ptr ActionEntry -> IO ()) -> IO ())
-> (Ptr ActionEntry -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr ActionEntry
ptr -> do
    Ptr (FunPtr C_ActionEntryActivateFieldCallback)
-> FunPtr C_ActionEntryActivateFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ActionEntry
ptr Ptr ActionEntry
-> Int -> Ptr (FunPtr C_ActionEntryActivateFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
32) (FunPtr C_ActionEntryActivateFieldCallback
val :: FunPtr Gio.Callbacks.C_ActionEntryChangeStateFieldCallback)

-- | Set the value of the “@change_state@” field to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #changeState
-- @
clearActionEntryChangeState :: MonadIO m => ActionEntry -> m ()
clearActionEntryChangeState :: forall (m :: * -> *). MonadIO m => ActionEntry -> m ()
clearActionEntryChangeState ActionEntry
s = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ ActionEntry -> (Ptr ActionEntry -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ActionEntry
s ((Ptr ActionEntry -> IO ()) -> IO ())
-> (Ptr ActionEntry -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr ActionEntry
ptr -> do
    Ptr (FunPtr C_ActionEntryActivateFieldCallback)
-> FunPtr C_ActionEntryActivateFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ActionEntry
ptr Ptr ActionEntry
-> Int -> Ptr (FunPtr C_ActionEntryActivateFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
32) (FunPtr C_ActionEntryActivateFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gio.Callbacks.C_ActionEntryChangeStateFieldCallback)

#if defined(ENABLE_OVERLOADING)
data ActionEntryChangeStateFieldInfo
instance AttrInfo ActionEntryChangeStateFieldInfo where
    type AttrBaseTypeConstraint ActionEntryChangeStateFieldInfo = (~) ActionEntry
    type AttrAllowedOps ActionEntryChangeStateFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint ActionEntryChangeStateFieldInfo = (~) (FunPtr Gio.Callbacks.C_ActionEntryChangeStateFieldCallback)
    type AttrTransferTypeConstraint ActionEntryChangeStateFieldInfo = (~)Gio.Callbacks.ActionEntryChangeStateFieldCallback_WithClosures
    type AttrTransferType ActionEntryChangeStateFieldInfo = (FunPtr Gio.Callbacks.C_ActionEntryChangeStateFieldCallback)
    type AttrGetType ActionEntryChangeStateFieldInfo = Maybe Gio.Callbacks.ActionEntryChangeStateFieldCallback_WithClosures
    type AttrLabel ActionEntryChangeStateFieldInfo = "change_state"
    type AttrOrigin ActionEntryChangeStateFieldInfo = ActionEntry
    attrGet :: forall o.
AttrBaseTypeConstraint ActionEntryChangeStateFieldInfo o =>
o -> IO (AttrGetType ActionEntryChangeStateFieldInfo)
attrGet = o -> IO (AttrGetType ActionEntryChangeStateFieldInfo)
ActionEntry
-> IO (Maybe ActionEntryChangeStateFieldCallback_WithClosures)
forall (m :: * -> *).
MonadIO m =>
ActionEntry
-> m (Maybe ActionEntryChangeStateFieldCallback_WithClosures)
getActionEntryChangeState
    attrSet :: forall o b.
(AttrBaseTypeConstraint ActionEntryChangeStateFieldInfo o,
 AttrSetTypeConstraint ActionEntryChangeStateFieldInfo b) =>
o -> b -> IO ()
attrSet = o -> b -> IO ()
ActionEntry -> FunPtr C_ActionEntryActivateFieldCallback -> IO ()
forall (m :: * -> *).
MonadIO m =>
ActionEntry -> FunPtr C_ActionEntryActivateFieldCallback -> m ()
setActionEntryChangeState
    attrConstruct :: forall o b.
(AttrBaseTypeConstraint ActionEntryChangeStateFieldInfo o,
 AttrSetTypeConstraint ActionEntryChangeStateFieldInfo b) =>
b -> IO (GValueConstruct o)
attrConstruct = b -> IO (GValueConstruct o)
forall a. HasCallStack => a
undefined
    attrClear :: forall o.
AttrBaseTypeConstraint ActionEntryChangeStateFieldInfo o =>
o -> IO ()
attrClear = o -> IO ()
ActionEntry -> IO ()
forall (m :: * -> *). MonadIO m => ActionEntry -> m ()
clearActionEntryChangeState
    attrTransfer :: forall o b.
(AttrBaseTypeConstraint ActionEntryChangeStateFieldInfo o,
 AttrTransferTypeConstraint ActionEntryChangeStateFieldInfo b) =>
Proxy o
-> b -> IO (AttrTransferType ActionEntryChangeStateFieldInfo)
attrTransfer Proxy o
_ b
v = do
        C_ActionEntryActivateFieldCallback
-> IO (FunPtr C_ActionEntryActivateFieldCallback)
Gio.Callbacks.mk_ActionEntryChangeStateFieldCallback (Maybe (Ptr (FunPtr C_ActionEntryActivateFieldCallback))
-> ActionEntryChangeStateFieldCallback_WithClosures
-> C_ActionEntryActivateFieldCallback
Gio.Callbacks.wrap_ActionEntryChangeStateFieldCallback Maybe (Ptr (FunPtr C_ActionEntryActivateFieldCallback))
forall a. Maybe a
Nothing b
ActionEntryChangeStateFieldCallback_WithClosures
v)
    dbgAttrInfo :: Maybe ResolvedSymbolInfo
dbgAttrInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
        resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.Gio.Structs.ActionEntry.changeState"
        , resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-gio-2.0.38/docs/GI-Gio-Structs-ActionEntry.html#g:attr:changeState"
        })

actionEntry_changeState :: AttrLabelProxy "changeState"
actionEntry_changeState :: AttrLabelProxy "changeState"
actionEntry_changeState = AttrLabelProxy "changeState"
forall (a :: Symbol). AttrLabelProxy a
AttrLabelProxy

#endif



#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList ActionEntry
type instance O.AttributeList ActionEntry = ActionEntryAttributeList
type ActionEntryAttributeList = ('[ '("name", ActionEntryNameFieldInfo), '("activate", ActionEntryActivateFieldInfo), '("parameterType", ActionEntryParameterTypeFieldInfo), '("state", ActionEntryStateFieldInfo), '("changeState", ActionEntryChangeStateFieldInfo)] :: [(Symbol, DK.Type)])
#endif

#if defined(ENABLE_OVERLOADING)
type family ResolveActionEntryMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
    ResolveActionEntryMethod l o = O.MethodResolutionFailed l o

instance (info ~ ResolveActionEntryMethod t ActionEntry, O.OverloadedMethod info ActionEntry p) => OL.IsLabel t (ActionEntry -> p) where
#if MIN_VERSION_base(4,10,0)
    fromLabel :: ActionEntry -> p
fromLabel = forall {k} (i :: k) o s. OverloadedMethod i o s => o -> s
forall i o s. OverloadedMethod i o s => o -> s
O.overloadedMethod @info
#else
    fromLabel _ = O.overloadedMethod @info
#endif

#if MIN_VERSION_base(4,13,0)
instance (info ~ ResolveActionEntryMethod t ActionEntry, O.OverloadedMethod info ActionEntry p, R.HasField t ActionEntry p) => R.HasField t ActionEntry p where
    getField :: ActionEntry -> p
getField = forall {k} (i :: k) o s. OverloadedMethod i o s => o -> s
forall i o s. OverloadedMethod i o s => o -> s
O.overloadedMethod @info

#endif

instance (info ~ ResolveActionEntryMethod t ActionEntry, O.OverloadedMethodInfo info ActionEntry) => OL.IsLabel t (O.MethodProxy info ActionEntry) where
#if MIN_VERSION_base(4,10,0)
    fromLabel :: MethodProxy info ActionEntry
fromLabel = MethodProxy info ActionEntry
forall info obj. MethodProxy info obj
O.MethodProxy
#else
    fromLabel _ = O.MethodProxy
#endif

#endif