{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Pango.Structs.ScriptIter
(
ScriptIter(..) ,
#if defined(ENABLE_OVERLOADING)
ResolveScriptIterMethod ,
#endif
#if defined(ENABLE_OVERLOADING)
ScriptIterFreeMethodInfo ,
#endif
scriptIterFree ,
#if defined(ENABLE_OVERLOADING)
ScriptIterGetRangeMethodInfo ,
#endif
scriptIterGetRange ,
scriptIterNew ,
#if defined(ENABLE_OVERLOADING)
ScriptIterNextMethodInfo ,
#endif
scriptIterNext ,
) where
import Data.GI.Base.ShortPrelude
import qualified Data.GI.Base.ShortPrelude as SP
import qualified Data.GI.Base.Overloading as O
import qualified Prelude as P
import qualified Data.GI.Base.Attributes as GI.Attributes
import qualified Data.GI.Base.BasicTypes as B.Types
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GArray as B.GArray
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GHashTable as B.GHT
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.GI.Base.Signals as B.Signals
import qualified Control.Monad.IO.Class as MIO
import qualified Data.Coerce as Coerce
import qualified Data.Text as T
import qualified Data.Kind as DK
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL
import qualified GHC.Records as R
import {-# SOURCE #-} qualified GI.Pango.Enums as Pango.Enums
newtype ScriptIter = ScriptIter (SP.ManagedPtr ScriptIter)
deriving (ScriptIter -> ScriptIter -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ScriptIter -> ScriptIter -> Bool
$c/= :: ScriptIter -> ScriptIter -> Bool
== :: ScriptIter -> ScriptIter -> Bool
$c== :: ScriptIter -> ScriptIter -> Bool
Eq)
instance SP.ManagedPtrNewtype ScriptIter where
toManagedPtr :: ScriptIter -> ManagedPtr ScriptIter
toManagedPtr (ScriptIter ManagedPtr ScriptIter
p) = ManagedPtr ScriptIter
p
foreign import ccall "pango_script_iter_get_type" c_pango_script_iter_get_type ::
IO GType
type instance O.ParentTypes ScriptIter = '[]
instance O.HasParentTypes ScriptIter
instance B.Types.TypedObject ScriptIter where
glibType :: IO GType
glibType = IO GType
c_pango_script_iter_get_type
instance B.Types.GBoxed ScriptIter
instance B.GValue.IsGValue (Maybe ScriptIter) where
gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_pango_script_iter_get_type
gvalueSet_ :: Ptr GValue -> Maybe ScriptIter -> IO ()
gvalueSet_ Ptr GValue
gv Maybe ScriptIter
P.Nothing = forall a. Ptr GValue -> Ptr a -> IO ()
B.GValue.set_boxed Ptr GValue
gv (forall a. Ptr a
FP.nullPtr :: FP.Ptr ScriptIter)
gvalueSet_ Ptr GValue
gv (P.Just ScriptIter
obj) = forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr ScriptIter
obj (forall a. Ptr GValue -> Ptr a -> IO ()
B.GValue.set_boxed Ptr GValue
gv)
gvalueGet_ :: Ptr GValue -> IO (Maybe ScriptIter)
gvalueGet_ Ptr GValue
gv = do
Ptr ScriptIter
ptr <- forall b. Ptr GValue -> IO (Ptr b)
B.GValue.get_boxed Ptr GValue
gv :: IO (Ptr ScriptIter)
if Ptr ScriptIter
ptr forall a. Eq a => a -> a -> Bool
/= forall a. Ptr a
FP.nullPtr
then forall a. a -> Maybe a
P.Just forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
B.ManagedPtr.newBoxed ManagedPtr ScriptIter -> ScriptIter
ScriptIter Ptr ScriptIter
ptr
else forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Maybe a
P.Nothing
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList ScriptIter
type instance O.AttributeList ScriptIter = ScriptIterAttributeList
type ScriptIterAttributeList = ('[ ] :: [(Symbol, DK.Type)])
#endif
foreign import ccall "pango_script_iter_new" pango_script_iter_new ::
CString ->
Int32 ->
IO (Ptr ScriptIter)
scriptIterNew ::
(B.CallStack.HasCallStack, MonadIO m) =>
T.Text
-> Int32
-> m ScriptIter
scriptIterNew :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Text -> Int32 -> m ScriptIter
scriptIterNew Text
text Int32
length_ = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
CString
text' <- Text -> IO CString
textToCString Text
text
Ptr ScriptIter
result <- CString -> Int32 -> IO (Ptr ScriptIter)
pango_script_iter_new CString
text' Int32
length_
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"scriptIterNew" Ptr ScriptIter
result
ScriptIter
result' <- (forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr ScriptIter -> ScriptIter
ScriptIter) Ptr ScriptIter
result
forall a. Ptr a -> IO ()
freeMem CString
text'
forall (m :: * -> *) a. Monad m => a -> m a
return ScriptIter
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "pango_script_iter_free" pango_script_iter_free ::
Ptr ScriptIter ->
IO ()
scriptIterFree ::
(B.CallStack.HasCallStack, MonadIO m) =>
ScriptIter
-> m ()
scriptIterFree :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
ScriptIter -> m ()
scriptIterFree ScriptIter
iter = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr ScriptIter
iter' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr ScriptIter
iter
Ptr ScriptIter -> IO ()
pango_script_iter_free Ptr ScriptIter
iter'
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr ScriptIter
iter
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data ScriptIterFreeMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.OverloadedMethod ScriptIterFreeMethodInfo ScriptIter signature where
overloadedMethod = scriptIterFree
instance O.OverloadedMethodInfo ScriptIterFreeMethodInfo ScriptIter where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Pango.Structs.ScriptIter.scriptIterFree",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-pango-1.0.27/docs/GI-Pango-Structs-ScriptIter.html#v:scriptIterFree"
})
#endif
foreign import ccall "pango_script_iter_get_range" pango_script_iter_get_range ::
Ptr ScriptIter ->
Ptr CString ->
Ptr CString ->
Ptr CInt ->
IO ()
scriptIterGetRange ::
(B.CallStack.HasCallStack, MonadIO m) =>
ScriptIter
-> m ((T.Text, T.Text, Pango.Enums.Script))
scriptIterGetRange :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
ScriptIter -> m (Text, Text, Script)
scriptIterGetRange ScriptIter
iter = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr ScriptIter
iter' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr ScriptIter
iter
Ptr CString
start <- forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr CString)
Ptr CString
end <- forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr CString)
Ptr CInt
script <- forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CInt)
Ptr ScriptIter -> Ptr CString -> Ptr CString -> Ptr CInt -> IO ()
pango_script_iter_get_range Ptr ScriptIter
iter' Ptr CString
start Ptr CString
end Ptr CInt
script
CString
start' <- forall a. Storable a => Ptr a -> IO a
peek Ptr CString
start
Text
start'' <- HasCallStack => CString -> IO Text
cstringToText CString
start'
forall a. Ptr a -> IO ()
freeMem CString
start'
CString
end' <- forall a. Storable a => Ptr a -> IO a
peek Ptr CString
end
Text
end'' <- HasCallStack => CString -> IO Text
cstringToText CString
end'
forall a. Ptr a -> IO ()
freeMem CString
end'
CInt
script' <- forall a. Storable a => Ptr a -> IO a
peek Ptr CInt
script
let script'' :: Script
script'' = (forall a. Enum a => Int -> a
toEnum forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (Integral a, Num b) => a -> b
fromIntegral) CInt
script'
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr ScriptIter
iter
forall a. Ptr a -> IO ()
freeMem Ptr CString
start
forall a. Ptr a -> IO ()
freeMem Ptr CString
end
forall a. Ptr a -> IO ()
freeMem Ptr CInt
script
forall (m :: * -> *) a. Monad m => a -> m a
return (Text
start'', Text
end'', Script
script'')
#if defined(ENABLE_OVERLOADING)
data ScriptIterGetRangeMethodInfo
instance (signature ~ (m ((T.Text, T.Text, Pango.Enums.Script))), MonadIO m) => O.OverloadedMethod ScriptIterGetRangeMethodInfo ScriptIter signature where
overloadedMethod = scriptIterGetRange
instance O.OverloadedMethodInfo ScriptIterGetRangeMethodInfo ScriptIter where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Pango.Structs.ScriptIter.scriptIterGetRange",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-pango-1.0.27/docs/GI-Pango-Structs-ScriptIter.html#v:scriptIterGetRange"
})
#endif
foreign import ccall "pango_script_iter_next" pango_script_iter_next ::
Ptr ScriptIter ->
IO CInt
scriptIterNext ::
(B.CallStack.HasCallStack, MonadIO m) =>
ScriptIter
-> m Bool
scriptIterNext :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
ScriptIter -> m Bool
scriptIterNext ScriptIter
iter = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr ScriptIter
iter' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr ScriptIter
iter
CInt
result <- Ptr ScriptIter -> IO CInt
pango_script_iter_next Ptr ScriptIter
iter'
let result' :: Bool
result' = (forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr ScriptIter
iter
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data ScriptIterNextMethodInfo
instance (signature ~ (m Bool), MonadIO m) => O.OverloadedMethod ScriptIterNextMethodInfo ScriptIter signature where
overloadedMethod = scriptIterNext
instance O.OverloadedMethodInfo ScriptIterNextMethodInfo ScriptIter where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Pango.Structs.ScriptIter.scriptIterNext",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-pango-1.0.27/docs/GI-Pango-Structs-ScriptIter.html#v:scriptIterNext"
})
#endif
#if defined(ENABLE_OVERLOADING)
type family ResolveScriptIterMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
ResolveScriptIterMethod "free" o = ScriptIterFreeMethodInfo
ResolveScriptIterMethod "next" o = ScriptIterNextMethodInfo
ResolveScriptIterMethod "getRange" o = ScriptIterGetRangeMethodInfo
ResolveScriptIterMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveScriptIterMethod t ScriptIter, O.OverloadedMethod info ScriptIter p) => OL.IsLabel t (ScriptIter -> 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 ~ ResolveScriptIterMethod t ScriptIter, O.OverloadedMethod info ScriptIter p, R.HasField t ScriptIter p) => R.HasField t ScriptIter p where
getField = O.overloadedMethod @info
#endif
instance (info ~ ResolveScriptIterMethod t ScriptIter, O.OverloadedMethodInfo info ScriptIter) => OL.IsLabel t (O.MethodProxy info ScriptIter) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.MethodProxy
#else
fromLabel _ = O.MethodProxy
#endif
#endif