{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Gtk.Objects.TreeModelFilter
(
TreeModelFilter(..) ,
IsTreeModelFilter ,
toTreeModelFilter ,
#if defined(ENABLE_OVERLOADING)
ResolveTreeModelFilterMethod ,
#endif
#if defined(ENABLE_OVERLOADING)
TreeModelFilterClearCacheMethodInfo ,
#endif
treeModelFilterClearCache ,
#if defined(ENABLE_OVERLOADING)
TreeModelFilterConvertChildIterToIterMethodInfo,
#endif
treeModelFilterConvertChildIterToIter ,
#if defined(ENABLE_OVERLOADING)
TreeModelFilterConvertChildPathToPathMethodInfo,
#endif
treeModelFilterConvertChildPathToPath ,
#if defined(ENABLE_OVERLOADING)
TreeModelFilterConvertIterToChildIterMethodInfo,
#endif
treeModelFilterConvertIterToChildIter ,
#if defined(ENABLE_OVERLOADING)
TreeModelFilterConvertPathToChildPathMethodInfo,
#endif
treeModelFilterConvertPathToChildPath ,
#if defined(ENABLE_OVERLOADING)
TreeModelFilterGetModelMethodInfo ,
#endif
treeModelFilterGetModel ,
#if defined(ENABLE_OVERLOADING)
TreeModelFilterRefilterMethodInfo ,
#endif
treeModelFilterRefilter ,
#if defined(ENABLE_OVERLOADING)
TreeModelFilterSetVisibleColumnMethodInfo,
#endif
treeModelFilterSetVisibleColumn ,
#if defined(ENABLE_OVERLOADING)
TreeModelFilterSetVisibleFuncMethodInfo ,
#endif
treeModelFilterSetVisibleFunc ,
#if defined(ENABLE_OVERLOADING)
TreeModelFilterChildModelPropertyInfo ,
#endif
constructTreeModelFilterChildModel ,
getTreeModelFilterChildModel ,
#if defined(ENABLE_OVERLOADING)
treeModelFilterChildModel ,
#endif
#if defined(ENABLE_OVERLOADING)
TreeModelFilterVirtualRootPropertyInfo ,
#endif
constructTreeModelFilterVirtualRoot ,
getTreeModelFilterVirtualRoot ,
#if defined(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.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.GHashTable as B.GHT
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.Kind as DK
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 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
newtype TreeModelFilter = TreeModelFilter (SP.ManagedPtr TreeModelFilter)
deriving (TreeModelFilter -> TreeModelFilter -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: TreeModelFilter -> TreeModelFilter -> Bool
$c/= :: TreeModelFilter -> TreeModelFilter -> Bool
== :: TreeModelFilter -> TreeModelFilter -> Bool
$c== :: TreeModelFilter -> TreeModelFilter -> Bool
Eq)
instance SP.ManagedPtrNewtype TreeModelFilter where
toManagedPtr :: TreeModelFilter -> ManagedPtr TreeModelFilter
toManagedPtr (TreeModelFilter ManagedPtr TreeModelFilter
p) = ManagedPtr TreeModelFilter
p
foreign import ccall "gtk_tree_model_filter_get_type"
c_gtk_tree_model_filter_get_type :: IO B.Types.GType
instance B.Types.TypedObject TreeModelFilter where
glibType :: IO GType
glibType = IO GType
c_gtk_tree_model_filter_get_type
instance B.Types.GObject TreeModelFilter
class (SP.GObject o, O.IsDescendantOf TreeModelFilter o) => IsTreeModelFilter o
instance (SP.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]
toTreeModelFilter :: (MIO.MonadIO m, IsTreeModelFilter o) => o -> m TreeModelFilter
toTreeModelFilter :: forall (m :: * -> *) o.
(MonadIO m, IsTreeModelFilter o) =>
o -> m TreeModelFilter
toTreeModelFilter = forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall o o'.
(HasCallStack, ManagedPtrNewtype o, TypedObject o,
ManagedPtrNewtype o', TypedObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
B.ManagedPtr.unsafeCastTo ManagedPtr TreeModelFilter -> TreeModelFilter
TreeModelFilter
instance B.GValue.IsGValue (Maybe TreeModelFilter) where
gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_gtk_tree_model_filter_get_type
gvalueSet_ :: Ptr GValue -> Maybe TreeModelFilter -> IO ()
gvalueSet_ Ptr GValue
gv Maybe TreeModelFilter
P.Nothing = forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv (forall a. Ptr a
FP.nullPtr :: FP.Ptr TreeModelFilter)
gvalueSet_ Ptr GValue
gv (P.Just TreeModelFilter
obj) = forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr TreeModelFilter
obj (forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv)
gvalueGet_ :: Ptr GValue -> IO (Maybe TreeModelFilter)
gvalueGet_ Ptr GValue
gv = do
Ptr TreeModelFilter
ptr <- forall a. GObject a => Ptr GValue -> IO (Ptr a)
B.GValue.get_object Ptr GValue
gv :: IO (FP.Ptr TreeModelFilter)
if Ptr TreeModelFilter
ptr forall a. Eq a => a -> a -> Bool
/= forall a. Ptr a
FP.nullPtr
then forall a. a -> Maybe a
P.Just forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr TreeModelFilter -> TreeModelFilter
TreeModelFilter Ptr TreeModelFilter
ptr
else forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Maybe a
P.Nothing
#if defined(ENABLE_OVERLOADING)
type family ResolveTreeModelFilterMethod (t :: Symbol) (o :: DK.Type) :: DK.Type 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 "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 "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
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.OverloadedMethod info TreeModelFilter p) => OL.IsLabel t (TreeModelFilter -> 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 ~ ResolveTreeModelFilterMethod t TreeModelFilter, O.OverloadedMethod info TreeModelFilter p, R.HasField t TreeModelFilter p) => R.HasField t TreeModelFilter p where
getField = O.overloadedMethod @info
#endif
instance (info ~ ResolveTreeModelFilterMethod t TreeModelFilter, O.OverloadedMethodInfo info TreeModelFilter) => OL.IsLabel t (O.MethodProxy info TreeModelFilter) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.MethodProxy
#else
fromLabel _ = O.MethodProxy
#endif
#endif
getTreeModelFilterChildModel :: (MonadIO m, IsTreeModelFilter o) => o -> m (Maybe Gtk.TreeModel.TreeModel)
getTreeModelFilterChildModel :: forall (m :: * -> *) o.
(MonadIO m, IsTreeModelFilter o) =>
o -> m (Maybe TreeModel)
getTreeModelFilterChildModel o
obj = forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO forall a b. (a -> b) -> a -> b
$ forall a b.
(GObject a, GObject b) =>
a -> String -> (ManagedPtr b -> b) -> IO (Maybe b)
B.Properties.getObjectPropertyObject o
obj String
"child-model" ManagedPtr TreeModel -> TreeModel
Gtk.TreeModel.TreeModel
constructTreeModelFilterChildModel :: (IsTreeModelFilter o, MIO.MonadIO m, Gtk.TreeModel.IsTreeModel a) => a -> m (GValueConstruct o)
constructTreeModelFilterChildModel :: forall o (m :: * -> *) a.
(IsTreeModelFilter o, MonadIO m, IsTreeModel a) =>
a -> m (GValueConstruct o)
constructTreeModelFilterChildModel a
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO forall a b. (a -> b) -> a -> b
$ do
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO forall a b. (a -> b) -> a -> b
$ forall a o.
GObject a =>
String -> Maybe a -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyObject String
"child-model" (forall a. a -> Maybe a
P.Just a
val)
#if defined(ENABLE_OVERLOADING)
data TreeModelFilterChildModelPropertyInfo
instance AttrInfo TreeModelFilterChildModelPropertyInfo where
type AttrAllowedOps TreeModelFilterChildModelPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear]
type AttrBaseTypeConstraint TreeModelFilterChildModelPropertyInfo = IsTreeModelFilter
type AttrSetTypeConstraint TreeModelFilterChildModelPropertyInfo = Gtk.TreeModel.IsTreeModel
type AttrTransferTypeConstraint TreeModelFilterChildModelPropertyInfo = Gtk.TreeModel.IsTreeModel
type AttrTransferType TreeModelFilterChildModelPropertyInfo = Gtk.TreeModel.TreeModel
type AttrGetType TreeModelFilterChildModelPropertyInfo = (Maybe Gtk.TreeModel.TreeModel)
type AttrLabel TreeModelFilterChildModelPropertyInfo = "child-model"
type AttrOrigin TreeModelFilterChildModelPropertyInfo = TreeModelFilter
attrGet = getTreeModelFilterChildModel
attrSet = undefined
attrTransfer _ v = do
unsafeCastTo Gtk.TreeModel.TreeModel v
attrConstruct = constructTreeModelFilterChildModel
attrClear = undefined
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Objects.TreeModelFilter.childModel"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.39/docs/GI-Gtk-Objects-TreeModelFilter.html#g:attr:childModel"
})
#endif
getTreeModelFilterVirtualRoot :: (MonadIO m, IsTreeModelFilter o) => o -> m (Maybe Gtk.TreePath.TreePath)
getTreeModelFilterVirtualRoot :: forall (m :: * -> *) o.
(MonadIO m, IsTreeModelFilter o) =>
o -> m (Maybe TreePath)
getTreeModelFilterVirtualRoot o
obj = forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO forall a b. (a -> b) -> a -> b
$ forall a b.
(GObject a, GBoxed b) =>
a -> String -> (ManagedPtr b -> b) -> IO (Maybe b)
B.Properties.getObjectPropertyBoxed o
obj String
"virtual-root" ManagedPtr TreePath -> TreePath
Gtk.TreePath.TreePath
constructTreeModelFilterVirtualRoot :: (IsTreeModelFilter o, MIO.MonadIO m) => Gtk.TreePath.TreePath -> m (GValueConstruct o)
constructTreeModelFilterVirtualRoot :: forall o (m :: * -> *).
(IsTreeModelFilter o, MonadIO m) =>
TreePath -> m (GValueConstruct o)
constructTreeModelFilterVirtualRoot TreePath
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO forall a b. (a -> b) -> a -> b
$ do
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO forall a b. (a -> b) -> a -> b
$ forall a o. GBoxed a => String -> Maybe a -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyBoxed String
"virtual-root" (forall a. a -> Maybe a
P.Just TreePath
val)
#if defined(ENABLE_OVERLOADING)
data TreeModelFilterVirtualRootPropertyInfo
instance AttrInfo TreeModelFilterVirtualRootPropertyInfo where
type AttrAllowedOps TreeModelFilterVirtualRootPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear]
type AttrBaseTypeConstraint TreeModelFilterVirtualRootPropertyInfo = IsTreeModelFilter
type AttrSetTypeConstraint TreeModelFilterVirtualRootPropertyInfo = (~) Gtk.TreePath.TreePath
type AttrTransferTypeConstraint TreeModelFilterVirtualRootPropertyInfo = (~) Gtk.TreePath.TreePath
type AttrTransferType TreeModelFilterVirtualRootPropertyInfo = Gtk.TreePath.TreePath
type AttrGetType TreeModelFilterVirtualRootPropertyInfo = (Maybe Gtk.TreePath.TreePath)
type AttrLabel TreeModelFilterVirtualRootPropertyInfo = "virtual-root"
type AttrOrigin TreeModelFilterVirtualRootPropertyInfo = TreeModelFilter
attrGet = getTreeModelFilterVirtualRoot
attrSet = undefined
attrTransfer _ v = do
return v
attrConstruct = constructTreeModelFilterVirtualRoot
attrClear = undefined
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Objects.TreeModelFilter.virtualRoot"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.39/docs/GI-Gtk-Objects-TreeModelFilter.html#g:attr:virtualRoot"
})
#endif
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList TreeModelFilter
type instance O.AttributeList TreeModelFilter = TreeModelFilterAttributeList
type TreeModelFilterAttributeList = ('[ '("childModel", TreeModelFilterChildModelPropertyInfo), '("virtualRoot", TreeModelFilterVirtualRootPropertyInfo)] :: [(Symbol, DK.Type)])
#endif
#if defined(ENABLE_OVERLOADING)
treeModelFilterChildModel :: AttrLabelProxy "childModel"
treeModelFilterChildModel = AttrLabelProxy
treeModelFilterVirtualRoot :: AttrLabelProxy "virtualRoot"
treeModelFilterVirtualRoot = AttrLabelProxy
#endif
#if defined(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, DK.Type)])
#endif
foreign import ccall "gtk_tree_model_filter_clear_cache" gtk_tree_model_filter_clear_cache ::
Ptr TreeModelFilter ->
IO ()
treeModelFilterClearCache ::
(B.CallStack.HasCallStack, MonadIO m, IsTreeModelFilter a) =>
a
-> m ()
treeModelFilterClearCache :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTreeModelFilter a) =>
a -> m ()
treeModelFilterClearCache a
filter = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr TreeModelFilter
filter' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
filter
Ptr TreeModelFilter -> IO ()
gtk_tree_model_filter_clear_cache Ptr TreeModelFilter
filter'
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
filter
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data TreeModelFilterClearCacheMethodInfo
instance (signature ~ (m ()), MonadIO m, IsTreeModelFilter a) => O.OverloadedMethod TreeModelFilterClearCacheMethodInfo a signature where
overloadedMethod = treeModelFilterClearCache
instance O.OverloadedMethodInfo TreeModelFilterClearCacheMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Objects.TreeModelFilter.treeModelFilterClearCache",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.39/docs/GI-Gtk-Objects-TreeModelFilter.html#v:treeModelFilterClearCache"
})
#endif
foreign import ccall "gtk_tree_model_filter_convert_child_iter_to_iter" gtk_tree_model_filter_convert_child_iter_to_iter ::
Ptr TreeModelFilter ->
Ptr Gtk.TreeIter.TreeIter ->
Ptr Gtk.TreeIter.TreeIter ->
IO CInt
treeModelFilterConvertChildIterToIter ::
(B.CallStack.HasCallStack, MonadIO m, IsTreeModelFilter a) =>
a
-> Gtk.TreeIter.TreeIter
-> m ((Bool, Gtk.TreeIter.TreeIter))
treeModelFilterConvertChildIterToIter :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTreeModelFilter a) =>
a -> TreeIter -> m (Bool, TreeIter)
treeModelFilterConvertChildIterToIter a
filter TreeIter
childIter = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr TreeModelFilter
filter' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
filter
Ptr TreeIter
filterIter <- forall a. GBoxed a => Int -> IO (Ptr a)
SP.callocBoxedBytes Int
32 :: IO (Ptr Gtk.TreeIter.TreeIter)
Ptr TreeIter
childIter' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr TreeIter
childIter
CInt
result <- Ptr TreeModelFilter -> Ptr TreeIter -> Ptr TreeIter -> IO CInt
gtk_tree_model_filter_convert_child_iter_to_iter Ptr TreeModelFilter
filter' Ptr TreeIter
filterIter Ptr TreeIter
childIter'
let result' :: Bool
result' = (forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
TreeIter
filterIter' <- (forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr TreeIter -> TreeIter
Gtk.TreeIter.TreeIter) Ptr TreeIter
filterIter
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
filter
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr TreeIter
childIter
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool
result', TreeIter
filterIter')
#if defined(ENABLE_OVERLOADING)
data TreeModelFilterConvertChildIterToIterMethodInfo
instance (signature ~ (Gtk.TreeIter.TreeIter -> m ((Bool, Gtk.TreeIter.TreeIter))), MonadIO m, IsTreeModelFilter a) => O.OverloadedMethod TreeModelFilterConvertChildIterToIterMethodInfo a signature where
overloadedMethod = treeModelFilterConvertChildIterToIter
instance O.OverloadedMethodInfo TreeModelFilterConvertChildIterToIterMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Objects.TreeModelFilter.treeModelFilterConvertChildIterToIter",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.39/docs/GI-Gtk-Objects-TreeModelFilter.html#v:treeModelFilterConvertChildIterToIter"
})
#endif
foreign import ccall "gtk_tree_model_filter_convert_child_path_to_path" gtk_tree_model_filter_convert_child_path_to_path ::
Ptr TreeModelFilter ->
Ptr Gtk.TreePath.TreePath ->
IO (Ptr Gtk.TreePath.TreePath)
treeModelFilterConvertChildPathToPath ::
(B.CallStack.HasCallStack, MonadIO m, IsTreeModelFilter a) =>
a
-> Gtk.TreePath.TreePath
-> m (Maybe Gtk.TreePath.TreePath)
treeModelFilterConvertChildPathToPath :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTreeModelFilter a) =>
a -> TreePath -> m (Maybe TreePath)
treeModelFilterConvertChildPathToPath a
filter TreePath
childPath = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr TreeModelFilter
filter' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
filter
Ptr TreePath
childPath' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr TreePath
childPath
Ptr TreePath
result <- Ptr TreeModelFilter -> Ptr TreePath -> IO (Ptr TreePath)
gtk_tree_model_filter_convert_child_path_to_path Ptr TreeModelFilter
filter' Ptr TreePath
childPath'
Maybe TreePath
maybeResult <- forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr TreePath
result forall a b. (a -> b) -> a -> b
$ \Ptr TreePath
result' -> do
TreePath
result'' <- (forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr TreePath -> TreePath
Gtk.TreePath.TreePath) Ptr TreePath
result'
forall (m :: * -> *) a. Monad m => a -> m a
return TreePath
result''
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
filter
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr TreePath
childPath
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe TreePath
maybeResult
#if defined(ENABLE_OVERLOADING)
data TreeModelFilterConvertChildPathToPathMethodInfo
instance (signature ~ (Gtk.TreePath.TreePath -> m (Maybe Gtk.TreePath.TreePath)), MonadIO m, IsTreeModelFilter a) => O.OverloadedMethod TreeModelFilterConvertChildPathToPathMethodInfo a signature where
overloadedMethod = treeModelFilterConvertChildPathToPath
instance O.OverloadedMethodInfo TreeModelFilterConvertChildPathToPathMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Objects.TreeModelFilter.treeModelFilterConvertChildPathToPath",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.39/docs/GI-Gtk-Objects-TreeModelFilter.html#v:treeModelFilterConvertChildPathToPath"
})
#endif
foreign import ccall "gtk_tree_model_filter_convert_iter_to_child_iter" gtk_tree_model_filter_convert_iter_to_child_iter ::
Ptr TreeModelFilter ->
Ptr Gtk.TreeIter.TreeIter ->
Ptr Gtk.TreeIter.TreeIter ->
IO ()
treeModelFilterConvertIterToChildIter ::
(B.CallStack.HasCallStack, MonadIO m, IsTreeModelFilter a) =>
a
-> Gtk.TreeIter.TreeIter
-> m (Gtk.TreeIter.TreeIter)
treeModelFilterConvertIterToChildIter :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTreeModelFilter a) =>
a -> TreeIter -> m TreeIter
treeModelFilterConvertIterToChildIter a
filter TreeIter
filterIter = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr TreeModelFilter
filter' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
filter
Ptr TreeIter
childIter <- forall a. GBoxed a => Int -> IO (Ptr a)
SP.callocBoxedBytes Int
32 :: IO (Ptr Gtk.TreeIter.TreeIter)
Ptr TreeIter
filterIter' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr TreeIter
filterIter
Ptr TreeModelFilter -> Ptr TreeIter -> Ptr TreeIter -> IO ()
gtk_tree_model_filter_convert_iter_to_child_iter Ptr TreeModelFilter
filter' Ptr TreeIter
childIter Ptr TreeIter
filterIter'
TreeIter
childIter' <- (forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr TreeIter -> TreeIter
Gtk.TreeIter.TreeIter) Ptr TreeIter
childIter
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
filter
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr TreeIter
filterIter
forall (m :: * -> *) a. Monad m => a -> m a
return TreeIter
childIter'
#if defined(ENABLE_OVERLOADING)
data TreeModelFilterConvertIterToChildIterMethodInfo
instance (signature ~ (Gtk.TreeIter.TreeIter -> m (Gtk.TreeIter.TreeIter)), MonadIO m, IsTreeModelFilter a) => O.OverloadedMethod TreeModelFilterConvertIterToChildIterMethodInfo a signature where
overloadedMethod = treeModelFilterConvertIterToChildIter
instance O.OverloadedMethodInfo TreeModelFilterConvertIterToChildIterMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Objects.TreeModelFilter.treeModelFilterConvertIterToChildIter",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.39/docs/GI-Gtk-Objects-TreeModelFilter.html#v:treeModelFilterConvertIterToChildIter"
})
#endif
foreign import ccall "gtk_tree_model_filter_convert_path_to_child_path" gtk_tree_model_filter_convert_path_to_child_path ::
Ptr TreeModelFilter ->
Ptr Gtk.TreePath.TreePath ->
IO (Ptr Gtk.TreePath.TreePath)
treeModelFilterConvertPathToChildPath ::
(B.CallStack.HasCallStack, MonadIO m, IsTreeModelFilter a) =>
a
-> Gtk.TreePath.TreePath
-> m (Maybe Gtk.TreePath.TreePath)
treeModelFilterConvertPathToChildPath :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTreeModelFilter a) =>
a -> TreePath -> m (Maybe TreePath)
treeModelFilterConvertPathToChildPath a
filter TreePath
filterPath = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr TreeModelFilter
filter' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
filter
Ptr TreePath
filterPath' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr TreePath
filterPath
Ptr TreePath
result <- Ptr TreeModelFilter -> Ptr TreePath -> IO (Ptr TreePath)
gtk_tree_model_filter_convert_path_to_child_path Ptr TreeModelFilter
filter' Ptr TreePath
filterPath'
Maybe TreePath
maybeResult <- forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr TreePath
result forall a b. (a -> b) -> a -> b
$ \Ptr TreePath
result' -> do
TreePath
result'' <- (forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr TreePath -> TreePath
Gtk.TreePath.TreePath) Ptr TreePath
result'
forall (m :: * -> *) a. Monad m => a -> m a
return TreePath
result''
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
filter
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr TreePath
filterPath
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe TreePath
maybeResult
#if defined(ENABLE_OVERLOADING)
data TreeModelFilterConvertPathToChildPathMethodInfo
instance (signature ~ (Gtk.TreePath.TreePath -> m (Maybe Gtk.TreePath.TreePath)), MonadIO m, IsTreeModelFilter a) => O.OverloadedMethod TreeModelFilterConvertPathToChildPathMethodInfo a signature where
overloadedMethod = treeModelFilterConvertPathToChildPath
instance O.OverloadedMethodInfo TreeModelFilterConvertPathToChildPathMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Objects.TreeModelFilter.treeModelFilterConvertPathToChildPath",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.39/docs/GI-Gtk-Objects-TreeModelFilter.html#v:treeModelFilterConvertPathToChildPath"
})
#endif
foreign import ccall "gtk_tree_model_filter_get_model" gtk_tree_model_filter_get_model ::
Ptr TreeModelFilter ->
IO (Ptr Gtk.TreeModel.TreeModel)
treeModelFilterGetModel ::
(B.CallStack.HasCallStack, MonadIO m, IsTreeModelFilter a) =>
a
-> m Gtk.TreeModel.TreeModel
treeModelFilterGetModel :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTreeModelFilter a) =>
a -> m TreeModel
treeModelFilterGetModel a
filter = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr TreeModelFilter
filter' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
filter
Ptr TreeModel
result <- Ptr TreeModelFilter -> IO (Ptr TreeModel)
gtk_tree_model_filter_get_model Ptr TreeModelFilter
filter'
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"treeModelFilterGetModel" Ptr TreeModel
result
TreeModel
result' <- (forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr TreeModel -> TreeModel
Gtk.TreeModel.TreeModel) Ptr TreeModel
result
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
filter
forall (m :: * -> *) a. Monad m => a -> m a
return TreeModel
result'
#if defined(ENABLE_OVERLOADING)
data TreeModelFilterGetModelMethodInfo
instance (signature ~ (m Gtk.TreeModel.TreeModel), MonadIO m, IsTreeModelFilter a) => O.OverloadedMethod TreeModelFilterGetModelMethodInfo a signature where
overloadedMethod = treeModelFilterGetModel
instance O.OverloadedMethodInfo TreeModelFilterGetModelMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Objects.TreeModelFilter.treeModelFilterGetModel",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.39/docs/GI-Gtk-Objects-TreeModelFilter.html#v:treeModelFilterGetModel"
})
#endif
foreign import ccall "gtk_tree_model_filter_refilter" gtk_tree_model_filter_refilter ::
Ptr TreeModelFilter ->
IO ()
treeModelFilterRefilter ::
(B.CallStack.HasCallStack, MonadIO m, IsTreeModelFilter a) =>
a
-> m ()
treeModelFilterRefilter :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTreeModelFilter a) =>
a -> m ()
treeModelFilterRefilter a
filter = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr TreeModelFilter
filter' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
filter
Ptr TreeModelFilter -> IO ()
gtk_tree_model_filter_refilter Ptr TreeModelFilter
filter'
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
filter
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data TreeModelFilterRefilterMethodInfo
instance (signature ~ (m ()), MonadIO m, IsTreeModelFilter a) => O.OverloadedMethod TreeModelFilterRefilterMethodInfo a signature where
overloadedMethod = treeModelFilterRefilter
instance O.OverloadedMethodInfo TreeModelFilterRefilterMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Objects.TreeModelFilter.treeModelFilterRefilter",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.39/docs/GI-Gtk-Objects-TreeModelFilter.html#v:treeModelFilterRefilter"
})
#endif
foreign import ccall "gtk_tree_model_filter_set_visible_column" gtk_tree_model_filter_set_visible_column ::
Ptr TreeModelFilter ->
Int32 ->
IO ()
treeModelFilterSetVisibleColumn ::
(B.CallStack.HasCallStack, MonadIO m, IsTreeModelFilter a) =>
a
-> Int32
-> m ()
treeModelFilterSetVisibleColumn :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTreeModelFilter a) =>
a -> Int32 -> m ()
treeModelFilterSetVisibleColumn a
filter Int32
column = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr TreeModelFilter
filter' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
filter
Ptr TreeModelFilter -> Int32 -> IO ()
gtk_tree_model_filter_set_visible_column Ptr TreeModelFilter
filter' Int32
column
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
filter
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data TreeModelFilterSetVisibleColumnMethodInfo
instance (signature ~ (Int32 -> m ()), MonadIO m, IsTreeModelFilter a) => O.OverloadedMethod TreeModelFilterSetVisibleColumnMethodInfo a signature where
overloadedMethod = treeModelFilterSetVisibleColumn
instance O.OverloadedMethodInfo TreeModelFilterSetVisibleColumnMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Objects.TreeModelFilter.treeModelFilterSetVisibleColumn",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.39/docs/GI-Gtk-Objects-TreeModelFilter.html#v:treeModelFilterSetVisibleColumn"
})
#endif
foreign import ccall "gtk_tree_model_filter_set_visible_func" gtk_tree_model_filter_set_visible_func ::
Ptr TreeModelFilter ->
FunPtr Gtk.Callbacks.C_TreeModelFilterVisibleFunc ->
Ptr () ->
FunPtr GLib.Callbacks.C_DestroyNotify ->
IO ()
treeModelFilterSetVisibleFunc ::
(B.CallStack.HasCallStack, MonadIO m, IsTreeModelFilter a) =>
a
-> Gtk.Callbacks.TreeModelFilterVisibleFunc
-> m ()
treeModelFilterSetVisibleFunc :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTreeModelFilter a) =>
a -> TreeModelFilterVisibleFunc -> m ()
treeModelFilterSetVisibleFunc a
filter TreeModelFilterVisibleFunc
func = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr TreeModelFilter
filter' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
filter
FunPtr C_TreeModelFilterVisibleFunc
func' <- C_TreeModelFilterVisibleFunc
-> IO (FunPtr C_TreeModelFilterVisibleFunc)
Gtk.Callbacks.mk_TreeModelFilterVisibleFunc (Maybe (Ptr (FunPtr C_TreeModelFilterVisibleFunc))
-> TreeModelFilterVisibleFunc_WithClosures
-> C_TreeModelFilterVisibleFunc
Gtk.Callbacks.wrap_TreeModelFilterVisibleFunc forall a. Maybe a
Nothing (TreeModelFilterVisibleFunc
-> TreeModelFilterVisibleFunc_WithClosures
Gtk.Callbacks.drop_closures_TreeModelFilterVisibleFunc TreeModelFilterVisibleFunc
func))
let data_ :: Ptr ()
data_ = forall a b. FunPtr a -> Ptr b
castFunPtrToPtr FunPtr C_TreeModelFilterVisibleFunc
func'
let destroy :: FunPtr (Ptr a -> IO ())
destroy = forall a. FunPtr (Ptr a -> IO ())
SP.safeFreeFunPtrPtr
Ptr TreeModelFilter
-> FunPtr C_TreeModelFilterVisibleFunc
-> Ptr ()
-> FunPtr C_DestroyNotify
-> IO ()
gtk_tree_model_filter_set_visible_func Ptr TreeModelFilter
filter' FunPtr C_TreeModelFilterVisibleFunc
func' Ptr ()
data_ forall a. FunPtr (Ptr a -> IO ())
destroy
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
filter
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data TreeModelFilterSetVisibleFuncMethodInfo
instance (signature ~ (Gtk.Callbacks.TreeModelFilterVisibleFunc -> m ()), MonadIO m, IsTreeModelFilter a) => O.OverloadedMethod TreeModelFilterSetVisibleFuncMethodInfo a signature where
overloadedMethod = treeModelFilterSetVisibleFunc
instance O.OverloadedMethodInfo TreeModelFilterSetVisibleFuncMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Objects.TreeModelFilter.treeModelFilterSetVisibleFunc",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.39/docs/GI-Gtk-Objects-TreeModelFilter.html#v:treeModelFilterSetVisibleFunc"
})
#endif