ListStore.hs


{- |
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 <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> 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