{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- t'GI.Gtk.Objects.FlattenListModel.FlattenListModel' is a list model that takes a list model containing
-- list models and flattens it into a single model.
-- 
-- Another term for this is concatenation: t'GI.Gtk.Objects.FlattenListModel.FlattenListModel' takes a
-- list of lists and concatenates them into a single list.

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

module GI.Gtk.Objects.FlattenListModel
    ( 

-- * Exported types
    FlattenListModel(..)                    ,
    IsFlattenListModel                      ,
    toFlattenListModel                      ,


 -- * Methods
-- ** Overloaded methods #method:Overloaded methods#

#if defined(ENABLE_OVERLOADING)
    ResolveFlattenListModelMethod           ,
#endif


-- ** getModel #method:getModel#

#if defined(ENABLE_OVERLOADING)
    FlattenListModelGetModelMethodInfo      ,
#endif
    flattenListModelGetModel                ,


-- ** getModelForItem #method:getModelForItem#

#if defined(ENABLE_OVERLOADING)
    FlattenListModelGetModelForItemMethodInfo,
#endif
    flattenListModelGetModelForItem         ,


-- ** new #method:new#

    flattenListModelNew                     ,


-- ** setModel #method:setModel#

#if defined(ENABLE_OVERLOADING)
    FlattenListModelSetModelMethodInfo      ,
#endif
    flattenListModelSetModel                ,




 -- * Properties
-- ** itemType #attr:itemType#
-- | The t'GType' for elements of this object

#if defined(ENABLE_OVERLOADING)
    FlattenListModelItemTypePropertyInfo    ,
#endif
    constructFlattenListModelItemType       ,
#if defined(ENABLE_OVERLOADING)
    flattenListModelItemType                ,
#endif
    getFlattenListModelItemType             ,


-- ** model #attr:model#
-- | The model being flattened

#if defined(ENABLE_OVERLOADING)
    FlattenListModelModelPropertyInfo       ,
#endif
    clearFlattenListModelModel              ,
    constructFlattenListModelModel          ,
#if defined(ENABLE_OVERLOADING)
    flattenListModelModel                   ,
#endif
    getFlattenListModelModel                ,
    setFlattenListModelModel                ,




    ) 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.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.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.GObject.Objects.Object as GObject.Object
import qualified GI.Gio.Interfaces.ListModel as Gio.ListModel

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

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

foreign import ccall "gtk_flatten_list_model_get_type"
    c_gtk_flatten_list_model_get_type :: IO B.Types.GType

instance B.Types.TypedObject FlattenListModel where
    glibType :: IO GType
glibType = IO GType
c_gtk_flatten_list_model_get_type

instance B.Types.GObject FlattenListModel

-- | Convert 'FlattenListModel' to and from 'Data.GI.Base.GValue.GValue' with 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'.
instance B.GValue.IsGValue FlattenListModel where
    toGValue :: FlattenListModel -> IO GValue
toGValue FlattenListModel
o = do
        GType
gtype <- IO GType
c_gtk_flatten_list_model_get_type
        FlattenListModel
-> (Ptr FlattenListModel -> IO GValue) -> IO GValue
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr FlattenListModel
o (GType
-> (GValue -> Ptr FlattenListModel -> IO ())
-> Ptr FlattenListModel
-> IO GValue
forall a. GType -> (GValue -> a -> IO ()) -> a -> IO GValue
B.GValue.buildGValue GType
gtype GValue -> Ptr FlattenListModel -> IO ()
forall a. GObject a => GValue -> Ptr a -> IO ()
B.GValue.set_object)
        
    fromGValue :: GValue -> IO FlattenListModel
fromGValue GValue
gv = do
        Ptr FlattenListModel
ptr <- GValue -> IO (Ptr FlattenListModel)
forall b. GObject b => GValue -> IO (Ptr b)
B.GValue.get_object GValue
gv :: IO (Ptr FlattenListModel)
        (ManagedPtr FlattenListModel -> FlattenListModel)
-> Ptr FlattenListModel -> IO FlattenListModel
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr FlattenListModel -> FlattenListModel
FlattenListModel Ptr FlattenListModel
ptr
        
    

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

instance O.HasParentTypes FlattenListModel
type instance O.ParentTypes FlattenListModel = '[GObject.Object.Object, Gio.ListModel.ListModel]

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

#if defined(ENABLE_OVERLOADING)
type family ResolveFlattenListModelMethod (t :: Symbol) (o :: *) :: * where
    ResolveFlattenListModelMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveFlattenListModelMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveFlattenListModelMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveFlattenListModelMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveFlattenListModelMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
    ResolveFlattenListModelMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveFlattenListModelMethod "itemsChanged" o = Gio.ListModel.ListModelItemsChangedMethodInfo
    ResolveFlattenListModelMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveFlattenListModelMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveFlattenListModelMethod "ref" o = GObject.Object.ObjectRefMethodInfo
    ResolveFlattenListModelMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveFlattenListModelMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveFlattenListModelMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveFlattenListModelMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveFlattenListModelMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveFlattenListModelMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
    ResolveFlattenListModelMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveFlattenListModelMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveFlattenListModelMethod "getItem" o = Gio.ListModel.ListModelGetItemMethodInfo
    ResolveFlattenListModelMethod "getItemType" o = Gio.ListModel.ListModelGetItemTypeMethodInfo
    ResolveFlattenListModelMethod "getModel" o = FlattenListModelGetModelMethodInfo
    ResolveFlattenListModelMethod "getModelForItem" o = FlattenListModelGetModelForItemMethodInfo
    ResolveFlattenListModelMethod "getNItems" o = Gio.ListModel.ListModelGetNItemsMethodInfo
    ResolveFlattenListModelMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveFlattenListModelMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveFlattenListModelMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveFlattenListModelMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
    ResolveFlattenListModelMethod "setModel" o = FlattenListModelSetModelMethodInfo
    ResolveFlattenListModelMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveFlattenListModelMethod l o = O.MethodResolutionFailed l o

instance (info ~ ResolveFlattenListModelMethod t FlattenListModel, O.MethodInfo info FlattenListModel p) => OL.IsLabel t (FlattenListModel -> p) where
#if MIN_VERSION_base(4,10,0)
    fromLabel = O.overloadedMethod @info
#else
    fromLabel _ = O.overloadedMethod @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' flattenListModel #itemType
-- @
getFlattenListModelItemType :: (MonadIO m, IsFlattenListModel o) => o -> m GType
getFlattenListModelItemType :: o -> m GType
getFlattenListModelItemType o
obj = IO GType -> m GType
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO GType -> m GType) -> IO GType -> m GType
forall a b. (a -> b) -> a -> b
$ o -> String -> IO GType
forall a. GObject a => a -> String -> IO GType
B.Properties.getObjectPropertyGType o
obj String
"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`.
constructFlattenListModelItemType :: (IsFlattenListModel o, MIO.MonadIO m) => GType -> m (GValueConstruct o)
constructFlattenListModelItemType :: GType -> m (GValueConstruct o)
constructFlattenListModelItemType GType
val = IO (GValueConstruct o) -> m (GValueConstruct o)
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
$ 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 FlattenListModelItemTypePropertyInfo
instance AttrInfo FlattenListModelItemTypePropertyInfo where
    type AttrAllowedOps FlattenListModelItemTypePropertyInfo = '[ 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint FlattenListModelItemTypePropertyInfo = IsFlattenListModel
    type AttrSetTypeConstraint FlattenListModelItemTypePropertyInfo = (~) GType
    type AttrTransferTypeConstraint FlattenListModelItemTypePropertyInfo = (~) GType
    type AttrTransferType FlattenListModelItemTypePropertyInfo = GType
    type AttrGetType FlattenListModelItemTypePropertyInfo = GType
    type AttrLabel FlattenListModelItemTypePropertyInfo = "item-type"
    type AttrOrigin FlattenListModelItemTypePropertyInfo = FlattenListModel
    attrGet = getFlattenListModelItemType
    attrSet = undefined
    attrTransfer _ v = do
        return v
    attrConstruct = constructFlattenListModelItemType
    attrClear = undefined
#endif

-- VVV Prop "model"
   -- Type: TInterface (Name {namespace = "Gio", name = "ListModel"})
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just True,Just True)

-- | Get the value of the “@model@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' flattenListModel #model
-- @
getFlattenListModelModel :: (MonadIO m, IsFlattenListModel o) => o -> m (Maybe Gio.ListModel.ListModel)
getFlattenListModelModel :: o -> m (Maybe ListModel)
getFlattenListModelModel o
obj = IO (Maybe ListModel) -> m (Maybe ListModel)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe ListModel) -> m (Maybe ListModel))
-> IO (Maybe ListModel) -> m (Maybe ListModel)
forall a b. (a -> b) -> a -> b
$ o
-> String
-> (ManagedPtr ListModel -> ListModel)
-> IO (Maybe ListModel)
forall a b.
(GObject a, GObject b) =>
a -> String -> (ManagedPtr b -> b) -> IO (Maybe b)
B.Properties.getObjectPropertyObject o
obj String
"model" ManagedPtr ListModel -> ListModel
Gio.ListModel.ListModel

-- | Set the value of the “@model@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' flattenListModel [ #model 'Data.GI.Base.Attributes.:=' value ]
-- @
setFlattenListModelModel :: (MonadIO m, IsFlattenListModel o, Gio.ListModel.IsListModel a) => o -> a -> m ()
setFlattenListModelModel :: o -> a -> m ()
setFlattenListModelModel o
obj a
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ o -> String -> Maybe a -> IO ()
forall a b.
(GObject a, GObject b) =>
a -> String -> Maybe b -> IO ()
B.Properties.setObjectPropertyObject o
obj String
"model" (a -> Maybe a
forall a. a -> Maybe a
Just a
val)

-- | Construct a `GValueConstruct` with valid value for the “@model@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructFlattenListModelModel :: (IsFlattenListModel o, MIO.MonadIO m, Gio.ListModel.IsListModel a) => a -> m (GValueConstruct o)
constructFlattenListModelModel :: a -> m (GValueConstruct o)
constructFlattenListModelModel a
val = IO (GValueConstruct o) -> m (GValueConstruct o)
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
$ String -> Maybe a -> IO (GValueConstruct o)
forall a o.
GObject a =>
String -> Maybe a -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyObject String
"model" (a -> Maybe a
forall a. a -> Maybe a
P.Just a
val)

-- | Set the value of the “@model@” property to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #model
-- @
clearFlattenListModelModel :: (MonadIO m, IsFlattenListModel o) => o -> m ()
clearFlattenListModelModel :: o -> m ()
clearFlattenListModelModel o
obj = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ o -> String -> Maybe ListModel -> IO ()
forall a b.
(GObject a, GObject b) =>
a -> String -> Maybe b -> IO ()
B.Properties.setObjectPropertyObject o
obj String
"model" (Maybe ListModel
forall a. Maybe a
Nothing :: Maybe Gio.ListModel.ListModel)

#if defined(ENABLE_OVERLOADING)
data FlattenListModelModelPropertyInfo
instance AttrInfo FlattenListModelModelPropertyInfo where
    type AttrAllowedOps FlattenListModelModelPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint FlattenListModelModelPropertyInfo = IsFlattenListModel
    type AttrSetTypeConstraint FlattenListModelModelPropertyInfo = Gio.ListModel.IsListModel
    type AttrTransferTypeConstraint FlattenListModelModelPropertyInfo = Gio.ListModel.IsListModel
    type AttrTransferType FlattenListModelModelPropertyInfo = Gio.ListModel.ListModel
    type AttrGetType FlattenListModelModelPropertyInfo = (Maybe Gio.ListModel.ListModel)
    type AttrLabel FlattenListModelModelPropertyInfo = "model"
    type AttrOrigin FlattenListModelModelPropertyInfo = FlattenListModel
    attrGet = getFlattenListModelModel
    attrSet = setFlattenListModelModel
    attrTransfer _ v = do
        unsafeCastTo Gio.ListModel.ListModel v
    attrConstruct = constructFlattenListModelModel
    attrClear = clearFlattenListModelModel
#endif

#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList FlattenListModel
type instance O.AttributeList FlattenListModel = FlattenListModelAttributeList
type FlattenListModelAttributeList = ('[ '("itemType", FlattenListModelItemTypePropertyInfo), '("model", FlattenListModelModelPropertyInfo)] :: [(Symbol, *)])
#endif

#if defined(ENABLE_OVERLOADING)
flattenListModelItemType :: AttrLabelProxy "itemType"
flattenListModelItemType = AttrLabelProxy

flattenListModelModel :: AttrLabelProxy "model"
flattenListModelModel = AttrLabelProxy

#endif

#if defined(ENABLE_OVERLOADING)
type instance O.SignalList FlattenListModel = FlattenListModelSignalList
type FlattenListModelSignalList = ('[ '("itemsChanged", Gio.ListModel.ListModelItemsChangedSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)])

#endif

-- method FlattenListModel::new
-- method type : Constructor
-- Args: [ Arg
--           { argCName = "item_type"
--           , argType = TBasicType TGType
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "The type of items in the to-be-flattened models"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "model"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "ListModel" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the item to be flattened"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface Name { namespace = "Gtk" , name = "FlattenListModel" })
-- throws : False
-- Skip return : False

foreign import ccall "gtk_flatten_list_model_new" gtk_flatten_list_model_new :: 
    CGType ->                               -- item_type : TBasicType TGType
    Ptr Gio.ListModel.ListModel ->          -- model : TInterface (Name {namespace = "Gio", name = "ListModel"})
    IO (Ptr FlattenListModel)

-- | Creates a new t'GI.Gtk.Objects.FlattenListModel.FlattenListModel' that flattens /@list@/. The
-- models returned by /@model@/ must conform to the given /@itemType@/,
-- either by having an identical type or a subtype.
flattenListModelNew ::
    (B.CallStack.HasCallStack, MonadIO m, Gio.ListModel.IsListModel a) =>
    GType
    -- ^ /@itemType@/: The type of items in the to-be-flattened models
    -> Maybe (a)
    -- ^ /@model@/: the item to be flattened
    -> m FlattenListModel
    -- ^ __Returns:__ a new t'GI.Gtk.Objects.FlattenListModel.FlattenListModel'
flattenListModelNew :: GType -> Maybe a -> m FlattenListModel
flattenListModelNew GType
itemType Maybe a
model = IO FlattenListModel -> m FlattenListModel
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO FlattenListModel -> m FlattenListModel)
-> IO FlattenListModel -> m FlattenListModel
forall a b. (a -> b) -> a -> b
$ do
    let itemType' :: CGType
itemType' = GType -> CGType
gtypeToCGType GType
itemType
    Ptr ListModel
maybeModel <- case Maybe a
model of
        Maybe a
Nothing -> Ptr ListModel -> IO (Ptr ListModel)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr ListModel
forall a. Ptr a
nullPtr
        Just a
jModel -> do
            Ptr ListModel
jModel' <- a -> IO (Ptr ListModel)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
jModel
            Ptr ListModel -> IO (Ptr ListModel)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr ListModel
jModel'
    Ptr FlattenListModel
result <- CGType -> Ptr ListModel -> IO (Ptr FlattenListModel)
gtk_flatten_list_model_new CGType
itemType' Ptr ListModel
maybeModel
    Text -> Ptr FlattenListModel -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"flattenListModelNew" Ptr FlattenListModel
result
    FlattenListModel
result' <- ((ManagedPtr FlattenListModel -> FlattenListModel)
-> Ptr FlattenListModel -> IO FlattenListModel
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr FlattenListModel -> FlattenListModel
FlattenListModel) Ptr FlattenListModel
result
    Maybe a -> (a -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe a
model a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
    FlattenListModel -> IO FlattenListModel
forall (m :: * -> *) a. Monad m => a -> m a
return FlattenListModel
result'

#if defined(ENABLE_OVERLOADING)
#endif

-- method FlattenListModel::get_model
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "FlattenListModel" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkFlattenListModel"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Gio" , name = "ListModel" })
-- throws : False
-- Skip return : False

foreign import ccall "gtk_flatten_list_model_get_model" gtk_flatten_list_model_get_model :: 
    Ptr FlattenListModel ->                 -- self : TInterface (Name {namespace = "Gtk", name = "FlattenListModel"})
    IO (Ptr Gio.ListModel.ListModel)

-- | Gets the model set via 'GI.Gtk.Objects.FlattenListModel.flattenListModelSetModel'.
flattenListModelGetModel ::
    (B.CallStack.HasCallStack, MonadIO m, IsFlattenListModel a) =>
    a
    -- ^ /@self@/: a t'GI.Gtk.Objects.FlattenListModel.FlattenListModel'
    -> m (Maybe Gio.ListModel.ListModel)
    -- ^ __Returns:__ The model flattened by /@self@/
flattenListModelGetModel :: a -> m (Maybe ListModel)
flattenListModelGetModel a
self = IO (Maybe ListModel) -> m (Maybe ListModel)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe ListModel) -> m (Maybe ListModel))
-> IO (Maybe ListModel) -> m (Maybe ListModel)
forall a b. (a -> b) -> a -> b
$ do
    Ptr FlattenListModel
self' <- a -> IO (Ptr FlattenListModel)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr ListModel
result <- Ptr FlattenListModel -> IO (Ptr ListModel)
gtk_flatten_list_model_get_model Ptr FlattenListModel
self'
    Maybe ListModel
maybeResult <- Ptr ListModel
-> (Ptr ListModel -> IO ListModel) -> IO (Maybe ListModel)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr ListModel
result ((Ptr ListModel -> IO ListModel) -> IO (Maybe ListModel))
-> (Ptr ListModel -> IO ListModel) -> IO (Maybe ListModel)
forall a b. (a -> b) -> a -> b
$ \Ptr ListModel
result' -> do
        ListModel
result'' <- ((ManagedPtr ListModel -> ListModel)
-> Ptr ListModel -> IO ListModel
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr ListModel -> ListModel
Gio.ListModel.ListModel) Ptr ListModel
result'
        ListModel -> IO ListModel
forall (m :: * -> *) a. Monad m => a -> m a
return ListModel
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Maybe ListModel -> IO (Maybe ListModel)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe ListModel
maybeResult

#if defined(ENABLE_OVERLOADING)
data FlattenListModelGetModelMethodInfo
instance (signature ~ (m (Maybe Gio.ListModel.ListModel)), MonadIO m, IsFlattenListModel a) => O.MethodInfo FlattenListModelGetModelMethodInfo a signature where
    overloadedMethod = flattenListModelGetModel

#endif

-- method FlattenListModel::get_model_for_item
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "FlattenListModel" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkFlattenListModel"
--                 , 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 "a position" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Gio" , name = "ListModel" })
-- throws : False
-- Skip return : False

foreign import ccall "gtk_flatten_list_model_get_model_for_item" gtk_flatten_list_model_get_model_for_item :: 
    Ptr FlattenListModel ->                 -- self : TInterface (Name {namespace = "Gtk", name = "FlattenListModel"})
    Word32 ->                               -- position : TBasicType TUInt
    IO (Ptr Gio.ListModel.ListModel)

-- | Returns the model containing the item at the given position.
flattenListModelGetModelForItem ::
    (B.CallStack.HasCallStack, MonadIO m, IsFlattenListModel a) =>
    a
    -- ^ /@self@/: a t'GI.Gtk.Objects.FlattenListModel.FlattenListModel'
    -> Word32
    -- ^ /@position@/: a position
    -> m Gio.ListModel.ListModel
    -- ^ __Returns:__ the model containing the item at /@position@/
flattenListModelGetModelForItem :: a -> Word32 -> m ListModel
flattenListModelGetModelForItem a
self Word32
position = 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
    Ptr FlattenListModel
self' <- a -> IO (Ptr FlattenListModel)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr ListModel
result <- Ptr FlattenListModel -> Word32 -> IO (Ptr ListModel)
gtk_flatten_list_model_get_model_for_item Ptr FlattenListModel
self' Word32
position
    Text -> Ptr ListModel -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"flattenListModelGetModelForItem" 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
newObject ManagedPtr ListModel -> ListModel
Gio.ListModel.ListModel) Ptr ListModel
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    ListModel -> IO ListModel
forall (m :: * -> *) a. Monad m => a -> m a
return ListModel
result'

#if defined(ENABLE_OVERLOADING)
data FlattenListModelGetModelForItemMethodInfo
instance (signature ~ (Word32 -> m Gio.ListModel.ListModel), MonadIO m, IsFlattenListModel a) => O.MethodInfo FlattenListModelGetModelForItemMethodInfo a signature where
    overloadedMethod = flattenListModelGetModelForItem

#endif

-- method FlattenListModel::set_model
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "FlattenListModel" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkFlattenListModel"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "model"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "ListModel" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the new model or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_flatten_list_model_set_model" gtk_flatten_list_model_set_model :: 
    Ptr FlattenListModel ->                 -- self : TInterface (Name {namespace = "Gtk", name = "FlattenListModel"})
    Ptr Gio.ListModel.ListModel ->          -- model : TInterface (Name {namespace = "Gio", name = "ListModel"})
    IO ()

-- | Sets a new model to be flattened. The model must contain items of
-- t'GI.Gio.Interfaces.ListModel.ListModel' that conform to the item type of /@self@/.
flattenListModelSetModel ::
    (B.CallStack.HasCallStack, MonadIO m, IsFlattenListModel a, Gio.ListModel.IsListModel b) =>
    a
    -- ^ /@self@/: a t'GI.Gtk.Objects.FlattenListModel.FlattenListModel'
    -> Maybe (b)
    -- ^ /@model@/: the new model or 'P.Nothing'
    -> m ()
flattenListModelSetModel :: a -> Maybe b -> m ()
flattenListModelSetModel a
self Maybe b
model = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr FlattenListModel
self' <- a -> IO (Ptr FlattenListModel)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr ListModel
maybeModel <- case Maybe b
model of
        Maybe b
Nothing -> Ptr ListModel -> IO (Ptr ListModel)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr ListModel
forall a. Ptr a
nullPtr
        Just b
jModel -> do
            Ptr ListModel
jModel' <- b -> IO (Ptr ListModel)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jModel
            Ptr ListModel -> IO (Ptr ListModel)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr ListModel
jModel'
    Ptr FlattenListModel -> Ptr ListModel -> IO ()
gtk_flatten_list_model_set_model Ptr FlattenListModel
self' Ptr ListModel
maybeModel
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Maybe b -> (b -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
model b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data FlattenListModelSetModelMethodInfo
instance (signature ~ (Maybe (b) -> m ()), MonadIO m, IsFlattenListModel a, Gio.ListModel.IsListModel b) => O.MethodInfo FlattenListModelSetModelMethodInfo a signature where
    overloadedMethod = flattenListModelSetModel

#endif