TreeModelFilter.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)

A 'GI.Gtk.Objects.TreeModelFilter.TreeModelFilter' is a tree model which wraps another tree model,
and can do the following things:

* Filter specific rows, based on data from a “visible column”, a column
storing booleans indicating whether the row should be filtered or not,
or based on the return value of a “visible function”, which gets a
model, iter and user_data and returns a boolean indicating whether the
row should be filtered or not.
* Modify the “appearance” of the model, using a modify function.
This is extremely powerful and allows for just changing some
values and also for creating a completely different model based
on the given child model.
* Set a different root node, also known as a “virtual root”. You can pass
in a 'GI.Gtk.Structs.TreePath.TreePath' indicating the root node for the filter at construction
time.


The basic API is similar to 'GI.Gtk.Objects.TreeModelSort.TreeModelSort'. For an example on its usage,
see the section on 'GI.Gtk.Objects.TreeModelSort.TreeModelSort'.

When using 'GI.Gtk.Objects.TreeModelFilter.TreeModelFilter', it is important to realize that
'GI.Gtk.Objects.TreeModelFilter.TreeModelFilter' maintains an internal cache of all nodes which are
visible in its clients. The cache is likely to be a subtree of the tree
exposed by the child model. 'GI.Gtk.Objects.TreeModelFilter.TreeModelFilter' will not cache the entire
child model when unnecessary to not compromise the caching mechanism
that is exposed by the reference counting scheme. If the child model
implements reference counting, unnecessary signals may not be emitted
because of reference counting rule 3, see the 'GI.Gtk.Interfaces.TreeModel.TreeModel'
documentation. (Note that e.g. 'GI.Gtk.Objects.TreeStore.TreeStore' does not implement
reference counting and will always emit all signals, even when
the receiving node is not visible).

Because of this, limitations for possible visible functions do apply.
In general, visible functions should only use data or properties from
the node for which the visibility state must be determined, its siblings
or its parents. Usually, having a dependency on the state of any child
node is not possible, unless references are taken on these explicitly.
When no such reference exists, no signals may be received for these child
nodes (see reference couting rule number 3 in the 'GI.Gtk.Interfaces.TreeModel.TreeModel' section).

Determining the visibility state of a given node based on the state
of its child nodes is a frequently occurring use case. Therefore,
'GI.Gtk.Objects.TreeModelFilter.TreeModelFilter' explicitly supports this. For example, when a node
does not have any children, you might not want the node to be visible.
As soon as the first row is added to the node’s child level (or the
last row removed), the node’s visibility should be updated.

This introduces a dependency from the node on its child nodes. In order
to accommodate this, 'GI.Gtk.Objects.TreeModelFilter.TreeModelFilter' must make sure the necessary
signals are received from the child model. This is achieved by building,
for all nodes which are exposed as visible nodes to 'GI.Gtk.Objects.TreeModelFilter.TreeModelFilter'\'s
clients, the child level (if any) and take a reference on the first node
in this level. Furthermore, for every row-inserted, row-changed or
row-deleted signal (also these which were not handled because the node
was not cached), 'GI.Gtk.Objects.TreeModelFilter.TreeModelFilter' will check if the visibility state
of any parent node has changed.

Beware, however, that this explicit support is limited to these two
cases. For example, if you want a node to be visible only if two nodes
in a child’s child level (2 levels deeper) are visible, you are on your
own. In this case, either rely on 'GI.Gtk.Objects.TreeStore.TreeStore' to emit all signals
because it does not implement reference counting, or for models that
do implement reference counting, obtain references on these child levels
yourself.
-}

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

module GI.Gtk.Objects.TreeModelFilter
    ( 

-- * Exported types
    TreeModelFilter(..)                     ,
    IsTreeModelFilter                       ,
    toTreeModelFilter                       ,
    noTreeModelFilter                       ,


 -- * Methods
-- ** clearCache #method:clearCache#

#if ENABLE_OVERLOADING
    TreeModelFilterClearCacheMethodInfo     ,
#endif
    treeModelFilterClearCache               ,


-- ** convertChildIterToIter #method:convertChildIterToIter#

#if ENABLE_OVERLOADING
    TreeModelFilterConvertChildIterToIterMethodInfo,
#endif
    treeModelFilterConvertChildIterToIter   ,


-- ** convertChildPathToPath #method:convertChildPathToPath#

#if ENABLE_OVERLOADING
    TreeModelFilterConvertChildPathToPathMethodInfo,
#endif
    treeModelFilterConvertChildPathToPath   ,


-- ** convertIterToChildIter #method:convertIterToChildIter#

#if ENABLE_OVERLOADING
    TreeModelFilterConvertIterToChildIterMethodInfo,
#endif
    treeModelFilterConvertIterToChildIter   ,


-- ** convertPathToChildPath #method:convertPathToChildPath#

#if ENABLE_OVERLOADING
    TreeModelFilterConvertPathToChildPathMethodInfo,
#endif
    treeModelFilterConvertPathToChildPath   ,


-- ** getModel #method:getModel#

#if ENABLE_OVERLOADING
    TreeModelFilterGetModelMethodInfo       ,
#endif
    treeModelFilterGetModel                 ,


-- ** refilter #method:refilter#

#if ENABLE_OVERLOADING
    TreeModelFilterRefilterMethodInfo       ,
#endif
    treeModelFilterRefilter                 ,


-- ** setVisibleColumn #method:setVisibleColumn#

#if ENABLE_OVERLOADING
    TreeModelFilterSetVisibleColumnMethodInfo,
#endif
    treeModelFilterSetVisibleColumn         ,


-- ** setVisibleFunc #method:setVisibleFunc#

#if ENABLE_OVERLOADING
    TreeModelFilterSetVisibleFuncMethodInfo ,
#endif
    treeModelFilterSetVisibleFunc           ,




 -- * Properties
-- ** childModel #attr:childModel#
{- | /No description available in the introspection data./
-}
#if ENABLE_OVERLOADING
    TreeModelFilterChildModelPropertyInfo   ,
#endif
    constructTreeModelFilterChildModel      ,
    getTreeModelFilterChildModel            ,
#if ENABLE_OVERLOADING
    treeModelFilterChildModel               ,
#endif


-- ** virtualRoot #attr:virtualRoot#
{- | /No description available in the introspection data./
-}
#if ENABLE_OVERLOADING
    TreeModelFilterVirtualRootPropertyInfo  ,
#endif
    constructTreeModelFilterVirtualRoot     ,
    getTreeModelFilterVirtualRoot           ,
#if ENABLE_OVERLOADING
    treeModelFilterVirtualRoot              ,
#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 qualified GI.Gtk.Callbacks as Gtk.Callbacks
import {-# SOURCE #-} qualified GI.Gtk.Interfaces.TreeDragSource as Gtk.TreeDragSource
import {-# SOURCE #-} qualified GI.Gtk.Interfaces.TreeModel as Gtk.TreeModel
import {-# SOURCE #-} qualified GI.Gtk.Structs.TreeIter as Gtk.TreeIter
import {-# SOURCE #-} qualified GI.Gtk.Structs.TreePath as Gtk.TreePath

-- | Memory-managed wrapper type.
newtype TreeModelFilter = TreeModelFilter (ManagedPtr TreeModelFilter)
foreign import ccall "gtk_tree_model_filter_get_type"
    c_gtk_tree_model_filter_get_type :: IO GType

instance GObject TreeModelFilter where
    gobjectType = c_gtk_tree_model_filter_get_type
    

-- | Type class for types which can be safely cast to `TreeModelFilter`, for instance with `toTreeModelFilter`.
class (GObject o, O.IsDescendantOf TreeModelFilter o) => IsTreeModelFilter o
instance (GObject o, O.IsDescendantOf TreeModelFilter o) => IsTreeModelFilter o

instance O.HasParentTypes TreeModelFilter
type instance O.ParentTypes TreeModelFilter = '[GObject.Object.Object, Gtk.TreeDragSource.TreeDragSource, Gtk.TreeModel.TreeModel]

-- | Cast to `TreeModelFilter`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`.
toTreeModelFilter :: (MonadIO m, IsTreeModelFilter o) => o -> m TreeModelFilter
toTreeModelFilter = liftIO . unsafeCastTo TreeModelFilter

-- | A convenience alias for `Nothing` :: `Maybe` `TreeModelFilter`.
noTreeModelFilter :: Maybe TreeModelFilter
noTreeModelFilter = Nothing

#if ENABLE_OVERLOADING
type family ResolveTreeModelFilterMethod (t :: Symbol) (o :: *) :: * where
    ResolveTreeModelFilterMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveTreeModelFilterMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveTreeModelFilterMethod "clearCache" o = TreeModelFilterClearCacheMethodInfo
    ResolveTreeModelFilterMethod "convertChildIterToIter" o = TreeModelFilterConvertChildIterToIterMethodInfo
    ResolveTreeModelFilterMethod "convertChildPathToPath" o = TreeModelFilterConvertChildPathToPathMethodInfo
    ResolveTreeModelFilterMethod "convertIterToChildIter" o = TreeModelFilterConvertIterToChildIterMethodInfo
    ResolveTreeModelFilterMethod "convertPathToChildPath" o = TreeModelFilterConvertPathToChildPathMethodInfo
    ResolveTreeModelFilterMethod "dragDataDelete" o = Gtk.TreeDragSource.TreeDragSourceDragDataDeleteMethodInfo
    ResolveTreeModelFilterMethod "dragDataGet" o = Gtk.TreeDragSource.TreeDragSourceDragDataGetMethodInfo
    ResolveTreeModelFilterMethod "filterNew" o = Gtk.TreeModel.TreeModelFilterNewMethodInfo
    ResolveTreeModelFilterMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveTreeModelFilterMethod "foreach" o = Gtk.TreeModel.TreeModelForeachMethodInfo
    ResolveTreeModelFilterMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveTreeModelFilterMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
    ResolveTreeModelFilterMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveTreeModelFilterMethod "iterChildren" o = Gtk.TreeModel.TreeModelIterChildrenMethodInfo
    ResolveTreeModelFilterMethod "iterHasChild" o = Gtk.TreeModel.TreeModelIterHasChildMethodInfo
    ResolveTreeModelFilterMethod "iterNChildren" o = Gtk.TreeModel.TreeModelIterNChildrenMethodInfo
    ResolveTreeModelFilterMethod "iterNext" o = Gtk.TreeModel.TreeModelIterNextMethodInfo
    ResolveTreeModelFilterMethod "iterNthChild" o = Gtk.TreeModel.TreeModelIterNthChildMethodInfo
    ResolveTreeModelFilterMethod "iterParent" o = Gtk.TreeModel.TreeModelIterParentMethodInfo
    ResolveTreeModelFilterMethod "iterPrevious" o = Gtk.TreeModel.TreeModelIterPreviousMethodInfo
    ResolveTreeModelFilterMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveTreeModelFilterMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveTreeModelFilterMethod "ref" o = GObject.Object.ObjectRefMethodInfo
    ResolveTreeModelFilterMethod "refNode" o = Gtk.TreeModel.TreeModelRefNodeMethodInfo
    ResolveTreeModelFilterMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveTreeModelFilterMethod "refilter" o = TreeModelFilterRefilterMethodInfo
    ResolveTreeModelFilterMethod "rowChanged" o = Gtk.TreeModel.TreeModelRowChangedMethodInfo
    ResolveTreeModelFilterMethod "rowDeleted" o = Gtk.TreeModel.TreeModelRowDeletedMethodInfo
    ResolveTreeModelFilterMethod "rowDraggable" o = Gtk.TreeDragSource.TreeDragSourceRowDraggableMethodInfo
    ResolveTreeModelFilterMethod "rowHasChildToggled" o = Gtk.TreeModel.TreeModelRowHasChildToggledMethodInfo
    ResolveTreeModelFilterMethod "rowInserted" o = Gtk.TreeModel.TreeModelRowInsertedMethodInfo
    ResolveTreeModelFilterMethod "rowsReordered" o = Gtk.TreeModel.TreeModelRowsReorderedMethodInfo
    ResolveTreeModelFilterMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveTreeModelFilterMethod "sortNewWithModel" o = Gtk.TreeModel.TreeModelSortNewWithModelMethodInfo
    ResolveTreeModelFilterMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveTreeModelFilterMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveTreeModelFilterMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveTreeModelFilterMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
    ResolveTreeModelFilterMethod "unrefNode" o = Gtk.TreeModel.TreeModelUnrefNodeMethodInfo
    ResolveTreeModelFilterMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveTreeModelFilterMethod "getColumnType" o = Gtk.TreeModel.TreeModelGetColumnTypeMethodInfo
    ResolveTreeModelFilterMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveTreeModelFilterMethod "getFlags" o = Gtk.TreeModel.TreeModelGetFlagsMethodInfo
    ResolveTreeModelFilterMethod "getIter" o = Gtk.TreeModel.TreeModelGetIterMethodInfo
    ResolveTreeModelFilterMethod "getIterFirst" o = Gtk.TreeModel.TreeModelGetIterFirstMethodInfo
    ResolveTreeModelFilterMethod "getIterFromString" o = Gtk.TreeModel.TreeModelGetIterFromStringMethodInfo
    ResolveTreeModelFilterMethod "getModel" o = TreeModelFilterGetModelMethodInfo
    ResolveTreeModelFilterMethod "getNColumns" o = Gtk.TreeModel.TreeModelGetNColumnsMethodInfo
    ResolveTreeModelFilterMethod "getPath" o = Gtk.TreeModel.TreeModelGetPathMethodInfo
    ResolveTreeModelFilterMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveTreeModelFilterMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveTreeModelFilterMethod "getStringFromIter" o = Gtk.TreeModel.TreeModelGetStringFromIterMethodInfo
    ResolveTreeModelFilterMethod "getValue" o = Gtk.TreeModel.TreeModelGetValueMethodInfo
    ResolveTreeModelFilterMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveTreeModelFilterMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveTreeModelFilterMethod "setVisibleColumn" o = TreeModelFilterSetVisibleColumnMethodInfo
    ResolveTreeModelFilterMethod "setVisibleFunc" o = TreeModelFilterSetVisibleFuncMethodInfo
    ResolveTreeModelFilterMethod l o = O.MethodResolutionFailed l o

instance (info ~ ResolveTreeModelFilterMethod t TreeModelFilter, O.MethodInfo info TreeModelFilter p) => OL.IsLabel t (TreeModelFilter -> 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 "child-model"
   -- Type: TInterface (Name {namespace = "Gtk", name = "TreeModel"})
   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]
   -- Nullable: (Nothing,Nothing)

{- |
Get the value of the “@child-model@” property.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.get' treeModelFilter #childModel
@
-}
getTreeModelFilterChildModel :: (MonadIO m, IsTreeModelFilter o) => o -> m (Maybe Gtk.TreeModel.TreeModel)
getTreeModelFilterChildModel obj = liftIO $ B.Properties.getObjectPropertyObject obj "child-model" Gtk.TreeModel.TreeModel

{- |
Construct a `GValueConstruct` with valid value for the “@child-model@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
-}
constructTreeModelFilterChildModel :: (IsTreeModelFilter o, Gtk.TreeModel.IsTreeModel a) => a -> IO (GValueConstruct o)
constructTreeModelFilterChildModel val = B.Properties.constructObjectPropertyObject "child-model" (Just val)

#if ENABLE_OVERLOADING
data TreeModelFilterChildModelPropertyInfo
instance AttrInfo TreeModelFilterChildModelPropertyInfo where
    type AttrAllowedOps TreeModelFilterChildModelPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint TreeModelFilterChildModelPropertyInfo = Gtk.TreeModel.IsTreeModel
    type AttrBaseTypeConstraint TreeModelFilterChildModelPropertyInfo = IsTreeModelFilter
    type AttrGetType TreeModelFilterChildModelPropertyInfo = (Maybe Gtk.TreeModel.TreeModel)
    type AttrLabel TreeModelFilterChildModelPropertyInfo = "child-model"
    type AttrOrigin TreeModelFilterChildModelPropertyInfo = TreeModelFilter
    attrGet _ = getTreeModelFilterChildModel
    attrSet _ = undefined
    attrConstruct _ = constructTreeModelFilterChildModel
    attrClear _ = undefined
#endif

-- VVV Prop "virtual-root"
   -- Type: TInterface (Name {namespace = "Gtk", name = "TreePath"})
   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]
   -- Nullable: (Nothing,Nothing)

{- |
Get the value of the “@virtual-root@” property.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.get' treeModelFilter #virtualRoot
@
-}
getTreeModelFilterVirtualRoot :: (MonadIO m, IsTreeModelFilter o) => o -> m (Maybe Gtk.TreePath.TreePath)
getTreeModelFilterVirtualRoot obj = liftIO $ B.Properties.getObjectPropertyBoxed obj "virtual-root" Gtk.TreePath.TreePath

{- |
Construct a `GValueConstruct` with valid value for the “@virtual-root@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
-}
constructTreeModelFilterVirtualRoot :: (IsTreeModelFilter o) => Gtk.TreePath.TreePath -> IO (GValueConstruct o)
constructTreeModelFilterVirtualRoot val = B.Properties.constructObjectPropertyBoxed "virtual-root" (Just val)

#if ENABLE_OVERLOADING
data TreeModelFilterVirtualRootPropertyInfo
instance AttrInfo TreeModelFilterVirtualRootPropertyInfo where
    type AttrAllowedOps TreeModelFilterVirtualRootPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint TreeModelFilterVirtualRootPropertyInfo = (~) Gtk.TreePath.TreePath
    type AttrBaseTypeConstraint TreeModelFilterVirtualRootPropertyInfo = IsTreeModelFilter
    type AttrGetType TreeModelFilterVirtualRootPropertyInfo = (Maybe Gtk.TreePath.TreePath)
    type AttrLabel TreeModelFilterVirtualRootPropertyInfo = "virtual-root"
    type AttrOrigin TreeModelFilterVirtualRootPropertyInfo = TreeModelFilter
    attrGet _ = getTreeModelFilterVirtualRoot
    attrSet _ = undefined
    attrConstruct _ = constructTreeModelFilterVirtualRoot
    attrClear _ = undefined
#endif

#if ENABLE_OVERLOADING
instance O.HasAttributeList TreeModelFilter
type instance O.AttributeList TreeModelFilter = TreeModelFilterAttributeList
type TreeModelFilterAttributeList = ('[ '("childModel", TreeModelFilterChildModelPropertyInfo), '("virtualRoot", TreeModelFilterVirtualRootPropertyInfo)] :: [(Symbol, *)])
#endif

#if ENABLE_OVERLOADING
treeModelFilterChildModel :: AttrLabelProxy "childModel"
treeModelFilterChildModel = AttrLabelProxy

treeModelFilterVirtualRoot :: AttrLabelProxy "virtualRoot"
treeModelFilterVirtualRoot = AttrLabelProxy

#endif

#if ENABLE_OVERLOADING
type instance O.SignalList TreeModelFilter = TreeModelFilterSignalList
type TreeModelFilterSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo), '("rowChanged", Gtk.TreeModel.TreeModelRowChangedSignalInfo), '("rowDeleted", Gtk.TreeModel.TreeModelRowDeletedSignalInfo), '("rowHasChildToggled", Gtk.TreeModel.TreeModelRowHasChildToggledSignalInfo), '("rowInserted", Gtk.TreeModel.TreeModelRowInsertedSignalInfo)] :: [(Symbol, *)])

#endif

-- method TreeModelFilter::clear_cache
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "filter", argType = TInterface (Name {namespace = "Gtk", name = "TreeModelFilter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GtkTreeModelFilter.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_tree_model_filter_clear_cache" gtk_tree_model_filter_clear_cache :: 
    Ptr TreeModelFilter ->                  -- filter : TInterface (Name {namespace = "Gtk", name = "TreeModelFilter"})
    IO ()

{- |
This function should almost never be called. It clears the /@filter@/
of any cached iterators that haven’t been reffed with
'GI.Gtk.Interfaces.TreeModel.treeModelRefNode'. This might be useful if the child model
being filtered is static (and doesn’t change often) and there has been
a lot of unreffed access to nodes. As a side effect of this function,
all unreffed iters will be invalid.

/Since: 2.4/
-}
treeModelFilterClearCache ::
    (B.CallStack.HasCallStack, MonadIO m, IsTreeModelFilter a) =>
    a
    {- ^ /@filter@/: A 'GI.Gtk.Objects.TreeModelFilter.TreeModelFilter'. -}
    -> m ()
treeModelFilterClearCache filter = liftIO $ do
    filter' <- unsafeManagedPtrCastPtr filter
    gtk_tree_model_filter_clear_cache filter'
    touchManagedPtr filter
    return ()

#if ENABLE_OVERLOADING
data TreeModelFilterClearCacheMethodInfo
instance (signature ~ (m ()), MonadIO m, IsTreeModelFilter a) => O.MethodInfo TreeModelFilterClearCacheMethodInfo a signature where
    overloadedMethod _ = treeModelFilterClearCache

#endif

-- method TreeModelFilter::convert_child_iter_to_iter
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "filter", argType = TInterface (Name {namespace = "Gtk", name = "TreeModelFilter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GtkTreeModelFilter.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "filter_iter", argType = TInterface (Name {namespace = "Gtk", name = "TreeIter"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "An uninitialized #GtkTreeIter.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = True, transfer = TransferNothing},Arg {argCName = "child_iter", argType = TInterface (Name {namespace = "Gtk", name = "TreeIter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A valid #GtkTreeIter pointing to a row on the child model.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_tree_model_filter_convert_child_iter_to_iter" gtk_tree_model_filter_convert_child_iter_to_iter :: 
    Ptr TreeModelFilter ->                  -- filter : TInterface (Name {namespace = "Gtk", name = "TreeModelFilter"})
    Ptr Gtk.TreeIter.TreeIter ->            -- filter_iter : TInterface (Name {namespace = "Gtk", name = "TreeIter"})
    Ptr Gtk.TreeIter.TreeIter ->            -- child_iter : TInterface (Name {namespace = "Gtk", name = "TreeIter"})
    IO CInt

{- |
Sets /@filterIter@/ to point to the row in /@filter@/ that corresponds to the
row pointed at by /@childIter@/.  If /@filterIter@/ was not set, 'False' is
returned.

/Since: 2.4/
-}
treeModelFilterConvertChildIterToIter ::
    (B.CallStack.HasCallStack, MonadIO m, IsTreeModelFilter a) =>
    a
    {- ^ /@filter@/: A 'GI.Gtk.Objects.TreeModelFilter.TreeModelFilter'. -}
    -> Gtk.TreeIter.TreeIter
    {- ^ /@childIter@/: A valid 'GI.Gtk.Structs.TreeIter.TreeIter' pointing to a row on the child model. -}
    -> m ((Bool, Gtk.TreeIter.TreeIter))
    {- ^ __Returns:__ 'True', if /@filterIter@/ was set, i.e. if /@childIter@/ is a
valid iterator pointing to a visible row in child model. -}
treeModelFilterConvertChildIterToIter filter childIter = liftIO $ do
    filter' <- unsafeManagedPtrCastPtr filter
    filterIter <- callocBoxedBytes 32 :: IO (Ptr Gtk.TreeIter.TreeIter)
    childIter' <- unsafeManagedPtrGetPtr childIter
    result <- gtk_tree_model_filter_convert_child_iter_to_iter filter' filterIter childIter'
    let result' = (/= 0) result
    filterIter' <- (wrapBoxed Gtk.TreeIter.TreeIter) filterIter
    touchManagedPtr filter
    touchManagedPtr childIter
    return (result', filterIter')

#if ENABLE_OVERLOADING
data TreeModelFilterConvertChildIterToIterMethodInfo
instance (signature ~ (Gtk.TreeIter.TreeIter -> m ((Bool, Gtk.TreeIter.TreeIter))), MonadIO m, IsTreeModelFilter a) => O.MethodInfo TreeModelFilterConvertChildIterToIterMethodInfo a signature where
    overloadedMethod _ = treeModelFilterConvertChildIterToIter

#endif

-- method TreeModelFilter::convert_child_path_to_path
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "filter", argType = TInterface (Name {namespace = "Gtk", name = "TreeModelFilter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GtkTreeModelFilter.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "child_path", argType = TInterface (Name {namespace = "Gtk", name = "TreePath"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GtkTreePath to convert.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gtk", name = "TreePath"}))
-- throws : False
-- Skip return : False

foreign import ccall "gtk_tree_model_filter_convert_child_path_to_path" gtk_tree_model_filter_convert_child_path_to_path :: 
    Ptr TreeModelFilter ->                  -- filter : TInterface (Name {namespace = "Gtk", name = "TreeModelFilter"})
    Ptr Gtk.TreePath.TreePath ->            -- child_path : TInterface (Name {namespace = "Gtk", name = "TreePath"})
    IO (Ptr Gtk.TreePath.TreePath)

{- |
Converts /@childPath@/ to a path relative to /@filter@/. That is, /@childPath@/
points to a path in the child model. The rerturned path will point to the
same row in the filtered model. If /@childPath@/ isn’t a valid path on the
child model or points to a row which is not visible in /@filter@/, then 'Nothing'
is returned.

/Since: 2.4/
-}
treeModelFilterConvertChildPathToPath ::
    (B.CallStack.HasCallStack, MonadIO m, IsTreeModelFilter a) =>
    a
    {- ^ /@filter@/: A 'GI.Gtk.Objects.TreeModelFilter.TreeModelFilter'. -}
    -> Gtk.TreePath.TreePath
    {- ^ /@childPath@/: A 'GI.Gtk.Structs.TreePath.TreePath' to convert. -}
    -> m (Maybe Gtk.TreePath.TreePath)
    {- ^ __Returns:__ A newly allocated 'GI.Gtk.Structs.TreePath.TreePath', or 'Nothing'. -}
treeModelFilterConvertChildPathToPath filter childPath = liftIO $ do
    filter' <- unsafeManagedPtrCastPtr filter
    childPath' <- unsafeManagedPtrGetPtr childPath
    result <- gtk_tree_model_filter_convert_child_path_to_path filter' childPath'
    maybeResult <- convertIfNonNull result $ \result' -> do
        result'' <- (wrapBoxed Gtk.TreePath.TreePath) result'
        return result''
    touchManagedPtr filter
    touchManagedPtr childPath
    return maybeResult

#if ENABLE_OVERLOADING
data TreeModelFilterConvertChildPathToPathMethodInfo
instance (signature ~ (Gtk.TreePath.TreePath -> m (Maybe Gtk.TreePath.TreePath)), MonadIO m, IsTreeModelFilter a) => O.MethodInfo TreeModelFilterConvertChildPathToPathMethodInfo a signature where
    overloadedMethod _ = treeModelFilterConvertChildPathToPath

#endif

-- method TreeModelFilter::convert_iter_to_child_iter
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "filter", argType = TInterface (Name {namespace = "Gtk", name = "TreeModelFilter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GtkTreeModelFilter.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "child_iter", argType = TInterface (Name {namespace = "Gtk", name = "TreeIter"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "An uninitialized #GtkTreeIter.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = True, transfer = TransferNothing},Arg {argCName = "filter_iter", argType = TInterface (Name {namespace = "Gtk", name = "TreeIter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A valid #GtkTreeIter pointing to a row on @filter.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_tree_model_filter_convert_iter_to_child_iter" gtk_tree_model_filter_convert_iter_to_child_iter :: 
    Ptr TreeModelFilter ->                  -- filter : TInterface (Name {namespace = "Gtk", name = "TreeModelFilter"})
    Ptr Gtk.TreeIter.TreeIter ->            -- child_iter : TInterface (Name {namespace = "Gtk", name = "TreeIter"})
    Ptr Gtk.TreeIter.TreeIter ->            -- filter_iter : TInterface (Name {namespace = "Gtk", name = "TreeIter"})
    IO ()

{- |
Sets /@childIter@/ to point to the row pointed to by /@filterIter@/.

/Since: 2.4/
-}
treeModelFilterConvertIterToChildIter ::
    (B.CallStack.HasCallStack, MonadIO m, IsTreeModelFilter a) =>
    a
    {- ^ /@filter@/: A 'GI.Gtk.Objects.TreeModelFilter.TreeModelFilter'. -}
    -> Gtk.TreeIter.TreeIter
    {- ^ /@filterIter@/: A valid 'GI.Gtk.Structs.TreeIter.TreeIter' pointing to a row on /@filter@/. -}
    -> m (Gtk.TreeIter.TreeIter)
treeModelFilterConvertIterToChildIter filter filterIter = liftIO $ do
    filter' <- unsafeManagedPtrCastPtr filter
    childIter <- callocBoxedBytes 32 :: IO (Ptr Gtk.TreeIter.TreeIter)
    filterIter' <- unsafeManagedPtrGetPtr filterIter
    gtk_tree_model_filter_convert_iter_to_child_iter filter' childIter filterIter'
    childIter' <- (wrapBoxed Gtk.TreeIter.TreeIter) childIter
    touchManagedPtr filter
    touchManagedPtr filterIter
    return childIter'

#if ENABLE_OVERLOADING
data TreeModelFilterConvertIterToChildIterMethodInfo
instance (signature ~ (Gtk.TreeIter.TreeIter -> m (Gtk.TreeIter.TreeIter)), MonadIO m, IsTreeModelFilter a) => O.MethodInfo TreeModelFilterConvertIterToChildIterMethodInfo a signature where
    overloadedMethod _ = treeModelFilterConvertIterToChildIter

#endif

-- method TreeModelFilter::convert_path_to_child_path
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "filter", argType = TInterface (Name {namespace = "Gtk", name = "TreeModelFilter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GtkTreeModelFilter.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "filter_path", argType = TInterface (Name {namespace = "Gtk", name = "TreePath"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GtkTreePath to convert.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gtk", name = "TreePath"}))
-- throws : False
-- Skip return : False

foreign import ccall "gtk_tree_model_filter_convert_path_to_child_path" gtk_tree_model_filter_convert_path_to_child_path :: 
    Ptr TreeModelFilter ->                  -- filter : TInterface (Name {namespace = "Gtk", name = "TreeModelFilter"})
    Ptr Gtk.TreePath.TreePath ->            -- filter_path : TInterface (Name {namespace = "Gtk", name = "TreePath"})
    IO (Ptr Gtk.TreePath.TreePath)

{- |
Converts /@filterPath@/ to a path on the child model of /@filter@/. That is,
/@filterPath@/ points to a location in /@filter@/. The returned path will
point to the same location in the model not being filtered. If /@filterPath@/
does not point to a location in the child model, 'Nothing' is returned.

/Since: 2.4/
-}
treeModelFilterConvertPathToChildPath ::
    (B.CallStack.HasCallStack, MonadIO m, IsTreeModelFilter a) =>
    a
    {- ^ /@filter@/: A 'GI.Gtk.Objects.TreeModelFilter.TreeModelFilter'. -}
    -> Gtk.TreePath.TreePath
    {- ^ /@filterPath@/: A 'GI.Gtk.Structs.TreePath.TreePath' to convert. -}
    -> m (Maybe Gtk.TreePath.TreePath)
    {- ^ __Returns:__ A newly allocated 'GI.Gtk.Structs.TreePath.TreePath', or 'Nothing'. -}
treeModelFilterConvertPathToChildPath filter filterPath = liftIO $ do
    filter' <- unsafeManagedPtrCastPtr filter
    filterPath' <- unsafeManagedPtrGetPtr filterPath
    result <- gtk_tree_model_filter_convert_path_to_child_path filter' filterPath'
    maybeResult <- convertIfNonNull result $ \result' -> do
        result'' <- (wrapBoxed Gtk.TreePath.TreePath) result'
        return result''
    touchManagedPtr filter
    touchManagedPtr filterPath
    return maybeResult

#if ENABLE_OVERLOADING
data TreeModelFilterConvertPathToChildPathMethodInfo
instance (signature ~ (Gtk.TreePath.TreePath -> m (Maybe Gtk.TreePath.TreePath)), MonadIO m, IsTreeModelFilter a) => O.MethodInfo TreeModelFilterConvertPathToChildPathMethodInfo a signature where
    overloadedMethod _ = treeModelFilterConvertPathToChildPath

#endif

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

foreign import ccall "gtk_tree_model_filter_get_model" gtk_tree_model_filter_get_model :: 
    Ptr TreeModelFilter ->                  -- filter : TInterface (Name {namespace = "Gtk", name = "TreeModelFilter"})
    IO (Ptr Gtk.TreeModel.TreeModel)

{- |
Returns a pointer to the child model of /@filter@/.

/Since: 2.4/
-}
treeModelFilterGetModel ::
    (B.CallStack.HasCallStack, MonadIO m, IsTreeModelFilter a) =>
    a
    {- ^ /@filter@/: A 'GI.Gtk.Objects.TreeModelFilter.TreeModelFilter'. -}
    -> m Gtk.TreeModel.TreeModel
    {- ^ __Returns:__ A pointer to a 'GI.Gtk.Interfaces.TreeModel.TreeModel'. -}
treeModelFilterGetModel filter = liftIO $ do
    filter' <- unsafeManagedPtrCastPtr filter
    result <- gtk_tree_model_filter_get_model filter'
    checkUnexpectedReturnNULL "treeModelFilterGetModel" result
    result' <- (newObject Gtk.TreeModel.TreeModel) result
    touchManagedPtr filter
    return result'

#if ENABLE_OVERLOADING
data TreeModelFilterGetModelMethodInfo
instance (signature ~ (m Gtk.TreeModel.TreeModel), MonadIO m, IsTreeModelFilter a) => O.MethodInfo TreeModelFilterGetModelMethodInfo a signature where
    overloadedMethod _ = treeModelFilterGetModel

#endif

-- method TreeModelFilter::refilter
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "filter", argType = TInterface (Name {namespace = "Gtk", name = "TreeModelFilter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GtkTreeModelFilter.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_tree_model_filter_refilter" gtk_tree_model_filter_refilter :: 
    Ptr TreeModelFilter ->                  -- filter : TInterface (Name {namespace = "Gtk", name = "TreeModelFilter"})
    IO ()

{- |
Emits ::row_changed for each row in the child model, which causes
the filter to re-evaluate whether a row is visible or not.

/Since: 2.4/
-}
treeModelFilterRefilter ::
    (B.CallStack.HasCallStack, MonadIO m, IsTreeModelFilter a) =>
    a
    {- ^ /@filter@/: A 'GI.Gtk.Objects.TreeModelFilter.TreeModelFilter'. -}
    -> m ()
treeModelFilterRefilter filter = liftIO $ do
    filter' <- unsafeManagedPtrCastPtr filter
    gtk_tree_model_filter_refilter filter'
    touchManagedPtr filter
    return ()

#if ENABLE_OVERLOADING
data TreeModelFilterRefilterMethodInfo
instance (signature ~ (m ()), MonadIO m, IsTreeModelFilter a) => O.MethodInfo TreeModelFilterRefilterMethodInfo a signature where
    overloadedMethod _ = treeModelFilterRefilter

#endif

-- method TreeModelFilter::set_visible_column
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "filter", argType = TInterface (Name {namespace = "Gtk", name = "TreeModelFilter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GtkTreeModelFilter", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "column", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #gint which is the column containing the visible information", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_tree_model_filter_set_visible_column" gtk_tree_model_filter_set_visible_column :: 
    Ptr TreeModelFilter ->                  -- filter : TInterface (Name {namespace = "Gtk", name = "TreeModelFilter"})
    Int32 ->                                -- column : TBasicType TInt
    IO ()

{- |
Sets /@column@/ of the child_model to be the column where /@filter@/ should
look for visibility information. /@columns@/ should be a column of type
@/G_TYPE_BOOLEAN/@, where 'True' means that a row is visible, and 'False'
if not.

Note that 'GI.Gtk.Objects.TreeModelFilter.treeModelFilterSetVisibleFunc' or
'GI.Gtk.Objects.TreeModelFilter.treeModelFilterSetVisibleColumn' can only be called
once for a given filter model.

/Since: 2.4/
-}
treeModelFilterSetVisibleColumn ::
    (B.CallStack.HasCallStack, MonadIO m, IsTreeModelFilter a) =>
    a
    {- ^ /@filter@/: A 'GI.Gtk.Objects.TreeModelFilter.TreeModelFilter' -}
    -> Int32
    {- ^ /@column@/: A @/gint/@ which is the column containing the visible information -}
    -> m ()
treeModelFilterSetVisibleColumn filter column = liftIO $ do
    filter' <- unsafeManagedPtrCastPtr filter
    gtk_tree_model_filter_set_visible_column filter' column
    touchManagedPtr filter
    return ()

#if ENABLE_OVERLOADING
data TreeModelFilterSetVisibleColumnMethodInfo
instance (signature ~ (Int32 -> m ()), MonadIO m, IsTreeModelFilter a) => O.MethodInfo TreeModelFilterSetVisibleColumnMethodInfo a signature where
    overloadedMethod _ = treeModelFilterSetVisibleColumn

#endif

-- method TreeModelFilter::set_visible_func
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "filter", argType = TInterface (Name {namespace = "Gtk", name = "TreeModelFilter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GtkTreeModelFilter", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "func", argType = TInterface (Name {namespace = "Gtk", name = "TreeModelFilterVisibleFunc"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GtkTreeModelFilterVisibleFunc, the visible function", sinceVersion = Nothing}, argScope = ScopeTypeNotified, argClosure = 2, argDestroy = 3, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "User data to pass to the visible function, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "destroy", argType = TInterface (Name {namespace = "GLib", name = "DestroyNotify"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Destroy notifier of @data, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeAsync, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_tree_model_filter_set_visible_func" gtk_tree_model_filter_set_visible_func :: 
    Ptr TreeModelFilter ->                  -- filter : TInterface (Name {namespace = "Gtk", name = "TreeModelFilter"})
    FunPtr Gtk.Callbacks.C_TreeModelFilterVisibleFunc -> -- func : TInterface (Name {namespace = "Gtk", name = "TreeModelFilterVisibleFunc"})
    Ptr () ->                               -- data : TBasicType TPtr
    FunPtr GLib.Callbacks.C_DestroyNotify -> -- destroy : TInterface (Name {namespace = "GLib", name = "DestroyNotify"})
    IO ()

{- |
Sets the visible function used when filtering the /@filter@/ to be /@func@/.
The function should return 'True' if the given row should be visible and
'False' otherwise.

If the condition calculated by the function changes over time (e.g.
because it depends on some global parameters), you must call
'GI.Gtk.Objects.TreeModelFilter.treeModelFilterRefilter' to keep the visibility information
of the model up-to-date.

Note that /@func@/ is called whenever a row is inserted, when it may still
be empty. The visible function should therefore take special care of empty
rows, like in the example below.


=== /C code/
>
>static gboolean
>visible_func (GtkTreeModel *model,
>              GtkTreeIter  *iter,
>              gpointer      data)
>{
>  // Visible if row is non-empty and first column is “HI”
>  gchar *str;
>  gboolean visible = FALSE;
>
>  gtk_tree_model_get (model, iter, 0, &str, -1);
>  if (str && strcmp (str, "HI") == 0)
>    visible = TRUE;
>  g_free (str);
>
>  return visible;
>}


Note that 'GI.Gtk.Objects.TreeModelFilter.treeModelFilterSetVisibleFunc' or
'GI.Gtk.Objects.TreeModelFilter.treeModelFilterSetVisibleColumn' can only be called
once for a given filter model.

/Since: 2.4/
-}
treeModelFilterSetVisibleFunc ::
    (B.CallStack.HasCallStack, MonadIO m, IsTreeModelFilter a) =>
    a
    {- ^ /@filter@/: A 'GI.Gtk.Objects.TreeModelFilter.TreeModelFilter' -}
    -> Gtk.Callbacks.TreeModelFilterVisibleFunc
    {- ^ /@func@/: A 'GI.Gtk.Callbacks.TreeModelFilterVisibleFunc', the visible function -}
    -> m ()
treeModelFilterSetVisibleFunc filter func = liftIO $ do
    filter' <- unsafeManagedPtrCastPtr filter
    func' <- Gtk.Callbacks.mk_TreeModelFilterVisibleFunc (Gtk.Callbacks.wrap_TreeModelFilterVisibleFunc Nothing (Gtk.Callbacks.drop_closures_TreeModelFilterVisibleFunc func))
    let data_ = castFunPtrToPtr func'
    let destroy = safeFreeFunPtrPtr
    gtk_tree_model_filter_set_visible_func filter' func' data_ destroy
    touchManagedPtr filter
    return ()

#if ENABLE_OVERLOADING
data TreeModelFilterSetVisibleFuncMethodInfo
instance (signature ~ (Gtk.Callbacks.TreeModelFilterVisibleFunc -> m ()), MonadIO m, IsTreeModelFilter a) => O.MethodInfo TreeModelFilterSetVisibleFuncMethodInfo a signature where
    overloadedMethod _ = treeModelFilterSetVisibleFunc

#endif