{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Gio.Objects.ListStore
(
ListStore(..) ,
IsListStore ,
toListStore ,
#if defined(ENABLE_OVERLOADING)
ResolveListStoreMethod ,
#endif
#if defined(ENABLE_OVERLOADING)
ListStoreAppendMethodInfo ,
#endif
listStoreAppend ,
#if defined(ENABLE_OVERLOADING)
ListStoreFindMethodInfo ,
#endif
listStoreFind ,
#if defined(ENABLE_OVERLOADING)
ListStoreFindWithEqualFuncMethodInfo ,
#endif
listStoreFindWithEqualFunc ,
#if defined(ENABLE_OVERLOADING)
ListStoreFindWithEqualFuncFullMethodInfo,
#endif
listStoreFindWithEqualFuncFull ,
#if defined(ENABLE_OVERLOADING)
ListStoreInsertMethodInfo ,
#endif
listStoreInsert ,
#if defined(ENABLE_OVERLOADING)
ListStoreInsertSortedMethodInfo ,
#endif
listStoreInsertSorted ,
listStoreNew ,
#if defined(ENABLE_OVERLOADING)
ListStoreRemoveMethodInfo ,
#endif
listStoreRemove ,
#if defined(ENABLE_OVERLOADING)
ListStoreRemoveAllMethodInfo ,
#endif
listStoreRemoveAll ,
#if defined(ENABLE_OVERLOADING)
ListStoreSortMethodInfo ,
#endif
listStoreSort ,
#if defined(ENABLE_OVERLOADING)
ListStoreSpliceMethodInfo ,
#endif
listStoreSplice ,
#if defined(ENABLE_OVERLOADING)
ListStoreItemTypePropertyInfo ,
#endif
constructListStoreItemType ,
getListStoreItemType ,
#if defined(ENABLE_OVERLOADING)
listStoreItemType ,
#endif
#if defined(ENABLE_OVERLOADING)
ListStoreNItemsPropertyInfo ,
#endif
getListStoreNItems ,
#if defined(ENABLE_OVERLOADING)
listStoreNItems ,
#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.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
#if MIN_VERSION_base(4,18,0)
import qualified GI.GLib.Callbacks as GLib.Callbacks
import qualified GI.GObject.Objects.Object as GObject.Object
import {-# SOURCE #-} qualified GI.Gio.Interfaces.ListModel as Gio.ListModel
#else
import qualified GI.GLib.Callbacks as GLib.Callbacks
import qualified GI.GObject.Objects.Object as GObject.Object
import {-# SOURCE #-} qualified GI.Gio.Interfaces.ListModel as Gio.ListModel
#endif
newtype ListStore = ListStore (SP.ManagedPtr ListStore)
deriving (ListStore -> ListStore -> Bool
(ListStore -> ListStore -> Bool)
-> (ListStore -> ListStore -> Bool) -> Eq ListStore
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ListStore -> ListStore -> Bool
== :: ListStore -> ListStore -> Bool
$c/= :: ListStore -> ListStore -> Bool
/= :: ListStore -> ListStore -> Bool
Eq)
instance SP.ManagedPtrNewtype ListStore where
toManagedPtr :: ListStore -> ManagedPtr ListStore
toManagedPtr (ListStore ManagedPtr ListStore
p) = ManagedPtr ListStore
p
foreign import ccall "g_list_store_get_type"
c_g_list_store_get_type :: IO B.Types.GType
instance B.Types.TypedObject ListStore where
glibType :: IO GType
glibType = IO GType
c_g_list_store_get_type
instance B.Types.GObject ListStore
class (SP.GObject o, O.IsDescendantOf ListStore o) => IsListStore o
instance (SP.GObject o, O.IsDescendantOf ListStore o) => IsListStore o
instance O.HasParentTypes ListStore
type instance O.ParentTypes ListStore = '[GObject.Object.Object, Gio.ListModel.ListModel]
toListStore :: (MIO.MonadIO m, IsListStore o) => o -> m ListStore
toListStore :: forall (m :: * -> *) o.
(MonadIO m, IsListStore o) =>
o -> m ListStore
toListStore = IO ListStore -> m ListStore
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO ListStore -> m ListStore)
-> (o -> IO ListStore) -> o -> m ListStore
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ManagedPtr ListStore -> ListStore) -> o -> IO ListStore
forall o o'.
(HasCallStack, ManagedPtrNewtype o, TypedObject o,
ManagedPtrNewtype o', TypedObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
B.ManagedPtr.unsafeCastTo ManagedPtr ListStore -> ListStore
ListStore
instance B.GValue.IsGValue (Maybe ListStore) where
gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_g_list_store_get_type
gvalueSet_ :: Ptr GValue -> Maybe ListStore -> IO ()
gvalueSet_ Ptr GValue
gv Maybe ListStore
P.Nothing = Ptr GValue -> Ptr ListStore -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv (Ptr ListStore
forall a. Ptr a
FP.nullPtr :: FP.Ptr ListStore)
gvalueSet_ Ptr GValue
gv (P.Just ListStore
obj) = ListStore -> (Ptr ListStore -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr ListStore
obj (Ptr GValue -> Ptr ListStore -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv)
gvalueGet_ :: Ptr GValue -> IO (Maybe ListStore)
gvalueGet_ Ptr GValue
gv = do
ptr <- Ptr GValue -> IO (Ptr ListStore)
forall a. GObject a => Ptr GValue -> IO (Ptr a)
B.GValue.get_object Ptr GValue
gv :: IO (FP.Ptr ListStore)
if ptr /= FP.nullPtr
then P.Just <$> B.ManagedPtr.newObject ListStore ptr
else return P.Nothing
#if defined(ENABLE_OVERLOADING)
type family ResolveListStoreMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
ResolveListStoreMethod "append" o = ListStoreAppendMethodInfo
ResolveListStoreMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
ResolveListStoreMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
ResolveListStoreMethod "find" o = ListStoreFindMethodInfo
ResolveListStoreMethod "findWithEqualFunc" o = ListStoreFindWithEqualFuncMethodInfo
ResolveListStoreMethod "findWithEqualFuncFull" o = ListStoreFindWithEqualFuncFullMethodInfo
ResolveListStoreMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
ResolveListStoreMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
ResolveListStoreMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
ResolveListStoreMethod "insert" o = ListStoreInsertMethodInfo
ResolveListStoreMethod "insertSorted" o = ListStoreInsertSortedMethodInfo
ResolveListStoreMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
ResolveListStoreMethod "itemsChanged" o = Gio.ListModel.ListModelItemsChangedMethodInfo
ResolveListStoreMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
ResolveListStoreMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
ResolveListStoreMethod "ref" o = GObject.Object.ObjectRefMethodInfo
ResolveListStoreMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
ResolveListStoreMethod "remove" o = ListStoreRemoveMethodInfo
ResolveListStoreMethod "removeAll" o = ListStoreRemoveAllMethodInfo
ResolveListStoreMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
ResolveListStoreMethod "sort" o = ListStoreSortMethodInfo
ResolveListStoreMethod "splice" o = ListStoreSpliceMethodInfo
ResolveListStoreMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
ResolveListStoreMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
ResolveListStoreMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
ResolveListStoreMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
ResolveListStoreMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
ResolveListStoreMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
ResolveListStoreMethod "getItem" o = Gio.ListModel.ListModelGetItemMethodInfo
ResolveListStoreMethod "getItemType" o = Gio.ListModel.ListModelGetItemTypeMethodInfo
ResolveListStoreMethod "getNItems" o = Gio.ListModel.ListModelGetNItemsMethodInfo
ResolveListStoreMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
ResolveListStoreMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
ResolveListStoreMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
ResolveListStoreMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
ResolveListStoreMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
ResolveListStoreMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveListStoreMethod t ListStore, O.OverloadedMethod info ListStore p) => OL.IsLabel t (ListStore -> 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 ~ ResolveListStoreMethod t ListStore, O.OverloadedMethod info ListStore p, R.HasField t ListStore p) => R.HasField t ListStore p where
getField = O.overloadedMethod @info
#endif
instance (info ~ ResolveListStoreMethod t ListStore, O.OverloadedMethodInfo info ListStore) => OL.IsLabel t (O.MethodProxy info ListStore) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.MethodProxy
#else
fromLabel _ = O.MethodProxy
#endif
#endif
getListStoreItemType :: (MonadIO m, IsListStore o) => o -> m GType
getListStoreItemType :: forall (m :: * -> *) o. (MonadIO m, IsListStore o) => o -> m GType
getListStoreItemType o
obj = IO GType -> m GType
forall a. IO a -> m a
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
"item-type"
constructListStoreItemType :: (IsListStore o, MIO.MonadIO m) => GType -> m (GValueConstruct o)
constructListStoreItemType :: forall o (m :: * -> *).
(IsListStore o, MonadIO m) =>
GType -> m (GValueConstruct o)
constructListStoreItemType GType
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
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 a. IO a -> IO a
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
"item-type" GType
val
#if defined(ENABLE_OVERLOADING)
data ListStoreItemTypePropertyInfo
instance AttrInfo ListStoreItemTypePropertyInfo where
type AttrAllowedOps ListStoreItemTypePropertyInfo = '[ 'AttrConstruct, 'AttrGet]
type AttrBaseTypeConstraint ListStoreItemTypePropertyInfo = IsListStore
type AttrSetTypeConstraint ListStoreItemTypePropertyInfo = (~) GType
type AttrTransferTypeConstraint ListStoreItemTypePropertyInfo = (~) GType
type AttrTransferType ListStoreItemTypePropertyInfo = GType
type AttrGetType ListStoreItemTypePropertyInfo = GType
type AttrLabel ListStoreItemTypePropertyInfo = "item-type"
type AttrOrigin ListStoreItemTypePropertyInfo = ListStore
attrGet = getListStoreItemType
attrSet = undefined
attrTransfer _ v = do
return v
attrConstruct = constructListStoreItemType
attrClear = undefined
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Objects.ListStore.itemType"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.35/docs/GI-Gio-Objects-ListStore.html#g:attr:itemType"
})
#endif
getListStoreNItems :: (MonadIO m, IsListStore o) => o -> m Word32
getListStoreNItems :: forall (m :: * -> *) o. (MonadIO m, IsListStore o) => o -> m Word32
getListStoreNItems o
obj = IO Word32 -> m Word32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Word32
forall a. GObject a => a -> String -> IO Word32
B.Properties.getObjectPropertyUInt32 o
obj String
"n-items"
#if defined(ENABLE_OVERLOADING)
data ListStoreNItemsPropertyInfo
instance AttrInfo ListStoreNItemsPropertyInfo where
type AttrAllowedOps ListStoreNItemsPropertyInfo = '[ 'AttrGet]
type AttrBaseTypeConstraint ListStoreNItemsPropertyInfo = IsListStore
type AttrSetTypeConstraint ListStoreNItemsPropertyInfo = (~) ()
type AttrTransferTypeConstraint ListStoreNItemsPropertyInfo = (~) ()
type AttrTransferType ListStoreNItemsPropertyInfo = ()
type AttrGetType ListStoreNItemsPropertyInfo = Word32
type AttrLabel ListStoreNItemsPropertyInfo = "n-items"
type AttrOrigin ListStoreNItemsPropertyInfo = ListStore
attrGet = getListStoreNItems
attrSet = undefined
attrTransfer _ = undefined
attrConstruct = undefined
attrClear = undefined
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Objects.ListStore.nItems"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.35/docs/GI-Gio-Objects-ListStore.html#g:attr:nItems"
})
#endif
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList ListStore
type instance O.AttributeList ListStore = ListStoreAttributeList
type ListStoreAttributeList = ('[ '("itemType", ListStoreItemTypePropertyInfo), '("nItems", ListStoreNItemsPropertyInfo)] :: [(Symbol, DK.Type)])
#endif
#if defined(ENABLE_OVERLOADING)
listStoreItemType :: AttrLabelProxy "itemType"
listStoreItemType = AttrLabelProxy
listStoreNItems :: AttrLabelProxy "nItems"
listStoreNItems = AttrLabelProxy
#endif
#if defined(ENABLE_OVERLOADING)
type instance O.SignalList ListStore = ListStoreSignalList
type ListStoreSignalList = ('[ '("itemsChanged", Gio.ListModel.ListModelItemsChangedSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, DK.Type)])
#endif
foreign import ccall "g_list_store_new" g_list_store_new ::
CGType ->
IO (Ptr ListStore)
listStoreNew ::
(B.CallStack.HasCallStack, MonadIO m) =>
GType
-> m ListStore
listStoreNew :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
GType -> m ListStore
listStoreNew GType
itemType = IO ListStore -> m ListStore
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO ListStore -> m ListStore) -> IO ListStore -> m ListStore
forall a b. (a -> b) -> a -> b
$ do
let itemType' :: CGType
itemType' = GType -> CGType
gtypeToCGType GType
itemType
result <- CGType -> IO (Ptr ListStore)
g_list_store_new CGType
itemType'
checkUnexpectedReturnNULL "listStoreNew" result
result' <- (wrapObject ListStore) result
return result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "g_list_store_append" g_list_store_append ::
Ptr ListStore ->
Ptr GObject.Object.Object ->
IO ()
listStoreAppend ::
(B.CallStack.HasCallStack, MonadIO m, IsListStore a, GObject.Object.IsObject b) =>
a
-> b
-> m ()
listStoreAppend :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsListStore a, IsObject b) =>
a -> b -> m ()
listStoreAppend a
store b
item = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
store' <- a -> IO (Ptr ListStore)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
store
item' <- unsafeManagedPtrCastPtr item
g_list_store_append store' item'
touchManagedPtr store
touchManagedPtr item
return ()
#if defined(ENABLE_OVERLOADING)
data ListStoreAppendMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsListStore a, GObject.Object.IsObject b) => O.OverloadedMethod ListStoreAppendMethodInfo a signature where
overloadedMethod = listStoreAppend
instance O.OverloadedMethodInfo ListStoreAppendMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Objects.ListStore.listStoreAppend",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.35/docs/GI-Gio-Objects-ListStore.html#v:listStoreAppend"
})
#endif
foreign import ccall "g_list_store_find" g_list_store_find ::
Ptr ListStore ->
Ptr GObject.Object.Object ->
Ptr Word32 ->
IO CInt
listStoreFind ::
(B.CallStack.HasCallStack, MonadIO m, IsListStore a, GObject.Object.IsObject b) =>
a
-> b
-> m ((Bool, Word32))
listStoreFind :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsListStore a, IsObject b) =>
a -> b -> m (Bool, Word32)
listStoreFind a
store b
item = IO (Bool, Word32) -> m (Bool, Word32)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Bool, Word32) -> m (Bool, Word32))
-> IO (Bool, Word32) -> m (Bool, Word32)
forall a b. (a -> b) -> a -> b
$ do
store' <- a -> IO (Ptr ListStore)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
store
item' <- unsafeManagedPtrCastPtr item
position <- allocMem :: IO (Ptr Word32)
result <- g_list_store_find store' item' position
let result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
position' <- peek position
touchManagedPtr store
touchManagedPtr item
freeMem position
return (result', position')
#if defined(ENABLE_OVERLOADING)
data ListStoreFindMethodInfo
instance (signature ~ (b -> m ((Bool, Word32))), MonadIO m, IsListStore a, GObject.Object.IsObject b) => O.OverloadedMethod ListStoreFindMethodInfo a signature where
overloadedMethod = listStoreFind
instance O.OverloadedMethodInfo ListStoreFindMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Objects.ListStore.listStoreFind",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.35/docs/GI-Gio-Objects-ListStore.html#v:listStoreFind"
})
#endif
foreign import ccall "g_list_store_find_with_equal_func" g_list_store_find_with_equal_func ::
Ptr ListStore ->
Ptr GObject.Object.Object ->
FunPtr GLib.Callbacks.C_EqualFunc ->
Ptr Word32 ->
IO CInt
listStoreFindWithEqualFunc ::
(B.CallStack.HasCallStack, MonadIO m, IsListStore a, GObject.Object.IsObject b) =>
a
-> Maybe (b)
-> GLib.Callbacks.EqualFunc
-> m ((Bool, Word32))
listStoreFindWithEqualFunc :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsListStore a, IsObject b) =>
a -> Maybe b -> EqualFunc -> m (Bool, Word32)
listStoreFindWithEqualFunc a
store Maybe b
item EqualFunc
equalFunc = IO (Bool, Word32) -> m (Bool, Word32)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Bool, Word32) -> m (Bool, Word32))
-> IO (Bool, Word32) -> m (Bool, Word32)
forall a b. (a -> b) -> a -> b
$ do
store' <- a -> IO (Ptr ListStore)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
store
maybeItem <- case item of
Maybe b
Nothing -> Ptr Object -> IO (Ptr Object)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Object
forall a. Ptr a
FP.nullPtr
Just b
jItem -> do
jItem' <- b -> IO (Ptr Object)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jItem
return jItem'
equalFunc' <- GLib.Callbacks.mk_EqualFunc (GLib.Callbacks.wrap_EqualFunc Nothing equalFunc)
position <- allocMem :: IO (Ptr Word32)
result <- g_list_store_find_with_equal_func store' maybeItem equalFunc' position
let result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
position' <- peek position
safeFreeFunPtr $ castFunPtrToPtr equalFunc'
touchManagedPtr store
whenJust item touchManagedPtr
freeMem position
return (result', position')
#if defined(ENABLE_OVERLOADING)
data ListStoreFindWithEqualFuncMethodInfo
instance (signature ~ (Maybe (b) -> GLib.Callbacks.EqualFunc -> m ((Bool, Word32))), MonadIO m, IsListStore a, GObject.Object.IsObject b) => O.OverloadedMethod ListStoreFindWithEqualFuncMethodInfo a signature where
overloadedMethod = listStoreFindWithEqualFunc
instance O.OverloadedMethodInfo ListStoreFindWithEqualFuncMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Objects.ListStore.listStoreFindWithEqualFunc",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.35/docs/GI-Gio-Objects-ListStore.html#v:listStoreFindWithEqualFunc"
})
#endif
foreign import ccall "g_list_store_find_with_equal_func_full" g_list_store_find_with_equal_func_full ::
Ptr ListStore ->
Ptr GObject.Object.Object ->
FunPtr GLib.Callbacks.C_EqualFuncFull ->
Ptr () ->
Ptr Word32 ->
IO CInt
listStoreFindWithEqualFuncFull ::
(B.CallStack.HasCallStack, MonadIO m, IsListStore a, GObject.Object.IsObject b) =>
a
-> Maybe (b)
-> GLib.Callbacks.EqualFuncFull
-> m ((Bool, Word32))
listStoreFindWithEqualFuncFull :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsListStore a, IsObject b) =>
a -> Maybe b -> EqualFunc -> m (Bool, Word32)
listStoreFindWithEqualFuncFull a
store Maybe b
item EqualFunc
equalFunc = IO (Bool, Word32) -> m (Bool, Word32)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Bool, Word32) -> m (Bool, Word32))
-> IO (Bool, Word32) -> m (Bool, Word32)
forall a b. (a -> b) -> a -> b
$ do
store' <- a -> IO (Ptr ListStore)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
store
maybeItem <- case item of
Maybe b
Nothing -> Ptr Object -> IO (Ptr Object)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Object
forall a. Ptr a
FP.nullPtr
Just b
jItem -> do
jItem' <- b -> IO (Ptr Object)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jItem
return jItem'
equalFunc' <- GLib.Callbacks.mk_EqualFuncFull (GLib.Callbacks.wrap_EqualFuncFull Nothing (GLib.Callbacks.drop_closures_EqualFuncFull equalFunc))
position <- allocMem :: IO (Ptr Word32)
let userData = Ptr a
forall a. Ptr a
nullPtr
result <- g_list_store_find_with_equal_func_full store' maybeItem equalFunc' userData position
let result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
position' <- peek position
safeFreeFunPtr $ castFunPtrToPtr equalFunc'
touchManagedPtr store
whenJust item touchManagedPtr
freeMem position
return (result', position')
#if defined(ENABLE_OVERLOADING)
data ListStoreFindWithEqualFuncFullMethodInfo
instance (signature ~ (Maybe (b) -> GLib.Callbacks.EqualFuncFull -> m ((Bool, Word32))), MonadIO m, IsListStore a, GObject.Object.IsObject b) => O.OverloadedMethod ListStoreFindWithEqualFuncFullMethodInfo a signature where
overloadedMethod = listStoreFindWithEqualFuncFull
instance O.OverloadedMethodInfo ListStoreFindWithEqualFuncFullMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Objects.ListStore.listStoreFindWithEqualFuncFull",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.35/docs/GI-Gio-Objects-ListStore.html#v:listStoreFindWithEqualFuncFull"
})
#endif
foreign import ccall "g_list_store_insert" g_list_store_insert ::
Ptr ListStore ->
Word32 ->
Ptr GObject.Object.Object ->
IO ()
listStoreInsert ::
(B.CallStack.HasCallStack, MonadIO m, IsListStore a, GObject.Object.IsObject b) =>
a
-> Word32
-> b
-> m ()
listStoreInsert :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsListStore a, IsObject b) =>
a -> Word32 -> b -> m ()
listStoreInsert a
store Word32
position b
item = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
store' <- a -> IO (Ptr ListStore)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
store
item' <- unsafeManagedPtrCastPtr item
g_list_store_insert store' position item'
touchManagedPtr store
touchManagedPtr item
return ()
#if defined(ENABLE_OVERLOADING)
data ListStoreInsertMethodInfo
instance (signature ~ (Word32 -> b -> m ()), MonadIO m, IsListStore a, GObject.Object.IsObject b) => O.OverloadedMethod ListStoreInsertMethodInfo a signature where
overloadedMethod = listStoreInsert
instance O.OverloadedMethodInfo ListStoreInsertMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Objects.ListStore.listStoreInsert",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.35/docs/GI-Gio-Objects-ListStore.html#v:listStoreInsert"
})
#endif
foreign import ccall "g_list_store_insert_sorted" g_list_store_insert_sorted ::
Ptr ListStore ->
Ptr GObject.Object.Object ->
FunPtr GLib.Callbacks.C_CompareDataFunc ->
Ptr () ->
IO Word32
listStoreInsertSorted ::
(B.CallStack.HasCallStack, MonadIO m, IsListStore a, GObject.Object.IsObject b) =>
a
-> b
-> GLib.Callbacks.CompareDataFunc
-> m Word32
listStoreInsertSorted :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsListStore a, IsObject b) =>
a -> b -> CompareDataFunc -> m Word32
listStoreInsertSorted a
store b
item CompareDataFunc
compareFunc = IO Word32 -> m Word32
forall a. IO a -> m a
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
store' <- a -> IO (Ptr ListStore)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
store
item' <- unsafeManagedPtrCastPtr item
compareFunc' <- GLib.Callbacks.mk_CompareDataFunc (GLib.Callbacks.wrap_CompareDataFunc Nothing (GLib.Callbacks.drop_closures_CompareDataFunc compareFunc))
let userData = Ptr a
forall a. Ptr a
nullPtr
result <- g_list_store_insert_sorted store' item' compareFunc' userData
safeFreeFunPtr $ castFunPtrToPtr compareFunc'
touchManagedPtr store
touchManagedPtr item
return result
#if defined(ENABLE_OVERLOADING)
data ListStoreInsertSortedMethodInfo
instance (signature ~ (b -> GLib.Callbacks.CompareDataFunc -> m Word32), MonadIO m, IsListStore a, GObject.Object.IsObject b) => O.OverloadedMethod ListStoreInsertSortedMethodInfo a signature where
overloadedMethod = listStoreInsertSorted
instance O.OverloadedMethodInfo ListStoreInsertSortedMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Objects.ListStore.listStoreInsertSorted",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.35/docs/GI-Gio-Objects-ListStore.html#v:listStoreInsertSorted"
})
#endif
foreign import ccall "g_list_store_remove" g_list_store_remove ::
Ptr ListStore ->
Word32 ->
IO ()
listStoreRemove ::
(B.CallStack.HasCallStack, MonadIO m, IsListStore a) =>
a
-> Word32
-> m ()
listStoreRemove :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsListStore a) =>
a -> Word32 -> m ()
listStoreRemove a
store Word32
position = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
store' <- a -> IO (Ptr ListStore)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
store
g_list_store_remove store' position
touchManagedPtr store
return ()
#if defined(ENABLE_OVERLOADING)
data ListStoreRemoveMethodInfo
instance (signature ~ (Word32 -> m ()), MonadIO m, IsListStore a) => O.OverloadedMethod ListStoreRemoveMethodInfo a signature where
overloadedMethod = listStoreRemove
instance O.OverloadedMethodInfo ListStoreRemoveMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Objects.ListStore.listStoreRemove",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.35/docs/GI-Gio-Objects-ListStore.html#v:listStoreRemove"
})
#endif
foreign import ccall "g_list_store_remove_all" g_list_store_remove_all ::
Ptr ListStore ->
IO ()
listStoreRemoveAll ::
(B.CallStack.HasCallStack, MonadIO m, IsListStore a) =>
a
-> m ()
listStoreRemoveAll :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsListStore a) =>
a -> m ()
listStoreRemoveAll a
store = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
store' <- a -> IO (Ptr ListStore)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
store
g_list_store_remove_all store'
touchManagedPtr store
return ()
#if defined(ENABLE_OVERLOADING)
data ListStoreRemoveAllMethodInfo
instance (signature ~ (m ()), MonadIO m, IsListStore a) => O.OverloadedMethod ListStoreRemoveAllMethodInfo a signature where
overloadedMethod = listStoreRemoveAll
instance O.OverloadedMethodInfo ListStoreRemoveAllMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Objects.ListStore.listStoreRemoveAll",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.35/docs/GI-Gio-Objects-ListStore.html#v:listStoreRemoveAll"
})
#endif
foreign import ccall "g_list_store_sort" g_list_store_sort ::
Ptr ListStore ->
FunPtr GLib.Callbacks.C_CompareDataFunc ->
Ptr () ->
IO ()
listStoreSort ::
(B.CallStack.HasCallStack, MonadIO m, IsListStore a) =>
a
-> GLib.Callbacks.CompareDataFunc
-> m ()
listStoreSort :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsListStore a) =>
a -> CompareDataFunc -> m ()
listStoreSort a
store CompareDataFunc
compareFunc = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
store' <- a -> IO (Ptr ListStore)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
store
compareFunc' <- GLib.Callbacks.mk_CompareDataFunc (GLib.Callbacks.wrap_CompareDataFunc Nothing (GLib.Callbacks.drop_closures_CompareDataFunc compareFunc))
let userData = Ptr a
forall a. Ptr a
nullPtr
g_list_store_sort store' compareFunc' userData
safeFreeFunPtr $ castFunPtrToPtr compareFunc'
touchManagedPtr store
return ()
#if defined(ENABLE_OVERLOADING)
data ListStoreSortMethodInfo
instance (signature ~ (GLib.Callbacks.CompareDataFunc -> m ()), MonadIO m, IsListStore a) => O.OverloadedMethod ListStoreSortMethodInfo a signature where
overloadedMethod = listStoreSort
instance O.OverloadedMethodInfo ListStoreSortMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Objects.ListStore.listStoreSort",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.35/docs/GI-Gio-Objects-ListStore.html#v:listStoreSort"
})
#endif
foreign import ccall "g_list_store_splice" g_list_store_splice ::
Ptr ListStore ->
Word32 ->
Word32 ->
Ptr (Ptr GObject.Object.Object) ->
Word32 ->
IO ()
listStoreSplice ::
(B.CallStack.HasCallStack, MonadIO m, IsListStore a) =>
a
-> Word32
-> Word32
-> [GObject.Object.Object]
-> m ()
listStoreSplice :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsListStore a) =>
a -> Word32 -> Word32 -> [Object] -> m ()
listStoreSplice a
store Word32
position Word32
nRemovals [Object]
additions = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
let nAdditions :: Word32
nAdditions = Int -> Word32
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> Word32) -> Int -> Word32
forall a b. (a -> b) -> a -> b
$ [Object] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
P.length [Object]
additions
store' <- a -> IO (Ptr ListStore)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
store
additions' <- mapM unsafeManagedPtrCastPtr additions
additions'' <- packPtrArray additions'
g_list_store_splice store' position nRemovals additions'' nAdditions
touchManagedPtr store
mapM_ touchManagedPtr additions
freeMem additions''
return ()
#if defined(ENABLE_OVERLOADING)
data ListStoreSpliceMethodInfo
instance (signature ~ (Word32 -> Word32 -> [GObject.Object.Object] -> m ()), MonadIO m, IsListStore a) => O.OverloadedMethod ListStoreSpliceMethodInfo a signature where
overloadedMethod = listStoreSplice
instance O.OverloadedMethodInfo ListStoreSpliceMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Objects.ListStore.listStoreSplice",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.35/docs/GI-Gio-Objects-ListStore.html#v:listStoreSplice"
})
#endif