{- | Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte License : LGPL-2.1 Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) 'GI.Gio.Objects.ListStore.ListStore' is a simple implementation of 'GI.Gio.Interfaces.ListModel.ListModel' that stores all items in memory. It provides insertions, deletions, and lookups in logarithmic time with a fast path for the common case of iterating the list linearly. -} #define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ && !defined(__HADDOCK_VERSION__)) module GI.Gio.Objects.ListStore ( -- * Exported types ListStore(..) , IsListStore , toListStore , noListStore , -- * Methods -- ** append #method:append# #if ENABLE_OVERLOADING ListStoreAppendMethodInfo , #endif listStoreAppend , -- ** insert #method:insert# #if ENABLE_OVERLOADING ListStoreInsertMethodInfo , #endif listStoreInsert , -- ** insertSorted #method:insertSorted# #if ENABLE_OVERLOADING ListStoreInsertSortedMethodInfo , #endif listStoreInsertSorted , -- ** new #method:new# listStoreNew , -- ** remove #method:remove# #if ENABLE_OVERLOADING ListStoreRemoveMethodInfo , #endif listStoreRemove , -- ** removeAll #method:removeAll# #if ENABLE_OVERLOADING ListStoreRemoveAllMethodInfo , #endif listStoreRemoveAll , -- ** sort #method:sort# #if ENABLE_OVERLOADING ListStoreSortMethodInfo , #endif listStoreSort , -- ** splice #method:splice# #if ENABLE_OVERLOADING ListStoreSpliceMethodInfo , #endif listStoreSplice , -- * Properties -- ** itemType #attr:itemType# {- | The type of items contained in this list store. Items must be subclasses of 'GI.GObject.Objects.Object.Object'. /Since: 2.44/ -} #if ENABLE_OVERLOADING ListStoreItemTypePropertyInfo , #endif constructListStoreItemType , getListStoreItemType , #if ENABLE_OVERLOADING listStoreItemType , #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.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 {-# SOURCE #-} qualified GI.Gio.Interfaces.ListModel as Gio.ListModel -- | Memory-managed wrapper type. newtype ListStore = ListStore (ManagedPtr ListStore) foreign import ccall "g_list_store_get_type" c_g_list_store_get_type :: IO GType instance GObject ListStore where gobjectType = c_g_list_store_get_type -- | Type class for types which can be safely cast to `ListStore`, for instance with `toListStore`. class (GObject o, O.IsDescendantOf ListStore o) => IsListStore o instance (GObject o, O.IsDescendantOf ListStore o) => IsListStore o instance O.HasParentTypes ListStore type instance O.ParentTypes ListStore = '[GObject.Object.Object, Gio.ListModel.ListModel] -- | Cast to `ListStore`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. toListStore :: (MonadIO m, IsListStore o) => o -> m ListStore toListStore = liftIO . unsafeCastTo ListStore -- | A convenience alias for `Nothing` :: `Maybe` `ListStore`. noListStore :: Maybe ListStore noListStore = Nothing #if ENABLE_OVERLOADING type family ResolveListStoreMethod (t :: Symbol) (o :: *) :: * where ResolveListStoreMethod "append" o = ListStoreAppendMethodInfo ResolveListStoreMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo ResolveListStoreMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo 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 "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo ResolveListStoreMethod l o = O.MethodResolutionFailed l o instance (info ~ ResolveListStoreMethod t ListStore, O.MethodInfo info ListStore p) => OL.IsLabel t (ListStore -> p) where #if MIN_VERSION_base(4,10,0) fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) #else fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) #endif #endif -- VVV Prop "item-type" -- Type: TBasicType TGType -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly] -- Nullable: (Nothing,Nothing) {- | Get the value of the “@item-type@” property. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.get' listStore #itemType @ -} getListStoreItemType :: (MonadIO m, IsListStore o) => o -> m GType getListStoreItemType obj = liftIO $ B.Properties.getObjectPropertyGType obj "item-type" {- | Construct a `GValueConstruct` with valid value for the “@item-type@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. -} constructListStoreItemType :: (IsListStore o) => GType -> IO (GValueConstruct o) constructListStoreItemType val = B.Properties.constructObjectPropertyGType "item-type" val #if ENABLE_OVERLOADING data ListStoreItemTypePropertyInfo instance AttrInfo ListStoreItemTypePropertyInfo where type AttrAllowedOps ListStoreItemTypePropertyInfo = '[ 'AttrConstruct, 'AttrGet] type AttrSetTypeConstraint ListStoreItemTypePropertyInfo = (~) GType type AttrBaseTypeConstraint ListStoreItemTypePropertyInfo = IsListStore type AttrGetType ListStoreItemTypePropertyInfo = GType type AttrLabel ListStoreItemTypePropertyInfo = "item-type" type AttrOrigin ListStoreItemTypePropertyInfo = ListStore attrGet _ = getListStoreItemType attrSet _ = undefined attrConstruct _ = constructListStoreItemType attrClear _ = undefined #endif #if ENABLE_OVERLOADING instance O.HasAttributeList ListStore type instance O.AttributeList ListStore = ListStoreAttributeList type ListStoreAttributeList = ('[ '("itemType", ListStoreItemTypePropertyInfo)] :: [(Symbol, *)]) #endif #if ENABLE_OVERLOADING listStoreItemType :: AttrLabelProxy "itemType" listStoreItemType = AttrLabelProxy #endif #if ENABLE_OVERLOADING type instance O.SignalList ListStore = ListStoreSignalList type ListStoreSignalList = ('[ '("itemsChanged", Gio.ListModel.ListModelItemsChangedSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)]) #endif -- method ListStore::new -- method type : Constructor -- Args : [Arg {argCName = "item_type", argType = TBasicType TGType, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GType of items in the list", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TInterface (Name {namespace = "Gio", name = "ListStore"})) -- throws : False -- Skip return : False foreign import ccall "g_list_store_new" g_list_store_new :: CGType -> -- item_type : TBasicType TGType IO (Ptr ListStore) {- | Creates a new 'GI.Gio.Objects.ListStore.ListStore' with items of type /@itemType@/. /@itemType@/ must be a subclass of 'GI.GObject.Objects.Object.Object'. /Since: 2.44/ -} listStoreNew :: (B.CallStack.HasCallStack, MonadIO m) => GType {- ^ /@itemType@/: the 'GType' of items in the list -} -> m ListStore {- ^ __Returns:__ a new 'GI.Gio.Objects.ListStore.ListStore' -} listStoreNew itemType = liftIO $ do let itemType' = gtypeToCGType itemType result <- g_list_store_new itemType' checkUnexpectedReturnNULL "listStoreNew" result result' <- (wrapObject ListStore) result return result' #if ENABLE_OVERLOADING #endif -- method ListStore::append -- method type : OrdinaryMethod -- Args : [Arg {argCName = "store", argType = TInterface (Name {namespace = "Gio", name = "ListStore"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GListStore", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "item", argType = TInterface (Name {namespace = "GObject", name = "Object"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the new item", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Nothing -- throws : False -- Skip return : False foreign import ccall "g_list_store_append" g_list_store_append :: Ptr ListStore -> -- store : TInterface (Name {namespace = "Gio", name = "ListStore"}) Ptr GObject.Object.Object -> -- item : TInterface (Name {namespace = "GObject", name = "Object"}) IO () {- | Appends /@item@/ to /@store@/. /@item@/ must be of type 'GI.Gio.Objects.ListStore.ListStore':@/item-type/@. This function takes a ref on /@item@/. Use 'GI.Gio.Objects.ListStore.listStoreSplice' to append multiple items at the same time efficiently. /Since: 2.44/ -} listStoreAppend :: (B.CallStack.HasCallStack, MonadIO m, IsListStore a, GObject.Object.IsObject b) => a {- ^ /@store@/: a 'GI.Gio.Objects.ListStore.ListStore' -} -> b {- ^ /@item@/: the new item -} -> m () listStoreAppend store item = liftIO $ do store' <- unsafeManagedPtrCastPtr store item' <- unsafeManagedPtrCastPtr item g_list_store_append store' item' touchManagedPtr store touchManagedPtr item return () #if ENABLE_OVERLOADING data ListStoreAppendMethodInfo instance (signature ~ (b -> m ()), MonadIO m, IsListStore a, GObject.Object.IsObject b) => O.MethodInfo ListStoreAppendMethodInfo a signature where overloadedMethod _ = listStoreAppend #endif -- method ListStore::insert -- method type : OrdinaryMethod -- Args : [Arg {argCName = "store", argType = TInterface (Name {namespace = "Gio", name = "ListStore"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GListStore", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "position", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the position at which to insert the new item", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "item", argType = TInterface (Name {namespace = "GObject", name = "Object"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the new item", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Nothing -- throws : False -- Skip return : False foreign import ccall "g_list_store_insert" g_list_store_insert :: Ptr ListStore -> -- store : TInterface (Name {namespace = "Gio", name = "ListStore"}) Word32 -> -- position : TBasicType TUInt Ptr GObject.Object.Object -> -- item : TInterface (Name {namespace = "GObject", name = "Object"}) IO () {- | Inserts /@item@/ into /@store@/ at /@position@/. /@item@/ must be of type 'GI.Gio.Objects.ListStore.ListStore':@/item-type/@ or derived from it. /@position@/ must be smaller than the length of the list, or equal to it to append. This function takes a ref on /@item@/. Use 'GI.Gio.Objects.ListStore.listStoreSplice' to insert multiple items at the same time efficiently. /Since: 2.44/ -} listStoreInsert :: (B.CallStack.HasCallStack, MonadIO m, IsListStore a, GObject.Object.IsObject b) => a {- ^ /@store@/: a 'GI.Gio.Objects.ListStore.ListStore' -} -> Word32 {- ^ /@position@/: the position at which to insert the new item -} -> b {- ^ /@item@/: the new item -} -> m () listStoreInsert store position item = liftIO $ do store' <- unsafeManagedPtrCastPtr store item' <- unsafeManagedPtrCastPtr item g_list_store_insert store' position item' touchManagedPtr store touchManagedPtr item return () #if ENABLE_OVERLOADING data ListStoreInsertMethodInfo instance (signature ~ (Word32 -> b -> m ()), MonadIO m, IsListStore a, GObject.Object.IsObject b) => O.MethodInfo ListStoreInsertMethodInfo a signature where overloadedMethod _ = listStoreInsert #endif -- method ListStore::insert_sorted -- method type : OrdinaryMethod -- Args : [Arg {argCName = "store", argType = TInterface (Name {namespace = "Gio", name = "ListStore"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GListStore", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "item", argType = TInterface (Name {namespace = "GObject", name = "Object"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the new item", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "compare_func", argType = TInterface (Name {namespace = "GLib", name = "CompareDataFunc"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "pairwise comparison function for sorting", sinceVersion = Nothing}, argScope = ScopeTypeCall, argClosure = 3, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "user data for @compare_func", 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 "g_list_store_insert_sorted" g_list_store_insert_sorted :: Ptr ListStore -> -- store : TInterface (Name {namespace = "Gio", name = "ListStore"}) Ptr GObject.Object.Object -> -- item : TInterface (Name {namespace = "GObject", name = "Object"}) FunPtr GLib.Callbacks.C_CompareDataFunc -> -- compare_func : TInterface (Name {namespace = "GLib", name = "CompareDataFunc"}) Ptr () -> -- user_data : TBasicType TPtr IO Word32 {- | Inserts /@item@/ into /@store@/ at a position to be determined by the /@compareFunc@/. The list must already be sorted before calling this function or the result is undefined. Usually you would approach this by only ever inserting items by way of this function. This function takes a ref on /@item@/. /Since: 2.44/ -} listStoreInsertSorted :: (B.CallStack.HasCallStack, MonadIO m, IsListStore a, GObject.Object.IsObject b) => a {- ^ /@store@/: a 'GI.Gio.Objects.ListStore.ListStore' -} -> b {- ^ /@item@/: the new item -} -> GLib.Callbacks.CompareDataFunc {- ^ /@compareFunc@/: pairwise comparison function for sorting -} -> m Word32 {- ^ __Returns:__ the position at which /@item@/ was inserted -} listStoreInsertSorted store item compareFunc = liftIO $ do store' <- unsafeManagedPtrCastPtr store item' <- unsafeManagedPtrCastPtr item compareFunc' <- GLib.Callbacks.mk_CompareDataFunc (GLib.Callbacks.wrap_CompareDataFunc Nothing (GLib.Callbacks.drop_closures_CompareDataFunc compareFunc)) let userData = nullPtr result <- g_list_store_insert_sorted store' item' compareFunc' userData safeFreeFunPtr $ castFunPtrToPtr compareFunc' touchManagedPtr store touchManagedPtr item return result #if ENABLE_OVERLOADING data ListStoreInsertSortedMethodInfo instance (signature ~ (b -> GLib.Callbacks.CompareDataFunc -> m Word32), MonadIO m, IsListStore a, GObject.Object.IsObject b) => O.MethodInfo ListStoreInsertSortedMethodInfo a signature where overloadedMethod _ = listStoreInsertSorted #endif -- method ListStore::remove -- method type : OrdinaryMethod -- Args : [Arg {argCName = "store", argType = TInterface (Name {namespace = "Gio", name = "ListStore"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GListStore", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "position", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the position of the item that is to be removed", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Nothing -- throws : False -- Skip return : False foreign import ccall "g_list_store_remove" g_list_store_remove :: Ptr ListStore -> -- store : TInterface (Name {namespace = "Gio", name = "ListStore"}) Word32 -> -- position : TBasicType TUInt IO () {- | Removes the item from /@store@/ that is at /@position@/. /@position@/ must be smaller than the current length of the list. Use 'GI.Gio.Objects.ListStore.listStoreSplice' to remove multiple items at the same time efficiently. /Since: 2.44/ -} listStoreRemove :: (B.CallStack.HasCallStack, MonadIO m, IsListStore a) => a {- ^ /@store@/: a 'GI.Gio.Objects.ListStore.ListStore' -} -> Word32 {- ^ /@position@/: the position of the item that is to be removed -} -> m () listStoreRemove store position = liftIO $ do store' <- unsafeManagedPtrCastPtr store g_list_store_remove store' position touchManagedPtr store return () #if ENABLE_OVERLOADING data ListStoreRemoveMethodInfo instance (signature ~ (Word32 -> m ()), MonadIO m, IsListStore a) => O.MethodInfo ListStoreRemoveMethodInfo a signature where overloadedMethod _ = listStoreRemove #endif -- method ListStore::remove_all -- method type : OrdinaryMethod -- Args : [Arg {argCName = "store", argType = TInterface (Name {namespace = "Gio", name = "ListStore"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GListStore", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Nothing -- throws : False -- Skip return : False foreign import ccall "g_list_store_remove_all" g_list_store_remove_all :: Ptr ListStore -> -- store : TInterface (Name {namespace = "Gio", name = "ListStore"}) IO () {- | Removes all items from /@store@/. /Since: 2.44/ -} listStoreRemoveAll :: (B.CallStack.HasCallStack, MonadIO m, IsListStore a) => a {- ^ /@store@/: a 'GI.Gio.Objects.ListStore.ListStore' -} -> m () listStoreRemoveAll store = liftIO $ do store' <- unsafeManagedPtrCastPtr store g_list_store_remove_all store' touchManagedPtr store return () #if ENABLE_OVERLOADING data ListStoreRemoveAllMethodInfo instance (signature ~ (m ()), MonadIO m, IsListStore a) => O.MethodInfo ListStoreRemoveAllMethodInfo a signature where overloadedMethod _ = listStoreRemoveAll #endif -- method ListStore::sort -- method type : OrdinaryMethod -- Args : [Arg {argCName = "store", argType = TInterface (Name {namespace = "Gio", name = "ListStore"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GListStore", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "compare_func", argType = TInterface (Name {namespace = "GLib", name = "CompareDataFunc"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "pairwise comparison function for sorting", sinceVersion = Nothing}, argScope = ScopeTypeCall, argClosure = 2, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "user data for @compare_func", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Nothing -- throws : False -- Skip return : False foreign import ccall "g_list_store_sort" g_list_store_sort :: Ptr ListStore -> -- store : TInterface (Name {namespace = "Gio", name = "ListStore"}) FunPtr GLib.Callbacks.C_CompareDataFunc -> -- compare_func : TInterface (Name {namespace = "GLib", name = "CompareDataFunc"}) Ptr () -> -- user_data : TBasicType TPtr IO () {- | Sort the items in /@store@/ according to /@compareFunc@/. /Since: 2.46/ -} listStoreSort :: (B.CallStack.HasCallStack, MonadIO m, IsListStore a) => a {- ^ /@store@/: a 'GI.Gio.Objects.ListStore.ListStore' -} -> GLib.Callbacks.CompareDataFunc {- ^ /@compareFunc@/: pairwise comparison function for sorting -} -> m () listStoreSort store compareFunc = liftIO $ do store' <- unsafeManagedPtrCastPtr store compareFunc' <- GLib.Callbacks.mk_CompareDataFunc (GLib.Callbacks.wrap_CompareDataFunc Nothing (GLib.Callbacks.drop_closures_CompareDataFunc compareFunc)) let userData = nullPtr g_list_store_sort store' compareFunc' userData safeFreeFunPtr $ castFunPtrToPtr compareFunc' touchManagedPtr store return () #if ENABLE_OVERLOADING data ListStoreSortMethodInfo instance (signature ~ (GLib.Callbacks.CompareDataFunc -> m ()), MonadIO m, IsListStore a) => O.MethodInfo ListStoreSortMethodInfo a signature where overloadedMethod _ = listStoreSort #endif -- method ListStore::splice -- method type : OrdinaryMethod -- Args : [Arg {argCName = "store", argType = TInterface (Name {namespace = "Gio", name = "ListStore"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GListStore", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "position", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the position at which to make the change", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "n_removals", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the number of items to remove", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "additions", argType = TCArray False (-1) 4 (TInterface (Name {namespace = "GObject", name = "Object"})), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the items to add", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "n_additions", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the number of items to add", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [Arg {argCName = "n_additions", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the number of items to add", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- returnType : Nothing -- throws : False -- Skip return : False foreign import ccall "g_list_store_splice" g_list_store_splice :: Ptr ListStore -> -- store : TInterface (Name {namespace = "Gio", name = "ListStore"}) Word32 -> -- position : TBasicType TUInt Word32 -> -- n_removals : TBasicType TUInt Ptr (Ptr GObject.Object.Object) -> -- additions : TCArray False (-1) 4 (TInterface (Name {namespace = "GObject", name = "Object"})) Word32 -> -- n_additions : TBasicType TUInt IO () {- | Changes /@store@/ by removing /@nRemovals@/ items and adding /@nAdditions@/ items to it. /@additions@/ must contain /@nAdditions@/ items of type 'GI.Gio.Objects.ListStore.ListStore':@/item-type/@. 'Nothing' is not permitted. This function is more efficient than 'GI.Gio.Objects.ListStore.listStoreInsert' and 'GI.Gio.Objects.ListStore.listStoreRemove', because it only emits 'GI.Gio.Interfaces.ListModel.ListModel'::@/items-changed/@ once for the change. This function takes a ref on each item in /@additions@/. The parameters /@position@/ and /@nRemovals@/ must be correct (ie: /@position@/ + /@nRemovals@/ must be less than or equal to the length of the list at the time this function is called). /Since: 2.44/ -} listStoreSplice :: (B.CallStack.HasCallStack, MonadIO m, IsListStore a) => a {- ^ /@store@/: a 'GI.Gio.Objects.ListStore.ListStore' -} -> Word32 {- ^ /@position@/: the position at which to make the change -} -> Word32 {- ^ /@nRemovals@/: the number of items to remove -} -> [GObject.Object.Object] {- ^ /@additions@/: the items to add -} -> m () listStoreSplice store position nRemovals additions = liftIO $ do let nAdditions = fromIntegral $ length additions store' <- unsafeManagedPtrCastPtr 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 ENABLE_OVERLOADING data ListStoreSpliceMethodInfo instance (signature ~ (Word32 -> Word32 -> [GObject.Object.Object] -> m ()), MonadIO m, IsListStore a) => O.MethodInfo ListStoreSpliceMethodInfo a signature where overloadedMethod _ = listStoreSplice #endif