{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- URI

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

module GI.Poppler.Structs.ActionUri
    ( 

-- * Exported types
    ActionUri(..)                           ,
    newZeroActionUri                        ,


 -- * Methods

#if defined(ENABLE_OVERLOADING)
    ResolveActionUriMethod                  ,
#endif



 -- * Properties


-- ** title #attr:title#
-- | action title

#if defined(ENABLE_OVERLOADING)
    actionUri_title                         ,
#endif
    clearActionUriTitle                     ,
    getActionUriTitle                       ,
    setActionUriTitle                       ,


-- ** type #attr:type#
-- | action type ('GI.Poppler.Enums.ActionTypeUri')

#if defined(ENABLE_OVERLOADING)
    actionUri_type                          ,
#endif
    getActionUriType                        ,
    setActionUriType                        ,


-- ** uri #attr:uri#
-- | URI

#if defined(ENABLE_OVERLOADING)
    actionUri_uri                           ,
#endif
    clearActionUriUri                       ,
    getActionUriUri                         ,
    setActionUriUri                         ,




    ) 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.Coerce as Coerce
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 ActionUri = ActionUri (SP.ManagedPtr ActionUri)
    deriving (ActionUri -> ActionUri -> Bool
(ActionUri -> ActionUri -> Bool)
-> (ActionUri -> ActionUri -> Bool) -> Eq ActionUri
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ActionUri -> ActionUri -> Bool
$c/= :: ActionUri -> ActionUri -> Bool
== :: ActionUri -> ActionUri -> Bool
$c== :: ActionUri -> ActionUri -> Bool
Eq)

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

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


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

instance tag ~ 'AttrSet => Constructible ActionUri tag where
    new :: forall (m :: * -> *).
MonadIO m =>
(ManagedPtr ActionUri -> ActionUri)
-> [AttrOp ActionUri tag] -> m ActionUri
new ManagedPtr ActionUri -> ActionUri
_ [AttrOp ActionUri tag]
attrs = do
        ActionUri
o <- m ActionUri
forall (m :: * -> *). MonadIO m => m ActionUri
newZeroActionUri
        ActionUri -> [AttrOp ActionUri 'AttrSet] -> m ()
forall o (m :: * -> *).
MonadIO m =>
o -> [AttrOp o 'AttrSet] -> m ()
GI.Attributes.set ActionUri
o [AttrOp ActionUri tag]
[AttrOp ActionUri 'AttrSet]
attrs
        ActionUri -> m ActionUri
forall (m :: * -> *) a. Monad m => a -> m a
return ActionUri
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' actionUri #type
-- @
getActionUriType :: MonadIO m => ActionUri -> m Poppler.Enums.ActionType
getActionUriType :: forall (m :: * -> *). MonadIO m => ActionUri -> m ActionType
getActionUriType ActionUri
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
$ ActionUri -> (Ptr ActionUri -> IO ActionType) -> IO ActionType
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ActionUri
s ((Ptr ActionUri -> IO ActionType) -> IO ActionType)
-> (Ptr ActionUri -> IO ActionType) -> IO ActionType
forall a b. (a -> b) -> a -> b
$ \Ptr ActionUri
ptr -> do
    CUInt
val <- Ptr CUInt -> IO CUInt
forall a. Storable a => Ptr a -> IO a
peek (Ptr ActionUri
ptr Ptr ActionUri -> 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' actionUri [ #type 'Data.GI.Base.Attributes.:=' value ]
-- @
setActionUriType :: MonadIO m => ActionUri -> Poppler.Enums.ActionType -> m ()
setActionUriType :: forall (m :: * -> *). MonadIO m => ActionUri -> ActionType -> m ()
setActionUriType ActionUri
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
$ ActionUri -> (Ptr ActionUri -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ActionUri
s ((Ptr ActionUri -> IO ()) -> IO ())
-> (Ptr ActionUri -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr ActionUri
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 ActionUri
ptr Ptr ActionUri -> Int -> Ptr CUInt
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0) (CUInt
val' :: CUInt)

#if defined(ENABLE_OVERLOADING)
data ActionUriTypeFieldInfo
instance AttrInfo ActionUriTypeFieldInfo where
    type AttrBaseTypeConstraint ActionUriTypeFieldInfo = (~) ActionUri
    type AttrAllowedOps ActionUriTypeFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint ActionUriTypeFieldInfo = (~) Poppler.Enums.ActionType
    type AttrTransferTypeConstraint ActionUriTypeFieldInfo = (~)Poppler.Enums.ActionType
    type AttrTransferType ActionUriTypeFieldInfo = Poppler.Enums.ActionType
    type AttrGetType ActionUriTypeFieldInfo = Poppler.Enums.ActionType
    type AttrLabel ActionUriTypeFieldInfo = "type"
    type AttrOrigin ActionUriTypeFieldInfo = ActionUri
    attrGet = getActionUriType
    attrSet = setActionUriType
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer _ v = do
        return v
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Poppler.Structs.ActionUri.type"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-poppler-0.18.26/docs/GI-Poppler-Structs-ActionUri.html#g:attr:type"
        })

actionUri_type :: AttrLabelProxy "type"
actionUri_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' actionUri #title
-- @
getActionUriTitle :: MonadIO m => ActionUri -> m (Maybe T.Text)
getActionUriTitle :: forall (m :: * -> *). MonadIO m => ActionUri -> m (Maybe Text)
getActionUriTitle ActionUri
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
$ ActionUri -> (Ptr ActionUri -> IO (Maybe Text)) -> IO (Maybe Text)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ActionUri
s ((Ptr ActionUri -> IO (Maybe Text)) -> IO (Maybe Text))
-> (Ptr ActionUri -> IO (Maybe Text)) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \Ptr ActionUri
ptr -> do
    CString
val <- Ptr CString -> IO CString
forall a. Storable a => Ptr a -> IO a
peek (Ptr ActionUri
ptr Ptr ActionUri -> 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' actionUri [ #title 'Data.GI.Base.Attributes.:=' value ]
-- @
setActionUriTitle :: MonadIO m => ActionUri -> CString -> m ()
setActionUriTitle :: forall (m :: * -> *). MonadIO m => ActionUri -> CString -> m ()
setActionUriTitle ActionUri
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
$ ActionUri -> (Ptr ActionUri -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ActionUri
s ((Ptr ActionUri -> IO ()) -> IO ())
-> (Ptr ActionUri -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr ActionUri
ptr -> do
    Ptr CString -> CString -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ActionUri
ptr Ptr ActionUri -> 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
-- @
clearActionUriTitle :: MonadIO m => ActionUri -> m ()
clearActionUriTitle :: forall (m :: * -> *). MonadIO m => ActionUri -> m ()
clearActionUriTitle ActionUri
s = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ ActionUri -> (Ptr ActionUri -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ActionUri
s ((Ptr ActionUri -> IO ()) -> IO ())
-> (Ptr ActionUri -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr ActionUri
ptr -> do
    Ptr CString -> CString -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ActionUri
ptr Ptr ActionUri -> 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 ActionUriTitleFieldInfo
instance AttrInfo ActionUriTitleFieldInfo where
    type AttrBaseTypeConstraint ActionUriTitleFieldInfo = (~) ActionUri
    type AttrAllowedOps ActionUriTitleFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint ActionUriTitleFieldInfo = (~) CString
    type AttrTransferTypeConstraint ActionUriTitleFieldInfo = (~)CString
    type AttrTransferType ActionUriTitleFieldInfo = CString
    type AttrGetType ActionUriTitleFieldInfo = Maybe T.Text
    type AttrLabel ActionUriTitleFieldInfo = "title"
    type AttrOrigin ActionUriTitleFieldInfo = ActionUri
    attrGet = getActionUriTitle
    attrSet = setActionUriTitle
    attrConstruct = undefined
    attrClear = clearActionUriTitle
    attrTransfer _ v = do
        return v
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Poppler.Structs.ActionUri.title"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-poppler-0.18.26/docs/GI-Poppler-Structs-ActionUri.html#g:attr:title"
        })

actionUri_title :: AttrLabelProxy "title"
actionUri_title = AttrLabelProxy

#endif


-- | Get the value of the “@uri@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' actionUri #uri
-- @
getActionUriUri :: MonadIO m => ActionUri -> m (Maybe T.Text)
getActionUriUri :: forall (m :: * -> *). MonadIO m => ActionUri -> m (Maybe Text)
getActionUriUri ActionUri
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
$ ActionUri -> (Ptr ActionUri -> IO (Maybe Text)) -> IO (Maybe Text)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ActionUri
s ((Ptr ActionUri -> IO (Maybe Text)) -> IO (Maybe Text))
-> (Ptr ActionUri -> IO (Maybe Text)) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \Ptr ActionUri
ptr -> do
    CString
val <- Ptr CString -> IO CString
forall a. Storable a => Ptr a -> IO a
peek (Ptr ActionUri
ptr Ptr ActionUri -> 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 “@uri@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' actionUri [ #uri 'Data.GI.Base.Attributes.:=' value ]
-- @
setActionUriUri :: MonadIO m => ActionUri -> CString -> m ()
setActionUriUri :: forall (m :: * -> *). MonadIO m => ActionUri -> CString -> m ()
setActionUriUri ActionUri
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
$ ActionUri -> (Ptr ActionUri -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ActionUri
s ((Ptr ActionUri -> IO ()) -> IO ())
-> (Ptr ActionUri -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr ActionUri
ptr -> do
    Ptr CString -> CString -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ActionUri
ptr Ptr ActionUri -> Int -> Ptr CString
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
16) (CString
val :: CString)

-- | Set the value of the “@uri@” 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' #uri
-- @
clearActionUriUri :: MonadIO m => ActionUri -> m ()
clearActionUriUri :: forall (m :: * -> *). MonadIO m => ActionUri -> m ()
clearActionUriUri ActionUri
s = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ ActionUri -> (Ptr ActionUri -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ActionUri
s ((Ptr ActionUri -> IO ()) -> IO ())
-> (Ptr ActionUri -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr ActionUri
ptr -> do
    Ptr CString -> CString -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ActionUri
ptr Ptr ActionUri -> 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 ActionUriUriFieldInfo
instance AttrInfo ActionUriUriFieldInfo where
    type AttrBaseTypeConstraint ActionUriUriFieldInfo = (~) ActionUri
    type AttrAllowedOps ActionUriUriFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint ActionUriUriFieldInfo = (~) CString
    type AttrTransferTypeConstraint ActionUriUriFieldInfo = (~)CString
    type AttrTransferType ActionUriUriFieldInfo = CString
    type AttrGetType ActionUriUriFieldInfo = Maybe T.Text
    type AttrLabel ActionUriUriFieldInfo = "uri"
    type AttrOrigin ActionUriUriFieldInfo = ActionUri
    attrGet = getActionUriUri
    attrSet = setActionUriUri
    attrConstruct = undefined
    attrClear = clearActionUriUri
    attrTransfer _ v = do
        return v
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Poppler.Structs.ActionUri.uri"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-poppler-0.18.26/docs/GI-Poppler-Structs-ActionUri.html#g:attr:uri"
        })

actionUri_uri :: AttrLabelProxy "uri"
actionUri_uri = AttrLabelProxy

#endif



#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList ActionUri
type instance O.AttributeList ActionUri = ActionUriAttributeList
type ActionUriAttributeList = ('[ '("type", ActionUriTypeFieldInfo), '("title", ActionUriTitleFieldInfo), '("uri", ActionUriUriFieldInfo)] :: [(Symbol, *)])
#endif

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

instance (info ~ ResolveActionUriMethod t ActionUri, O.OverloadedMethod info ActionUri p) => OL.IsLabel t (ActionUri -> 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 ~ ResolveActionUriMethod t ActionUri, O.OverloadedMethod info ActionUri p, R.HasField t ActionUri p) => R.HasField t ActionUri p where
    getField = O.overloadedMethod @info

#endif

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

#endif