{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- /No description available in the introspection data./

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

module GI.Poppler.Structs.ActionNamed
    ( 

-- * Exported types
    ActionNamed(..)                         ,
    newZeroActionNamed                      ,


 -- * Methods

#if defined(ENABLE_OVERLOADING)
    ResolveActionNamedMethod                ,
#endif



 -- * Properties


-- ** namedDest #attr:namedDest#
-- | /No description available in the introspection data./

#if defined(ENABLE_OVERLOADING)
    actionNamed_namedDest                   ,
#endif
    clearActionNamedNamedDest               ,
    getActionNamedNamedDest                 ,
    setActionNamedNamedDest                 ,


-- ** title #attr:title#
-- | /No description available in the introspection data./

#if defined(ENABLE_OVERLOADING)
    actionNamed_title                       ,
#endif
    clearActionNamedTitle                   ,
    getActionNamedTitle                     ,
    setActionNamedTitle                     ,


-- ** type #attr:type#
-- | /No description available in the introspection data./

#if defined(ENABLE_OVERLOADING)
    actionNamed_type                        ,
#endif
    getActionNamedType                      ,
    setActionNamedType                      ,




    ) 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.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.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 GHC.Records as R

import {-# SOURCE #-} qualified GI.Poppler.Enums as Poppler.Enums

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

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

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


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

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


-- | Get the value of the “@type@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' actionNamed #type
-- @
getActionNamedType :: MonadIO m => ActionNamed -> m Poppler.Enums.ActionType
getActionNamedType :: forall (m :: * -> *). MonadIO m => ActionNamed -> m ActionType
getActionNamedType ActionNamed
s = IO ActionType -> m ActionType
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO ActionType -> m ActionType) -> IO ActionType -> m ActionType
forall a b. (a -> b) -> a -> b
$ ActionNamed -> (Ptr ActionNamed -> IO ActionType) -> IO ActionType
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ActionNamed
s ((Ptr ActionNamed -> IO ActionType) -> IO ActionType)
-> (Ptr ActionNamed -> IO ActionType) -> IO ActionType
forall a b. (a -> b) -> a -> b
$ \Ptr ActionNamed
ptr -> do
    CUInt
val <- Ptr CUInt -> IO CUInt
forall a. Storable a => Ptr a -> IO a
peek (Ptr ActionNamed
ptr Ptr ActionNamed -> Int -> Ptr CUInt
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0) :: IO CUInt
    let val' :: ActionType
val' = (Int -> ActionType
forall a. Enum a => Int -> a
toEnum (Int -> ActionType) -> (CUInt -> Int) -> CUInt -> ActionType
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
val
    ActionType -> IO ActionType
forall (m :: * -> *) a. Monad m => a -> m a
return ActionType
val'

-- | Set the value of the “@type@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' actionNamed [ #type 'Data.GI.Base.Attributes.:=' value ]
-- @
setActionNamedType :: MonadIO m => ActionNamed -> Poppler.Enums.ActionType -> m ()
setActionNamedType :: forall (m :: * -> *).
MonadIO m =>
ActionNamed -> ActionType -> m ()
setActionNamedType ActionNamed
s ActionType
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ ActionNamed -> (Ptr ActionNamed -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ActionNamed
s ((Ptr ActionNamed -> IO ()) -> IO ())
-> (Ptr ActionNamed -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr ActionNamed
ptr -> do
    let val' :: CUInt
val' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (ActionType -> Int) -> ActionType -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ActionType -> Int
forall a. Enum a => a -> Int
fromEnum) ActionType
val
    Ptr CUInt -> CUInt -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ActionNamed
ptr Ptr ActionNamed -> Int -> Ptr CUInt
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0) (CUInt
val' :: CUInt)

#if defined(ENABLE_OVERLOADING)
data ActionNamedTypeFieldInfo
instance AttrInfo ActionNamedTypeFieldInfo where
    type AttrBaseTypeConstraint ActionNamedTypeFieldInfo = (~) ActionNamed
    type AttrAllowedOps ActionNamedTypeFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint ActionNamedTypeFieldInfo = (~) Poppler.Enums.ActionType
    type AttrTransferTypeConstraint ActionNamedTypeFieldInfo = (~)Poppler.Enums.ActionType
    type AttrTransferType ActionNamedTypeFieldInfo = Poppler.Enums.ActionType
    type AttrGetType ActionNamedTypeFieldInfo = Poppler.Enums.ActionType
    type AttrLabel ActionNamedTypeFieldInfo = "type"
    type AttrOrigin ActionNamedTypeFieldInfo = ActionNamed
    attrGet = getActionNamedType
    attrSet = setActionNamedType
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer _ v = do
        return v

actionNamed_type :: AttrLabelProxy "type"
actionNamed_type = AttrLabelProxy

#endif


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

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

-- | Set the value of the “@title@” 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' #title
-- @
clearActionNamedTitle :: MonadIO m => ActionNamed -> m ()
clearActionNamedTitle :: forall (m :: * -> *). MonadIO m => ActionNamed -> m ()
clearActionNamedTitle ActionNamed
s = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ ActionNamed -> (Ptr ActionNamed -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ActionNamed
s ((Ptr ActionNamed -> IO ()) -> IO ())
-> (Ptr ActionNamed -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr ActionNamed
ptr -> do
    Ptr CString -> CString -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ActionNamed
ptr Ptr ActionNamed -> Int -> Ptr CString
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
8) (CString
forall a. Ptr a
FP.nullPtr :: CString)

#if defined(ENABLE_OVERLOADING)
data ActionNamedTitleFieldInfo
instance AttrInfo ActionNamedTitleFieldInfo where
    type AttrBaseTypeConstraint ActionNamedTitleFieldInfo = (~) ActionNamed
    type AttrAllowedOps ActionNamedTitleFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint ActionNamedTitleFieldInfo = (~) CString
    type AttrTransferTypeConstraint ActionNamedTitleFieldInfo = (~)CString
    type AttrTransferType ActionNamedTitleFieldInfo = CString
    type AttrGetType ActionNamedTitleFieldInfo = Maybe T.Text
    type AttrLabel ActionNamedTitleFieldInfo = "title"
    type AttrOrigin ActionNamedTitleFieldInfo = ActionNamed
    attrGet = getActionNamedTitle
    attrSet = setActionNamedTitle
    attrConstruct = undefined
    attrClear = clearActionNamedTitle
    attrTransfer _ v = do
        return v

actionNamed_title :: AttrLabelProxy "title"
actionNamed_title = AttrLabelProxy

#endif


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

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

-- | Set the value of the “@named_dest@” 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' #namedDest
-- @
clearActionNamedNamedDest :: MonadIO m => ActionNamed -> m ()
clearActionNamedNamedDest :: forall (m :: * -> *). MonadIO m => ActionNamed -> m ()
clearActionNamedNamedDest ActionNamed
s = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ ActionNamed -> (Ptr ActionNamed -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ActionNamed
s ((Ptr ActionNamed -> IO ()) -> IO ())
-> (Ptr ActionNamed -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr ActionNamed
ptr -> do
    Ptr CString -> CString -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ActionNamed
ptr Ptr ActionNamed -> 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 ActionNamedNamedDestFieldInfo
instance AttrInfo ActionNamedNamedDestFieldInfo where
    type AttrBaseTypeConstraint ActionNamedNamedDestFieldInfo = (~) ActionNamed
    type AttrAllowedOps ActionNamedNamedDestFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint ActionNamedNamedDestFieldInfo = (~) CString
    type AttrTransferTypeConstraint ActionNamedNamedDestFieldInfo = (~)CString
    type AttrTransferType ActionNamedNamedDestFieldInfo = CString
    type AttrGetType ActionNamedNamedDestFieldInfo = Maybe T.Text
    type AttrLabel ActionNamedNamedDestFieldInfo = "named_dest"
    type AttrOrigin ActionNamedNamedDestFieldInfo = ActionNamed
    attrGet = getActionNamedNamedDest
    attrSet = setActionNamedNamedDest
    attrConstruct = undefined
    attrClear = clearActionNamedNamedDest
    attrTransfer _ v = do
        return v

actionNamed_namedDest :: AttrLabelProxy "namedDest"
actionNamed_namedDest = AttrLabelProxy

#endif



#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList ActionNamed
type instance O.AttributeList ActionNamed = ActionNamedAttributeList
type ActionNamedAttributeList = ('[ '("type", ActionNamedTypeFieldInfo), '("title", ActionNamedTitleFieldInfo), '("namedDest", ActionNamedNamedDestFieldInfo)] :: [(Symbol, *)])
#endif

#if defined(ENABLE_OVERLOADING)
type family ResolveActionNamedMethod (t :: Symbol) (o :: *) :: * where
    ResolveActionNamedMethod l o = O.MethodResolutionFailed l o

instance (info ~ ResolveActionNamedMethod t ActionNamed, O.OverloadedMethod info ActionNamed p) => OL.IsLabel t (ActionNamed -> p) where
#if MIN_VERSION_base(4,10,0)
    fromLabel = O.overloadedMethod @info
#else
    fromLabel _ = O.overloadedMethod @info
#endif

#if MIN_VERSION_base(4,13,0)
instance (info ~ ResolveActionNamedMethod t ActionNamed, O.OverloadedMethod info ActionNamed p, R.HasField t ActionNamed p) => R.HasField t ActionNamed p where
    getField = O.overloadedMethod @info

#endif

instance (info ~ ResolveActionNamedMethod t ActionNamed, O.OverloadedMethodInfo info ActionNamed) => OL.IsLabel t (O.MethodProxy info ActionNamed) where
#if MIN_VERSION_base(4,10,0)
    fromLabel = O.MethodProxy
#else
    fromLabel _ = O.MethodProxy
#endif

#endif