{- | Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte License : LGPL-2.1 Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) The 'GI.Gtk.Objects.TreeSelection.TreeSelection' object is a helper object to manage the selection for a 'GI.Gtk.Objects.TreeView.TreeView' widget. The 'GI.Gtk.Objects.TreeSelection.TreeSelection' object is automatically created when a new 'GI.Gtk.Objects.TreeView.TreeView' widget is created, and cannot exist independently of this widget. The primary reason the 'GI.Gtk.Objects.TreeSelection.TreeSelection' objects exists is for cleanliness of code and API. That is, there is no conceptual reason all these functions could not be methods on the 'GI.Gtk.Objects.TreeView.TreeView' widget instead of a separate function. The 'GI.Gtk.Objects.TreeSelection.TreeSelection' object is gotten from a 'GI.Gtk.Objects.TreeView.TreeView' by calling 'GI.Gtk.Objects.TreeView.treeViewGetSelection'. It can be manipulated to check the selection status of the tree, as well as select and deselect individual rows. Selection is done completely view side. As a result, multiple views of the same model can have completely different selections. Additionally, you cannot change the selection of a row on the model that is not currently displayed by the view without expanding its parents first. One of the important things to remember when monitoring the selection of a view is that the 'GI.Gtk.Objects.TreeSelection.TreeSelection'::@/changed/@ signal is mostly a hint. That is, it may only emit one signal when a range of rows is selected. Additionally, it may on occasion emit a 'GI.Gtk.Objects.TreeSelection.TreeSelection'::@/changed/@ signal when nothing has happened (mostly as a result of programmers calling select_row on an already selected row). -} #define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ && !defined(__HADDOCK_VERSION__)) module GI.Gtk.Objects.TreeSelection ( -- * Exported types TreeSelection(..) , IsTreeSelection , toTreeSelection , noTreeSelection , -- * Methods -- ** countSelectedRows #method:countSelectedRows# #if ENABLE_OVERLOADING TreeSelectionCountSelectedRowsMethodInfo, #endif treeSelectionCountSelectedRows , -- ** getMode #method:getMode# #if ENABLE_OVERLOADING TreeSelectionGetModeMethodInfo , #endif treeSelectionGetMode , -- ** getSelected #method:getSelected# #if ENABLE_OVERLOADING TreeSelectionGetSelectedMethodInfo , #endif treeSelectionGetSelected , -- ** getSelectedRows #method:getSelectedRows# #if ENABLE_OVERLOADING TreeSelectionGetSelectedRowsMethodInfo , #endif treeSelectionGetSelectedRows , -- ** getTreeView #method:getTreeView# #if ENABLE_OVERLOADING TreeSelectionGetTreeViewMethodInfo , #endif treeSelectionGetTreeView , -- ** iterIsSelected #method:iterIsSelected# #if ENABLE_OVERLOADING TreeSelectionIterIsSelectedMethodInfo , #endif treeSelectionIterIsSelected , -- ** pathIsSelected #method:pathIsSelected# #if ENABLE_OVERLOADING TreeSelectionPathIsSelectedMethodInfo , #endif treeSelectionPathIsSelected , -- ** selectAll #method:selectAll# #if ENABLE_OVERLOADING TreeSelectionSelectAllMethodInfo , #endif treeSelectionSelectAll , -- ** selectIter #method:selectIter# #if ENABLE_OVERLOADING TreeSelectionSelectIterMethodInfo , #endif treeSelectionSelectIter , -- ** selectPath #method:selectPath# #if ENABLE_OVERLOADING TreeSelectionSelectPathMethodInfo , #endif treeSelectionSelectPath , -- ** selectRange #method:selectRange# #if ENABLE_OVERLOADING TreeSelectionSelectRangeMethodInfo , #endif treeSelectionSelectRange , -- ** selectedForeach #method:selectedForeach# #if ENABLE_OVERLOADING TreeSelectionSelectedForeachMethodInfo , #endif treeSelectionSelectedForeach , -- ** setMode #method:setMode# #if ENABLE_OVERLOADING TreeSelectionSetModeMethodInfo , #endif treeSelectionSetMode , -- ** setSelectFunction #method:setSelectFunction# #if ENABLE_OVERLOADING TreeSelectionSetSelectFunctionMethodInfo, #endif treeSelectionSetSelectFunction , -- ** unselectAll #method:unselectAll# #if ENABLE_OVERLOADING TreeSelectionUnselectAllMethodInfo , #endif treeSelectionUnselectAll , -- ** unselectIter #method:unselectIter# #if ENABLE_OVERLOADING TreeSelectionUnselectIterMethodInfo , #endif treeSelectionUnselectIter , -- ** unselectPath #method:unselectPath# #if ENABLE_OVERLOADING TreeSelectionUnselectPathMethodInfo , #endif treeSelectionUnselectPath , -- ** unselectRange #method:unselectRange# #if ENABLE_OVERLOADING TreeSelectionUnselectRangeMethodInfo , #endif treeSelectionUnselectRange , -- * Properties -- ** mode #attr:mode# {- | Selection mode. See 'GI.Gtk.Objects.TreeSelection.treeSelectionSetMode' for more information on this property. /Since: 3.2/ -} #if ENABLE_OVERLOADING TreeSelectionModePropertyInfo , #endif constructTreeSelectionMode , getTreeSelectionMode , setTreeSelectionMode , #if ENABLE_OVERLOADING treeSelectionMode , #endif -- * Signals -- ** changed #signal:changed# C_TreeSelectionChangedCallback , TreeSelectionChangedCallback , #if ENABLE_OVERLOADING TreeSelectionChangedSignalInfo , #endif afterTreeSelectionChanged , genClosure_TreeSelectionChanged , mk_TreeSelectionChangedCallback , noTreeSelectionChangedCallback , onTreeSelectionChanged , wrap_TreeSelectionChangedCallback , ) 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.Enums as Gtk.Enums import {-# SOURCE #-} qualified GI.Gtk.Interfaces.TreeModel as Gtk.TreeModel import {-# SOURCE #-} qualified GI.Gtk.Objects.TreeView as Gtk.TreeView 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 TreeSelection = TreeSelection (ManagedPtr TreeSelection) foreign import ccall "gtk_tree_selection_get_type" c_gtk_tree_selection_get_type :: IO GType instance GObject TreeSelection where gobjectType = c_gtk_tree_selection_get_type -- | Type class for types which can be safely cast to `TreeSelection`, for instance with `toTreeSelection`. class (GObject o, O.IsDescendantOf TreeSelection o) => IsTreeSelection o instance (GObject o, O.IsDescendantOf TreeSelection o) => IsTreeSelection o instance O.HasParentTypes TreeSelection type instance O.ParentTypes TreeSelection = '[GObject.Object.Object] -- | Cast to `TreeSelection`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. toTreeSelection :: (MonadIO m, IsTreeSelection o) => o -> m TreeSelection toTreeSelection = liftIO . unsafeCastTo TreeSelection -- | A convenience alias for `Nothing` :: `Maybe` `TreeSelection`. noTreeSelection :: Maybe TreeSelection noTreeSelection = Nothing #if ENABLE_OVERLOADING type family ResolveTreeSelectionMethod (t :: Symbol) (o :: *) :: * where ResolveTreeSelectionMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo ResolveTreeSelectionMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo ResolveTreeSelectionMethod "countSelectedRows" o = TreeSelectionCountSelectedRowsMethodInfo ResolveTreeSelectionMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo ResolveTreeSelectionMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo ResolveTreeSelectionMethod "getv" o = GObject.Object.ObjectGetvMethodInfo ResolveTreeSelectionMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo ResolveTreeSelectionMethod "iterIsSelected" o = TreeSelectionIterIsSelectedMethodInfo ResolveTreeSelectionMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo ResolveTreeSelectionMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo ResolveTreeSelectionMethod "pathIsSelected" o = TreeSelectionPathIsSelectedMethodInfo ResolveTreeSelectionMethod "ref" o = GObject.Object.ObjectRefMethodInfo ResolveTreeSelectionMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo ResolveTreeSelectionMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo ResolveTreeSelectionMethod "selectAll" o = TreeSelectionSelectAllMethodInfo ResolveTreeSelectionMethod "selectIter" o = TreeSelectionSelectIterMethodInfo ResolveTreeSelectionMethod "selectPath" o = TreeSelectionSelectPathMethodInfo ResolveTreeSelectionMethod "selectRange" o = TreeSelectionSelectRangeMethodInfo ResolveTreeSelectionMethod "selectedForeach" o = TreeSelectionSelectedForeachMethodInfo ResolveTreeSelectionMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo ResolveTreeSelectionMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo ResolveTreeSelectionMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo ResolveTreeSelectionMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo ResolveTreeSelectionMethod "unselectAll" o = TreeSelectionUnselectAllMethodInfo ResolveTreeSelectionMethod "unselectIter" o = TreeSelectionUnselectIterMethodInfo ResolveTreeSelectionMethod "unselectPath" o = TreeSelectionUnselectPathMethodInfo ResolveTreeSelectionMethod "unselectRange" o = TreeSelectionUnselectRangeMethodInfo ResolveTreeSelectionMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo ResolveTreeSelectionMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo ResolveTreeSelectionMethod "getMode" o = TreeSelectionGetModeMethodInfo ResolveTreeSelectionMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo ResolveTreeSelectionMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo ResolveTreeSelectionMethod "getSelected" o = TreeSelectionGetSelectedMethodInfo ResolveTreeSelectionMethod "getSelectedRows" o = TreeSelectionGetSelectedRowsMethodInfo ResolveTreeSelectionMethod "getTreeView" o = TreeSelectionGetTreeViewMethodInfo ResolveTreeSelectionMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo ResolveTreeSelectionMethod "setMode" o = TreeSelectionSetModeMethodInfo ResolveTreeSelectionMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo ResolveTreeSelectionMethod "setSelectFunction" o = TreeSelectionSetSelectFunctionMethodInfo ResolveTreeSelectionMethod l o = O.MethodResolutionFailed l o instance (info ~ ResolveTreeSelectionMethod t TreeSelection, O.MethodInfo info TreeSelection p) => OL.IsLabel t (TreeSelection -> 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 -- signal TreeSelection::changed {- | Emitted whenever the selection has (possibly) changed. Please note that this signal is mostly a hint. It may only be emitted once when a range of rows are selected, and it may occasionally be emitted when nothing has happened. -} type TreeSelectionChangedCallback = IO () -- | A convenience synonym for @`Nothing` :: `Maybe` `TreeSelectionChangedCallback`@. noTreeSelectionChangedCallback :: Maybe TreeSelectionChangedCallback noTreeSelectionChangedCallback = Nothing -- | Type for the callback on the (unwrapped) C side. type C_TreeSelectionChangedCallback = Ptr () -> -- object Ptr () -> -- user_data IO () -- | Generate a function pointer callable from C code, from a `C_TreeSelectionChangedCallback`. foreign import ccall "wrapper" mk_TreeSelectionChangedCallback :: C_TreeSelectionChangedCallback -> IO (FunPtr C_TreeSelectionChangedCallback) -- | Wrap the callback into a `GClosure`. genClosure_TreeSelectionChanged :: MonadIO m => TreeSelectionChangedCallback -> m (GClosure C_TreeSelectionChangedCallback) genClosure_TreeSelectionChanged cb = liftIO $ do let cb' = wrap_TreeSelectionChangedCallback cb mk_TreeSelectionChangedCallback cb' >>= B.GClosure.newGClosure -- | Wrap a `TreeSelectionChangedCallback` into a `C_TreeSelectionChangedCallback`. wrap_TreeSelectionChangedCallback :: TreeSelectionChangedCallback -> C_TreeSelectionChangedCallback wrap_TreeSelectionChangedCallback _cb _ _ = do _cb {- | Connect a signal handler for the “@changed@” signal, to be run before the default handler. When is enabled, this is equivalent to @ 'Data.GI.Base.Signals.on' treeSelection #changed callback @ -} onTreeSelectionChanged :: (IsTreeSelection a, MonadIO m) => a -> TreeSelectionChangedCallback -> m SignalHandlerId onTreeSelectionChanged obj cb = liftIO $ do let cb' = wrap_TreeSelectionChangedCallback cb cb'' <- mk_TreeSelectionChangedCallback cb' connectSignalFunPtr obj "changed" cb'' SignalConnectBefore {- | Connect a signal handler for the “@changed@” signal, to be run after the default handler. When is enabled, this is equivalent to @ 'Data.GI.Base.Signals.after' treeSelection #changed callback @ -} afterTreeSelectionChanged :: (IsTreeSelection a, MonadIO m) => a -> TreeSelectionChangedCallback -> m SignalHandlerId afterTreeSelectionChanged obj cb = liftIO $ do let cb' = wrap_TreeSelectionChangedCallback cb cb'' <- mk_TreeSelectionChangedCallback cb' connectSignalFunPtr obj "changed" cb'' SignalConnectAfter -- VVV Prop "mode" -- Type: TInterface (Name {namespace = "Gtk", name = "SelectionMode"}) -- Flags: [PropertyReadable,PropertyWritable] -- Nullable: (Just False,Just False) {- | Get the value of the “@mode@” property. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.get' treeSelection #mode @ -} getTreeSelectionMode :: (MonadIO m, IsTreeSelection o) => o -> m Gtk.Enums.SelectionMode getTreeSelectionMode obj = liftIO $ B.Properties.getObjectPropertyEnum obj "mode" {- | Set the value of the “@mode@” property. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.set' treeSelection [ #mode 'Data.GI.Base.Attributes.:=' value ] @ -} setTreeSelectionMode :: (MonadIO m, IsTreeSelection o) => o -> Gtk.Enums.SelectionMode -> m () setTreeSelectionMode obj val = liftIO $ B.Properties.setObjectPropertyEnum obj "mode" val {- | Construct a `GValueConstruct` with valid value for the “@mode@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. -} constructTreeSelectionMode :: (IsTreeSelection o) => Gtk.Enums.SelectionMode -> IO (GValueConstruct o) constructTreeSelectionMode val = B.Properties.constructObjectPropertyEnum "mode" val #if ENABLE_OVERLOADING data TreeSelectionModePropertyInfo instance AttrInfo TreeSelectionModePropertyInfo where type AttrAllowedOps TreeSelectionModePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] type AttrSetTypeConstraint TreeSelectionModePropertyInfo = (~) Gtk.Enums.SelectionMode type AttrBaseTypeConstraint TreeSelectionModePropertyInfo = IsTreeSelection type AttrGetType TreeSelectionModePropertyInfo = Gtk.Enums.SelectionMode type AttrLabel TreeSelectionModePropertyInfo = "mode" type AttrOrigin TreeSelectionModePropertyInfo = TreeSelection attrGet _ = getTreeSelectionMode attrSet _ = setTreeSelectionMode attrConstruct _ = constructTreeSelectionMode attrClear _ = undefined #endif #if ENABLE_OVERLOADING instance O.HasAttributeList TreeSelection type instance O.AttributeList TreeSelection = TreeSelectionAttributeList type TreeSelectionAttributeList = ('[ '("mode", TreeSelectionModePropertyInfo)] :: [(Symbol, *)]) #endif #if ENABLE_OVERLOADING treeSelectionMode :: AttrLabelProxy "mode" treeSelectionMode = AttrLabelProxy #endif #if ENABLE_OVERLOADING data TreeSelectionChangedSignalInfo instance SignalInfo TreeSelectionChangedSignalInfo where type HaskellCallbackType TreeSelectionChangedSignalInfo = TreeSelectionChangedCallback connectSignal _ obj cb connectMode = do let cb' = wrap_TreeSelectionChangedCallback cb cb'' <- mk_TreeSelectionChangedCallback cb' connectSignalFunPtr obj "changed" cb'' connectMode type instance O.SignalList TreeSelection = TreeSelectionSignalList type TreeSelectionSignalList = ('[ '("changed", TreeSelectionChangedSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)]) #endif -- method TreeSelection::count_selected_rows -- method type : OrdinaryMethod -- Args : [Arg {argCName = "selection", argType = TInterface (Name {namespace = "Gtk", name = "TreeSelection"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GtkTreeSelection.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TBasicType TInt) -- throws : False -- Skip return : False foreign import ccall "gtk_tree_selection_count_selected_rows" gtk_tree_selection_count_selected_rows :: Ptr TreeSelection -> -- selection : TInterface (Name {namespace = "Gtk", name = "TreeSelection"}) IO Int32 {- | Returns the number of rows that have been selected in /@tree@/. /Since: 2.2/ -} treeSelectionCountSelectedRows :: (B.CallStack.HasCallStack, MonadIO m, IsTreeSelection a) => a {- ^ /@selection@/: A 'GI.Gtk.Objects.TreeSelection.TreeSelection'. -} -> m Int32 {- ^ __Returns:__ The number of rows selected. -} treeSelectionCountSelectedRows selection = liftIO $ do selection' <- unsafeManagedPtrCastPtr selection result <- gtk_tree_selection_count_selected_rows selection' touchManagedPtr selection return result #if ENABLE_OVERLOADING data TreeSelectionCountSelectedRowsMethodInfo instance (signature ~ (m Int32), MonadIO m, IsTreeSelection a) => O.MethodInfo TreeSelectionCountSelectedRowsMethodInfo a signature where overloadedMethod _ = treeSelectionCountSelectedRows #endif -- method TreeSelection::get_mode -- method type : OrdinaryMethod -- Args : [Arg {argCName = "selection", argType = TInterface (Name {namespace = "Gtk", name = "TreeSelection"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkTreeSelection", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TInterface (Name {namespace = "Gtk", name = "SelectionMode"})) -- throws : False -- Skip return : False foreign import ccall "gtk_tree_selection_get_mode" gtk_tree_selection_get_mode :: Ptr TreeSelection -> -- selection : TInterface (Name {namespace = "Gtk", name = "TreeSelection"}) IO CUInt {- | Gets the selection mode for /@selection@/. See 'GI.Gtk.Objects.TreeSelection.treeSelectionSetMode'. -} treeSelectionGetMode :: (B.CallStack.HasCallStack, MonadIO m, IsTreeSelection a) => a {- ^ /@selection@/: a 'GI.Gtk.Objects.TreeSelection.TreeSelection' -} -> m Gtk.Enums.SelectionMode {- ^ __Returns:__ the current selection mode -} treeSelectionGetMode selection = liftIO $ do selection' <- unsafeManagedPtrCastPtr selection result <- gtk_tree_selection_get_mode selection' let result' = (toEnum . fromIntegral) result touchManagedPtr selection return result' #if ENABLE_OVERLOADING data TreeSelectionGetModeMethodInfo instance (signature ~ (m Gtk.Enums.SelectionMode), MonadIO m, IsTreeSelection a) => O.MethodInfo TreeSelectionGetModeMethodInfo a signature where overloadedMethod _ = treeSelectionGetMode #endif -- method TreeSelection::get_selected -- method type : OrdinaryMethod -- Args : [Arg {argCName = "selection", argType = TInterface (Name {namespace = "Gtk", name = "TreeSelection"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GtkTreeSelection.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "model", argType = TInterface (Name {namespace = "Gtk", name = "TreeModel"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A pointer to set to the #GtkTreeModel, or NULL.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "iter", argType = TInterface (Name {namespace = "Gtk", name = "TreeIter"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The #GtkTreeIter, or NULL.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = True, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TBasicType TBoolean) -- throws : False -- Skip return : False foreign import ccall "gtk_tree_selection_get_selected" gtk_tree_selection_get_selected :: Ptr TreeSelection -> -- selection : TInterface (Name {namespace = "Gtk", name = "TreeSelection"}) Ptr (Ptr Gtk.TreeModel.TreeModel) -> -- model : TInterface (Name {namespace = "Gtk", name = "TreeModel"}) Ptr Gtk.TreeIter.TreeIter -> -- iter : TInterface (Name {namespace = "Gtk", name = "TreeIter"}) IO CInt {- | Sets /@iter@/ to the currently selected node if /@selection@/ is set to @/GTK_SELECTION_SINGLE/@ or @/GTK_SELECTION_BROWSE/@. /@iter@/ may be NULL if you just want to test if /@selection@/ has any selected nodes. /@model@/ is filled with the current model as a convenience. This function will not work if you use /@selection@/ is @/GTK_SELECTION_MULTIPLE/@. -} treeSelectionGetSelected :: (B.CallStack.HasCallStack, MonadIO m, IsTreeSelection a) => a {- ^ /@selection@/: A 'GI.Gtk.Objects.TreeSelection.TreeSelection'. -} -> m ((Bool, Gtk.TreeModel.TreeModel, Gtk.TreeIter.TreeIter)) {- ^ __Returns:__ TRUE, if there is a selected node. -} treeSelectionGetSelected selection = liftIO $ do selection' <- unsafeManagedPtrCastPtr selection model <- allocMem :: IO (Ptr (Ptr Gtk.TreeModel.TreeModel)) iter <- callocBoxedBytes 32 :: IO (Ptr Gtk.TreeIter.TreeIter) result <- gtk_tree_selection_get_selected selection' model iter let result' = (/= 0) result model' <- peek model model'' <- (newObject Gtk.TreeModel.TreeModel) model' iter' <- (wrapBoxed Gtk.TreeIter.TreeIter) iter touchManagedPtr selection freeMem model return (result', model'', iter') #if ENABLE_OVERLOADING data TreeSelectionGetSelectedMethodInfo instance (signature ~ (m ((Bool, Gtk.TreeModel.TreeModel, Gtk.TreeIter.TreeIter))), MonadIO m, IsTreeSelection a) => O.MethodInfo TreeSelectionGetSelectedMethodInfo a signature where overloadedMethod _ = treeSelectionGetSelected #endif -- method TreeSelection::get_selected_rows -- method type : OrdinaryMethod -- Args : [Arg {argCName = "selection", argType = TInterface (Name {namespace = "Gtk", name = "TreeSelection"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GtkTreeSelection.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "model", argType = TInterface (Name {namespace = "Gtk", name = "TreeModel"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A pointer to set to the #GtkTreeModel, or %NULL.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TGList (TInterface (Name {namespace = "Gtk", name = "TreePath"}))) -- throws : False -- Skip return : False foreign import ccall "gtk_tree_selection_get_selected_rows" gtk_tree_selection_get_selected_rows :: Ptr TreeSelection -> -- selection : TInterface (Name {namespace = "Gtk", name = "TreeSelection"}) Ptr (Ptr Gtk.TreeModel.TreeModel) -> -- model : TInterface (Name {namespace = "Gtk", name = "TreeModel"}) IO (Ptr (GList (Ptr Gtk.TreePath.TreePath))) {- | Creates a list of path of all selected rows. Additionally, if you are planning on modifying the model after calling this function, you may want to convert the returned list into a list of @/GtkTreeRowReferences/@. To do this, you can use 'GI.Gtk.Structs.TreeRowReference.treeRowReferenceNew'. To free the return value, use: === /C code/ > >g_list_free_full (list, (GDestroyNotify) gtk_tree_path_free); /Since: 2.2/ -} treeSelectionGetSelectedRows :: (B.CallStack.HasCallStack, MonadIO m, IsTreeSelection a) => a {- ^ /@selection@/: A 'GI.Gtk.Objects.TreeSelection.TreeSelection'. -} -> m (([Gtk.TreePath.TreePath], Gtk.TreeModel.TreeModel)) {- ^ __Returns:__ A 'GI.GLib.Structs.List.List' containing a 'GI.Gtk.Structs.TreePath.TreePath' for each selected row. -} treeSelectionGetSelectedRows selection = liftIO $ do selection' <- unsafeManagedPtrCastPtr selection model <- allocMem :: IO (Ptr (Ptr Gtk.TreeModel.TreeModel)) result <- gtk_tree_selection_get_selected_rows selection' model result' <- unpackGList result result'' <- mapM (wrapBoxed Gtk.TreePath.TreePath) result' g_list_free result model' <- peek model model'' <- (newObject Gtk.TreeModel.TreeModel) model' touchManagedPtr selection freeMem model return (result'', model'') #if ENABLE_OVERLOADING data TreeSelectionGetSelectedRowsMethodInfo instance (signature ~ (m (([Gtk.TreePath.TreePath], Gtk.TreeModel.TreeModel))), MonadIO m, IsTreeSelection a) => O.MethodInfo TreeSelectionGetSelectedRowsMethodInfo a signature where overloadedMethod _ = treeSelectionGetSelectedRows #endif -- method TreeSelection::get_tree_view -- method type : OrdinaryMethod -- Args : [Arg {argCName = "selection", argType = TInterface (Name {namespace = "Gtk", name = "TreeSelection"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GtkTreeSelection", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TInterface (Name {namespace = "Gtk", name = "TreeView"})) -- throws : False -- Skip return : False foreign import ccall "gtk_tree_selection_get_tree_view" gtk_tree_selection_get_tree_view :: Ptr TreeSelection -> -- selection : TInterface (Name {namespace = "Gtk", name = "TreeSelection"}) IO (Ptr Gtk.TreeView.TreeView) {- | Returns the tree view associated with /@selection@/. -} treeSelectionGetTreeView :: (B.CallStack.HasCallStack, MonadIO m, IsTreeSelection a) => a {- ^ /@selection@/: A 'GI.Gtk.Objects.TreeSelection.TreeSelection' -} -> m Gtk.TreeView.TreeView {- ^ __Returns:__ A 'GI.Gtk.Objects.TreeView.TreeView' -} treeSelectionGetTreeView selection = liftIO $ do selection' <- unsafeManagedPtrCastPtr selection result <- gtk_tree_selection_get_tree_view selection' checkUnexpectedReturnNULL "treeSelectionGetTreeView" result result' <- (newObject Gtk.TreeView.TreeView) result touchManagedPtr selection return result' #if ENABLE_OVERLOADING data TreeSelectionGetTreeViewMethodInfo instance (signature ~ (m Gtk.TreeView.TreeView), MonadIO m, IsTreeSelection a) => O.MethodInfo TreeSelectionGetTreeViewMethodInfo a signature where overloadedMethod _ = treeSelectionGetTreeView #endif -- method TreeSelection::iter_is_selected -- method type : OrdinaryMethod -- Args : [Arg {argCName = "selection", argType = TInterface (Name {namespace = "Gtk", name = "TreeSelection"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GtkTreeSelection", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "iter", argType = TInterface (Name {namespace = "Gtk", name = "TreeIter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A valid #GtkTreeIter", 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_selection_iter_is_selected" gtk_tree_selection_iter_is_selected :: Ptr TreeSelection -> -- selection : TInterface (Name {namespace = "Gtk", name = "TreeSelection"}) Ptr Gtk.TreeIter.TreeIter -> -- iter : TInterface (Name {namespace = "Gtk", name = "TreeIter"}) IO CInt {- | Returns 'True' if the row at /@iter@/ is currently selected. -} treeSelectionIterIsSelected :: (B.CallStack.HasCallStack, MonadIO m, IsTreeSelection a) => a {- ^ /@selection@/: A 'GI.Gtk.Objects.TreeSelection.TreeSelection' -} -> Gtk.TreeIter.TreeIter {- ^ /@iter@/: A valid 'GI.Gtk.Structs.TreeIter.TreeIter' -} -> m Bool {- ^ __Returns:__ 'True', if /@iter@/ is selected -} treeSelectionIterIsSelected selection iter = liftIO $ do selection' <- unsafeManagedPtrCastPtr selection iter' <- unsafeManagedPtrGetPtr iter result <- gtk_tree_selection_iter_is_selected selection' iter' let result' = (/= 0) result touchManagedPtr selection touchManagedPtr iter return result' #if ENABLE_OVERLOADING data TreeSelectionIterIsSelectedMethodInfo instance (signature ~ (Gtk.TreeIter.TreeIter -> m Bool), MonadIO m, IsTreeSelection a) => O.MethodInfo TreeSelectionIterIsSelectedMethodInfo a signature where overloadedMethod _ = treeSelectionIterIsSelected #endif -- method TreeSelection::path_is_selected -- method type : OrdinaryMethod -- Args : [Arg {argCName = "selection", argType = TInterface (Name {namespace = "Gtk", name = "TreeSelection"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GtkTreeSelection.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "path", argType = TInterface (Name {namespace = "Gtk", name = "TreePath"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GtkTreePath to check selection on.", 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_selection_path_is_selected" gtk_tree_selection_path_is_selected :: Ptr TreeSelection -> -- selection : TInterface (Name {namespace = "Gtk", name = "TreeSelection"}) Ptr Gtk.TreePath.TreePath -> -- path : TInterface (Name {namespace = "Gtk", name = "TreePath"}) IO CInt {- | Returns 'True' if the row pointed to by /@path@/ is currently selected. If /@path@/ does not point to a valid location, 'False' is returned -} treeSelectionPathIsSelected :: (B.CallStack.HasCallStack, MonadIO m, IsTreeSelection a) => a {- ^ /@selection@/: A 'GI.Gtk.Objects.TreeSelection.TreeSelection'. -} -> Gtk.TreePath.TreePath {- ^ /@path@/: A 'GI.Gtk.Structs.TreePath.TreePath' to check selection on. -} -> m Bool {- ^ __Returns:__ 'True' if /@path@/ is selected. -} treeSelectionPathIsSelected selection path = liftIO $ do selection' <- unsafeManagedPtrCastPtr selection path' <- unsafeManagedPtrGetPtr path result <- gtk_tree_selection_path_is_selected selection' path' let result' = (/= 0) result touchManagedPtr selection touchManagedPtr path return result' #if ENABLE_OVERLOADING data TreeSelectionPathIsSelectedMethodInfo instance (signature ~ (Gtk.TreePath.TreePath -> m Bool), MonadIO m, IsTreeSelection a) => O.MethodInfo TreeSelectionPathIsSelectedMethodInfo a signature where overloadedMethod _ = treeSelectionPathIsSelected #endif -- method TreeSelection::select_all -- method type : OrdinaryMethod -- Args : [Arg {argCName = "selection", argType = TInterface (Name {namespace = "Gtk", name = "TreeSelection"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GtkTreeSelection.", 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_selection_select_all" gtk_tree_selection_select_all :: Ptr TreeSelection -> -- selection : TInterface (Name {namespace = "Gtk", name = "TreeSelection"}) IO () {- | Selects all the nodes. /@selection@/ must be set to @/GTK_SELECTION_MULTIPLE/@ mode. -} treeSelectionSelectAll :: (B.CallStack.HasCallStack, MonadIO m, IsTreeSelection a) => a {- ^ /@selection@/: A 'GI.Gtk.Objects.TreeSelection.TreeSelection'. -} -> m () treeSelectionSelectAll selection = liftIO $ do selection' <- unsafeManagedPtrCastPtr selection gtk_tree_selection_select_all selection' touchManagedPtr selection return () #if ENABLE_OVERLOADING data TreeSelectionSelectAllMethodInfo instance (signature ~ (m ()), MonadIO m, IsTreeSelection a) => O.MethodInfo TreeSelectionSelectAllMethodInfo a signature where overloadedMethod _ = treeSelectionSelectAll #endif -- method TreeSelection::select_iter -- method type : OrdinaryMethod -- Args : [Arg {argCName = "selection", argType = TInterface (Name {namespace = "Gtk", name = "TreeSelection"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GtkTreeSelection.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "iter", argType = TInterface (Name {namespace = "Gtk", name = "TreeIter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The #GtkTreeIter to be selected.", 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_selection_select_iter" gtk_tree_selection_select_iter :: Ptr TreeSelection -> -- selection : TInterface (Name {namespace = "Gtk", name = "TreeSelection"}) Ptr Gtk.TreeIter.TreeIter -> -- iter : TInterface (Name {namespace = "Gtk", name = "TreeIter"}) IO () {- | Selects the specified iterator. -} treeSelectionSelectIter :: (B.CallStack.HasCallStack, MonadIO m, IsTreeSelection a) => a {- ^ /@selection@/: A 'GI.Gtk.Objects.TreeSelection.TreeSelection'. -} -> Gtk.TreeIter.TreeIter {- ^ /@iter@/: The 'GI.Gtk.Structs.TreeIter.TreeIter' to be selected. -} -> m () treeSelectionSelectIter selection iter = liftIO $ do selection' <- unsafeManagedPtrCastPtr selection iter' <- unsafeManagedPtrGetPtr iter gtk_tree_selection_select_iter selection' iter' touchManagedPtr selection touchManagedPtr iter return () #if ENABLE_OVERLOADING data TreeSelectionSelectIterMethodInfo instance (signature ~ (Gtk.TreeIter.TreeIter -> m ()), MonadIO m, IsTreeSelection a) => O.MethodInfo TreeSelectionSelectIterMethodInfo a signature where overloadedMethod _ = treeSelectionSelectIter #endif -- method TreeSelection::select_path -- method type : OrdinaryMethod -- Args : [Arg {argCName = "selection", argType = TInterface (Name {namespace = "Gtk", name = "TreeSelection"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GtkTreeSelection.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "path", argType = TInterface (Name {namespace = "Gtk", name = "TreePath"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The #GtkTreePath to be selected.", 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_selection_select_path" gtk_tree_selection_select_path :: Ptr TreeSelection -> -- selection : TInterface (Name {namespace = "Gtk", name = "TreeSelection"}) Ptr Gtk.TreePath.TreePath -> -- path : TInterface (Name {namespace = "Gtk", name = "TreePath"}) IO () {- | Select the row at /@path@/. -} treeSelectionSelectPath :: (B.CallStack.HasCallStack, MonadIO m, IsTreeSelection a) => a {- ^ /@selection@/: A 'GI.Gtk.Objects.TreeSelection.TreeSelection'. -} -> Gtk.TreePath.TreePath {- ^ /@path@/: The 'GI.Gtk.Structs.TreePath.TreePath' to be selected. -} -> m () treeSelectionSelectPath selection path = liftIO $ do selection' <- unsafeManagedPtrCastPtr selection path' <- unsafeManagedPtrGetPtr path gtk_tree_selection_select_path selection' path' touchManagedPtr selection touchManagedPtr path return () #if ENABLE_OVERLOADING data TreeSelectionSelectPathMethodInfo instance (signature ~ (Gtk.TreePath.TreePath -> m ()), MonadIO m, IsTreeSelection a) => O.MethodInfo TreeSelectionSelectPathMethodInfo a signature where overloadedMethod _ = treeSelectionSelectPath #endif -- method TreeSelection::select_range -- method type : OrdinaryMethod -- Args : [Arg {argCName = "selection", argType = TInterface (Name {namespace = "Gtk", name = "TreeSelection"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GtkTreeSelection.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "start_path", argType = TInterface (Name {namespace = "Gtk", name = "TreePath"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The initial node of the range.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "end_path", argType = TInterface (Name {namespace = "Gtk", name = "TreePath"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The final node of the range.", 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_selection_select_range" gtk_tree_selection_select_range :: Ptr TreeSelection -> -- selection : TInterface (Name {namespace = "Gtk", name = "TreeSelection"}) Ptr Gtk.TreePath.TreePath -> -- start_path : TInterface (Name {namespace = "Gtk", name = "TreePath"}) Ptr Gtk.TreePath.TreePath -> -- end_path : TInterface (Name {namespace = "Gtk", name = "TreePath"}) IO () {- | Selects a range of nodes, determined by /@startPath@/ and /@endPath@/ inclusive. /@selection@/ must be set to @/GTK_SELECTION_MULTIPLE/@ mode. -} treeSelectionSelectRange :: (B.CallStack.HasCallStack, MonadIO m, IsTreeSelection a) => a {- ^ /@selection@/: A 'GI.Gtk.Objects.TreeSelection.TreeSelection'. -} -> Gtk.TreePath.TreePath {- ^ /@startPath@/: The initial node of the range. -} -> Gtk.TreePath.TreePath {- ^ /@endPath@/: The final node of the range. -} -> m () treeSelectionSelectRange selection startPath endPath = liftIO $ do selection' <- unsafeManagedPtrCastPtr selection startPath' <- unsafeManagedPtrGetPtr startPath endPath' <- unsafeManagedPtrGetPtr endPath gtk_tree_selection_select_range selection' startPath' endPath' touchManagedPtr selection touchManagedPtr startPath touchManagedPtr endPath return () #if ENABLE_OVERLOADING data TreeSelectionSelectRangeMethodInfo instance (signature ~ (Gtk.TreePath.TreePath -> Gtk.TreePath.TreePath -> m ()), MonadIO m, IsTreeSelection a) => O.MethodInfo TreeSelectionSelectRangeMethodInfo a signature where overloadedMethod _ = treeSelectionSelectRange #endif -- method TreeSelection::selected_foreach -- method type : OrdinaryMethod -- Args : [Arg {argCName = "selection", argType = TInterface (Name {namespace = "Gtk", name = "TreeSelection"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GtkTreeSelection.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "func", argType = TInterface (Name {namespace = "Gtk", name = "TreeSelectionForeachFunc"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The function to call for each selected node.", sinceVersion = Nothing}, argScope = ScopeTypeCall, argClosure = 2, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "user data to pass to the function.", 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_selection_selected_foreach" gtk_tree_selection_selected_foreach :: Ptr TreeSelection -> -- selection : TInterface (Name {namespace = "Gtk", name = "TreeSelection"}) FunPtr Gtk.Callbacks.C_TreeSelectionForeachFunc -> -- func : TInterface (Name {namespace = "Gtk", name = "TreeSelectionForeachFunc"}) Ptr () -> -- data : TBasicType TPtr IO () {- | Calls a function for each selected node. Note that you cannot modify the tree or selection from within this function. As a result, 'GI.Gtk.Objects.TreeSelection.treeSelectionGetSelectedRows' might be more useful. -} treeSelectionSelectedForeach :: (B.CallStack.HasCallStack, MonadIO m, IsTreeSelection a) => a {- ^ /@selection@/: A 'GI.Gtk.Objects.TreeSelection.TreeSelection'. -} -> Gtk.Callbacks.TreeSelectionForeachFunc {- ^ /@func@/: The function to call for each selected node. -} -> m () treeSelectionSelectedForeach selection func = liftIO $ do selection' <- unsafeManagedPtrCastPtr selection func' <- Gtk.Callbacks.mk_TreeSelectionForeachFunc (Gtk.Callbacks.wrap_TreeSelectionForeachFunc Nothing (Gtk.Callbacks.drop_closures_TreeSelectionForeachFunc func)) let data_ = nullPtr gtk_tree_selection_selected_foreach selection' func' data_ safeFreeFunPtr $ castFunPtrToPtr func' touchManagedPtr selection return () #if ENABLE_OVERLOADING data TreeSelectionSelectedForeachMethodInfo instance (signature ~ (Gtk.Callbacks.TreeSelectionForeachFunc -> m ()), MonadIO m, IsTreeSelection a) => O.MethodInfo TreeSelectionSelectedForeachMethodInfo a signature where overloadedMethod _ = treeSelectionSelectedForeach #endif -- method TreeSelection::set_mode -- method type : OrdinaryMethod -- Args : [Arg {argCName = "selection", argType = TInterface (Name {namespace = "Gtk", name = "TreeSelection"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GtkTreeSelection.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "type", argType = TInterface (Name {namespace = "Gtk", name = "SelectionMode"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The selection mode", 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_selection_set_mode" gtk_tree_selection_set_mode :: Ptr TreeSelection -> -- selection : TInterface (Name {namespace = "Gtk", name = "TreeSelection"}) CUInt -> -- type : TInterface (Name {namespace = "Gtk", name = "SelectionMode"}) IO () {- | Sets the selection mode of the /@selection@/. If the previous type was @/GTK_SELECTION_MULTIPLE/@, then the anchor is kept selected, if it was previously selected. -} treeSelectionSetMode :: (B.CallStack.HasCallStack, MonadIO m, IsTreeSelection a) => a {- ^ /@selection@/: A 'GI.Gtk.Objects.TreeSelection.TreeSelection'. -} -> Gtk.Enums.SelectionMode {- ^ /@type@/: The selection mode -} -> m () treeSelectionSetMode selection type_ = liftIO $ do selection' <- unsafeManagedPtrCastPtr selection let type_' = (fromIntegral . fromEnum) type_ gtk_tree_selection_set_mode selection' type_' touchManagedPtr selection return () #if ENABLE_OVERLOADING data TreeSelectionSetModeMethodInfo instance (signature ~ (Gtk.Enums.SelectionMode -> m ()), MonadIO m, IsTreeSelection a) => O.MethodInfo TreeSelectionSetModeMethodInfo a signature where overloadedMethod _ = treeSelectionSetMode #endif -- method TreeSelection::set_select_function -- method type : OrdinaryMethod -- Args : [Arg {argCName = "selection", argType = TInterface (Name {namespace = "Gtk", name = "TreeSelection"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GtkTreeSelection.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "func", argType = TInterface (Name {namespace = "Gtk", name = "TreeSelectionFunc"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "The selection function. May be %NULL", 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 "The selection function\8217s data. May be %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 = False, argDoc = Documentation {rawDocText = Just "The destroy function for user data. May be %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_selection_set_select_function" gtk_tree_selection_set_select_function :: Ptr TreeSelection -> -- selection : TInterface (Name {namespace = "Gtk", name = "TreeSelection"}) FunPtr Gtk.Callbacks.C_TreeSelectionFunc -> -- func : TInterface (Name {namespace = "Gtk", name = "TreeSelectionFunc"}) Ptr () -> -- data : TBasicType TPtr FunPtr GLib.Callbacks.C_DestroyNotify -> -- destroy : TInterface (Name {namespace = "GLib", name = "DestroyNotify"}) IO () {- | Sets the selection function. If set, this function is called before any node is selected or unselected, giving some control over which nodes are selected. The select function should return 'True' if the state of the node may be toggled, and 'False' if the state of the node should be left unchanged. -} treeSelectionSetSelectFunction :: (B.CallStack.HasCallStack, MonadIO m, IsTreeSelection a) => a {- ^ /@selection@/: A 'GI.Gtk.Objects.TreeSelection.TreeSelection'. -} -> Maybe (Gtk.Callbacks.TreeSelectionFunc) {- ^ /@func@/: The selection function. May be 'Nothing' -} -> m () treeSelectionSetSelectFunction selection func = liftIO $ do selection' <- unsafeManagedPtrCastPtr selection maybeFunc <- case func of Nothing -> return (castPtrToFunPtr nullPtr) Just jFunc -> do jFunc' <- Gtk.Callbacks.mk_TreeSelectionFunc (Gtk.Callbacks.wrap_TreeSelectionFunc Nothing (Gtk.Callbacks.drop_closures_TreeSelectionFunc jFunc)) return jFunc' let data_ = castFunPtrToPtr maybeFunc let destroy = safeFreeFunPtrPtr gtk_tree_selection_set_select_function selection' maybeFunc data_ destroy touchManagedPtr selection return () #if ENABLE_OVERLOADING data TreeSelectionSetSelectFunctionMethodInfo instance (signature ~ (Maybe (Gtk.Callbacks.TreeSelectionFunc) -> m ()), MonadIO m, IsTreeSelection a) => O.MethodInfo TreeSelectionSetSelectFunctionMethodInfo a signature where overloadedMethod _ = treeSelectionSetSelectFunction #endif -- method TreeSelection::unselect_all -- method type : OrdinaryMethod -- Args : [Arg {argCName = "selection", argType = TInterface (Name {namespace = "Gtk", name = "TreeSelection"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GtkTreeSelection.", 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_selection_unselect_all" gtk_tree_selection_unselect_all :: Ptr TreeSelection -> -- selection : TInterface (Name {namespace = "Gtk", name = "TreeSelection"}) IO () {- | Unselects all the nodes. -} treeSelectionUnselectAll :: (B.CallStack.HasCallStack, MonadIO m, IsTreeSelection a) => a {- ^ /@selection@/: A 'GI.Gtk.Objects.TreeSelection.TreeSelection'. -} -> m () treeSelectionUnselectAll selection = liftIO $ do selection' <- unsafeManagedPtrCastPtr selection gtk_tree_selection_unselect_all selection' touchManagedPtr selection return () #if ENABLE_OVERLOADING data TreeSelectionUnselectAllMethodInfo instance (signature ~ (m ()), MonadIO m, IsTreeSelection a) => O.MethodInfo TreeSelectionUnselectAllMethodInfo a signature where overloadedMethod _ = treeSelectionUnselectAll #endif -- method TreeSelection::unselect_iter -- method type : OrdinaryMethod -- Args : [Arg {argCName = "selection", argType = TInterface (Name {namespace = "Gtk", name = "TreeSelection"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GtkTreeSelection.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "iter", argType = TInterface (Name {namespace = "Gtk", name = "TreeIter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The #GtkTreeIter to be unselected.", 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_selection_unselect_iter" gtk_tree_selection_unselect_iter :: Ptr TreeSelection -> -- selection : TInterface (Name {namespace = "Gtk", name = "TreeSelection"}) Ptr Gtk.TreeIter.TreeIter -> -- iter : TInterface (Name {namespace = "Gtk", name = "TreeIter"}) IO () {- | Unselects the specified iterator. -} treeSelectionUnselectIter :: (B.CallStack.HasCallStack, MonadIO m, IsTreeSelection a) => a {- ^ /@selection@/: A 'GI.Gtk.Objects.TreeSelection.TreeSelection'. -} -> Gtk.TreeIter.TreeIter {- ^ /@iter@/: The 'GI.Gtk.Structs.TreeIter.TreeIter' to be unselected. -} -> m () treeSelectionUnselectIter selection iter = liftIO $ do selection' <- unsafeManagedPtrCastPtr selection iter' <- unsafeManagedPtrGetPtr iter gtk_tree_selection_unselect_iter selection' iter' touchManagedPtr selection touchManagedPtr iter return () #if ENABLE_OVERLOADING data TreeSelectionUnselectIterMethodInfo instance (signature ~ (Gtk.TreeIter.TreeIter -> m ()), MonadIO m, IsTreeSelection a) => O.MethodInfo TreeSelectionUnselectIterMethodInfo a signature where overloadedMethod _ = treeSelectionUnselectIter #endif -- method TreeSelection::unselect_path -- method type : OrdinaryMethod -- Args : [Arg {argCName = "selection", argType = TInterface (Name {namespace = "Gtk", name = "TreeSelection"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GtkTreeSelection.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "path", argType = TInterface (Name {namespace = "Gtk", name = "TreePath"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The #GtkTreePath to be unselected.", 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_selection_unselect_path" gtk_tree_selection_unselect_path :: Ptr TreeSelection -> -- selection : TInterface (Name {namespace = "Gtk", name = "TreeSelection"}) Ptr Gtk.TreePath.TreePath -> -- path : TInterface (Name {namespace = "Gtk", name = "TreePath"}) IO () {- | Unselects the row at /@path@/. -} treeSelectionUnselectPath :: (B.CallStack.HasCallStack, MonadIO m, IsTreeSelection a) => a {- ^ /@selection@/: A 'GI.Gtk.Objects.TreeSelection.TreeSelection'. -} -> Gtk.TreePath.TreePath {- ^ /@path@/: The 'GI.Gtk.Structs.TreePath.TreePath' to be unselected. -} -> m () treeSelectionUnselectPath selection path = liftIO $ do selection' <- unsafeManagedPtrCastPtr selection path' <- unsafeManagedPtrGetPtr path gtk_tree_selection_unselect_path selection' path' touchManagedPtr selection touchManagedPtr path return () #if ENABLE_OVERLOADING data TreeSelectionUnselectPathMethodInfo instance (signature ~ (Gtk.TreePath.TreePath -> m ()), MonadIO m, IsTreeSelection a) => O.MethodInfo TreeSelectionUnselectPathMethodInfo a signature where overloadedMethod _ = treeSelectionUnselectPath #endif -- method TreeSelection::unselect_range -- method type : OrdinaryMethod -- Args : [Arg {argCName = "selection", argType = TInterface (Name {namespace = "Gtk", name = "TreeSelection"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GtkTreeSelection.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "start_path", argType = TInterface (Name {namespace = "Gtk", name = "TreePath"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The initial node of the range.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "end_path", argType = TInterface (Name {namespace = "Gtk", name = "TreePath"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The initial node of the range.", 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_selection_unselect_range" gtk_tree_selection_unselect_range :: Ptr TreeSelection -> -- selection : TInterface (Name {namespace = "Gtk", name = "TreeSelection"}) Ptr Gtk.TreePath.TreePath -> -- start_path : TInterface (Name {namespace = "Gtk", name = "TreePath"}) Ptr Gtk.TreePath.TreePath -> -- end_path : TInterface (Name {namespace = "Gtk", name = "TreePath"}) IO () {- | Unselects a range of nodes, determined by /@startPath@/ and /@endPath@/ inclusive. /Since: 2.2/ -} treeSelectionUnselectRange :: (B.CallStack.HasCallStack, MonadIO m, IsTreeSelection a) => a {- ^ /@selection@/: A 'GI.Gtk.Objects.TreeSelection.TreeSelection'. -} -> Gtk.TreePath.TreePath {- ^ /@startPath@/: The initial node of the range. -} -> Gtk.TreePath.TreePath {- ^ /@endPath@/: The initial node of the range. -} -> m () treeSelectionUnselectRange selection startPath endPath = liftIO $ do selection' <- unsafeManagedPtrCastPtr selection startPath' <- unsafeManagedPtrGetPtr startPath endPath' <- unsafeManagedPtrGetPtr endPath gtk_tree_selection_unselect_range selection' startPath' endPath' touchManagedPtr selection touchManagedPtr startPath touchManagedPtr endPath return () #if ENABLE_OVERLOADING data TreeSelectionUnselectRangeMethodInfo instance (signature ~ (Gtk.TreePath.TreePath -> Gtk.TreePath.TreePath -> m ()), MonadIO m, IsTreeSelection a) => O.MethodInfo TreeSelectionUnselectRangeMethodInfo a signature where overloadedMethod _ = treeSelectionUnselectRange #endif