{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Adw.Objects.EnumListItem
(
EnumListItem(..) ,
IsEnumListItem ,
toEnumListItem ,
#if defined(ENABLE_OVERLOADING)
ResolveEnumListItemMethod ,
#endif
#if defined(ENABLE_OVERLOADING)
EnumListItemGetNameMethodInfo ,
#endif
enumListItemGetName ,
#if defined(ENABLE_OVERLOADING)
EnumListItemGetNickMethodInfo ,
#endif
enumListItemGetNick ,
#if defined(ENABLE_OVERLOADING)
EnumListItemGetValueMethodInfo ,
#endif
enumListItemGetValue ,
#if defined(ENABLE_OVERLOADING)
EnumListItemNamePropertyInfo ,
#endif
#if defined(ENABLE_OVERLOADING)
enumListItemName ,
#endif
getEnumListItemName ,
#if defined(ENABLE_OVERLOADING)
EnumListItemNickPropertyInfo ,
#endif
#if defined(ENABLE_OVERLOADING)
enumListItemNick ,
#endif
getEnumListItemNick ,
#if defined(ENABLE_OVERLOADING)
EnumListItemValuePropertyInfo ,
#endif
#if defined(ENABLE_OVERLOADING)
enumListItemValue ,
#endif
getEnumListItemValue ,
) 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 GI.GObject.Objects.Object as GObject.Object
newtype EnumListItem = EnumListItem (SP.ManagedPtr EnumListItem)
deriving (EnumListItem -> EnumListItem -> Bool
(EnumListItem -> EnumListItem -> Bool)
-> (EnumListItem -> EnumListItem -> Bool) -> Eq EnumListItem
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: EnumListItem -> EnumListItem -> Bool
== :: EnumListItem -> EnumListItem -> Bool
$c/= :: EnumListItem -> EnumListItem -> Bool
/= :: EnumListItem -> EnumListItem -> Bool
Eq)
instance SP.ManagedPtrNewtype EnumListItem where
toManagedPtr :: EnumListItem -> ManagedPtr EnumListItem
toManagedPtr (EnumListItem ManagedPtr EnumListItem
p) = ManagedPtr EnumListItem
p
foreign import ccall "adw_enum_list_item_get_type"
c_adw_enum_list_item_get_type :: IO B.Types.GType
instance B.Types.TypedObject EnumListItem where
glibType :: IO GType
glibType = IO GType
c_adw_enum_list_item_get_type
instance B.Types.GObject EnumListItem
class (SP.GObject o, O.IsDescendantOf EnumListItem o) => IsEnumListItem o
instance (SP.GObject o, O.IsDescendantOf EnumListItem o) => IsEnumListItem o
instance O.HasParentTypes EnumListItem
type instance O.ParentTypes EnumListItem = '[GObject.Object.Object]
toEnumListItem :: (MIO.MonadIO m, IsEnumListItem o) => o -> m EnumListItem
toEnumListItem :: forall (m :: * -> *) o.
(MonadIO m, IsEnumListItem o) =>
o -> m EnumListItem
toEnumListItem = IO EnumListItem -> m EnumListItem
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO EnumListItem -> m EnumListItem)
-> (o -> IO EnumListItem) -> o -> m EnumListItem
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ManagedPtr EnumListItem -> EnumListItem) -> o -> IO EnumListItem
forall o o'.
(HasCallStack, ManagedPtrNewtype o, TypedObject o,
ManagedPtrNewtype o', TypedObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
B.ManagedPtr.unsafeCastTo ManagedPtr EnumListItem -> EnumListItem
EnumListItem
instance B.GValue.IsGValue (Maybe EnumListItem) where
gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_adw_enum_list_item_get_type
gvalueSet_ :: Ptr GValue -> Maybe EnumListItem -> IO ()
gvalueSet_ Ptr GValue
gv Maybe EnumListItem
P.Nothing = Ptr GValue -> Ptr EnumListItem -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv (Ptr EnumListItem
forall a. Ptr a
FP.nullPtr :: FP.Ptr EnumListItem)
gvalueSet_ Ptr GValue
gv (P.Just EnumListItem
obj) = EnumListItem -> (Ptr EnumListItem -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr EnumListItem
obj (Ptr GValue -> Ptr EnumListItem -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv)
gvalueGet_ :: Ptr GValue -> IO (Maybe EnumListItem)
gvalueGet_ Ptr GValue
gv = do
Ptr EnumListItem
ptr <- Ptr GValue -> IO (Ptr EnumListItem)
forall a. GObject a => Ptr GValue -> IO (Ptr a)
B.GValue.get_object Ptr GValue
gv :: IO (FP.Ptr EnumListItem)
if Ptr EnumListItem
ptr Ptr EnumListItem -> Ptr EnumListItem -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr EnumListItem
forall a. Ptr a
FP.nullPtr
then EnumListItem -> Maybe EnumListItem
forall a. a -> Maybe a
P.Just (EnumListItem -> Maybe EnumListItem)
-> IO EnumListItem -> IO (Maybe EnumListItem)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ManagedPtr EnumListItem -> EnumListItem)
-> Ptr EnumListItem -> IO EnumListItem
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr EnumListItem -> EnumListItem
EnumListItem Ptr EnumListItem
ptr
else Maybe EnumListItem -> IO (Maybe EnumListItem)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe EnumListItem
forall a. Maybe a
P.Nothing
#if defined(ENABLE_OVERLOADING)
type family ResolveEnumListItemMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
ResolveEnumListItemMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
ResolveEnumListItemMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
ResolveEnumListItemMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
ResolveEnumListItemMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
ResolveEnumListItemMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
ResolveEnumListItemMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
ResolveEnumListItemMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
ResolveEnumListItemMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
ResolveEnumListItemMethod "ref" o = GObject.Object.ObjectRefMethodInfo
ResolveEnumListItemMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
ResolveEnumListItemMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
ResolveEnumListItemMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
ResolveEnumListItemMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
ResolveEnumListItemMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
ResolveEnumListItemMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
ResolveEnumListItemMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
ResolveEnumListItemMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
ResolveEnumListItemMethod "getName" o = EnumListItemGetNameMethodInfo
ResolveEnumListItemMethod "getNick" o = EnumListItemGetNickMethodInfo
ResolveEnumListItemMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
ResolveEnumListItemMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
ResolveEnumListItemMethod "getValue" o = EnumListItemGetValueMethodInfo
ResolveEnumListItemMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
ResolveEnumListItemMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
ResolveEnumListItemMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
ResolveEnumListItemMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveEnumListItemMethod t EnumListItem, O.OverloadedMethod info EnumListItem p) => OL.IsLabel t (EnumListItem -> 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 ~ ResolveEnumListItemMethod t EnumListItem, O.OverloadedMethod info EnumListItem p, R.HasField t EnumListItem p) => R.HasField t EnumListItem p where
getField = O.overloadedMethod @info
#endif
instance (info ~ ResolveEnumListItemMethod t EnumListItem, O.OverloadedMethodInfo info EnumListItem) => OL.IsLabel t (O.MethodProxy info EnumListItem) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.MethodProxy
#else
fromLabel _ = O.MethodProxy
#endif
#endif
getEnumListItemName :: (MonadIO m, IsEnumListItem o) => o -> m T.Text
getEnumListItemName :: forall (m :: * -> *) o.
(MonadIO m, IsEnumListItem o) =>
o -> m Text
getEnumListItemName o
obj = IO Text -> m Text
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ Text -> IO (Maybe Text) -> IO Text
forall a. HasCallStack => Text -> IO (Maybe a) -> IO a
checkUnexpectedNothing Text
"getEnumListItemName" (IO (Maybe Text) -> IO Text) -> IO (Maybe Text) -> IO Text
forall a b. (a -> b) -> a -> b
$ o -> String -> IO (Maybe Text)
forall a. GObject a => a -> String -> IO (Maybe Text)
B.Properties.getObjectPropertyString o
obj String
"name"
#if defined(ENABLE_OVERLOADING)
data EnumListItemNamePropertyInfo
instance AttrInfo EnumListItemNamePropertyInfo where
type AttrAllowedOps EnumListItemNamePropertyInfo = '[ 'AttrGet, 'AttrClear]
type AttrBaseTypeConstraint EnumListItemNamePropertyInfo = IsEnumListItem
type AttrSetTypeConstraint EnumListItemNamePropertyInfo = (~) ()
type AttrTransferTypeConstraint EnumListItemNamePropertyInfo = (~) ()
type AttrTransferType EnumListItemNamePropertyInfo = ()
type AttrGetType EnumListItemNamePropertyInfo = T.Text
type AttrLabel EnumListItemNamePropertyInfo = "name"
type AttrOrigin EnumListItemNamePropertyInfo = EnumListItem
attrGet = getEnumListItemName
attrSet = undefined
attrTransfer _ = undefined
attrConstruct = undefined
attrClear = undefined
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Adw.Objects.EnumListItem.name"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.5/docs/GI-Adw-Objects-EnumListItem.html#g:attr:name"
})
#endif
getEnumListItemNick :: (MonadIO m, IsEnumListItem o) => o -> m T.Text
getEnumListItemNick :: forall (m :: * -> *) o.
(MonadIO m, IsEnumListItem o) =>
o -> m Text
getEnumListItemNick o
obj = IO Text -> m Text
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ Text -> IO (Maybe Text) -> IO Text
forall a. HasCallStack => Text -> IO (Maybe a) -> IO a
checkUnexpectedNothing Text
"getEnumListItemNick" (IO (Maybe Text) -> IO Text) -> IO (Maybe Text) -> IO Text
forall a b. (a -> b) -> a -> b
$ o -> String -> IO (Maybe Text)
forall a. GObject a => a -> String -> IO (Maybe Text)
B.Properties.getObjectPropertyString o
obj String
"nick"
#if defined(ENABLE_OVERLOADING)
data EnumListItemNickPropertyInfo
instance AttrInfo EnumListItemNickPropertyInfo where
type AttrAllowedOps EnumListItemNickPropertyInfo = '[ 'AttrGet, 'AttrClear]
type AttrBaseTypeConstraint EnumListItemNickPropertyInfo = IsEnumListItem
type AttrSetTypeConstraint EnumListItemNickPropertyInfo = (~) ()
type AttrTransferTypeConstraint EnumListItemNickPropertyInfo = (~) ()
type AttrTransferType EnumListItemNickPropertyInfo = ()
type AttrGetType EnumListItemNickPropertyInfo = T.Text
type AttrLabel EnumListItemNickPropertyInfo = "nick"
type AttrOrigin EnumListItemNickPropertyInfo = EnumListItem
attrGet = getEnumListItemNick
attrSet = undefined
attrTransfer _ = undefined
attrConstruct = undefined
attrClear = undefined
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Adw.Objects.EnumListItem.nick"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.5/docs/GI-Adw-Objects-EnumListItem.html#g:attr:nick"
})
#endif
getEnumListItemValue :: (MonadIO m, IsEnumListItem o) => o -> m Int32
getEnumListItemValue :: forall (m :: * -> *) o.
(MonadIO m, IsEnumListItem o) =>
o -> m Int32
getEnumListItemValue o
obj = IO Int32 -> m Int32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Int32
forall a. GObject a => a -> String -> IO Int32
B.Properties.getObjectPropertyInt32 o
obj String
"value"
#if defined(ENABLE_OVERLOADING)
data EnumListItemValuePropertyInfo
instance AttrInfo EnumListItemValuePropertyInfo where
type AttrAllowedOps EnumListItemValuePropertyInfo = '[ 'AttrGet]
type AttrBaseTypeConstraint EnumListItemValuePropertyInfo = IsEnumListItem
type AttrSetTypeConstraint EnumListItemValuePropertyInfo = (~) ()
type AttrTransferTypeConstraint EnumListItemValuePropertyInfo = (~) ()
type AttrTransferType EnumListItemValuePropertyInfo = ()
type AttrGetType EnumListItemValuePropertyInfo = Int32
type AttrLabel EnumListItemValuePropertyInfo = "value"
type AttrOrigin EnumListItemValuePropertyInfo = EnumListItem
attrGet = getEnumListItemValue
attrSet = undefined
attrTransfer _ = undefined
attrConstruct = undefined
attrClear = undefined
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Adw.Objects.EnumListItem.value"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.5/docs/GI-Adw-Objects-EnumListItem.html#g:attr:value"
})
#endif
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList EnumListItem
type instance O.AttributeList EnumListItem = EnumListItemAttributeList
type EnumListItemAttributeList = ('[ '("name", EnumListItemNamePropertyInfo), '("nick", EnumListItemNickPropertyInfo), '("value", EnumListItemValuePropertyInfo)] :: [(Symbol, DK.Type)])
#endif
#if defined(ENABLE_OVERLOADING)
enumListItemName :: AttrLabelProxy "name"
enumListItemName = AttrLabelProxy
enumListItemNick :: AttrLabelProxy "nick"
enumListItemNick = AttrLabelProxy
enumListItemValue :: AttrLabelProxy "value"
enumListItemValue = AttrLabelProxy
#endif
#if defined(ENABLE_OVERLOADING)
type instance O.SignalList EnumListItem = EnumListItemSignalList
type EnumListItemSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, DK.Type)])
#endif
foreign import ccall "adw_enum_list_item_get_name" adw_enum_list_item_get_name ::
Ptr EnumListItem ->
IO CString
enumListItemGetName ::
(B.CallStack.HasCallStack, MonadIO m, IsEnumListItem a) =>
a
-> m T.Text
enumListItemGetName :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsEnumListItem a) =>
a -> m Text
enumListItemGetName a
self = IO Text -> m Text
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ do
Ptr EnumListItem
self' <- a -> IO (Ptr EnumListItem)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
CString
result <- Ptr EnumListItem -> IO CString
adw_enum_list_item_get_name Ptr EnumListItem
self'
Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"enumListItemGetName" CString
result
Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
Text -> IO Text
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'
#if defined(ENABLE_OVERLOADING)
data EnumListItemGetNameMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsEnumListItem a) => O.OverloadedMethod EnumListItemGetNameMethodInfo a signature where
overloadedMethod = enumListItemGetName
instance O.OverloadedMethodInfo EnumListItemGetNameMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Adw.Objects.EnumListItem.enumListItemGetName",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.5/docs/GI-Adw-Objects-EnumListItem.html#v:enumListItemGetName"
})
#endif
foreign import ccall "adw_enum_list_item_get_nick" adw_enum_list_item_get_nick ::
Ptr EnumListItem ->
IO CString
enumListItemGetNick ::
(B.CallStack.HasCallStack, MonadIO m, IsEnumListItem a) =>
a
-> m T.Text
enumListItemGetNick :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsEnumListItem a) =>
a -> m Text
enumListItemGetNick a
self = IO Text -> m Text
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ do
Ptr EnumListItem
self' <- a -> IO (Ptr EnumListItem)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
CString
result <- Ptr EnumListItem -> IO CString
adw_enum_list_item_get_nick Ptr EnumListItem
self'
Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"enumListItemGetNick" CString
result
Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
Text -> IO Text
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'
#if defined(ENABLE_OVERLOADING)
data EnumListItemGetNickMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsEnumListItem a) => O.OverloadedMethod EnumListItemGetNickMethodInfo a signature where
overloadedMethod = enumListItemGetNick
instance O.OverloadedMethodInfo EnumListItemGetNickMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Adw.Objects.EnumListItem.enumListItemGetNick",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.5/docs/GI-Adw-Objects-EnumListItem.html#v:enumListItemGetNick"
})
#endif
foreign import ccall "adw_enum_list_item_get_value" adw_enum_list_item_get_value ::
Ptr EnumListItem ->
IO Int32
enumListItemGetValue ::
(B.CallStack.HasCallStack, MonadIO m, IsEnumListItem a) =>
a
-> m Int32
enumListItemGetValue :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsEnumListItem a) =>
a -> m Int32
enumListItemGetValue a
self = IO Int32 -> m Int32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ do
Ptr EnumListItem
self' <- a -> IO (Ptr EnumListItem)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
Int32
result <- Ptr EnumListItem -> IO Int32
adw_enum_list_item_get_value Ptr EnumListItem
self'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
Int32 -> IO Int32
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result
#if defined(ENABLE_OVERLOADING)
data EnumListItemGetValueMethodInfo
instance (signature ~ (m Int32), MonadIO m, IsEnumListItem a) => O.OverloadedMethod EnumListItemGetValueMethodInfo a signature where
overloadedMethod = enumListItemGetValue
instance O.OverloadedMethodInfo EnumListItemGetValueMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Adw.Objects.EnumListItem.enumListItemGetValue",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.5/docs/GI-Adw-Objects-EnumListItem.html#v:enumListItemGetValue"
})
#endif