{- | 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.Structs.TreeIter.TreeIter' is the primary structure for accessing a 'GI.Gtk.Interfaces.TreeModel.TreeModel'. Models are expected to put a unique integer in the /@stamp@/ member, and put model-specific data in the three /@userData@/ members. -} #define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ && !defined(__HADDOCK_VERSION__)) module GI.Gtk.Structs.TreeIter ( -- * Exported types TreeIter(..) , newZeroTreeIter , noTreeIter , -- * Methods -- ** copy #method:copy# #if ENABLE_OVERLOADING TreeIterCopyMethodInfo , #endif treeIterCopy , -- ** free #method:free# #if ENABLE_OVERLOADING TreeIterFreeMethodInfo , #endif treeIterFree , -- * Properties -- ** stamp #attr:stamp# {- | a unique stamp to catch invalid iterators -} getTreeIterStamp , setTreeIterStamp , #if ENABLE_OVERLOADING treeIter_stamp , #endif -- ** userData #attr:userData# {- | model-specific data -} clearTreeIterUserData , getTreeIterUserData , setTreeIterUserData , #if ENABLE_OVERLOADING treeIter_userData , #endif -- ** userData2 #attr:userData2# {- | model-specific data -} clearTreeIterUserData2 , getTreeIterUserData2 , setTreeIterUserData2 , #if ENABLE_OVERLOADING treeIter_userData2 , #endif -- ** userData3 #attr:userData3# {- | model-specific data -} clearTreeIterUserData3 , getTreeIterUserData3 , setTreeIterUserData3 , #if ENABLE_OVERLOADING treeIter_userData3 , #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 -- | Memory-managed wrapper type. newtype TreeIter = TreeIter (ManagedPtr TreeIter) foreign import ccall "gtk_tree_iter_get_type" c_gtk_tree_iter_get_type :: IO GType instance BoxedObject TreeIter where boxedType _ = c_gtk_tree_iter_get_type -- | Construct a `TreeIter` struct initialized to zero. newZeroTreeIter :: MonadIO m => m TreeIter newZeroTreeIter = liftIO $ callocBoxedBytes 32 >>= wrapBoxed TreeIter instance tag ~ 'AttrSet => Constructible TreeIter tag where new _ attrs = do o <- newZeroTreeIter GI.Attributes.set o attrs return o -- | A convenience alias for `Nothing` :: `Maybe` `TreeIter`. noTreeIter :: Maybe TreeIter noTreeIter = Nothing {- | Get the value of the “@stamp@” field. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.get' treeIter #stamp @ -} getTreeIterStamp :: MonadIO m => TreeIter -> m Int32 getTreeIterStamp s = liftIO $ withManagedPtr s $ \ptr -> do val <- peek (ptr `plusPtr` 0) :: IO Int32 return val {- | Set the value of the “@stamp@” field. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.set' treeIter [ #stamp 'Data.GI.Base.Attributes.:=' value ] @ -} setTreeIterStamp :: MonadIO m => TreeIter -> Int32 -> m () setTreeIterStamp s val = liftIO $ withManagedPtr s $ \ptr -> do poke (ptr `plusPtr` 0) (val :: Int32) #if ENABLE_OVERLOADING data TreeIterStampFieldInfo instance AttrInfo TreeIterStampFieldInfo where type AttrAllowedOps TreeIterStampFieldInfo = '[ 'AttrSet, 'AttrGet] type AttrSetTypeConstraint TreeIterStampFieldInfo = (~) Int32 type AttrBaseTypeConstraint TreeIterStampFieldInfo = (~) TreeIter type AttrGetType TreeIterStampFieldInfo = Int32 type AttrLabel TreeIterStampFieldInfo = "stamp" type AttrOrigin TreeIterStampFieldInfo = TreeIter attrGet _ = getTreeIterStamp attrSet _ = setTreeIterStamp attrConstruct = undefined attrClear _ = undefined treeIter_stamp :: AttrLabelProxy "stamp" treeIter_stamp = AttrLabelProxy #endif {- | Get the value of the “@user_data@” field. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.get' treeIter #userData @ -} getTreeIterUserData :: MonadIO m => TreeIter -> m (Ptr ()) getTreeIterUserData s = liftIO $ withManagedPtr s $ \ptr -> do val <- peek (ptr `plusPtr` 8) :: IO (Ptr ()) return val {- | Set the value of the “@user_data@” field. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.set' treeIter [ #userData 'Data.GI.Base.Attributes.:=' value ] @ -} setTreeIterUserData :: MonadIO m => TreeIter -> Ptr () -> m () setTreeIterUserData s val = liftIO $ withManagedPtr s $ \ptr -> do poke (ptr `plusPtr` 8) (val :: Ptr ()) {- | Set the value of the “@user_data@” field to `Nothing`. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.clear' #userData @ -} clearTreeIterUserData :: MonadIO m => TreeIter -> m () clearTreeIterUserData s = liftIO $ withManagedPtr s $ \ptr -> do poke (ptr `plusPtr` 8) (FP.nullPtr :: Ptr ()) #if ENABLE_OVERLOADING data TreeIterUserDataFieldInfo instance AttrInfo TreeIterUserDataFieldInfo where type AttrAllowedOps TreeIterUserDataFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear] type AttrSetTypeConstraint TreeIterUserDataFieldInfo = (~) (Ptr ()) type AttrBaseTypeConstraint TreeIterUserDataFieldInfo = (~) TreeIter type AttrGetType TreeIterUserDataFieldInfo = Ptr () type AttrLabel TreeIterUserDataFieldInfo = "user_data" type AttrOrigin TreeIterUserDataFieldInfo = TreeIter attrGet _ = getTreeIterUserData attrSet _ = setTreeIterUserData attrConstruct = undefined attrClear _ = clearTreeIterUserData treeIter_userData :: AttrLabelProxy "userData" treeIter_userData = AttrLabelProxy #endif {- | Get the value of the “@user_data2@” field. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.get' treeIter #userData2 @ -} getTreeIterUserData2 :: MonadIO m => TreeIter -> m (Ptr ()) getTreeIterUserData2 s = liftIO $ withManagedPtr s $ \ptr -> do val <- peek (ptr `plusPtr` 16) :: IO (Ptr ()) return val {- | Set the value of the “@user_data2@” field. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.set' treeIter [ #userData2 'Data.GI.Base.Attributes.:=' value ] @ -} setTreeIterUserData2 :: MonadIO m => TreeIter -> Ptr () -> m () setTreeIterUserData2 s val = liftIO $ withManagedPtr s $ \ptr -> do poke (ptr `plusPtr` 16) (val :: Ptr ()) {- | Set the value of the “@user_data2@” field to `Nothing`. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.clear' #userData2 @ -} clearTreeIterUserData2 :: MonadIO m => TreeIter -> m () clearTreeIterUserData2 s = liftIO $ withManagedPtr s $ \ptr -> do poke (ptr `plusPtr` 16) (FP.nullPtr :: Ptr ()) #if ENABLE_OVERLOADING data TreeIterUserData2FieldInfo instance AttrInfo TreeIterUserData2FieldInfo where type AttrAllowedOps TreeIterUserData2FieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear] type AttrSetTypeConstraint TreeIterUserData2FieldInfo = (~) (Ptr ()) type AttrBaseTypeConstraint TreeIterUserData2FieldInfo = (~) TreeIter type AttrGetType TreeIterUserData2FieldInfo = Ptr () type AttrLabel TreeIterUserData2FieldInfo = "user_data2" type AttrOrigin TreeIterUserData2FieldInfo = TreeIter attrGet _ = getTreeIterUserData2 attrSet _ = setTreeIterUserData2 attrConstruct = undefined attrClear _ = clearTreeIterUserData2 treeIter_userData2 :: AttrLabelProxy "userData2" treeIter_userData2 = AttrLabelProxy #endif {- | Get the value of the “@user_data3@” field. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.get' treeIter #userData3 @ -} getTreeIterUserData3 :: MonadIO m => TreeIter -> m (Ptr ()) getTreeIterUserData3 s = liftIO $ withManagedPtr s $ \ptr -> do val <- peek (ptr `plusPtr` 24) :: IO (Ptr ()) return val {- | Set the value of the “@user_data3@” field. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.set' treeIter [ #userData3 'Data.GI.Base.Attributes.:=' value ] @ -} setTreeIterUserData3 :: MonadIO m => TreeIter -> Ptr () -> m () setTreeIterUserData3 s val = liftIO $ withManagedPtr s $ \ptr -> do poke (ptr `plusPtr` 24) (val :: Ptr ()) {- | Set the value of the “@user_data3@” field to `Nothing`. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.clear' #userData3 @ -} clearTreeIterUserData3 :: MonadIO m => TreeIter -> m () clearTreeIterUserData3 s = liftIO $ withManagedPtr s $ \ptr -> do poke (ptr `plusPtr` 24) (FP.nullPtr :: Ptr ()) #if ENABLE_OVERLOADING data TreeIterUserData3FieldInfo instance AttrInfo TreeIterUserData3FieldInfo where type AttrAllowedOps TreeIterUserData3FieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear] type AttrSetTypeConstraint TreeIterUserData3FieldInfo = (~) (Ptr ()) type AttrBaseTypeConstraint TreeIterUserData3FieldInfo = (~) TreeIter type AttrGetType TreeIterUserData3FieldInfo = Ptr () type AttrLabel TreeIterUserData3FieldInfo = "user_data3" type AttrOrigin TreeIterUserData3FieldInfo = TreeIter attrGet _ = getTreeIterUserData3 attrSet _ = setTreeIterUserData3 attrConstruct = undefined attrClear _ = clearTreeIterUserData3 treeIter_userData3 :: AttrLabelProxy "userData3" treeIter_userData3 = AttrLabelProxy #endif #if ENABLE_OVERLOADING instance O.HasAttributeList TreeIter type instance O.AttributeList TreeIter = TreeIterAttributeList type TreeIterAttributeList = ('[ '("stamp", TreeIterStampFieldInfo), '("userData", TreeIterUserDataFieldInfo), '("userData2", TreeIterUserData2FieldInfo), '("userData3", TreeIterUserData3FieldInfo)] :: [(Symbol, *)]) #endif -- method TreeIter::copy -- method type : OrdinaryMethod -- Args : [Arg {argCName = "iter", argType = TInterface (Name {namespace = "Gtk", name = "TreeIter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkTreeIter-struct", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TInterface (Name {namespace = "Gtk", name = "TreeIter"})) -- throws : False -- Skip return : False foreign import ccall "gtk_tree_iter_copy" gtk_tree_iter_copy :: Ptr TreeIter -> -- iter : TInterface (Name {namespace = "Gtk", name = "TreeIter"}) IO (Ptr TreeIter) {- | Creates a dynamically allocated tree iterator as a copy of /@iter@/. This function is not intended for use in applications, because you can just copy the structs by value (@GtkTreeIter new_iter = iter;@). You must free this iter with 'GI.Gtk.Structs.TreeIter.treeIterFree'. -} treeIterCopy :: (B.CallStack.HasCallStack, MonadIO m) => TreeIter {- ^ /@iter@/: a 'GI.Gtk.Structs.TreeIter.TreeIter'-struct -} -> m TreeIter {- ^ __Returns:__ a newly-allocated copy of /@iter@/ -} treeIterCopy iter = liftIO $ do iter' <- unsafeManagedPtrGetPtr iter result <- gtk_tree_iter_copy iter' checkUnexpectedReturnNULL "treeIterCopy" result result' <- (wrapBoxed TreeIter) result touchManagedPtr iter return result' #if ENABLE_OVERLOADING data TreeIterCopyMethodInfo instance (signature ~ (m TreeIter), MonadIO m) => O.MethodInfo TreeIterCopyMethodInfo TreeIter signature where overloadedMethod _ = treeIterCopy #endif -- method TreeIter::free -- method type : OrdinaryMethod -- Args : [Arg {argCName = "iter", argType = TInterface (Name {namespace = "Gtk", name = "TreeIter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a dynamically allocated tree iterator", 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_iter_free" gtk_tree_iter_free :: Ptr TreeIter -> -- iter : TInterface (Name {namespace = "Gtk", name = "TreeIter"}) IO () {- | Frees an iterator that has been allocated by 'GI.Gtk.Structs.TreeIter.treeIterCopy'. This function is mainly used for language bindings. -} treeIterFree :: (B.CallStack.HasCallStack, MonadIO m) => TreeIter {- ^ /@iter@/: a dynamically allocated tree iterator -} -> m () treeIterFree iter = liftIO $ do iter' <- unsafeManagedPtrGetPtr iter gtk_tree_iter_free iter' touchManagedPtr iter return () #if ENABLE_OVERLOADING data TreeIterFreeMethodInfo instance (signature ~ (m ()), MonadIO m) => O.MethodInfo TreeIterFreeMethodInfo TreeIter signature where overloadedMethod _ = treeIterFree #endif #if ENABLE_OVERLOADING type family ResolveTreeIterMethod (t :: Symbol) (o :: *) :: * where ResolveTreeIterMethod "copy" o = TreeIterCopyMethodInfo ResolveTreeIterMethod "free" o = TreeIterFreeMethodInfo ResolveTreeIterMethod l o = O.MethodResolutionFailed l o instance (info ~ ResolveTreeIterMethod t TreeIter, O.MethodInfo info TreeIter p) => OL.IsLabel t (TreeIter -> 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