{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- A t'GI.Gio.Interfaces.ListModel.ListModel' representing values of a given enum.
-- 
-- @AdwEnumListModel@ contains objects of type [class/@adwEnumListItem@/].
-- 
-- /Since: 1.0/

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

module GI.Adw.Objects.EnumListModel
    ( 

-- * Exported types
    EnumListModel(..)                       ,
    IsEnumListModel                         ,
    toEnumListModel                         ,


 -- * 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"), [findPosition]("GI.Adw.Objects.EnumListModel#g:method:findPosition"), [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"), [itemsChanged]("GI.Gio.Interfaces.ListModel#g:method:itemsChanged"), [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"), [getEnumType]("GI.Adw.Objects.EnumListModel#g:method:getEnumType"), [getItem]("GI.Gio.Interfaces.ListModel#g:method:getItem"), [getItemType]("GI.Gio.Interfaces.ListModel#g:method:getItemType"), [getNItems]("GI.Gio.Interfaces.ListModel#g:method:getNItems"), [getProperty]("GI.GObject.Objects.Object#g:method:getProperty"), [getQdata]("GI.GObject.Objects.Object#g:method:getQdata").
-- 
-- ==== 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)
    ResolveEnumListModelMethod              ,
#endif

-- ** findPosition #method:findPosition#

#if defined(ENABLE_OVERLOADING)
    EnumListModelFindPositionMethodInfo     ,
#endif
    enumListModelFindPosition               ,


-- ** getEnumType #method:getEnumType#

#if defined(ENABLE_OVERLOADING)
    EnumListModelGetEnumTypeMethodInfo      ,
#endif
    enumListModelGetEnumType                ,


-- ** new #method:new#

    enumListModelNew                        ,




 -- * Properties


-- ** enumType #attr:enumType#
-- | The type of the enum represented by the model.
-- 
-- /Since: 1.0/

#if defined(ENABLE_OVERLOADING)
    EnumListModelEnumTypePropertyInfo       ,
#endif
    constructEnumListModelEnumType          ,
#if defined(ENABLE_OVERLOADING)
    enumListModelEnumType                   ,
#endif
    getEnumListModelEnumType                ,




    ) 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 qualified GI.GObject.Objects.Object as GObject.Object
import qualified GI.Gio.Interfaces.ListModel as Gio.ListModel

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

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

foreign import ccall "adw_enum_list_model_get_type"
    c_adw_enum_list_model_get_type :: IO B.Types.GType

instance B.Types.TypedObject EnumListModel where
    glibType :: IO GType
glibType = IO GType
c_adw_enum_list_model_get_type

instance B.Types.GObject EnumListModel

-- | Type class for types which can be safely cast to `EnumListModel`, for instance with `toEnumListModel`.
class (SP.GObject o, O.IsDescendantOf EnumListModel o) => IsEnumListModel o
instance (SP.GObject o, O.IsDescendantOf EnumListModel o) => IsEnumListModel o

instance O.HasParentTypes EnumListModel
type instance O.ParentTypes EnumListModel = '[GObject.Object.Object, Gio.ListModel.ListModel]

-- | Cast to `EnumListModel`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`.
toEnumListModel :: (MIO.MonadIO m, IsEnumListModel o) => o -> m EnumListModel
toEnumListModel :: forall (m :: * -> *) o.
(MonadIO m, IsEnumListModel o) =>
o -> m EnumListModel
toEnumListModel = IO EnumListModel -> m EnumListModel
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO EnumListModel -> m EnumListModel)
-> (o -> IO EnumListModel) -> o -> m EnumListModel
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ManagedPtr EnumListModel -> EnumListModel)
-> o -> IO EnumListModel
forall o o'.
(HasCallStack, ManagedPtrNewtype o, TypedObject o,
 ManagedPtrNewtype o', TypedObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
B.ManagedPtr.unsafeCastTo ManagedPtr EnumListModel -> EnumListModel
EnumListModel

-- | Convert 'EnumListModel' to and from 'Data.GI.Base.GValue.GValue'. See 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'.
instance B.GValue.IsGValue (Maybe EnumListModel) where
    gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_adw_enum_list_model_get_type
    gvalueSet_ :: Ptr GValue -> Maybe EnumListModel -> IO ()
gvalueSet_ Ptr GValue
gv Maybe EnumListModel
P.Nothing = Ptr GValue -> Ptr EnumListModel -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv (Ptr EnumListModel
forall a. Ptr a
FP.nullPtr :: FP.Ptr EnumListModel)
    gvalueSet_ Ptr GValue
gv (P.Just EnumListModel
obj) = EnumListModel -> (Ptr EnumListModel -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr EnumListModel
obj (Ptr GValue -> Ptr EnumListModel -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv)
    gvalueGet_ :: Ptr GValue -> IO (Maybe EnumListModel)
gvalueGet_ Ptr GValue
gv = do
        Ptr EnumListModel
ptr <- Ptr GValue -> IO (Ptr EnumListModel)
forall a. GObject a => Ptr GValue -> IO (Ptr a)
B.GValue.get_object Ptr GValue
gv :: IO (FP.Ptr EnumListModel)
        if Ptr EnumListModel
ptr Ptr EnumListModel -> Ptr EnumListModel -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr EnumListModel
forall a. Ptr a
FP.nullPtr
        then EnumListModel -> Maybe EnumListModel
forall a. a -> Maybe a
P.Just (EnumListModel -> Maybe EnumListModel)
-> IO EnumListModel -> IO (Maybe EnumListModel)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ManagedPtr EnumListModel -> EnumListModel)
-> Ptr EnumListModel -> IO EnumListModel
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr EnumListModel -> EnumListModel
EnumListModel Ptr EnumListModel
ptr
        else Maybe EnumListModel -> IO (Maybe EnumListModel)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe EnumListModel
forall a. Maybe a
P.Nothing
        
    

#if defined(ENABLE_OVERLOADING)
type family ResolveEnumListModelMethod (t :: Symbol) (o :: *) :: * where
    ResolveEnumListModelMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveEnumListModelMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveEnumListModelMethod "findPosition" o = EnumListModelFindPositionMethodInfo
    ResolveEnumListModelMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveEnumListModelMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveEnumListModelMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
    ResolveEnumListModelMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveEnumListModelMethod "itemsChanged" o = Gio.ListModel.ListModelItemsChangedMethodInfo
    ResolveEnumListModelMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveEnumListModelMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveEnumListModelMethod "ref" o = GObject.Object.ObjectRefMethodInfo
    ResolveEnumListModelMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveEnumListModelMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveEnumListModelMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveEnumListModelMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveEnumListModelMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveEnumListModelMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
    ResolveEnumListModelMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveEnumListModelMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveEnumListModelMethod "getEnumType" o = EnumListModelGetEnumTypeMethodInfo
    ResolveEnumListModelMethod "getItem" o = Gio.ListModel.ListModelGetItemMethodInfo
    ResolveEnumListModelMethod "getItemType" o = Gio.ListModel.ListModelGetItemTypeMethodInfo
    ResolveEnumListModelMethod "getNItems" o = Gio.ListModel.ListModelGetNItemsMethodInfo
    ResolveEnumListModelMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveEnumListModelMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveEnumListModelMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveEnumListModelMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
    ResolveEnumListModelMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveEnumListModelMethod l o = O.MethodResolutionFailed l o

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

#endif

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

#endif

-- VVV Prop "enum-type"
   -- Type: TBasicType TGType
   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]
   -- Nullable: (Just False,Nothing)

-- | Get the value of the “@enum-type@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' enumListModel #enumType
-- @
getEnumListModelEnumType :: (MonadIO m, IsEnumListModel o) => o -> m GType
getEnumListModelEnumType :: forall (m :: * -> *) o.
(MonadIO m, IsEnumListModel o) =>
o -> m GType
getEnumListModelEnumType o
obj = IO GType -> m GType
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO GType -> m GType) -> IO GType -> m GType
forall a b. (a -> b) -> a -> b
$ o -> String -> IO GType
forall a. GObject a => a -> String -> IO GType
B.Properties.getObjectPropertyGType o
obj String
"enum-type"

-- | Construct a `GValueConstruct` with valid value for the “@enum-type@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructEnumListModelEnumType :: (IsEnumListModel o, MIO.MonadIO m) => GType -> m (GValueConstruct o)
constructEnumListModelEnumType :: forall o (m :: * -> *).
(IsEnumListModel o, MonadIO m) =>
GType -> m (GValueConstruct o)
constructEnumListModelEnumType GType
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> GType -> IO (GValueConstruct o)
forall o. String -> GType -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyGType String
"enum-type" GType
val

#if defined(ENABLE_OVERLOADING)
data EnumListModelEnumTypePropertyInfo
instance AttrInfo EnumListModelEnumTypePropertyInfo where
    type AttrAllowedOps EnumListModelEnumTypePropertyInfo = '[ 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint EnumListModelEnumTypePropertyInfo = IsEnumListModel
    type AttrSetTypeConstraint EnumListModelEnumTypePropertyInfo = (~) GType
    type AttrTransferTypeConstraint EnumListModelEnumTypePropertyInfo = (~) GType
    type AttrTransferType EnumListModelEnumTypePropertyInfo = GType
    type AttrGetType EnumListModelEnumTypePropertyInfo = GType
    type AttrLabel EnumListModelEnumTypePropertyInfo = "enum-type"
    type AttrOrigin EnumListModelEnumTypePropertyInfo = EnumListModel
    attrGet = getEnumListModelEnumType
    attrSet = undefined
    attrTransfer _ v = do
        return v
    attrConstruct = constructEnumListModelEnumType
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.EnumListModel.enumType"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.1/docs/GI-Adw-Objects-EnumListModel.html#g:attr:enumType"
        })
#endif

#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList EnumListModel
type instance O.AttributeList EnumListModel = EnumListModelAttributeList
type EnumListModelAttributeList = ('[ '("enumType", EnumListModelEnumTypePropertyInfo)] :: [(Symbol, *)])
#endif

#if defined(ENABLE_OVERLOADING)
enumListModelEnumType :: AttrLabelProxy "enumType"
enumListModelEnumType = AttrLabelProxy

#endif

#if defined(ENABLE_OVERLOADING)
type instance O.SignalList EnumListModel = EnumListModelSignalList
type EnumListModelSignalList = ('[ '("itemsChanged", Gio.ListModel.ListModelItemsChangedSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)])

#endif

-- method EnumListModel::new
-- method type : Constructor
-- Args: [ Arg
--           { argCName = "enum_type"
--           , argType = TBasicType TGType
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "the type of the enum to construct the model from"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface Name { namespace = "Adw" , name = "EnumListModel" })
-- throws : False
-- Skip return : False

foreign import ccall "adw_enum_list_model_new" adw_enum_list_model_new :: 
    CGType ->                               -- enum_type : TBasicType TGType
    IO (Ptr EnumListModel)

-- | Creates a new @AdwEnumListModel@ for /@enumType@/.
-- 
-- /Since: 1.0/
enumListModelNew ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    GType
    -- ^ /@enumType@/: the type of the enum to construct the model from
    -> m EnumListModel
    -- ^ __Returns:__ the newly created @AdwEnumListModel@
enumListModelNew :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
GType -> m EnumListModel
enumListModelNew GType
enumType = IO EnumListModel -> m EnumListModel
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO EnumListModel -> m EnumListModel)
-> IO EnumListModel -> m EnumListModel
forall a b. (a -> b) -> a -> b
$ do
    let enumType' :: CGType
enumType' = GType -> CGType
gtypeToCGType GType
enumType
    Ptr EnumListModel
result <- CGType -> IO (Ptr EnumListModel)
adw_enum_list_model_new CGType
enumType'
    Text -> Ptr EnumListModel -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"enumListModelNew" Ptr EnumListModel
result
    EnumListModel
result' <- ((ManagedPtr EnumListModel -> EnumListModel)
-> Ptr EnumListModel -> IO EnumListModel
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr EnumListModel -> EnumListModel
EnumListModel) Ptr EnumListModel
result
    EnumListModel -> IO EnumListModel
forall (m :: * -> *) a. Monad m => a -> m a
return EnumListModel
result'

#if defined(ENABLE_OVERLOADING)
#endif

-- method EnumListModel::find_position
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "EnumListModel" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "value"
--           , argType = TBasicType TInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "an enum value" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TUInt)
-- throws : False
-- Skip return : False

foreign import ccall "adw_enum_list_model_find_position" adw_enum_list_model_find_position :: 
    Ptr EnumListModel ->                    -- self : TInterface (Name {namespace = "Adw", name = "EnumListModel"})
    Int32 ->                                -- value : TBasicType TInt
    IO Word32

-- | Finds the position of a given enum value in /@self@/.
-- 
-- /Since: 1.0/
enumListModelFindPosition ::
    (B.CallStack.HasCallStack, MonadIO m, IsEnumListModel a) =>
    a
    -> Int32
    -- ^ /@value@/: an enum value
    -> m Word32
enumListModelFindPosition :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsEnumListModel a) =>
a -> Int32 -> m Word32
enumListModelFindPosition a
self Int32
value = 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
$ do
    Ptr EnumListModel
self' <- a -> IO (Ptr EnumListModel)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Word32
result <- Ptr EnumListModel -> Int32 -> IO Word32
adw_enum_list_model_find_position Ptr EnumListModel
self' Int32
value
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Word32 -> IO Word32
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
result

#if defined(ENABLE_OVERLOADING)
data EnumListModelFindPositionMethodInfo
instance (signature ~ (Int32 -> m Word32), MonadIO m, IsEnumListModel a) => O.OverloadedMethod EnumListModelFindPositionMethodInfo a signature where
    overloadedMethod = enumListModelFindPosition

instance O.OverloadedMethodInfo EnumListModelFindPositionMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.EnumListModel.enumListModelFindPosition",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.1/docs/GI-Adw-Objects-EnumListModel.html#v:enumListModelFindPosition"
        })


#endif

-- method EnumListModel::get_enum_type
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "EnumListModel" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TGType)
-- throws : False
-- Skip return : False

foreign import ccall "adw_enum_list_model_get_enum_type" adw_enum_list_model_get_enum_type :: 
    Ptr EnumListModel ->                    -- self : TInterface (Name {namespace = "Adw", name = "EnumListModel"})
    IO CGType

-- | Gets the type of the enum represented by /@self@/.
-- 
-- /Since: 1.0/
enumListModelGetEnumType ::
    (B.CallStack.HasCallStack, MonadIO m, IsEnumListModel a) =>
    a
    -> m GType
    -- ^ __Returns:__ the enum type
enumListModelGetEnumType :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsEnumListModel a) =>
a -> m GType
enumListModelGetEnumType a
self = IO GType -> m GType
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO GType -> m GType) -> IO GType -> m GType
forall a b. (a -> b) -> a -> b
$ do
    Ptr EnumListModel
self' <- a -> IO (Ptr EnumListModel)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CGType
result <- Ptr EnumListModel -> IO CGType
adw_enum_list_model_get_enum_type Ptr EnumListModel
self'
    let result' :: GType
result' = CGType -> GType
GType CGType
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    GType -> IO GType
forall (m :: * -> *) a. Monad m => a -> m a
return GType
result'

#if defined(ENABLE_OVERLOADING)
data EnumListModelGetEnumTypeMethodInfo
instance (signature ~ (m GType), MonadIO m, IsEnumListModel a) => O.OverloadedMethod EnumListModelGetEnumTypeMethodInfo a signature where
    overloadedMethod = enumListModelGetEnumType

instance O.OverloadedMethodInfo EnumListModelGetEnumTypeMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.EnumListModel.enumListModelGetEnumType",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.1/docs/GI-Adw-Objects-EnumListModel.html#v:enumListModelGetEnumType"
        })


#endif