{- | 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 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 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