{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Pango.Objects.Coverage
(
Coverage(..) ,
IsCoverage ,
toCoverage ,
#if defined(ENABLE_OVERLOADING)
ResolveCoverageMethod ,
#endif
#if defined(ENABLE_OVERLOADING)
CoverageCopyMethodInfo ,
#endif
coverageCopy ,
coverageFromBytes ,
#if defined(ENABLE_OVERLOADING)
CoverageGetMethodInfo ,
#endif
coverageGet ,
#if defined(ENABLE_OVERLOADING)
CoverageMaxMethodInfo ,
#endif
coverageMax ,
coverageNew ,
#if defined(ENABLE_OVERLOADING)
CoverageRefMethodInfo ,
#endif
coverageRef ,
#if defined(ENABLE_OVERLOADING)
CoverageSetMethodInfo ,
#endif
coverageSet ,
#if defined(ENABLE_OVERLOADING)
CoverageToBytesMethodInfo ,
#endif
coverageToBytes ,
#if defined(ENABLE_OVERLOADING)
CoverageUnrefMethodInfo ,
#endif
coverageUnref ,
) 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 qualified GI.GObject.Objects.Object as GObject.Object
import {-# SOURCE #-} qualified GI.Pango.Enums as Pango.Enums
newtype Coverage = Coverage (SP.ManagedPtr Coverage)
deriving (Coverage -> Coverage -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Coverage -> Coverage -> Bool
$c/= :: Coverage -> Coverage -> Bool
== :: Coverage -> Coverage -> Bool
$c== :: Coverage -> Coverage -> Bool
Eq)
instance SP.ManagedPtrNewtype Coverage where
toManagedPtr :: Coverage -> ManagedPtr Coverage
toManagedPtr (Coverage ManagedPtr Coverage
p) = ManagedPtr Coverage
p
foreign import ccall "pango_coverage_get_type"
c_pango_coverage_get_type :: IO B.Types.GType
instance B.Types.TypedObject Coverage where
glibType :: IO GType
glibType = IO GType
c_pango_coverage_get_type
instance B.Types.GObject Coverage
class (SP.GObject o, O.IsDescendantOf Coverage o) => IsCoverage o
instance (SP.GObject o, O.IsDescendantOf Coverage o) => IsCoverage o
instance O.HasParentTypes Coverage
type instance O.ParentTypes Coverage = '[GObject.Object.Object]
toCoverage :: (MIO.MonadIO m, IsCoverage o) => o -> m Coverage
toCoverage :: forall (m :: * -> *) o.
(MonadIO m, IsCoverage o) =>
o -> m Coverage
toCoverage = forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall o o'.
(HasCallStack, ManagedPtrNewtype o, TypedObject o,
ManagedPtrNewtype o', TypedObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
B.ManagedPtr.unsafeCastTo ManagedPtr Coverage -> Coverage
Coverage
instance B.GValue.IsGValue (Maybe Coverage) where
gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_pango_coverage_get_type
gvalueSet_ :: Ptr GValue -> Maybe Coverage -> IO ()
gvalueSet_ Ptr GValue
gv Maybe Coverage
P.Nothing = forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv (forall a. Ptr a
FP.nullPtr :: FP.Ptr Coverage)
gvalueSet_ Ptr GValue
gv (P.Just Coverage
obj) = forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr Coverage
obj (forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv)
gvalueGet_ :: Ptr GValue -> IO (Maybe Coverage)
gvalueGet_ Ptr GValue
gv = do
Ptr Coverage
ptr <- forall a. GObject a => Ptr GValue -> IO (Ptr a)
B.GValue.get_object Ptr GValue
gv :: IO (FP.Ptr Coverage)
if Ptr Coverage
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 b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr Coverage -> Coverage
Coverage Ptr Coverage
ptr
else forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Maybe a
P.Nothing
#if defined(ENABLE_OVERLOADING)
type family ResolveCoverageMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
ResolveCoverageMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
ResolveCoverageMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
ResolveCoverageMethod "copy" o = CoverageCopyMethodInfo
ResolveCoverageMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
ResolveCoverageMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
ResolveCoverageMethod "get" o = CoverageGetMethodInfo
ResolveCoverageMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
ResolveCoverageMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
ResolveCoverageMethod "max" o = CoverageMaxMethodInfo
ResolveCoverageMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
ResolveCoverageMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
ResolveCoverageMethod "ref" o = CoverageRefMethodInfo
ResolveCoverageMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
ResolveCoverageMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
ResolveCoverageMethod "set" o = CoverageSetMethodInfo
ResolveCoverageMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
ResolveCoverageMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
ResolveCoverageMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
ResolveCoverageMethod "toBytes" o = CoverageToBytesMethodInfo
ResolveCoverageMethod "unref" o = CoverageUnrefMethodInfo
ResolveCoverageMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
ResolveCoverageMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
ResolveCoverageMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
ResolveCoverageMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
ResolveCoverageMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
ResolveCoverageMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
ResolveCoverageMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
ResolveCoverageMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveCoverageMethod t Coverage, O.OverloadedMethod info Coverage p) => OL.IsLabel t (Coverage -> 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 ~ ResolveCoverageMethod t Coverage, O.OverloadedMethod info Coverage p, R.HasField t Coverage p) => R.HasField t Coverage p where
getField = O.overloadedMethod @info
#endif
instance (info ~ ResolveCoverageMethod t Coverage, O.OverloadedMethodInfo info Coverage) => OL.IsLabel t (O.MethodProxy info Coverage) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.MethodProxy
#else
fromLabel _ = O.MethodProxy
#endif
#endif
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList Coverage
type instance O.AttributeList Coverage = CoverageAttributeList
type CoverageAttributeList = ('[ ] :: [(Symbol, DK.Type)])
#endif
#if defined(ENABLE_OVERLOADING)
#endif
#if defined(ENABLE_OVERLOADING)
type instance O.SignalList Coverage = CoverageSignalList
type CoverageSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, DK.Type)])
#endif
foreign import ccall "pango_coverage_new" pango_coverage_new ::
IO (Ptr Coverage)
coverageNew ::
(B.CallStack.HasCallStack, MonadIO m) =>
m Coverage
coverageNew :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m Coverage
coverageNew = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr Coverage
result <- IO (Ptr Coverage)
pango_coverage_new
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"coverageNew" Ptr Coverage
result
Coverage
result' <- (forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr Coverage -> Coverage
Coverage) Ptr Coverage
result
forall (m :: * -> *) a. Monad m => a -> m a
return Coverage
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "pango_coverage_copy" pango_coverage_copy ::
Ptr Coverage ->
IO (Ptr Coverage)
coverageCopy ::
(B.CallStack.HasCallStack, MonadIO m, IsCoverage a) =>
a
-> m Coverage
coverageCopy :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsCoverage a) =>
a -> m Coverage
coverageCopy a
coverage = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr Coverage
coverage' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
coverage
Ptr Coverage
result <- Ptr Coverage -> IO (Ptr Coverage)
pango_coverage_copy Ptr Coverage
coverage'
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"coverageCopy" Ptr Coverage
result
Coverage
result' <- (forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr Coverage -> Coverage
Coverage) Ptr Coverage
result
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
coverage
forall (m :: * -> *) a. Monad m => a -> m a
return Coverage
result'
#if defined(ENABLE_OVERLOADING)
data CoverageCopyMethodInfo
instance (signature ~ (m Coverage), MonadIO m, IsCoverage a) => O.OverloadedMethod CoverageCopyMethodInfo a signature where
overloadedMethod = coverageCopy
instance O.OverloadedMethodInfo CoverageCopyMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Pango.Objects.Coverage.coverageCopy",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-pango-1.0.27/docs/GI-Pango-Objects-Coverage.html#v:coverageCopy"
})
#endif
foreign import ccall "pango_coverage_get" pango_coverage_get ::
Ptr Coverage ->
Int32 ->
IO CUInt
coverageGet ::
(B.CallStack.HasCallStack, MonadIO m, IsCoverage a) =>
a
-> Int32
-> m Pango.Enums.CoverageLevel
coverageGet :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsCoverage a) =>
a -> Int32 -> m CoverageLevel
coverageGet a
coverage Int32
index_ = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr Coverage
coverage' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
coverage
CUInt
result <- Ptr Coverage -> Int32 -> IO CUInt
pango_coverage_get Ptr Coverage
coverage' Int32
index_
let result' :: CoverageLevel
result' = (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) CUInt
result
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
coverage
forall (m :: * -> *) a. Monad m => a -> m a
return CoverageLevel
result'
#if defined(ENABLE_OVERLOADING)
data CoverageGetMethodInfo
instance (signature ~ (Int32 -> m Pango.Enums.CoverageLevel), MonadIO m, IsCoverage a) => O.OverloadedMethod CoverageGetMethodInfo a signature where
overloadedMethod = coverageGet
instance O.OverloadedMethodInfo CoverageGetMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Pango.Objects.Coverage.coverageGet",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-pango-1.0.27/docs/GI-Pango-Objects-Coverage.html#v:coverageGet"
})
#endif
foreign import ccall "pango_coverage_max" pango_coverage_max ::
Ptr Coverage ->
Ptr Coverage ->
IO ()
{-# DEPRECATED coverageMax ["(Since version 1.44)","This function does nothing"] #-}
coverageMax ::
(B.CallStack.HasCallStack, MonadIO m, IsCoverage a, IsCoverage b) =>
a
-> b
-> m ()
coverageMax :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsCoverage a, IsCoverage b) =>
a -> b -> m ()
coverageMax a
coverage b
other = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr Coverage
coverage' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
coverage
Ptr Coverage
other' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
other
Ptr Coverage -> Ptr Coverage -> IO ()
pango_coverage_max Ptr Coverage
coverage' Ptr Coverage
other'
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
coverage
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
other
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data CoverageMaxMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsCoverage a, IsCoverage b) => O.OverloadedMethod CoverageMaxMethodInfo a signature where
overloadedMethod = coverageMax
instance O.OverloadedMethodInfo CoverageMaxMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Pango.Objects.Coverage.coverageMax",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-pango-1.0.27/docs/GI-Pango-Objects-Coverage.html#v:coverageMax"
})
#endif
foreign import ccall "pango_coverage_ref" pango_coverage_ref ::
Ptr Coverage ->
IO (Ptr Coverage)
{-# DEPRECATED coverageRef ["(Since version 1.52)","Use g_object_ref instead"] #-}
coverageRef ::
(B.CallStack.HasCallStack, MonadIO m, IsCoverage a) =>
a
-> m Coverage
coverageRef :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsCoverage a) =>
a -> m Coverage
coverageRef a
coverage = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr Coverage
coverage' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
coverage
Ptr Coverage
result <- Ptr Coverage -> IO (Ptr Coverage)
pango_coverage_ref Ptr Coverage
coverage'
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"coverageRef" Ptr Coverage
result
Coverage
result' <- (forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr Coverage -> Coverage
Coverage) Ptr Coverage
result
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
coverage
forall (m :: * -> *) a. Monad m => a -> m a
return Coverage
result'
#if defined(ENABLE_OVERLOADING)
data CoverageRefMethodInfo
instance (signature ~ (m Coverage), MonadIO m, IsCoverage a) => O.OverloadedMethod CoverageRefMethodInfo a signature where
overloadedMethod = coverageRef
instance O.OverloadedMethodInfo CoverageRefMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Pango.Objects.Coverage.coverageRef",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-pango-1.0.27/docs/GI-Pango-Objects-Coverage.html#v:coverageRef"
})
#endif
foreign import ccall "pango_coverage_set" pango_coverage_set ::
Ptr Coverage ->
Int32 ->
CUInt ->
IO ()
coverageSet ::
(B.CallStack.HasCallStack, MonadIO m, IsCoverage a) =>
a
-> Int32
-> Pango.Enums.CoverageLevel
-> m ()
coverageSet :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsCoverage a) =>
a -> Int32 -> CoverageLevel -> m ()
coverageSet a
coverage Int32
index_ CoverageLevel
level = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr Coverage
coverage' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
coverage
let level' :: CUInt
level' = (forall a b. (Integral a, Num b) => a -> b
fromIntegral forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Enum a => a -> Int
fromEnum) CoverageLevel
level
Ptr Coverage -> Int32 -> CUInt -> IO ()
pango_coverage_set Ptr Coverage
coverage' Int32
index_ CUInt
level'
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
coverage
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data CoverageSetMethodInfo
instance (signature ~ (Int32 -> Pango.Enums.CoverageLevel -> m ()), MonadIO m, IsCoverage a) => O.OverloadedMethod CoverageSetMethodInfo a signature where
overloadedMethod = coverageSet
instance O.OverloadedMethodInfo CoverageSetMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Pango.Objects.Coverage.coverageSet",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-pango-1.0.27/docs/GI-Pango-Objects-Coverage.html#v:coverageSet"
})
#endif
foreign import ccall "pango_coverage_to_bytes" pango_coverage_to_bytes ::
Ptr Coverage ->
Ptr (Ptr Word8) ->
Ptr Int32 ->
IO ()
{-# DEPRECATED coverageToBytes ["(Since version 1.44)","This returns 'P.Nothing'"] #-}
coverageToBytes ::
(B.CallStack.HasCallStack, MonadIO m, IsCoverage a) =>
a
-> m (ByteString)
coverageToBytes :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsCoverage a) =>
a -> m ByteString
coverageToBytes a
coverage = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr Coverage
coverage' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
coverage
Ptr (Ptr Word8)
bytes <- forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (Ptr Word8))
Ptr Int32
nBytes <- forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Int32)
Ptr Coverage -> Ptr (Ptr Word8) -> Ptr Int32 -> IO ()
pango_coverage_to_bytes Ptr Coverage
coverage' Ptr (Ptr Word8)
bytes Ptr Int32
nBytes
Int32
nBytes' <- forall a. Storable a => Ptr a -> IO a
peek Ptr Int32
nBytes
Ptr Word8
bytes' <- forall a. Storable a => Ptr a -> IO a
peek Ptr (Ptr Word8)
bytes
ByteString
bytes'' <- (forall a. Integral a => a -> Ptr Word8 -> IO ByteString
unpackByteStringWithLength Int32
nBytes') Ptr Word8
bytes'
forall a. Ptr a -> IO ()
freeMem Ptr Word8
bytes'
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
coverage
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr Word8)
bytes
forall a. Ptr a -> IO ()
freeMem Ptr Int32
nBytes
forall (m :: * -> *) a. Monad m => a -> m a
return ByteString
bytes''
#if defined(ENABLE_OVERLOADING)
data CoverageToBytesMethodInfo
instance (signature ~ (m (ByteString)), MonadIO m, IsCoverage a) => O.OverloadedMethod CoverageToBytesMethodInfo a signature where
overloadedMethod = coverageToBytes
instance O.OverloadedMethodInfo CoverageToBytesMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Pango.Objects.Coverage.coverageToBytes",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-pango-1.0.27/docs/GI-Pango-Objects-Coverage.html#v:coverageToBytes"
})
#endif
foreign import ccall "pango_coverage_unref" pango_coverage_unref ::
Ptr Coverage ->
IO ()
{-# DEPRECATED coverageUnref ["(Since version 1.52)","Use g_object_unref instead"] #-}
coverageUnref ::
(B.CallStack.HasCallStack, MonadIO m, IsCoverage a) =>
a
-> m ()
coverageUnref :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsCoverage a) =>
a -> m ()
coverageUnref a
coverage = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr Coverage
coverage' <- forall a b. (HasCallStack, GObject a) => a -> IO (Ptr b)
B.ManagedPtr.disownObject a
coverage
Ptr Coverage -> IO ()
pango_coverage_unref Ptr Coverage
coverage'
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
coverage
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data CoverageUnrefMethodInfo
instance (signature ~ (m ()), MonadIO m, IsCoverage a) => O.OverloadedMethod CoverageUnrefMethodInfo a signature where
overloadedMethod = coverageUnref
instance O.OverloadedMethodInfo CoverageUnrefMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Pango.Objects.Coverage.coverageUnref",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-pango-1.0.27/docs/GI-Pango-Objects-Coverage.html#v:coverageUnref"
})
#endif
foreign import ccall "pango_coverage_from_bytes" pango_coverage_from_bytes ::
Ptr Word8 ->
Int32 ->
IO (Ptr Coverage)
{-# DEPRECATED coverageFromBytes ["(Since version 1.44)","This returns 'P.Nothing'"] #-}
coverageFromBytes ::
(B.CallStack.HasCallStack, MonadIO m) =>
ByteString
-> m (Maybe Coverage)
coverageFromBytes :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
ByteString -> m (Maybe Coverage)
coverageFromBytes ByteString
bytes = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
let nBytes :: Int32
nBytes = forall a b. (Integral a, Num b) => a -> b
fromIntegral forall a b. (a -> b) -> a -> b
$ ByteString -> Int
B.length ByteString
bytes
Ptr Word8
bytes' <- ByteString -> IO (Ptr Word8)
packByteString ByteString
bytes
Ptr Coverage
result <- Ptr Word8 -> Int32 -> IO (Ptr Coverage)
pango_coverage_from_bytes Ptr Word8
bytes' Int32
nBytes
Maybe Coverage
maybeResult <- forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Coverage
result forall a b. (a -> b) -> a -> b
$ \Ptr Coverage
result' -> do
Coverage
result'' <- (forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr Coverage -> Coverage
Coverage) Ptr Coverage
result'
forall (m :: * -> *) a. Monad m => a -> m a
return Coverage
result''
forall a. Ptr a -> IO ()
freeMem Ptr Word8
bytes'
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Coverage
maybeResult
#if defined(ENABLE_OVERLOADING)
#endif