{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Gtk.Objects.SortListModel
(
SortListModel(..) ,
IsSortListModel ,
toSortListModel ,
noSortListModel ,
#if defined(ENABLE_OVERLOADING)
ResolveSortListModelMethod ,
#endif
#if defined(ENABLE_OVERLOADING)
SortListModelGetModelMethodInfo ,
#endif
sortListModelGetModel ,
#if defined(ENABLE_OVERLOADING)
SortListModelHasSortMethodInfo ,
#endif
sortListModelHasSort ,
sortListModelNew ,
sortListModelNewForType ,
#if defined(ENABLE_OVERLOADING)
SortListModelResortMethodInfo ,
#endif
sortListModelResort ,
#if defined(ENABLE_OVERLOADING)
SortListModelSetModelMethodInfo ,
#endif
sortListModelSetModel ,
#if defined(ENABLE_OVERLOADING)
SortListModelSetSortFuncMethodInfo ,
#endif
sortListModelSetSortFunc ,
#if defined(ENABLE_OVERLOADING)
SortListModelHasSortPropertyInfo ,
#endif
getSortListModelHasSort ,
#if defined(ENABLE_OVERLOADING)
SortListModelItemTypePropertyInfo ,
#endif
constructSortListModelItemType ,
getSortListModelItemType ,
#if defined(ENABLE_OVERLOADING)
sortListModelItemType ,
#endif
#if defined(ENABLE_OVERLOADING)
SortListModelModelPropertyInfo ,
#endif
constructSortListModelModel ,
getSortListModelModel ,
#if defined(ENABLE_OVERLOADING)
sortListModelModel ,
#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.ManagedPtr as B.ManagedPtr
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 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 GI.GLib.Callbacks as GLib.Callbacks
import qualified GI.GObject.Objects.Object as GObject.Object
import qualified GI.Gio.Interfaces.ListModel as Gio.ListModel
newtype SortListModel = SortListModel (ManagedPtr SortListModel)
deriving (SortListModel -> SortListModel -> Bool
(SortListModel -> SortListModel -> Bool)
-> (SortListModel -> SortListModel -> Bool) -> Eq SortListModel
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SortListModel -> SortListModel -> Bool
$c/= :: SortListModel -> SortListModel -> Bool
== :: SortListModel -> SortListModel -> Bool
$c== :: SortListModel -> SortListModel -> Bool
Eq)
foreign import ccall "gtk_sort_list_model_get_type"
c_gtk_sort_list_model_get_type :: IO GType
instance GObject SortListModel where
gobjectType :: IO GType
gobjectType = IO GType
c_gtk_sort_list_model_get_type
instance B.GValue.IsGValue SortListModel where
toGValue :: SortListModel -> IO GValue
toGValue o :: SortListModel
o = do
GType
gtype <- IO GType
c_gtk_sort_list_model_get_type
SortListModel -> (Ptr SortListModel -> IO GValue) -> IO GValue
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr SortListModel
o (GType
-> (GValue -> Ptr SortListModel -> IO ())
-> Ptr SortListModel
-> IO GValue
forall a. GType -> (GValue -> a -> IO ()) -> a -> IO GValue
B.GValue.buildGValue GType
gtype GValue -> Ptr SortListModel -> IO ()
forall a. GObject a => GValue -> Ptr a -> IO ()
B.GValue.set_object)
fromGValue :: GValue -> IO SortListModel
fromGValue gv :: GValue
gv = do
Ptr SortListModel
ptr <- GValue -> IO (Ptr SortListModel)
forall b. GObject b => GValue -> IO (Ptr b)
B.GValue.get_object GValue
gv :: IO (Ptr SortListModel)
(ManagedPtr SortListModel -> SortListModel)
-> Ptr SortListModel -> IO SortListModel
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr SortListModel -> SortListModel
SortListModel Ptr SortListModel
ptr
class (GObject o, O.IsDescendantOf SortListModel o) => IsSortListModel o
instance (GObject o, O.IsDescendantOf SortListModel o) => IsSortListModel o
instance O.HasParentTypes SortListModel
type instance O.ParentTypes SortListModel = '[GObject.Object.Object, Gio.ListModel.ListModel]
toSortListModel :: (MonadIO m, IsSortListModel o) => o -> m SortListModel
toSortListModel :: o -> m SortListModel
toSortListModel = IO SortListModel -> m SortListModel
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SortListModel -> m SortListModel)
-> (o -> IO SortListModel) -> o -> m SortListModel
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ManagedPtr SortListModel -> SortListModel)
-> o -> IO SortListModel
forall o o'.
(HasCallStack, GObject o, GObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
unsafeCastTo ManagedPtr SortListModel -> SortListModel
SortListModel
noSortListModel :: Maybe SortListModel
noSortListModel :: Maybe SortListModel
noSortListModel = Maybe SortListModel
forall a. Maybe a
Nothing
#if defined(ENABLE_OVERLOADING)
type family ResolveSortListModelMethod (t :: Symbol) (o :: *) :: * where
ResolveSortListModelMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
ResolveSortListModelMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
ResolveSortListModelMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
ResolveSortListModelMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
ResolveSortListModelMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
ResolveSortListModelMethod "hasSort" o = SortListModelHasSortMethodInfo
ResolveSortListModelMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
ResolveSortListModelMethod "itemsChanged" o = Gio.ListModel.ListModelItemsChangedMethodInfo
ResolveSortListModelMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
ResolveSortListModelMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
ResolveSortListModelMethod "ref" o = GObject.Object.ObjectRefMethodInfo
ResolveSortListModelMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
ResolveSortListModelMethod "resort" o = SortListModelResortMethodInfo
ResolveSortListModelMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
ResolveSortListModelMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
ResolveSortListModelMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
ResolveSortListModelMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
ResolveSortListModelMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
ResolveSortListModelMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
ResolveSortListModelMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
ResolveSortListModelMethod "getItem" o = Gio.ListModel.ListModelGetItemMethodInfo
ResolveSortListModelMethod "getItemType" o = Gio.ListModel.ListModelGetItemTypeMethodInfo
ResolveSortListModelMethod "getModel" o = SortListModelGetModelMethodInfo
ResolveSortListModelMethod "getNItems" o = Gio.ListModel.ListModelGetNItemsMethodInfo
ResolveSortListModelMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
ResolveSortListModelMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
ResolveSortListModelMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
ResolveSortListModelMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
ResolveSortListModelMethod "setModel" o = SortListModelSetModelMethodInfo
ResolveSortListModelMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
ResolveSortListModelMethod "setSortFunc" o = SortListModelSetSortFuncMethodInfo
ResolveSortListModelMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveSortListModelMethod t SortListModel, O.MethodInfo info SortListModel p) => OL.IsLabel t (SortListModel -> p) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.overloadedMethod @info
#else
fromLabel _ = O.overloadedMethod @info
#endif
#endif
getSortListModelHasSort :: (MonadIO m, IsSortListModel o) => o -> m Bool
getSortListModelHasSort :: o -> m Bool
getSortListModelHasSort obj :: o
obj = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Bool
forall a. GObject a => a -> String -> IO Bool
B.Properties.getObjectPropertyBool o
obj "has-sort"
#if defined(ENABLE_OVERLOADING)
data SortListModelHasSortPropertyInfo
instance AttrInfo SortListModelHasSortPropertyInfo where
type AttrAllowedOps SortListModelHasSortPropertyInfo = '[ 'AttrGet]
type AttrBaseTypeConstraint SortListModelHasSortPropertyInfo = IsSortListModel
type AttrSetTypeConstraint SortListModelHasSortPropertyInfo = (~) ()
type AttrTransferTypeConstraint SortListModelHasSortPropertyInfo = (~) ()
type AttrTransferType SortListModelHasSortPropertyInfo = ()
type AttrGetType SortListModelHasSortPropertyInfo = Bool
type AttrLabel SortListModelHasSortPropertyInfo = "has-sort"
type AttrOrigin SortListModelHasSortPropertyInfo = SortListModel
attrGet = getSortListModelHasSort
attrSet = undefined
attrTransfer _ = undefined
attrConstruct = undefined
attrClear = undefined
#endif
getSortListModelItemType :: (MonadIO m, IsSortListModel o) => o -> m GType
getSortListModelItemType :: o -> m GType
getSortListModelItemType obj :: o
obj = 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
$ o -> String -> IO GType
forall a. GObject a => a -> String -> IO GType
B.Properties.getObjectPropertyGType o
obj "item-type"
constructSortListModelItemType :: (IsSortListModel o) => GType -> IO (GValueConstruct o)
constructSortListModelItemType :: GType -> IO (GValueConstruct o)
constructSortListModelItemType val :: GType
val = String -> GType -> IO (GValueConstruct o)
forall o. String -> GType -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyGType "item-type" GType
val
#if defined(ENABLE_OVERLOADING)
data SortListModelItemTypePropertyInfo
instance AttrInfo SortListModelItemTypePropertyInfo where
type AttrAllowedOps SortListModelItemTypePropertyInfo = '[ 'AttrConstruct, 'AttrGet]
type AttrBaseTypeConstraint SortListModelItemTypePropertyInfo = IsSortListModel
type AttrSetTypeConstraint SortListModelItemTypePropertyInfo = (~) GType
type AttrTransferTypeConstraint SortListModelItemTypePropertyInfo = (~) GType
type AttrTransferType SortListModelItemTypePropertyInfo = GType
type AttrGetType SortListModelItemTypePropertyInfo = GType
type AttrLabel SortListModelItemTypePropertyInfo = "item-type"
type AttrOrigin SortListModelItemTypePropertyInfo = SortListModel
attrGet = getSortListModelItemType
attrSet = undefined
attrTransfer _ v = do
return v
attrConstruct = constructSortListModelItemType
attrClear = undefined
#endif
getSortListModelModel :: (MonadIO m, IsSortListModel o) => o -> m (Maybe Gio.ListModel.ListModel)
getSortListModelModel :: o -> m (Maybe ListModel)
getSortListModelModel obj :: o
obj = IO (Maybe ListModel) -> m (Maybe ListModel)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe ListModel) -> m (Maybe ListModel))
-> IO (Maybe ListModel) -> m (Maybe ListModel)
forall a b. (a -> b) -> a -> b
$ o
-> String
-> (ManagedPtr ListModel -> ListModel)
-> IO (Maybe ListModel)
forall a b.
(GObject a, GObject b) =>
a -> String -> (ManagedPtr b -> b) -> IO (Maybe b)
B.Properties.getObjectPropertyObject o
obj "model" ManagedPtr ListModel -> ListModel
Gio.ListModel.ListModel
constructSortListModelModel :: (IsSortListModel o, Gio.ListModel.IsListModel a) => a -> IO (GValueConstruct o)
constructSortListModelModel :: a -> IO (GValueConstruct o)
constructSortListModelModel val :: a
val = String -> Maybe a -> IO (GValueConstruct o)
forall a o.
GObject a =>
String -> Maybe a -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyObject "model" (a -> Maybe a
forall a. a -> Maybe a
Just a
val)
#if defined(ENABLE_OVERLOADING)
data SortListModelModelPropertyInfo
instance AttrInfo SortListModelModelPropertyInfo where
type AttrAllowedOps SortListModelModelPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear]
type AttrBaseTypeConstraint SortListModelModelPropertyInfo = IsSortListModel
type AttrSetTypeConstraint SortListModelModelPropertyInfo = Gio.ListModel.IsListModel
type AttrTransferTypeConstraint SortListModelModelPropertyInfo = Gio.ListModel.IsListModel
type AttrTransferType SortListModelModelPropertyInfo = Gio.ListModel.ListModel
type AttrGetType SortListModelModelPropertyInfo = (Maybe Gio.ListModel.ListModel)
type AttrLabel SortListModelModelPropertyInfo = "model"
type AttrOrigin SortListModelModelPropertyInfo = SortListModel
attrGet = getSortListModelModel
attrSet = undefined
attrTransfer _ v = do
unsafeCastTo Gio.ListModel.ListModel v
attrConstruct = constructSortListModelModel
attrClear = undefined
#endif
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList SortListModel
type instance O.AttributeList SortListModel = SortListModelAttributeList
type SortListModelAttributeList = ('[ '("hasSort", SortListModelHasSortPropertyInfo), '("itemType", SortListModelItemTypePropertyInfo), '("model", SortListModelModelPropertyInfo)] :: [(Symbol, *)])
#endif
#if defined(ENABLE_OVERLOADING)
sortListModelItemType :: AttrLabelProxy "itemType"
sortListModelItemType = AttrLabelProxy
sortListModelModel :: AttrLabelProxy "model"
sortListModelModel = AttrLabelProxy
#endif
#if defined(ENABLE_OVERLOADING)
type instance O.SignalList SortListModel = SortListModelSignalList
type SortListModelSignalList = ('[ '("itemsChanged", Gio.ListModel.ListModelItemsChangedSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)])
#endif
foreign import ccall "gtk_sort_list_model_new" gtk_sort_list_model_new ::
Ptr Gio.ListModel.ListModel ->
FunPtr GLib.Callbacks.C_CompareDataFunc ->
Ptr () ->
FunPtr GLib.Callbacks.C_DestroyNotify ->
IO (Ptr SortListModel)
sortListModelNew ::
(B.CallStack.HasCallStack, MonadIO m, Gio.ListModel.IsListModel a) =>
a
-> Maybe (GLib.Callbacks.CompareDataFunc)
-> m SortListModel
sortListModelNew :: a -> Maybe CompareDataFunc -> m SortListModel
sortListModelNew model :: a
model sortFunc :: Maybe CompareDataFunc
sortFunc = IO SortListModel -> m SortListModel
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SortListModel -> m SortListModel)
-> IO SortListModel -> m SortListModel
forall a b. (a -> b) -> a -> b
$ do
Ptr ListModel
model' <- a -> IO (Ptr ListModel)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
model
FunPtr C_CompareDataFunc
maybeSortFunc <- case Maybe CompareDataFunc
sortFunc of
Nothing -> FunPtr C_CompareDataFunc -> IO (FunPtr C_CompareDataFunc)
forall (m :: * -> *) a. Monad m => a -> m a
return (Ptr Any -> FunPtr C_CompareDataFunc
forall a b. Ptr a -> FunPtr b
castPtrToFunPtr Ptr Any
forall a. Ptr a
nullPtr)
Just jSortFunc :: CompareDataFunc
jSortFunc -> do
FunPtr C_CompareDataFunc
jSortFunc' <- C_CompareDataFunc -> IO (FunPtr C_CompareDataFunc)
GLib.Callbacks.mk_CompareDataFunc (Maybe (Ptr (FunPtr C_CompareDataFunc))
-> C_CompareDataFunc -> C_CompareDataFunc
GLib.Callbacks.wrap_CompareDataFunc Maybe (Ptr (FunPtr C_CompareDataFunc))
forall a. Maybe a
Nothing (CompareDataFunc -> C_CompareDataFunc
GLib.Callbacks.drop_closures_CompareDataFunc CompareDataFunc
jSortFunc))
FunPtr C_CompareDataFunc -> IO (FunPtr C_CompareDataFunc)
forall (m :: * -> *) a. Monad m => a -> m a
return FunPtr C_CompareDataFunc
jSortFunc'
let userData :: Ptr ()
userData = FunPtr C_CompareDataFunc -> Ptr ()
forall a b. FunPtr a -> Ptr b
castFunPtrToPtr FunPtr C_CompareDataFunc
maybeSortFunc
let userDestroy :: FunPtr (Ptr a -> IO ())
userDestroy = FunPtr (Ptr a -> IO ())
forall a. FunPtr (Ptr a -> IO ())
safeFreeFunPtrPtr
Ptr SortListModel
result <- Ptr ListModel
-> FunPtr C_CompareDataFunc
-> Ptr ()
-> FunPtr C_DestroyNotify
-> IO (Ptr SortListModel)
gtk_sort_list_model_new Ptr ListModel
model' FunPtr C_CompareDataFunc
maybeSortFunc Ptr ()
userData FunPtr C_DestroyNotify
forall a. FunPtr (Ptr a -> IO ())
userDestroy
Text -> Ptr SortListModel -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "sortListModelNew" Ptr SortListModel
result
SortListModel
result' <- ((ManagedPtr SortListModel -> SortListModel)
-> Ptr SortListModel -> IO SortListModel
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr SortListModel -> SortListModel
SortListModel) Ptr SortListModel
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
model
SortListModel -> IO SortListModel
forall (m :: * -> *) a. Monad m => a -> m a
return SortListModel
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "gtk_sort_list_model_new_for_type" gtk_sort_list_model_new_for_type ::
CGType ->
IO (Ptr SortListModel)
sortListModelNewForType ::
(B.CallStack.HasCallStack, MonadIO m) =>
GType
-> m SortListModel
sortListModelNewForType :: GType -> m SortListModel
sortListModelNewForType itemType :: GType
itemType = IO SortListModel -> m SortListModel
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SortListModel -> m SortListModel)
-> IO SortListModel -> m SortListModel
forall a b. (a -> b) -> a -> b
$ do
let itemType' :: CGType
itemType' = GType -> CGType
gtypeToCGType GType
itemType
Ptr SortListModel
result <- CGType -> IO (Ptr SortListModel)
gtk_sort_list_model_new_for_type CGType
itemType'
Text -> Ptr SortListModel -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "sortListModelNewForType" Ptr SortListModel
result
SortListModel
result' <- ((ManagedPtr SortListModel -> SortListModel)
-> Ptr SortListModel -> IO SortListModel
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr SortListModel -> SortListModel
SortListModel) Ptr SortListModel
result
SortListModel -> IO SortListModel
forall (m :: * -> *) a. Monad m => a -> m a
return SortListModel
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "gtk_sort_list_model_get_model" gtk_sort_list_model_get_model ::
Ptr SortListModel ->
IO (Ptr Gio.ListModel.ListModel)
sortListModelGetModel ::
(B.CallStack.HasCallStack, MonadIO m, IsSortListModel a) =>
a
-> m (Maybe Gio.ListModel.ListModel)
sortListModelGetModel :: a -> m (Maybe ListModel)
sortListModelGetModel self :: a
self = IO (Maybe ListModel) -> m (Maybe ListModel)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe ListModel) -> m (Maybe ListModel))
-> IO (Maybe ListModel) -> m (Maybe ListModel)
forall a b. (a -> b) -> a -> b
$ do
Ptr SortListModel
self' <- a -> IO (Ptr SortListModel)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
Ptr ListModel
result <- Ptr SortListModel -> IO (Ptr ListModel)
gtk_sort_list_model_get_model Ptr SortListModel
self'
Maybe ListModel
maybeResult <- Ptr ListModel
-> (Ptr ListModel -> IO ListModel) -> IO (Maybe ListModel)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr ListModel
result ((Ptr ListModel -> IO ListModel) -> IO (Maybe ListModel))
-> (Ptr ListModel -> IO ListModel) -> IO (Maybe ListModel)
forall a b. (a -> b) -> a -> b
$ \result' :: Ptr ListModel
result' -> do
ListModel
result'' <- ((ManagedPtr ListModel -> ListModel)
-> Ptr ListModel -> IO ListModel
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr ListModel -> ListModel
Gio.ListModel.ListModel) Ptr ListModel
result'
ListModel -> IO ListModel
forall (m :: * -> *) a. Monad m => a -> m a
return ListModel
result''
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
Maybe ListModel -> IO (Maybe ListModel)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe ListModel
maybeResult
#if defined(ENABLE_OVERLOADING)
data SortListModelGetModelMethodInfo
instance (signature ~ (m (Maybe Gio.ListModel.ListModel)), MonadIO m, IsSortListModel a) => O.MethodInfo SortListModelGetModelMethodInfo a signature where
overloadedMethod = sortListModelGetModel
#endif
foreign import ccall "gtk_sort_list_model_has_sort" gtk_sort_list_model_has_sort ::
Ptr SortListModel ->
IO CInt
sortListModelHasSort ::
(B.CallStack.HasCallStack, MonadIO m, IsSortListModel a) =>
a
-> m Bool
sortListModelHasSort :: a -> m Bool
sortListModelHasSort self :: a
self = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
Ptr SortListModel
self' <- a -> IO (Ptr SortListModel)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
CInt
result <- Ptr SortListModel -> IO CInt
gtk_sort_list_model_has_sort Ptr SortListModel
self'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= 0) CInt
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data SortListModelHasSortMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsSortListModel a) => O.MethodInfo SortListModelHasSortMethodInfo a signature where
overloadedMethod = sortListModelHasSort
#endif
foreign import ccall "gtk_sort_list_model_resort" gtk_sort_list_model_resort ::
Ptr SortListModel ->
IO ()
sortListModelResort ::
(B.CallStack.HasCallStack, MonadIO m, IsSortListModel a) =>
a
-> m ()
sortListModelResort :: a -> m ()
sortListModelResort self :: a
self = 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 SortListModel
self' <- a -> IO (Ptr SortListModel)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
Ptr SortListModel -> IO ()
gtk_sort_list_model_resort Ptr SortListModel
self'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data SortListModelResortMethodInfo
instance (signature ~ (m ()), MonadIO m, IsSortListModel a) => O.MethodInfo SortListModelResortMethodInfo a signature where
overloadedMethod = sortListModelResort
#endif
foreign import ccall "gtk_sort_list_model_set_model" gtk_sort_list_model_set_model ::
Ptr SortListModel ->
Ptr Gio.ListModel.ListModel ->
IO ()
sortListModelSetModel ::
(B.CallStack.HasCallStack, MonadIO m, IsSortListModel a, Gio.ListModel.IsListModel b) =>
a
-> Maybe (b)
-> m ()
sortListModelSetModel :: a -> Maybe b -> m ()
sortListModelSetModel self :: a
self model :: Maybe b
model = 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 SortListModel
self' <- a -> IO (Ptr SortListModel)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
Ptr ListModel
maybeModel <- case Maybe b
model of
Nothing -> Ptr ListModel -> IO (Ptr ListModel)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr ListModel
forall a. Ptr a
nullPtr
Just jModel :: b
jModel -> do
Ptr ListModel
jModel' <- b -> IO (Ptr ListModel)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jModel
Ptr ListModel -> IO (Ptr ListModel)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr ListModel
jModel'
Ptr SortListModel -> Ptr ListModel -> IO ()
gtk_sort_list_model_set_model Ptr SortListModel
self' Ptr ListModel
maybeModel
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
Maybe b -> (b -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
model b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data SortListModelSetModelMethodInfo
instance (signature ~ (Maybe (b) -> m ()), MonadIO m, IsSortListModel a, Gio.ListModel.IsListModel b) => O.MethodInfo SortListModelSetModelMethodInfo a signature where
overloadedMethod = sortListModelSetModel
#endif
foreign import ccall "gtk_sort_list_model_set_sort_func" gtk_sort_list_model_set_sort_func ::
Ptr SortListModel ->
FunPtr GLib.Callbacks.C_CompareDataFunc ->
Ptr () ->
FunPtr GLib.Callbacks.C_DestroyNotify ->
IO ()
sortListModelSetSortFunc ::
(B.CallStack.HasCallStack, MonadIO m, IsSortListModel a) =>
a
-> Maybe (GLib.Callbacks.CompareDataFunc)
-> m ()
sortListModelSetSortFunc :: a -> Maybe CompareDataFunc -> m ()
sortListModelSetSortFunc self :: a
self sortFunc :: Maybe CompareDataFunc
sortFunc = 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 SortListModel
self' <- a -> IO (Ptr SortListModel)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
FunPtr C_CompareDataFunc
maybeSortFunc <- case Maybe CompareDataFunc
sortFunc of
Nothing -> FunPtr C_CompareDataFunc -> IO (FunPtr C_CompareDataFunc)
forall (m :: * -> *) a. Monad m => a -> m a
return (Ptr Any -> FunPtr C_CompareDataFunc
forall a b. Ptr a -> FunPtr b
castPtrToFunPtr Ptr Any
forall a. Ptr a
nullPtr)
Just jSortFunc :: CompareDataFunc
jSortFunc -> do
FunPtr C_CompareDataFunc
jSortFunc' <- C_CompareDataFunc -> IO (FunPtr C_CompareDataFunc)
GLib.Callbacks.mk_CompareDataFunc (Maybe (Ptr (FunPtr C_CompareDataFunc))
-> C_CompareDataFunc -> C_CompareDataFunc
GLib.Callbacks.wrap_CompareDataFunc Maybe (Ptr (FunPtr C_CompareDataFunc))
forall a. Maybe a
Nothing (CompareDataFunc -> C_CompareDataFunc
GLib.Callbacks.drop_closures_CompareDataFunc CompareDataFunc
jSortFunc))
FunPtr C_CompareDataFunc -> IO (FunPtr C_CompareDataFunc)
forall (m :: * -> *) a. Monad m => a -> m a
return FunPtr C_CompareDataFunc
jSortFunc'
let userData :: Ptr ()
userData = FunPtr C_CompareDataFunc -> Ptr ()
forall a b. FunPtr a -> Ptr b
castFunPtrToPtr FunPtr C_CompareDataFunc
maybeSortFunc
let userDestroy :: FunPtr (Ptr a -> IO ())
userDestroy = FunPtr (Ptr a -> IO ())
forall a. FunPtr (Ptr a -> IO ())
safeFreeFunPtrPtr
Ptr SortListModel
-> FunPtr C_CompareDataFunc
-> Ptr ()
-> FunPtr C_DestroyNotify
-> IO ()
gtk_sort_list_model_set_sort_func Ptr SortListModel
self' FunPtr C_CompareDataFunc
maybeSortFunc Ptr ()
userData FunPtr C_DestroyNotify
forall a. FunPtr (Ptr a -> IO ())
userDestroy
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data SortListModelSetSortFuncMethodInfo
instance (signature ~ (Maybe (GLib.Callbacks.CompareDataFunc) -> m ()), MonadIO m, IsSortListModel a) => O.MethodInfo SortListModelSetSortFuncMethodInfo a signature where
overloadedMethod = sortListModelSetSortFunc
#endif