{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- @GtkEnumListItem@ is the type of items in a t'GI.Gtk.Objects.EnumList.EnumList'.
-- 
-- /Since: 4.24/

#if !defined(__HADDOCK_VERSION__)
#define ENABLE_OVERLOADING
#endif

module GI.Gtk.Objects.EnumListItem
    ( 

-- * Exported types
    EnumListItem(..)                        ,
    IsEnumListItem                          ,
    toEnumListItem                          ,


 -- * Methods
-- | 
-- 
--  === __Click to display all available methods, including inherited ones__
-- ==== Methods
-- [bindProperty]("GI.GObject.Objects.Object#g:method:bindProperty"), [bindPropertyFull]("GI.GObject.Objects.Object#g:method:bindPropertyFull"), [forceFloating]("GI.GObject.Objects.Object#g:method:forceFloating"), [freezeNotify]("GI.GObject.Objects.Object#g:method:freezeNotify"), [getv]("GI.GObject.Objects.Object#g:method:getv"), [isFloating]("GI.GObject.Objects.Object#g:method:isFloating"), [notify]("GI.GObject.Objects.Object#g:method:notify"), [notifyByPspec]("GI.GObject.Objects.Object#g:method:notifyByPspec"), [ref]("GI.GObject.Objects.Object#g:method:ref"), [refSink]("GI.GObject.Objects.Object#g:method:refSink"), [runDispose]("GI.GObject.Objects.Object#g:method:runDispose"), [stealData]("GI.GObject.Objects.Object#g:method:stealData"), [stealQdata]("GI.GObject.Objects.Object#g:method:stealQdata"), [thawNotify]("GI.GObject.Objects.Object#g:method:thawNotify"), [unref]("GI.GObject.Objects.Object#g:method:unref"), [watchClosure]("GI.GObject.Objects.Object#g:method:watchClosure").
-- 
-- ==== Getters
-- [getData]("GI.GObject.Objects.Object#g:method:getData"), [getName]("GI.Gtk.Objects.EnumListItem#g:method:getName"), [getNick]("GI.Gtk.Objects.EnumListItem#g:method:getNick"), [getProperty]("GI.GObject.Objects.Object#g:method:getProperty"), [getQdata]("GI.GObject.Objects.Object#g:method:getQdata"), [getValue]("GI.Gtk.Objects.EnumListItem#g:method:getValue").
-- 
-- ==== Setters
-- [setData]("GI.GObject.Objects.Object#g:method:setData"), [setDataFull]("GI.GObject.Objects.Object#g:method:setDataFull"), [setProperty]("GI.GObject.Objects.Object#g:method:setProperty").

#if defined(ENABLE_OVERLOADING)
    ResolveEnumListItemMethod               ,
#endif

-- ** getName #method:getName#

#if defined(ENABLE_OVERLOADING)
    EnumListItemGetNameMethodInfo           ,
#endif
    enumListItemGetName                     ,


-- ** getNick #method:getNick#

#if defined(ENABLE_OVERLOADING)
    EnumListItemGetNickMethodInfo           ,
#endif
    enumListItemGetNick                     ,


-- ** getValue #method:getValue#

#if defined(ENABLE_OVERLOADING)
    EnumListItemGetValueMethodInfo          ,
#endif
    enumListItemGetValue                    ,




 -- * Properties


-- ** name #attr:name#
-- | The enum value name.
-- 
-- /Since: 4.24/

#if defined(ENABLE_OVERLOADING)
    EnumListItemNamePropertyInfo            ,
#endif
#if defined(ENABLE_OVERLOADING)
    enumListItemName                        ,
#endif
    getEnumListItemName                     ,


-- ** nick #attr:nick#
-- | The enum value nick.
-- 
-- /Since: 4.24/

#if defined(ENABLE_OVERLOADING)
    EnumListItemNickPropertyInfo            ,
#endif
#if defined(ENABLE_OVERLOADING)
    enumListItemNick                        ,
#endif
    getEnumListItemNick                     ,


-- ** value #attr:value#
-- | The enum value.
-- 
-- /Since: 4.24/

#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 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.GObject.Objects.Object as GObject.Object

#else
import qualified GI.GObject.Objects.Object as GObject.Object

#endif

-- | Memory-managed wrapper type.
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 "gtk_enum_list_item_get_type"
    c_gtk_enum_list_item_get_type :: IO B.Types.GType

instance B.Types.TypedObject EnumListItem where
    glibType :: IO GType
glibType = IO GType
c_gtk_enum_list_item_get_type

instance B.Types.GObject EnumListItem

-- | Type class for types which can be safely cast to t'EnumListItem', for instance with `toEnumListItem`.
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]

-- | Cast to t'EnumListItem', for types for which this is known to be safe. For general casts, use 'Data.GI.Base.ManagedPtr.castTo'.
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

-- | Convert t'EnumListItem' to and from t'Data.GI.Base.GValue.GValue'. See 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'.
instance B.GValue.IsGValue (Maybe EnumListItem) where
    gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_gtk_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 <- 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 /= FP.nullPtr
        then P.Just <$> B.ManagedPtr.newObject EnumListItem ptr
        else return 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

-- VVV Prop "name"
   -- Type: TBasicType TUTF8
   -- Flags: [PropertyReadable]
   -- Nullable: (Just False,Nothing)

-- | Get the value of the “@name@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' enumListItem #name
-- @
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
    attrPut = undefined
    attrTransfer _ = undefined
    attrConstruct = undefined
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.EnumListItem.name"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-EnumListItem.html#g:attr:name"
        })
#endif

-- VVV Prop "nick"
   -- Type: TBasicType TUTF8
   -- Flags: [PropertyReadable]
   -- Nullable: (Just False,Nothing)

-- | Get the value of the “@nick@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' enumListItem #nick
-- @
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
    attrPut = undefined
    attrTransfer _ = undefined
    attrConstruct = undefined
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.EnumListItem.nick"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-EnumListItem.html#g:attr:nick"
        })
#endif

-- VVV Prop "value"
   -- Type: TBasicType TInt
   -- Flags: [PropertyReadable]
   -- Nullable: (Just False,Nothing)

-- | Get the value of the “@value@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' enumListItem #value
-- @
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
    attrPut = undefined
    attrTransfer _ = undefined
    attrConstruct = undefined
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.EnumListItem.value"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-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

-- method EnumListItem::get_name
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "EnumListItem" }
--           , argCType = Just "GtkEnumListItem*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TUTF8)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_enum_list_item_get_name" gtk_enum_list_item_get_name :: 
    Ptr EnumListItem ->                     -- self : TInterface (Name {namespace = "Gtk", name = "EnumListItem"})
    IO CString

-- | Gets the enum value name.
enumListItemGetName ::
    (B.CallStack.HasCallStack, MonadIO m, IsEnumListItem a) =>
    a
    -> m T.Text
    -- ^ __Returns:__ the enum value name
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
    self' <- a -> IO (Ptr EnumListItem)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    result <- gtk_enum_list_item_get_name self'
    checkUnexpectedReturnNULL "enumListItemGetName" result
    result' <- cstringToText result
    touchManagedPtr self
    return 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.Gtk.Objects.EnumListItem.enumListItemGetName",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-EnumListItem.html#v:enumListItemGetName"
        })


#endif

-- method EnumListItem::get_nick
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "EnumListItem" }
--           , argCType = Just "GtkEnumListItem*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TUTF8)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_enum_list_item_get_nick" gtk_enum_list_item_get_nick :: 
    Ptr EnumListItem ->                     -- self : TInterface (Name {namespace = "Gtk", name = "EnumListItem"})
    IO CString

-- | Gets the enum value nick.
enumListItemGetNick ::
    (B.CallStack.HasCallStack, MonadIO m, IsEnumListItem a) =>
    a
    -> m T.Text
    -- ^ __Returns:__ the enum value nick
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
    self' <- a -> IO (Ptr EnumListItem)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    result <- gtk_enum_list_item_get_nick self'
    checkUnexpectedReturnNULL "enumListItemGetNick" result
    result' <- cstringToText result
    touchManagedPtr self
    return 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.Gtk.Objects.EnumListItem.enumListItemGetNick",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-EnumListItem.html#v:enumListItemGetNick"
        })


#endif

-- method EnumListItem::get_value
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "EnumListItem" }
--           , argCType = Just "GtkEnumListItem*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TInt)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_enum_list_item_get_value" gtk_enum_list_item_get_value :: 
    Ptr EnumListItem ->                     -- self : TInterface (Name {namespace = "Gtk", name = "EnumListItem"})
    IO Int32

-- | Gets the enum value.
enumListItemGetValue ::
    (B.CallStack.HasCallStack, MonadIO m, IsEnumListItem a) =>
    a
    -> m Int32
    -- ^ __Returns:__ the enum value
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
    self' <- a -> IO (Ptr EnumListItem)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    result <- gtk_enum_list_item_get_value self'
    touchManagedPtr self
    return 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.Gtk.Objects.EnumListItem.enumListItemGetValue",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-EnumListItem.html#v:enumListItemGetValue"
        })


#endif