{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- t'GI.GtkSource.Structs.RegionIter.RegionIter' is an opaque datatype; ignore all its fields.
-- Initialize the iter with 'GI.GtkSource.Objects.Region.regionGetStartRegionIter'.
-- 
-- /Since: 3.22/

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

module GI.GtkSource.Structs.RegionIter
    ( 

-- * Exported types
    RegionIter(..)                          ,
    newZeroRegionIter                       ,


 -- * Methods
-- | 
-- 
--  === __Click to display all available methods, including inherited ones__
-- ==== Methods
-- [isEnd]("GI.GtkSource.Structs.RegionIter#g:method:isEnd"), [next]("GI.GtkSource.Structs.RegionIter#g:method:next").
-- 
-- ==== Getters
-- [getSubregion]("GI.GtkSource.Structs.RegionIter#g:method:getSubregion").
-- 
-- ==== Setters
-- /None/.

#if defined(ENABLE_OVERLOADING)
    ResolveRegionIterMethod                 ,
#endif

-- ** getSubregion #method:getSubregion#

#if defined(ENABLE_OVERLOADING)
    RegionIterGetSubregionMethodInfo        ,
#endif
    regionIterGetSubregion                  ,


-- ** isEnd #method:isEnd#

#if defined(ENABLE_OVERLOADING)
    RegionIterIsEndMethodInfo               ,
#endif
    regionIterIsEnd                         ,


-- ** next #method:next#

#if defined(ENABLE_OVERLOADING)
    RegionIterNextMethodInfo                ,
#endif
    regionIterNext                          ,




    ) where

import Data.GI.Base.ShortPrelude
import qualified Data.GI.Base.ShortPrelude as SP
import qualified Data.GI.Base.Overloading as O
import qualified Prelude as P

import qualified Data.GI.Base.Attributes as GI.Attributes
import qualified Data.GI.Base.BasicTypes as B.Types
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GArray as B.GArray
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.GI.Base.Signals as B.Signals
import qualified Control.Monad.IO.Class as MIO
import qualified Data.Coerce as Coerce
import qualified Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL
import qualified GHC.Records as R

import qualified GI.Gtk.Structs.TextIter as Gtk.TextIter

-- | Memory-managed wrapper type.
newtype RegionIter = RegionIter (SP.ManagedPtr RegionIter)
    deriving (RegionIter -> RegionIter -> Bool
(RegionIter -> RegionIter -> Bool)
-> (RegionIter -> RegionIter -> Bool) -> Eq RegionIter
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: RegionIter -> RegionIter -> Bool
$c/= :: RegionIter -> RegionIter -> Bool
== :: RegionIter -> RegionIter -> Bool
$c== :: RegionIter -> RegionIter -> Bool
Eq)

instance SP.ManagedPtrNewtype RegionIter where
    toManagedPtr :: RegionIter -> ManagedPtr RegionIter
toManagedPtr (RegionIter ManagedPtr RegionIter
p) = ManagedPtr RegionIter
p

instance BoxedPtr RegionIter where
    boxedPtrCopy :: RegionIter -> IO RegionIter
boxedPtrCopy = \RegionIter
p -> RegionIter -> (Ptr RegionIter -> IO RegionIter) -> IO RegionIter
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr RegionIter
p (Int -> Ptr RegionIter -> IO (Ptr RegionIter)
forall a. (HasCallStack, CallocPtr a) => Int -> Ptr a -> IO (Ptr a)
copyBytes Int
24 (Ptr RegionIter -> IO (Ptr RegionIter))
-> (Ptr RegionIter -> IO RegionIter)
-> Ptr RegionIter
-> IO RegionIter
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (ManagedPtr RegionIter -> RegionIter)
-> Ptr RegionIter -> IO RegionIter
forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
B.ManagedPtr.wrapPtr ManagedPtr RegionIter -> RegionIter
RegionIter)
    boxedPtrFree :: RegionIter -> IO ()
boxedPtrFree = \RegionIter
x -> RegionIter -> (Ptr RegionIter -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
SP.withManagedPtr RegionIter
x Ptr RegionIter -> IO ()
forall a. Ptr a -> IO ()
SP.freeMem
instance CallocPtr RegionIter where
    boxedPtrCalloc :: IO (Ptr RegionIter)
boxedPtrCalloc = Int -> IO (Ptr RegionIter)
forall a. Int -> IO (Ptr a)
callocBytes Int
24


-- | Construct a `RegionIter` struct initialized to zero.
newZeroRegionIter :: MonadIO m => m RegionIter
newZeroRegionIter :: forall (m :: * -> *). MonadIO m => m RegionIter
newZeroRegionIter = IO RegionIter -> m RegionIter
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO RegionIter -> m RegionIter) -> IO RegionIter -> m RegionIter
forall a b. (a -> b) -> a -> b
$ IO (Ptr RegionIter)
forall a. CallocPtr a => IO (Ptr a)
boxedPtrCalloc IO (Ptr RegionIter)
-> (Ptr RegionIter -> IO RegionIter) -> IO RegionIter
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (ManagedPtr RegionIter -> RegionIter)
-> Ptr RegionIter -> IO RegionIter
forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapPtr ManagedPtr RegionIter -> RegionIter
RegionIter

instance tag ~ 'AttrSet => Constructible RegionIter tag where
    new :: forall (m :: * -> *).
MonadIO m =>
(ManagedPtr RegionIter -> RegionIter)
-> [AttrOp RegionIter tag] -> m RegionIter
new ManagedPtr RegionIter -> RegionIter
_ [AttrOp RegionIter tag]
attrs = do
        RegionIter
o <- m RegionIter
forall (m :: * -> *). MonadIO m => m RegionIter
newZeroRegionIter
        RegionIter -> [AttrOp RegionIter 'AttrSet] -> m ()
forall o (m :: * -> *).
MonadIO m =>
o -> [AttrOp o 'AttrSet] -> m ()
GI.Attributes.set RegionIter
o [AttrOp RegionIter tag]
[AttrOp RegionIter 'AttrSet]
attrs
        RegionIter -> m RegionIter
forall (m :: * -> *) a. Monad m => a -> m a
return RegionIter
o



#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList RegionIter
type instance O.AttributeList RegionIter = RegionIterAttributeList
type RegionIterAttributeList = ('[ ] :: [(Symbol, *)])
#endif

-- method RegionIter::get_subregion
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "iter"
--           , argType =
--               TInterface Name { namespace = "GtkSource" , name = "RegionIter" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkSourceRegionIter."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "start"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "TextIter" }
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "iterator to initialize with the subregion start, or %NULL."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = True
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "end"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "TextIter" }
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "iterator to initialize with the subregion end, 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_source_region_iter_get_subregion" gtk_source_region_iter_get_subregion :: 
    Ptr RegionIter ->                       -- iter : TInterface (Name {namespace = "GtkSource", name = "RegionIter"})
    Ptr Gtk.TextIter.TextIter ->            -- start : TInterface (Name {namespace = "Gtk", name = "TextIter"})
    Ptr Gtk.TextIter.TextIter ->            -- end : TInterface (Name {namespace = "Gtk", name = "TextIter"})
    IO CInt

-- | Gets the subregion at this iterator.
-- 
-- /Since: 3.22/
regionIterGetSubregion ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    RegionIter
    -- ^ /@iter@/: a t'GI.GtkSource.Structs.RegionIter.RegionIter'.
    -> m ((Bool, Gtk.TextIter.TextIter, Gtk.TextIter.TextIter))
    -- ^ __Returns:__ 'P.True' if /@start@/ and /@end@/ have been set successfully (if non-'P.Nothing'),
    --   or 'P.False' if /@iter@/ is the end iterator or if the region is empty.
regionIterGetSubregion :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
RegionIter -> m (Bool, TextIter, TextIter)
regionIterGetSubregion RegionIter
iter = IO (Bool, TextIter, TextIter) -> m (Bool, TextIter, TextIter)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Bool, TextIter, TextIter) -> m (Bool, TextIter, TextIter))
-> IO (Bool, TextIter, TextIter) -> m (Bool, TextIter, TextIter)
forall a b. (a -> b) -> a -> b
$ do
    Ptr RegionIter
iter' <- RegionIter -> IO (Ptr RegionIter)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr RegionIter
iter
    Ptr TextIter
start <- Int -> IO (Ptr TextIter)
forall a. GBoxed a => Int -> IO (Ptr a)
SP.callocBoxedBytes Int
80 :: IO (Ptr Gtk.TextIter.TextIter)
    Ptr TextIter
end <- Int -> IO (Ptr TextIter)
forall a. GBoxed a => Int -> IO (Ptr a)
SP.callocBoxedBytes Int
80 :: IO (Ptr Gtk.TextIter.TextIter)
    CInt
result <- Ptr RegionIter -> Ptr TextIter -> Ptr TextIter -> IO CInt
gtk_source_region_iter_get_subregion Ptr RegionIter
iter' Ptr TextIter
start Ptr TextIter
end
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    TextIter
start' <- ((ManagedPtr TextIter -> TextIter) -> Ptr TextIter -> IO TextIter
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr TextIter -> TextIter
Gtk.TextIter.TextIter) Ptr TextIter
start
    TextIter
end' <- ((ManagedPtr TextIter -> TextIter) -> Ptr TextIter -> IO TextIter
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr TextIter -> TextIter
Gtk.TextIter.TextIter) Ptr TextIter
end
    RegionIter -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr RegionIter
iter
    (Bool, TextIter, TextIter) -> IO (Bool, TextIter, TextIter)
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool
result', TextIter
start', TextIter
end')

#if defined(ENABLE_OVERLOADING)
data RegionIterGetSubregionMethodInfo
instance (signature ~ (m ((Bool, Gtk.TextIter.TextIter, Gtk.TextIter.TextIter))), MonadIO m) => O.OverloadedMethod RegionIterGetSubregionMethodInfo RegionIter signature where
    overloadedMethod = regionIterGetSubregion

instance O.OverloadedMethodInfo RegionIterGetSubregionMethodInfo RegionIter where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Structs.RegionIter.regionIterGetSubregion",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-3.0.25/docs/GI-GtkSource-Structs-RegionIter.html#v:regionIterGetSubregion"
        })


#endif

-- method RegionIter::is_end
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "iter"
--           , argType =
--               TInterface Name { namespace = "GtkSource" , name = "RegionIter" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkSourceRegionIter."
--                 , 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_source_region_iter_is_end" gtk_source_region_iter_is_end :: 
    Ptr RegionIter ->                       -- iter : TInterface (Name {namespace = "GtkSource", name = "RegionIter"})
    IO CInt

-- | /No description available in the introspection data./
-- 
-- /Since: 3.22/
regionIterIsEnd ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    RegionIter
    -- ^ /@iter@/: a t'GI.GtkSource.Structs.RegionIter.RegionIter'.
    -> m Bool
    -- ^ __Returns:__ whether /@iter@/ is the end iterator.
regionIterIsEnd :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
RegionIter -> m Bool
regionIterIsEnd RegionIter
iter = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr RegionIter
iter' <- RegionIter -> IO (Ptr RegionIter)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr RegionIter
iter
    CInt
result <- Ptr RegionIter -> IO CInt
gtk_source_region_iter_is_end Ptr RegionIter
iter'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    RegionIter -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr RegionIter
iter
    Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data RegionIterIsEndMethodInfo
instance (signature ~ (m Bool), MonadIO m) => O.OverloadedMethod RegionIterIsEndMethodInfo RegionIter signature where
    overloadedMethod = regionIterIsEnd

instance O.OverloadedMethodInfo RegionIterIsEndMethodInfo RegionIter where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Structs.RegionIter.regionIterIsEnd",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-3.0.25/docs/GI-GtkSource-Structs-RegionIter.html#v:regionIterIsEnd"
        })


#endif

-- method RegionIter::next
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "iter"
--           , argType =
--               TInterface Name { namespace = "GtkSource" , name = "RegionIter" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkSourceRegionIter."
--                 , 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_source_region_iter_next" gtk_source_region_iter_next :: 
    Ptr RegionIter ->                       -- iter : TInterface (Name {namespace = "GtkSource", name = "RegionIter"})
    IO CInt

-- | Moves /@iter@/ to the next subregion.
-- 
-- /Since: 3.22/
regionIterNext ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    RegionIter
    -- ^ /@iter@/: a t'GI.GtkSource.Structs.RegionIter.RegionIter'.
    -> m Bool
    -- ^ __Returns:__ 'P.True' if /@iter@/ moved and is dereferenceable, or 'P.False' if /@iter@/ has
    --   been set to the end iterator.
regionIterNext :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
RegionIter -> m Bool
regionIterNext RegionIter
iter = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr RegionIter
iter' <- RegionIter -> IO (Ptr RegionIter)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr RegionIter
iter
    CInt
result <- Ptr RegionIter -> IO CInt
gtk_source_region_iter_next Ptr RegionIter
iter'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    RegionIter -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr RegionIter
iter
    Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data RegionIterNextMethodInfo
instance (signature ~ (m Bool), MonadIO m) => O.OverloadedMethod RegionIterNextMethodInfo RegionIter signature where
    overloadedMethod = regionIterNext

instance O.OverloadedMethodInfo RegionIterNextMethodInfo RegionIter where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Structs.RegionIter.regionIterNext",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-3.0.25/docs/GI-GtkSource-Structs-RegionIter.html#v:regionIterNext"
        })


#endif

#if defined(ENABLE_OVERLOADING)
type family ResolveRegionIterMethod (t :: Symbol) (o :: *) :: * where
    ResolveRegionIterMethod "isEnd" o = RegionIterIsEndMethodInfo
    ResolveRegionIterMethod "next" o = RegionIterNextMethodInfo
    ResolveRegionIterMethod "getSubregion" o = RegionIterGetSubregionMethodInfo
    ResolveRegionIterMethod l o = O.MethodResolutionFailed l o

instance (info ~ ResolveRegionIterMethod t RegionIter, O.OverloadedMethod info RegionIter p) => OL.IsLabel t (RegionIter -> p) where
#if MIN_VERSION_base(4,10,0)
    fromLabel = O.overloadedMethod @info
#else
    fromLabel _ = O.overloadedMethod @info
#endif

#if MIN_VERSION_base(4,13,0)
instance (info ~ ResolveRegionIterMethod t RegionIter, O.OverloadedMethod info RegionIter p, R.HasField t RegionIter p) => R.HasField t RegionIter p where
    getField = O.overloadedMethod @info

#endif

instance (info ~ ResolveRegionIterMethod t RegionIter, O.OverloadedMethodInfo info RegionIter) => OL.IsLabel t (O.MethodProxy info RegionIter) where
#if MIN_VERSION_base(4,10,0)
    fromLabel = O.MethodProxy
#else
    fromLabel _ = O.MethodProxy
#endif

#endif