{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Adw.Objects.EnumListModel
(
EnumListModel(..) ,
IsEnumListModel ,
toEnumListModel ,
#if defined(ENABLE_OVERLOADING)
ResolveEnumListModelMethod ,
#endif
#if defined(ENABLE_OVERLOADING)
EnumListModelFindPositionMethodInfo ,
#endif
enumListModelFindPosition ,
#if defined(ENABLE_OVERLOADING)
EnumListModelGetEnumTypeMethodInfo ,
#endif
enumListModelGetEnumType ,
enumListModelNew ,
#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
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
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]
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
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
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"
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
foreign import ccall "adw_enum_list_model_new" adw_enum_list_model_new ::
CGType ->
IO (Ptr EnumListModel)
enumListModelNew ::
(B.CallStack.HasCallStack, MonadIO m) =>
GType
-> m EnumListModel
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
foreign import ccall "adw_enum_list_model_find_position" adw_enum_list_model_find_position ::
Ptr EnumListModel ->
Int32 ->
IO Word32
enumListModelFindPosition ::
(B.CallStack.HasCallStack, MonadIO m, IsEnumListModel a) =>
a
-> Int32
-> 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
foreign import ccall "adw_enum_list_model_get_enum_type" adw_enum_list_model_get_enum_type ::
Ptr EnumListModel ->
IO CGType
enumListModelGetEnumType ::
(B.CallStack.HasCallStack, MonadIO m, IsEnumListModel a) =>
a
-> m GType
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