{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- The t'GI.Clutter.Objects.ListModel.ListModel' struct contains only private data.
-- 
-- /Since: 0.6/

#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif

module GI.Clutter.Objects.ListModel
    ( 

-- * Exported types
    ListModel(..)                           ,
    IsListModel                             ,
    toListModel                             ,


 -- * Methods
-- | 
-- 
--  === __Click to display all available methods, including inherited ones__
-- ==== Methods
-- [appendv]("GI.Clutter.Objects.Model#g:method:appendv"), [bindProperty]("GI.GObject.Objects.Object#g:method:bindProperty"), [bindPropertyFull]("GI.GObject.Objects.Object#g:method:bindPropertyFull"), [filterIter]("GI.Clutter.Objects.Model#g:method:filterIter"), [filterRow]("GI.Clutter.Objects.Model#g:method:filterRow"), [forceFloating]("GI.GObject.Objects.Object#g:method:forceFloating"), [foreach]("GI.Clutter.Objects.Model#g:method:foreach"), [freezeNotify]("GI.GObject.Objects.Object#g:method:freezeNotify"), [getv]("GI.GObject.Objects.Object#g:method:getv"), [insertValue]("GI.Clutter.Objects.Model#g:method:insertValue"), [insertv]("GI.Clutter.Objects.Model#g:method:insertv"), [isFloating]("GI.GObject.Objects.Object#g:method:isFloating"), [notify]("GI.GObject.Objects.Object#g:method:notify"), [notifyByPspec]("GI.GObject.Objects.Object#g:method:notifyByPspec"), [parseCustomNode]("GI.Clutter.Interfaces.Scriptable#g:method:parseCustomNode"), [prependv]("GI.Clutter.Objects.Model#g:method:prependv"), [ref]("GI.GObject.Objects.Object#g:method:ref"), [refSink]("GI.GObject.Objects.Object#g:method:refSink"), [remove]("GI.Clutter.Objects.Model#g:method:remove"), [resort]("GI.Clutter.Objects.Model#g:method:resort"), [runDispose]("GI.GObject.Objects.Object#g:method:runDispose"), [stealData]("GI.GObject.Objects.Object#g:method:stealData"), [stealQdata]("GI.GObject.Objects.Object#g:method:stealQdata"), [thawNotify]("GI.GObject.Objects.Object#g:method:thawNotify"), [unref]("GI.GObject.Objects.Object#g:method:unref"), [watchClosure]("GI.GObject.Objects.Object#g:method:watchClosure").
-- 
-- ==== Getters
-- [getColumnName]("GI.Clutter.Objects.Model#g:method:getColumnName"), [getColumnType]("GI.Clutter.Objects.Model#g:method:getColumnType"), [getData]("GI.GObject.Objects.Object#g:method:getData"), [getFilterSet]("GI.Clutter.Objects.Model#g:method:getFilterSet"), [getFirstIter]("GI.Clutter.Objects.Model#g:method:getFirstIter"), [getId]("GI.Clutter.Interfaces.Scriptable#g:method:getId"), [getIterAtRow]("GI.Clutter.Objects.Model#g:method:getIterAtRow"), [getLastIter]("GI.Clutter.Objects.Model#g:method:getLastIter"), [getNColumns]("GI.Clutter.Objects.Model#g:method:getNColumns"), [getNRows]("GI.Clutter.Objects.Model#g:method:getNRows"), [getProperty]("GI.GObject.Objects.Object#g:method:getProperty"), [getQdata]("GI.GObject.Objects.Object#g:method:getQdata"), [getSortingColumn]("GI.Clutter.Objects.Model#g:method:getSortingColumn").
-- 
-- ==== Setters
-- [setCustomProperty]("GI.Clutter.Interfaces.Scriptable#g:method:setCustomProperty"), [setData]("GI.GObject.Objects.Object#g:method:setData"), [setDataFull]("GI.GObject.Objects.Object#g:method:setDataFull"), [setFilter]("GI.Clutter.Objects.Model#g:method:setFilter"), [setId]("GI.Clutter.Interfaces.Scriptable#g:method:setId"), [setNames]("GI.Clutter.Objects.Model#g:method:setNames"), [setProperty]("GI.GObject.Objects.Object#g:method:setProperty"), [setSort]("GI.Clutter.Objects.Model#g:method:setSort"), [setSortingColumn]("GI.Clutter.Objects.Model#g:method:setSortingColumn"), [setTypes]("GI.Clutter.Objects.Model#g:method:setTypes").

#if defined(ENABLE_OVERLOADING)
    ResolveListModelMethod                  ,
#endif

-- ** newv #method:newv#

    listModelNewv                           ,




    ) where

import Data.GI.Base.ShortPrelude
import qualified Data.GI.Base.ShortPrelude as SP
import qualified Data.GI.Base.Overloading as O
import qualified Prelude as P

import qualified Data.GI.Base.Attributes as GI.Attributes
import qualified Data.GI.Base.BasicTypes as B.Types
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GArray as B.GArray
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.GI.Base.Signals as B.Signals
import qualified Control.Monad.IO.Class as MIO
import qualified Data.Coerce as Coerce
import qualified Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL
import qualified GHC.Records as R

import {-# SOURCE #-} qualified GI.Clutter.Interfaces.Scriptable as Clutter.Scriptable
import {-# SOURCE #-} qualified GI.Clutter.Objects.Model as Clutter.Model
import qualified GI.GObject.Objects.Object as GObject.Object

-- | Memory-managed wrapper type.
newtype ListModel = ListModel (SP.ManagedPtr ListModel)
    deriving (ListModel -> ListModel -> Bool
(ListModel -> ListModel -> Bool)
-> (ListModel -> ListModel -> Bool) -> Eq ListModel
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ListModel -> ListModel -> Bool
$c/= :: ListModel -> ListModel -> Bool
== :: ListModel -> ListModel -> Bool
$c== :: ListModel -> ListModel -> Bool
Eq)

instance SP.ManagedPtrNewtype ListModel where
    toManagedPtr :: ListModel -> ManagedPtr ListModel
toManagedPtr (ListModel ManagedPtr ListModel
p) = ManagedPtr ListModel
p

foreign import ccall "clutter_list_model_get_type"
    c_clutter_list_model_get_type :: IO B.Types.GType

instance B.Types.TypedObject ListModel where
    glibType :: IO GType
glibType = IO GType
c_clutter_list_model_get_type

instance B.Types.GObject ListModel

-- | Type class for types which can be safely cast to `ListModel`, for instance with `toListModel`.
class (SP.GObject o, O.IsDescendantOf ListModel o) => IsListModel o
instance (SP.GObject o, O.IsDescendantOf ListModel o) => IsListModel o

instance O.HasParentTypes ListModel
type instance O.ParentTypes ListModel = '[Clutter.Model.Model, GObject.Object.Object, Clutter.Scriptable.Scriptable]

-- | Cast to `ListModel`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`.
toListModel :: (MIO.MonadIO m, IsListModel o) => o -> m ListModel
toListModel :: forall (m :: * -> *) o.
(MonadIO m, IsListModel o) =>
o -> m ListModel
toListModel = IO ListModel -> m ListModel
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO ListModel -> m ListModel)
-> (o -> IO ListModel) -> o -> m ListModel
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ManagedPtr ListModel -> ListModel) -> o -> IO ListModel
forall o o'.
(HasCallStack, ManagedPtrNewtype o, TypedObject o,
 ManagedPtrNewtype o', TypedObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
B.ManagedPtr.unsafeCastTo ManagedPtr ListModel -> ListModel
ListModel

-- | Convert 'ListModel' to and from 'Data.GI.Base.GValue.GValue'. See 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'.
instance B.GValue.IsGValue (Maybe ListModel) where
    gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_clutter_list_model_get_type
    gvalueSet_ :: Ptr GValue -> Maybe ListModel -> IO ()
gvalueSet_ Ptr GValue
gv Maybe ListModel
P.Nothing = Ptr GValue -> Ptr ListModel -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv (Ptr ListModel
forall a. Ptr a
FP.nullPtr :: FP.Ptr ListModel)
    gvalueSet_ Ptr GValue
gv (P.Just ListModel
obj) = ListModel -> (Ptr ListModel -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr ListModel
obj (Ptr GValue -> Ptr ListModel -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv)
    gvalueGet_ :: Ptr GValue -> IO (Maybe ListModel)
gvalueGet_ Ptr GValue
gv = do
        Ptr ListModel
ptr <- Ptr GValue -> IO (Ptr ListModel)
forall a. GObject a => Ptr GValue -> IO (Ptr a)
B.GValue.get_object Ptr GValue
gv :: IO (FP.Ptr ListModel)
        if Ptr ListModel
ptr Ptr ListModel -> Ptr ListModel -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr ListModel
forall a. Ptr a
FP.nullPtr
        then ListModel -> Maybe ListModel
forall a. a -> Maybe a
P.Just (ListModel -> Maybe ListModel)
-> IO ListModel -> IO (Maybe ListModel)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ManagedPtr ListModel -> ListModel)
-> Ptr ListModel -> IO ListModel
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr ListModel -> ListModel
ListModel Ptr ListModel
ptr
        else Maybe ListModel -> IO (Maybe ListModel)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe ListModel
forall a. Maybe a
P.Nothing
        
    

#if defined(ENABLE_OVERLOADING)
type family ResolveListModelMethod (t :: Symbol) (o :: *) :: * where
    ResolveListModelMethod "appendv" o = Clutter.Model.ModelAppendvMethodInfo
    ResolveListModelMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveListModelMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveListModelMethod "filterIter" o = Clutter.Model.ModelFilterIterMethodInfo
    ResolveListModelMethod "filterRow" o = Clutter.Model.ModelFilterRowMethodInfo
    ResolveListModelMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveListModelMethod "foreach" o = Clutter.Model.ModelForeachMethodInfo
    ResolveListModelMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveListModelMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
    ResolveListModelMethod "insertValue" o = Clutter.Model.ModelInsertValueMethodInfo
    ResolveListModelMethod "insertv" o = Clutter.Model.ModelInsertvMethodInfo
    ResolveListModelMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveListModelMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveListModelMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveListModelMethod "parseCustomNode" o = Clutter.Scriptable.ScriptableParseCustomNodeMethodInfo
    ResolveListModelMethod "prependv" o = Clutter.Model.ModelPrependvMethodInfo
    ResolveListModelMethod "ref" o = GObject.Object.ObjectRefMethodInfo
    ResolveListModelMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveListModelMethod "remove" o = Clutter.Model.ModelRemoveMethodInfo
    ResolveListModelMethod "resort" o = Clutter.Model.ModelResortMethodInfo
    ResolveListModelMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveListModelMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveListModelMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveListModelMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveListModelMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
    ResolveListModelMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveListModelMethod "getColumnName" o = Clutter.Model.ModelGetColumnNameMethodInfo
    ResolveListModelMethod "getColumnType" o = Clutter.Model.ModelGetColumnTypeMethodInfo
    ResolveListModelMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveListModelMethod "getFilterSet" o = Clutter.Model.ModelGetFilterSetMethodInfo
    ResolveListModelMethod "getFirstIter" o = Clutter.Model.ModelGetFirstIterMethodInfo
    ResolveListModelMethod "getId" o = Clutter.Scriptable.ScriptableGetIdMethodInfo
    ResolveListModelMethod "getIterAtRow" o = Clutter.Model.ModelGetIterAtRowMethodInfo
    ResolveListModelMethod "getLastIter" o = Clutter.Model.ModelGetLastIterMethodInfo
    ResolveListModelMethod "getNColumns" o = Clutter.Model.ModelGetNColumnsMethodInfo
    ResolveListModelMethod "getNRows" o = Clutter.Model.ModelGetNRowsMethodInfo
    ResolveListModelMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveListModelMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveListModelMethod "getSortingColumn" o = Clutter.Model.ModelGetSortingColumnMethodInfo
    ResolveListModelMethod "setCustomProperty" o = Clutter.Scriptable.ScriptableSetCustomPropertyMethodInfo
    ResolveListModelMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveListModelMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
    ResolveListModelMethod "setFilter" o = Clutter.Model.ModelSetFilterMethodInfo
    ResolveListModelMethod "setId" o = Clutter.Scriptable.ScriptableSetIdMethodInfo
    ResolveListModelMethod "setNames" o = Clutter.Model.ModelSetNamesMethodInfo
    ResolveListModelMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveListModelMethod "setSort" o = Clutter.Model.ModelSetSortMethodInfo
    ResolveListModelMethod "setSortingColumn" o = Clutter.Model.ModelSetSortingColumnMethodInfo
    ResolveListModelMethod "setTypes" o = Clutter.Model.ModelSetTypesMethodInfo
    ResolveListModelMethod l o = O.MethodResolutionFailed l o

instance (info ~ ResolveListModelMethod t ListModel, O.OverloadedMethod info ListModel p) => OL.IsLabel t (ListModel -> 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 ~ ResolveListModelMethod t ListModel, O.OverloadedMethod info ListModel p, R.HasField t ListModel p) => R.HasField t ListModel p where
    getField = O.overloadedMethod @info

#endif

instance (info ~ ResolveListModelMethod t ListModel, O.OverloadedMethodInfo info ListModel) => OL.IsLabel t (O.MethodProxy info ListModel) where
#if MIN_VERSION_base(4,10,0)
    fromLabel = O.MethodProxy
#else
    fromLabel _ = O.MethodProxy
#endif

#endif

#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList ListModel
type instance O.AttributeList ListModel = ListModelAttributeList
type ListModelAttributeList = ('[ '("filterSet", Clutter.Model.ModelFilterSetPropertyInfo)] :: [(Symbol, *)])
#endif

#if defined(ENABLE_OVERLOADING)
#endif

#if defined(ENABLE_OVERLOADING)
type instance O.SignalList ListModel = ListModelSignalList
type ListModelSignalList = ('[ '("filterChanged", Clutter.Model.ModelFilterChangedSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("rowAdded", Clutter.Model.ModelRowAddedSignalInfo), '("rowChanged", Clutter.Model.ModelRowChangedSignalInfo), '("rowRemoved", Clutter.Model.ModelRowRemovedSignalInfo), '("sortChanged", Clutter.Model.ModelSortChangedSignalInfo)] :: [(Symbol, *)])

#endif

-- method ListModel::newv
-- method type : Constructor
-- Args: [ Arg
--           { argCName = "n_columns"
--           , argType = TBasicType TUInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "number of columns in the model"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "types"
--           , argType = TCArray False (-1) 0 (TBasicType TGType)
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "an array of #GType types for the columns, from first to last"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "names"
--           , argType = TCArray False (-1) 0 (TBasicType TUTF8)
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "an array of names for the columns, from first to last"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: [ Arg
--              { argCName = "n_columns"
--              , argType = TBasicType TUInt
--              , direction = DirectionIn
--              , mayBeNull = False
--              , argDoc =
--                  Documentation
--                    { rawDocText = Just "number of columns in the model"
--                    , sinceVersion = Nothing
--                    }
--              , argScope = ScopeTypeInvalid
--              , argClosure = -1
--              , argDestroy = -1
--              , argCallerAllocates = False
--              , transfer = TransferNothing
--              }
--          , Arg
--              { argCName = "n_columns"
--              , argType = TBasicType TUInt
--              , direction = DirectionIn
--              , mayBeNull = False
--              , argDoc =
--                  Documentation
--                    { rawDocText = Just "number of columns in the model"
--                    , sinceVersion = Nothing
--                    }
--              , argScope = ScopeTypeInvalid
--              , argClosure = -1
--              , argDestroy = -1
--              , argCallerAllocates = False
--              , transfer = TransferNothing
--              }
--          ]
-- returnType: Just
--               (TInterface Name { namespace = "Clutter" , name = "ListModel" })
-- throws : False
-- Skip return : False

foreign import ccall "clutter_list_model_newv" clutter_list_model_newv :: 
    Word32 ->                               -- n_columns : TBasicType TUInt
    Ptr CGType ->                           -- types : TCArray False (-1) 0 (TBasicType TGType)
    Ptr CString ->                          -- names : TCArray False (-1) 0 (TBasicType TUTF8)
    IO (Ptr ListModel)

{-# DEPRECATED listModelNewv ["(Since version 1.24)","Use t'GI.Gio.Objects.ListStore.ListStore' instead"] #-}
-- | Non-vararg version of @/clutter_list_model_new()/@. This function is
-- useful for language bindings.
-- 
-- /Since: 0.6/
listModelNewv ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    [GType]
    -- ^ /@types@/: an array of t'GType' types for the columns, from first to last
    -> [T.Text]
    -- ^ /@names@/: an array of names for the columns, from first to last
    -> m ListModel
    -- ^ __Returns:__ a new default t'GI.Clutter.Objects.Model.Model'
listModelNewv :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
[GType] -> [Text] -> m ListModel
listModelNewv [GType]
types [Text]
names = IO ListModel -> m ListModel
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO ListModel -> m ListModel) -> IO ListModel -> m ListModel
forall a b. (a -> b) -> a -> b
$ do
    let nColumns :: Word32
nColumns = Int -> Word32
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> Word32) -> Int -> Word32
forall a b. (a -> b) -> a -> b
$ [Text] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
P.length [Text]
names
    let types_expected_length_ :: Word32
types_expected_length_ = Int -> Word32
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> Word32) -> Int -> Word32
forall a b. (a -> b) -> a -> b
$ [GType] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
P.length [GType]
types
    Bool -> IO () -> IO ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (Word32
types_expected_length_ Word32 -> Word32 -> Bool
forall a. Eq a => a -> a -> Bool
/= Word32
nColumns) (IO () -> IO ()) -> IO () -> IO ()
forall a b. (a -> b) -> a -> b
$
        [Char] -> IO ()
forall a. HasCallStack => [Char] -> a
error [Char]
"Clutter.listModelNewv : length of 'types' does not agree with that of 'names'."
    Ptr CGType
types' <- ((GType -> CGType) -> [GType] -> IO (Ptr CGType)
forall a b. Storable b => (a -> b) -> [a] -> IO (Ptr b)
packMapStorableArray GType -> CGType
gtypeToCGType) [GType]
types
    Ptr (Ptr CChar)
names' <- [Text] -> IO (Ptr (Ptr CChar))
packUTF8CArray [Text]
names
    Ptr ListModel
result <- Word32 -> Ptr CGType -> Ptr (Ptr CChar) -> IO (Ptr ListModel)
clutter_list_model_newv Word32
nColumns Ptr CGType
types' Ptr (Ptr CChar)
names'
    Text -> Ptr ListModel -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"listModelNewv" Ptr ListModel
result
    ListModel
result' <- ((ManagedPtr ListModel -> ListModel)
-> Ptr ListModel -> IO ListModel
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr ListModel -> ListModel
ListModel) Ptr ListModel
result
    Ptr CGType -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CGType
types'
    (Word32 -> (Ptr CChar -> IO ()) -> Ptr (Ptr CChar) -> IO ()
forall a b c.
(Storable a, Integral b) =>
b -> (a -> IO c) -> Ptr a -> IO ()
mapCArrayWithLength Word32
nColumns) Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr CChar)
names'
    Ptr (Ptr CChar) -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr CChar)
names'
    ListModel -> IO ListModel
forall (m :: * -> *) a. Monad m => a -> m a
return ListModel
result'

#if defined(ENABLE_OVERLOADING)
#endif