{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Gtk.Structs.TargetEntry
(
TargetEntry(..) ,
newZeroTargetEntry ,
#if defined(ENABLE_OVERLOADING)
ResolveTargetEntryMethod ,
#endif
#if defined(ENABLE_OVERLOADING)
TargetEntryCopyMethodInfo ,
#endif
targetEntryCopy ,
#if defined(ENABLE_OVERLOADING)
TargetEntryFreeMethodInfo ,
#endif
targetEntryFree ,
targetEntryNew ,
getTargetEntryFlags ,
setTargetEntryFlags ,
#if defined(ENABLE_OVERLOADING)
targetEntry_flags ,
#endif
getTargetEntryInfo ,
setTargetEntryInfo ,
#if defined(ENABLE_OVERLOADING)
targetEntry_info ,
#endif
clearTargetEntryTarget ,
getTargetEntryTarget ,
setTargetEntryTarget ,
#if defined(ENABLE_OVERLOADING)
targetEntry_target ,
#endif
) 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
newtype TargetEntry = TargetEntry (SP.ManagedPtr TargetEntry)
deriving (TargetEntry -> TargetEntry -> Bool
(TargetEntry -> TargetEntry -> Bool)
-> (TargetEntry -> TargetEntry -> Bool) -> Eq TargetEntry
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: TargetEntry -> TargetEntry -> Bool
$c/= :: TargetEntry -> TargetEntry -> Bool
== :: TargetEntry -> TargetEntry -> Bool
$c== :: TargetEntry -> TargetEntry -> Bool
Eq)
instance SP.ManagedPtrNewtype TargetEntry where
toManagedPtr :: TargetEntry -> ManagedPtr TargetEntry
toManagedPtr (TargetEntry ManagedPtr TargetEntry
p) = ManagedPtr TargetEntry
p
foreign import ccall "gtk_target_entry_get_type" c_gtk_target_entry_get_type ::
IO GType
type instance O.ParentTypes TargetEntry = '[]
instance O.HasParentTypes TargetEntry
instance B.Types.TypedObject TargetEntry where
glibType :: IO GType
glibType = IO GType
c_gtk_target_entry_get_type
instance B.Types.GBoxed TargetEntry
instance B.GValue.IsGValue (Maybe TargetEntry) where
gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_gtk_target_entry_get_type
gvalueSet_ :: Ptr GValue -> Maybe TargetEntry -> IO ()
gvalueSet_ Ptr GValue
gv Maybe TargetEntry
P.Nothing = Ptr GValue -> Ptr TargetEntry -> IO ()
forall a. Ptr GValue -> Ptr a -> IO ()
B.GValue.set_boxed Ptr GValue
gv (Ptr TargetEntry
forall a. Ptr a
FP.nullPtr :: FP.Ptr TargetEntry)
gvalueSet_ Ptr GValue
gv (P.Just TargetEntry
obj) = TargetEntry -> (Ptr TargetEntry -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr TargetEntry
obj (Ptr GValue -> Ptr TargetEntry -> IO ()
forall a. Ptr GValue -> Ptr a -> IO ()
B.GValue.set_boxed Ptr GValue
gv)
gvalueGet_ :: Ptr GValue -> IO (Maybe TargetEntry)
gvalueGet_ Ptr GValue
gv = do
Ptr TargetEntry
ptr <- Ptr GValue -> IO (Ptr TargetEntry)
forall b. Ptr GValue -> IO (Ptr b)
B.GValue.get_boxed Ptr GValue
gv :: IO (Ptr TargetEntry)
if Ptr TargetEntry
ptr Ptr TargetEntry -> Ptr TargetEntry -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr TargetEntry
forall a. Ptr a
FP.nullPtr
then TargetEntry -> Maybe TargetEntry
forall a. a -> Maybe a
P.Just (TargetEntry -> Maybe TargetEntry)
-> IO TargetEntry -> IO (Maybe TargetEntry)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ManagedPtr TargetEntry -> TargetEntry)
-> Ptr TargetEntry -> IO TargetEntry
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
B.ManagedPtr.newBoxed ManagedPtr TargetEntry -> TargetEntry
TargetEntry Ptr TargetEntry
ptr
else Maybe TargetEntry -> IO (Maybe TargetEntry)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe TargetEntry
forall a. Maybe a
P.Nothing
newZeroTargetEntry :: MonadIO m => m TargetEntry
newZeroTargetEntry :: forall (m :: * -> *). MonadIO m => m TargetEntry
newZeroTargetEntry = IO TargetEntry -> m TargetEntry
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO TargetEntry -> m TargetEntry)
-> IO TargetEntry -> m TargetEntry
forall a b. (a -> b) -> a -> b
$ Int -> IO (Ptr TargetEntry)
forall a. GBoxed a => Int -> IO (Ptr a)
callocBoxedBytes Int
16 IO (Ptr TargetEntry)
-> (Ptr TargetEntry -> IO TargetEntry) -> IO TargetEntry
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (ManagedPtr TargetEntry -> TargetEntry)
-> Ptr TargetEntry -> IO TargetEntry
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr TargetEntry -> TargetEntry
TargetEntry
instance tag ~ 'AttrSet => Constructible TargetEntry tag where
new :: forall (m :: * -> *).
MonadIO m =>
(ManagedPtr TargetEntry -> TargetEntry)
-> [AttrOp TargetEntry tag] -> m TargetEntry
new ManagedPtr TargetEntry -> TargetEntry
_ [AttrOp TargetEntry tag]
attrs = do
TargetEntry
o <- m TargetEntry
forall (m :: * -> *). MonadIO m => m TargetEntry
newZeroTargetEntry
TargetEntry -> [AttrOp TargetEntry 'AttrSet] -> m ()
forall o (m :: * -> *).
MonadIO m =>
o -> [AttrOp o 'AttrSet] -> m ()
GI.Attributes.set TargetEntry
o [AttrOp TargetEntry tag]
[AttrOp TargetEntry 'AttrSet]
attrs
TargetEntry -> m TargetEntry
forall (m :: * -> *) a. Monad m => a -> m a
return TargetEntry
o
getTargetEntryTarget :: MonadIO m => TargetEntry -> m (Maybe T.Text)
getTargetEntryTarget :: forall (m :: * -> *). MonadIO m => TargetEntry -> m (Maybe Text)
getTargetEntryTarget TargetEntry
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
$ TargetEntry
-> (Ptr TargetEntry -> IO (Maybe Text)) -> IO (Maybe Text)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr TargetEntry
s ((Ptr TargetEntry -> IO (Maybe Text)) -> IO (Maybe Text))
-> (Ptr TargetEntry -> IO (Maybe Text)) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \Ptr TargetEntry
ptr -> do
CString
val <- Ptr CString -> IO CString
forall a. Storable a => Ptr a -> IO a
peek (Ptr TargetEntry
ptr Ptr TargetEntry -> Int -> Ptr CString
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0) :: 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
setTargetEntryTarget :: MonadIO m => TargetEntry -> CString -> m ()
setTargetEntryTarget :: forall (m :: * -> *). MonadIO m => TargetEntry -> CString -> m ()
setTargetEntryTarget TargetEntry
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
$ TargetEntry -> (Ptr TargetEntry -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr TargetEntry
s ((Ptr TargetEntry -> IO ()) -> IO ())
-> (Ptr TargetEntry -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr TargetEntry
ptr -> do
Ptr CString -> CString -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr TargetEntry
ptr Ptr TargetEntry -> Int -> Ptr CString
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0) (CString
val :: CString)
clearTargetEntryTarget :: MonadIO m => TargetEntry -> m ()
clearTargetEntryTarget :: forall (m :: * -> *). MonadIO m => TargetEntry -> m ()
clearTargetEntryTarget TargetEntry
s = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ TargetEntry -> (Ptr TargetEntry -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr TargetEntry
s ((Ptr TargetEntry -> IO ()) -> IO ())
-> (Ptr TargetEntry -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr TargetEntry
ptr -> do
Ptr CString -> CString -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr TargetEntry
ptr Ptr TargetEntry -> 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 TargetEntryTargetFieldInfo
instance AttrInfo TargetEntryTargetFieldInfo where
type AttrBaseTypeConstraint TargetEntryTargetFieldInfo = (~) TargetEntry
type AttrAllowedOps TargetEntryTargetFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint TargetEntryTargetFieldInfo = (~) CString
type AttrTransferTypeConstraint TargetEntryTargetFieldInfo = (~)CString
type AttrTransferType TargetEntryTargetFieldInfo = CString
type AttrGetType TargetEntryTargetFieldInfo = Maybe T.Text
type AttrLabel TargetEntryTargetFieldInfo = "target"
type AttrOrigin TargetEntryTargetFieldInfo = TargetEntry
attrGet = getTargetEntryTarget
attrSet = setTargetEntryTarget
attrConstruct = undefined
attrClear = clearTargetEntryTarget
attrTransfer _ v = do
return v
targetEntry_target :: AttrLabelProxy "target"
targetEntry_target = AttrLabelProxy
#endif
getTargetEntryFlags :: MonadIO m => TargetEntry -> m Word32
getTargetEntryFlags :: forall (m :: * -> *). MonadIO m => TargetEntry -> m Word32
getTargetEntryFlags TargetEntry
s = IO Word32 -> m Word32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
forall a b. (a -> b) -> a -> b
$ TargetEntry -> (Ptr TargetEntry -> IO Word32) -> IO Word32
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr TargetEntry
s ((Ptr TargetEntry -> IO Word32) -> IO Word32)
-> (Ptr TargetEntry -> IO Word32) -> IO Word32
forall a b. (a -> b) -> a -> b
$ \Ptr TargetEntry
ptr -> do
Word32
val <- Ptr Word32 -> IO Word32
forall a. Storable a => Ptr a -> IO a
peek (Ptr TargetEntry
ptr Ptr TargetEntry -> Int -> Ptr Word32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
8) :: IO Word32
Word32 -> IO Word32
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
val
setTargetEntryFlags :: MonadIO m => TargetEntry -> Word32 -> m ()
setTargetEntryFlags :: forall (m :: * -> *). MonadIO m => TargetEntry -> Word32 -> m ()
setTargetEntryFlags TargetEntry
s Word32
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ TargetEntry -> (Ptr TargetEntry -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr TargetEntry
s ((Ptr TargetEntry -> IO ()) -> IO ())
-> (Ptr TargetEntry -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr TargetEntry
ptr -> do
Ptr Word32 -> Word32 -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr TargetEntry
ptr Ptr TargetEntry -> Int -> Ptr Word32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
8) (Word32
val :: Word32)
#if defined(ENABLE_OVERLOADING)
data TargetEntryFlagsFieldInfo
instance AttrInfo TargetEntryFlagsFieldInfo where
type AttrBaseTypeConstraint TargetEntryFlagsFieldInfo = (~) TargetEntry
type AttrAllowedOps TargetEntryFlagsFieldInfo = '[ 'AttrSet, 'AttrGet]
type AttrSetTypeConstraint TargetEntryFlagsFieldInfo = (~) Word32
type AttrTransferTypeConstraint TargetEntryFlagsFieldInfo = (~)Word32
type AttrTransferType TargetEntryFlagsFieldInfo = Word32
type AttrGetType TargetEntryFlagsFieldInfo = Word32
type AttrLabel TargetEntryFlagsFieldInfo = "flags"
type AttrOrigin TargetEntryFlagsFieldInfo = TargetEntry
attrGet = getTargetEntryFlags
attrSet = setTargetEntryFlags
attrConstruct = undefined
attrClear = undefined
attrTransfer _ v = do
return v
targetEntry_flags :: AttrLabelProxy "flags"
targetEntry_flags = AttrLabelProxy
#endif
getTargetEntryInfo :: MonadIO m => TargetEntry -> m Word32
getTargetEntryInfo :: forall (m :: * -> *). MonadIO m => TargetEntry -> m Word32
getTargetEntryInfo TargetEntry
s = IO Word32 -> m Word32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
forall a b. (a -> b) -> a -> b
$ TargetEntry -> (Ptr TargetEntry -> IO Word32) -> IO Word32
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr TargetEntry
s ((Ptr TargetEntry -> IO Word32) -> IO Word32)
-> (Ptr TargetEntry -> IO Word32) -> IO Word32
forall a b. (a -> b) -> a -> b
$ \Ptr TargetEntry
ptr -> do
Word32
val <- Ptr Word32 -> IO Word32
forall a. Storable a => Ptr a -> IO a
peek (Ptr TargetEntry
ptr Ptr TargetEntry -> Int -> Ptr Word32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
12) :: IO Word32
Word32 -> IO Word32
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
val
setTargetEntryInfo :: MonadIO m => TargetEntry -> Word32 -> m ()
setTargetEntryInfo :: forall (m :: * -> *). MonadIO m => TargetEntry -> Word32 -> m ()
setTargetEntryInfo TargetEntry
s Word32
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ TargetEntry -> (Ptr TargetEntry -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr TargetEntry
s ((Ptr TargetEntry -> IO ()) -> IO ())
-> (Ptr TargetEntry -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr TargetEntry
ptr -> do
Ptr Word32 -> Word32 -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr TargetEntry
ptr Ptr TargetEntry -> Int -> Ptr Word32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
12) (Word32
val :: Word32)
#if defined(ENABLE_OVERLOADING)
data TargetEntryInfoFieldInfo
instance AttrInfo TargetEntryInfoFieldInfo where
type AttrBaseTypeConstraint TargetEntryInfoFieldInfo = (~) TargetEntry
type AttrAllowedOps TargetEntryInfoFieldInfo = '[ 'AttrSet, 'AttrGet]
type AttrSetTypeConstraint TargetEntryInfoFieldInfo = (~) Word32
type AttrTransferTypeConstraint TargetEntryInfoFieldInfo = (~)Word32
type AttrTransferType TargetEntryInfoFieldInfo = Word32
type AttrGetType TargetEntryInfoFieldInfo = Word32
type AttrLabel TargetEntryInfoFieldInfo = "info"
type AttrOrigin TargetEntryInfoFieldInfo = TargetEntry
attrGet = getTargetEntryInfo
attrSet = setTargetEntryInfo
attrConstruct = undefined
attrClear = undefined
attrTransfer _ v = do
return v
targetEntry_info :: AttrLabelProxy "info"
targetEntry_info = AttrLabelProxy
#endif
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList TargetEntry
type instance O.AttributeList TargetEntry = TargetEntryAttributeList
type TargetEntryAttributeList = ('[ '("target", TargetEntryTargetFieldInfo), '("flags", TargetEntryFlagsFieldInfo), '("info", TargetEntryInfoFieldInfo)] :: [(Symbol, *)])
#endif
foreign import ccall "gtk_target_entry_new" gtk_target_entry_new ::
CString ->
Word32 ->
Word32 ->
IO (Ptr TargetEntry)
targetEntryNew ::
(B.CallStack.HasCallStack, MonadIO m) =>
T.Text
-> Word32
-> Word32
-> m TargetEntry
targetEntryNew :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Text -> Word32 -> Word32 -> m TargetEntry
targetEntryNew Text
target Word32
flags Word32
info = IO TargetEntry -> m TargetEntry
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO TargetEntry -> m TargetEntry)
-> IO TargetEntry -> m TargetEntry
forall a b. (a -> b) -> a -> b
$ do
CString
target' <- Text -> IO CString
textToCString Text
target
Ptr TargetEntry
result <- CString -> Word32 -> Word32 -> IO (Ptr TargetEntry)
gtk_target_entry_new CString
target' Word32
flags Word32
info
Text -> Ptr TargetEntry -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"targetEntryNew" Ptr TargetEntry
result
TargetEntry
result' <- ((ManagedPtr TargetEntry -> TargetEntry)
-> Ptr TargetEntry -> IO TargetEntry
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr TargetEntry -> TargetEntry
TargetEntry) Ptr TargetEntry
result
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
target'
TargetEntry -> IO TargetEntry
forall (m :: * -> *) a. Monad m => a -> m a
return TargetEntry
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "gtk_target_entry_copy" gtk_target_entry_copy ::
Ptr TargetEntry ->
IO (Ptr TargetEntry)
targetEntryCopy ::
(B.CallStack.HasCallStack, MonadIO m) =>
TargetEntry
-> m TargetEntry
targetEntryCopy :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
TargetEntry -> m TargetEntry
targetEntryCopy TargetEntry
data_ = IO TargetEntry -> m TargetEntry
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO TargetEntry -> m TargetEntry)
-> IO TargetEntry -> m TargetEntry
forall a b. (a -> b) -> a -> b
$ do
Ptr TargetEntry
data_' <- TargetEntry -> IO (Ptr TargetEntry)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr TargetEntry
data_
Ptr TargetEntry
result <- Ptr TargetEntry -> IO (Ptr TargetEntry)
gtk_target_entry_copy Ptr TargetEntry
data_'
Text -> Ptr TargetEntry -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"targetEntryCopy" Ptr TargetEntry
result
TargetEntry
result' <- ((ManagedPtr TargetEntry -> TargetEntry)
-> Ptr TargetEntry -> IO TargetEntry
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr TargetEntry -> TargetEntry
TargetEntry) Ptr TargetEntry
result
TargetEntry -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr TargetEntry
data_
TargetEntry -> IO TargetEntry
forall (m :: * -> *) a. Monad m => a -> m a
return TargetEntry
result'
#if defined(ENABLE_OVERLOADING)
data TargetEntryCopyMethodInfo
instance (signature ~ (m TargetEntry), MonadIO m) => O.OverloadedMethod TargetEntryCopyMethodInfo TargetEntry signature where
overloadedMethod = targetEntryCopy
instance O.OverloadedMethodInfo TargetEntryCopyMethodInfo TargetEntry where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.Gtk.Structs.TargetEntry.targetEntryCopy",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-gtk-3.0.37/docs/GI-Gtk-Structs-TargetEntry.html#v:targetEntryCopy"
}
#endif
foreign import ccall "gtk_target_entry_free" gtk_target_entry_free ::
Ptr TargetEntry ->
IO ()
targetEntryFree ::
(B.CallStack.HasCallStack, MonadIO m) =>
TargetEntry
-> m ()
targetEntryFree :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
TargetEntry -> m ()
targetEntryFree TargetEntry
data_ = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr TargetEntry
data_' <- TargetEntry -> IO (Ptr TargetEntry)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr TargetEntry
data_
Ptr TargetEntry -> IO ()
gtk_target_entry_free Ptr TargetEntry
data_'
TargetEntry -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr TargetEntry
data_
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data TargetEntryFreeMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.OverloadedMethod TargetEntryFreeMethodInfo TargetEntry signature where
overloadedMethod = targetEntryFree
instance O.OverloadedMethodInfo TargetEntryFreeMethodInfo TargetEntry where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.Gtk.Structs.TargetEntry.targetEntryFree",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-gtk-3.0.37/docs/GI-Gtk-Structs-TargetEntry.html#v:targetEntryFree"
}
#endif
#if defined(ENABLE_OVERLOADING)
type family ResolveTargetEntryMethod (t :: Symbol) (o :: *) :: * where
ResolveTargetEntryMethod "copy" o = TargetEntryCopyMethodInfo
ResolveTargetEntryMethod "free" o = TargetEntryFreeMethodInfo
ResolveTargetEntryMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveTargetEntryMethod t TargetEntry, O.OverloadedMethod info TargetEntry p) => OL.IsLabel t (TargetEntry -> 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 ~ ResolveTargetEntryMethod t TargetEntry, O.OverloadedMethod info TargetEntry p, R.HasField t TargetEntry p) => R.HasField t TargetEntry p where
getField = O.overloadedMethod @info
#endif
instance (info ~ ResolveTargetEntryMethod t TargetEntry, O.OverloadedMethodInfo info TargetEntry) => OL.IsLabel t (O.MethodProxy info TargetEntry) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.MethodProxy
#else
fromLabel _ = O.MethodProxy
#endif
#endif