{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Pango.Structs.Attribute
(
Attribute(..) ,
#if defined(ENABLE_OVERLOADING)
ResolveAttributeMethod ,
#endif
#if defined(ENABLE_OVERLOADING)
AttributeAsColorMethodInfo ,
#endif
attributeAsColor ,
#if defined(ENABLE_OVERLOADING)
AttributeAsFloatMethodInfo ,
#endif
attributeAsFloat ,
#if defined(ENABLE_OVERLOADING)
AttributeAsFontDescMethodInfo ,
#endif
attributeAsFontDesc ,
#if defined(ENABLE_OVERLOADING)
AttributeAsFontFeaturesMethodInfo ,
#endif
attributeAsFontFeatures ,
#if defined(ENABLE_OVERLOADING)
AttributeAsIntMethodInfo ,
#endif
attributeAsInt ,
#if defined(ENABLE_OVERLOADING)
AttributeAsLanguageMethodInfo ,
#endif
attributeAsLanguage ,
#if defined(ENABLE_OVERLOADING)
AttributeAsShapeMethodInfo ,
#endif
attributeAsShape ,
#if defined(ENABLE_OVERLOADING)
AttributeAsSizeMethodInfo ,
#endif
attributeAsSize ,
#if defined(ENABLE_OVERLOADING)
AttributeAsStringMethodInfo ,
#endif
attributeAsString ,
#if defined(ENABLE_OVERLOADING)
AttributeCopyMethodInfo ,
#endif
attributeCopy ,
#if defined(ENABLE_OVERLOADING)
AttributeDestroyMethodInfo ,
#endif
attributeDestroy ,
#if defined(ENABLE_OVERLOADING)
AttributeEqualMethodInfo ,
#endif
attributeEqual ,
#if defined(ENABLE_OVERLOADING)
AttributeInitMethodInfo ,
#endif
attributeInit ,
#if defined(ENABLE_OVERLOADING)
attribute_endIndex ,
#endif
getAttributeEndIndex ,
setAttributeEndIndex ,
#if defined(ENABLE_OVERLOADING)
attribute_klass ,
#endif
clearAttributeKlass ,
getAttributeKlass ,
setAttributeKlass ,
#if defined(ENABLE_OVERLOADING)
attribute_startIndex ,
#endif
getAttributeStartIndex ,
setAttributeStartIndex ,
) 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.Structs.AttrClass as Pango.AttrClass
import {-# SOURCE #-} qualified GI.Pango.Structs.AttrColor as Pango.AttrColor
import {-# SOURCE #-} qualified GI.Pango.Structs.AttrFloat as Pango.AttrFloat
import {-# SOURCE #-} qualified GI.Pango.Structs.AttrFontDesc as Pango.AttrFontDesc
import {-# SOURCE #-} qualified GI.Pango.Structs.AttrFontFeatures as Pango.AttrFontFeatures
import {-# SOURCE #-} qualified GI.Pango.Structs.AttrInt as Pango.AttrInt
import {-# SOURCE #-} qualified GI.Pango.Structs.AttrLanguage as Pango.AttrLanguage
import {-# SOURCE #-} qualified GI.Pango.Structs.AttrShape as Pango.AttrShape
import {-# SOURCE #-} qualified GI.Pango.Structs.AttrSize as Pango.AttrSize
import {-# SOURCE #-} qualified GI.Pango.Structs.AttrString as Pango.AttrString
newtype Attribute = Attribute (SP.ManagedPtr Attribute)
deriving (Attribute -> Attribute -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Attribute -> Attribute -> Bool
$c/= :: Attribute -> Attribute -> Bool
== :: Attribute -> Attribute -> Bool
$c== :: Attribute -> Attribute -> Bool
Eq)
instance SP.ManagedPtrNewtype Attribute where
toManagedPtr :: Attribute -> ManagedPtr Attribute
toManagedPtr (Attribute ManagedPtr Attribute
p) = ManagedPtr Attribute
p
foreign import ccall "pango_attribute_get_type" c_pango_attribute_get_type ::
IO GType
type instance O.ParentTypes Attribute = '[]
instance O.HasParentTypes Attribute
instance B.Types.TypedObject Attribute where
glibType :: IO GType
glibType = IO GType
c_pango_attribute_get_type
instance B.Types.GBoxed Attribute
instance B.GValue.IsGValue (Maybe Attribute) where
gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_pango_attribute_get_type
gvalueSet_ :: Ptr GValue -> Maybe Attribute -> IO ()
gvalueSet_ Ptr GValue
gv Maybe Attribute
P.Nothing = forall a. Ptr GValue -> Ptr a -> IO ()
B.GValue.set_boxed Ptr GValue
gv (forall a. Ptr a
FP.nullPtr :: FP.Ptr Attribute)
gvalueSet_ Ptr GValue
gv (P.Just Attribute
obj) = forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr Attribute
obj (forall a. Ptr GValue -> Ptr a -> IO ()
B.GValue.set_boxed Ptr GValue
gv)
gvalueGet_ :: Ptr GValue -> IO (Maybe Attribute)
gvalueGet_ Ptr GValue
gv = do
Ptr Attribute
ptr <- forall b. Ptr GValue -> IO (Ptr b)
B.GValue.get_boxed Ptr GValue
gv :: IO (Ptr Attribute)
if Ptr Attribute
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 Attribute -> Attribute
Attribute Ptr Attribute
ptr
else forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Maybe a
P.Nothing
getAttributeKlass :: MonadIO m => Attribute -> m (Maybe Pango.AttrClass.AttrClass)
getAttributeKlass :: forall (m :: * -> *). MonadIO m => Attribute -> m (Maybe AttrClass)
getAttributeKlass Attribute
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Attribute
s forall a b. (a -> b) -> a -> b
$ \Ptr Attribute
ptr -> do
Ptr AttrClass
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr Attribute
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0) :: IO (Ptr Pango.AttrClass.AttrClass)
Maybe AttrClass
result <- forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
SP.convertIfNonNull Ptr AttrClass
val forall a b. (a -> b) -> a -> b
$ \Ptr AttrClass
val' -> do
AttrClass
val'' <- (forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newPtr ManagedPtr AttrClass -> AttrClass
Pango.AttrClass.AttrClass) Ptr AttrClass
val'
forall (m :: * -> *) a. Monad m => a -> m a
return AttrClass
val''
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe AttrClass
result
setAttributeKlass :: MonadIO m => Attribute -> Ptr Pango.AttrClass.AttrClass -> m ()
setAttributeKlass :: forall (m :: * -> *).
MonadIO m =>
Attribute -> Ptr AttrClass -> m ()
setAttributeKlass Attribute
s Ptr AttrClass
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Attribute
s forall a b. (a -> b) -> a -> b
$ \Ptr Attribute
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr Attribute
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0) (Ptr AttrClass
val :: Ptr Pango.AttrClass.AttrClass)
clearAttributeKlass :: MonadIO m => Attribute -> m ()
clearAttributeKlass :: forall (m :: * -> *). MonadIO m => Attribute -> m ()
clearAttributeKlass Attribute
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Attribute
s forall a b. (a -> b) -> a -> b
$ \Ptr Attribute
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr Attribute
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0) (forall a. Ptr a
FP.nullPtr :: Ptr Pango.AttrClass.AttrClass)
#if defined(ENABLE_OVERLOADING)
data AttributeKlassFieldInfo
instance AttrInfo AttributeKlassFieldInfo where
type AttrBaseTypeConstraint AttributeKlassFieldInfo = (~) Attribute
type AttrAllowedOps AttributeKlassFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint AttributeKlassFieldInfo = (~) (Ptr Pango.AttrClass.AttrClass)
type AttrTransferTypeConstraint AttributeKlassFieldInfo = (~)(Ptr Pango.AttrClass.AttrClass)
type AttrTransferType AttributeKlassFieldInfo = (Ptr Pango.AttrClass.AttrClass)
type AttrGetType AttributeKlassFieldInfo = Maybe Pango.AttrClass.AttrClass
type AttrLabel AttributeKlassFieldInfo = "klass"
type AttrOrigin AttributeKlassFieldInfo = Attribute
attrGet = getAttributeKlass
attrSet = setAttributeKlass
attrConstruct = undefined
attrClear = clearAttributeKlass
attrTransfer _ v = do
return v
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Pango.Structs.Attribute.klass"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-pango-1.0.27/docs/GI-Pango-Structs-Attribute.html#g:attr:klass"
})
attribute_klass :: AttrLabelProxy "klass"
attribute_klass = AttrLabelProxy
#endif
getAttributeStartIndex :: MonadIO m => Attribute -> m Word32
getAttributeStartIndex :: forall (m :: * -> *). MonadIO m => Attribute -> m Word32
getAttributeStartIndex Attribute
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Attribute
s forall a b. (a -> b) -> a -> b
$ \Ptr Attribute
ptr -> do
Word32
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr Attribute
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
8) :: IO Word32
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
val
setAttributeStartIndex :: MonadIO m => Attribute -> Word32 -> m ()
setAttributeStartIndex :: forall (m :: * -> *). MonadIO m => Attribute -> Word32 -> m ()
setAttributeStartIndex Attribute
s Word32
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Attribute
s forall a b. (a -> b) -> a -> b
$ \Ptr Attribute
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr Attribute
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
8) (Word32
val :: Word32)
#if defined(ENABLE_OVERLOADING)
data AttributeStartIndexFieldInfo
instance AttrInfo AttributeStartIndexFieldInfo where
type AttrBaseTypeConstraint AttributeStartIndexFieldInfo = (~) Attribute
type AttrAllowedOps AttributeStartIndexFieldInfo = '[ 'AttrSet, 'AttrGet]
type AttrSetTypeConstraint AttributeStartIndexFieldInfo = (~) Word32
type AttrTransferTypeConstraint AttributeStartIndexFieldInfo = (~)Word32
type AttrTransferType AttributeStartIndexFieldInfo = Word32
type AttrGetType AttributeStartIndexFieldInfo = Word32
type AttrLabel AttributeStartIndexFieldInfo = "start_index"
type AttrOrigin AttributeStartIndexFieldInfo = Attribute
attrGet = getAttributeStartIndex
attrSet = setAttributeStartIndex
attrConstruct = undefined
attrClear = undefined
attrTransfer _ v = do
return v
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Pango.Structs.Attribute.startIndex"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-pango-1.0.27/docs/GI-Pango-Structs-Attribute.html#g:attr:startIndex"
})
attribute_startIndex :: AttrLabelProxy "startIndex"
attribute_startIndex = AttrLabelProxy
#endif
getAttributeEndIndex :: MonadIO m => Attribute -> m Word32
getAttributeEndIndex :: forall (m :: * -> *). MonadIO m => Attribute -> m Word32
getAttributeEndIndex Attribute
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Attribute
s forall a b. (a -> b) -> a -> b
$ \Ptr Attribute
ptr -> do
Word32
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr Attribute
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
12) :: IO Word32
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
val
setAttributeEndIndex :: MonadIO m => Attribute -> Word32 -> m ()
setAttributeEndIndex :: forall (m :: * -> *). MonadIO m => Attribute -> Word32 -> m ()
setAttributeEndIndex Attribute
s Word32
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Attribute
s forall a b. (a -> b) -> a -> b
$ \Ptr Attribute
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr Attribute
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
12) (Word32
val :: Word32)
#if defined(ENABLE_OVERLOADING)
data AttributeEndIndexFieldInfo
instance AttrInfo AttributeEndIndexFieldInfo where
type AttrBaseTypeConstraint AttributeEndIndexFieldInfo = (~) Attribute
type AttrAllowedOps AttributeEndIndexFieldInfo = '[ 'AttrSet, 'AttrGet]
type AttrSetTypeConstraint AttributeEndIndexFieldInfo = (~) Word32
type AttrTransferTypeConstraint AttributeEndIndexFieldInfo = (~)Word32
type AttrTransferType AttributeEndIndexFieldInfo = Word32
type AttrGetType AttributeEndIndexFieldInfo = Word32
type AttrLabel AttributeEndIndexFieldInfo = "end_index"
type AttrOrigin AttributeEndIndexFieldInfo = Attribute
attrGet = getAttributeEndIndex
attrSet = setAttributeEndIndex
attrConstruct = undefined
attrClear = undefined
attrTransfer _ v = do
return v
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Pango.Structs.Attribute.endIndex"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-pango-1.0.27/docs/GI-Pango-Structs-Attribute.html#g:attr:endIndex"
})
attribute_endIndex :: AttrLabelProxy "endIndex"
attribute_endIndex = AttrLabelProxy
#endif
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList Attribute
type instance O.AttributeList Attribute = AttributeAttributeList
type AttributeAttributeList = ('[ '("klass", AttributeKlassFieldInfo), '("startIndex", AttributeStartIndexFieldInfo), '("endIndex", AttributeEndIndexFieldInfo)] :: [(Symbol, DK.Type)])
#endif
foreign import ccall "pango_attribute_as_color" pango_attribute_as_color ::
Ptr Attribute ->
IO (Ptr Pango.AttrColor.AttrColor)
attributeAsColor ::
(B.CallStack.HasCallStack, MonadIO m) =>
Attribute
-> m (Maybe Pango.AttrColor.AttrColor)
attributeAsColor :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Attribute -> m (Maybe AttrColor)
attributeAsColor Attribute
attr = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr Attribute
attr' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Attribute
attr
Ptr AttrColor
result <- Ptr Attribute -> IO (Ptr AttrColor)
pango_attribute_as_color Ptr Attribute
attr'
Maybe AttrColor
maybeResult <- forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr AttrColor
result forall a b. (a -> b) -> a -> b
$ \Ptr AttrColor
result' -> do
AttrColor
result'' <- (forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newPtr ManagedPtr AttrColor -> AttrColor
Pango.AttrColor.AttrColor) Ptr AttrColor
result'
forall (m :: * -> *) a. Monad m => a -> m a
return AttrColor
result''
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Attribute
attr
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe AttrColor
maybeResult
#if defined(ENABLE_OVERLOADING)
data AttributeAsColorMethodInfo
instance (signature ~ (m (Maybe Pango.AttrColor.AttrColor)), MonadIO m) => O.OverloadedMethod AttributeAsColorMethodInfo Attribute signature where
overloadedMethod = attributeAsColor
instance O.OverloadedMethodInfo AttributeAsColorMethodInfo Attribute where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Pango.Structs.Attribute.attributeAsColor",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-pango-1.0.27/docs/GI-Pango-Structs-Attribute.html#v:attributeAsColor"
})
#endif
foreign import ccall "pango_attribute_as_float" pango_attribute_as_float ::
Ptr Attribute ->
IO (Ptr Pango.AttrFloat.AttrFloat)
attributeAsFloat ::
(B.CallStack.HasCallStack, MonadIO m) =>
Attribute
-> m (Maybe Pango.AttrFloat.AttrFloat)
attributeAsFloat :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Attribute -> m (Maybe AttrFloat)
attributeAsFloat Attribute
attr = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr Attribute
attr' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Attribute
attr
Ptr AttrFloat
result <- Ptr Attribute -> IO (Ptr AttrFloat)
pango_attribute_as_float Ptr Attribute
attr'
Maybe AttrFloat
maybeResult <- forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr AttrFloat
result forall a b. (a -> b) -> a -> b
$ \Ptr AttrFloat
result' -> do
AttrFloat
result'' <- (forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newPtr ManagedPtr AttrFloat -> AttrFloat
Pango.AttrFloat.AttrFloat) Ptr AttrFloat
result'
forall (m :: * -> *) a. Monad m => a -> m a
return AttrFloat
result''
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Attribute
attr
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe AttrFloat
maybeResult
#if defined(ENABLE_OVERLOADING)
data AttributeAsFloatMethodInfo
instance (signature ~ (m (Maybe Pango.AttrFloat.AttrFloat)), MonadIO m) => O.OverloadedMethod AttributeAsFloatMethodInfo Attribute signature where
overloadedMethod = attributeAsFloat
instance O.OverloadedMethodInfo AttributeAsFloatMethodInfo Attribute where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Pango.Structs.Attribute.attributeAsFloat",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-pango-1.0.27/docs/GI-Pango-Structs-Attribute.html#v:attributeAsFloat"
})
#endif
foreign import ccall "pango_attribute_as_font_desc" pango_attribute_as_font_desc ::
Ptr Attribute ->
IO (Ptr Pango.AttrFontDesc.AttrFontDesc)
attributeAsFontDesc ::
(B.CallStack.HasCallStack, MonadIO m) =>
Attribute
-> m (Maybe Pango.AttrFontDesc.AttrFontDesc)
attributeAsFontDesc :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Attribute -> m (Maybe AttrFontDesc)
attributeAsFontDesc Attribute
attr = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr Attribute
attr' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Attribute
attr
Ptr AttrFontDesc
result <- Ptr Attribute -> IO (Ptr AttrFontDesc)
pango_attribute_as_font_desc Ptr Attribute
attr'
Maybe AttrFontDesc
maybeResult <- forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr AttrFontDesc
result forall a b. (a -> b) -> a -> b
$ \Ptr AttrFontDesc
result' -> do
AttrFontDesc
result'' <- (forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newPtr ManagedPtr AttrFontDesc -> AttrFontDesc
Pango.AttrFontDesc.AttrFontDesc) Ptr AttrFontDesc
result'
forall (m :: * -> *) a. Monad m => a -> m a
return AttrFontDesc
result''
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Attribute
attr
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe AttrFontDesc
maybeResult
#if defined(ENABLE_OVERLOADING)
data AttributeAsFontDescMethodInfo
instance (signature ~ (m (Maybe Pango.AttrFontDesc.AttrFontDesc)), MonadIO m) => O.OverloadedMethod AttributeAsFontDescMethodInfo Attribute signature where
overloadedMethod = attributeAsFontDesc
instance O.OverloadedMethodInfo AttributeAsFontDescMethodInfo Attribute where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Pango.Structs.Attribute.attributeAsFontDesc",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-pango-1.0.27/docs/GI-Pango-Structs-Attribute.html#v:attributeAsFontDesc"
})
#endif
foreign import ccall "pango_attribute_as_font_features" pango_attribute_as_font_features ::
Ptr Attribute ->
IO (Ptr Pango.AttrFontFeatures.AttrFontFeatures)
attributeAsFontFeatures ::
(B.CallStack.HasCallStack, MonadIO m) =>
Attribute
-> m (Maybe Pango.AttrFontFeatures.AttrFontFeatures)
attributeAsFontFeatures :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Attribute -> m (Maybe AttrFontFeatures)
attributeAsFontFeatures Attribute
attr = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr Attribute
attr' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Attribute
attr
Ptr AttrFontFeatures
result <- Ptr Attribute -> IO (Ptr AttrFontFeatures)
pango_attribute_as_font_features Ptr Attribute
attr'
Maybe AttrFontFeatures
maybeResult <- forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr AttrFontFeatures
result forall a b. (a -> b) -> a -> b
$ \Ptr AttrFontFeatures
result' -> do
AttrFontFeatures
result'' <- (forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newPtr ManagedPtr AttrFontFeatures -> AttrFontFeatures
Pango.AttrFontFeatures.AttrFontFeatures) Ptr AttrFontFeatures
result'
forall (m :: * -> *) a. Monad m => a -> m a
return AttrFontFeatures
result''
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Attribute
attr
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe AttrFontFeatures
maybeResult
#if defined(ENABLE_OVERLOADING)
data AttributeAsFontFeaturesMethodInfo
instance (signature ~ (m (Maybe Pango.AttrFontFeatures.AttrFontFeatures)), MonadIO m) => O.OverloadedMethod AttributeAsFontFeaturesMethodInfo Attribute signature where
overloadedMethod = attributeAsFontFeatures
instance O.OverloadedMethodInfo AttributeAsFontFeaturesMethodInfo Attribute where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Pango.Structs.Attribute.attributeAsFontFeatures",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-pango-1.0.27/docs/GI-Pango-Structs-Attribute.html#v:attributeAsFontFeatures"
})
#endif
foreign import ccall "pango_attribute_as_int" pango_attribute_as_int ::
Ptr Attribute ->
IO (Ptr Pango.AttrInt.AttrInt)
attributeAsInt ::
(B.CallStack.HasCallStack, MonadIO m) =>
Attribute
-> m (Maybe Pango.AttrInt.AttrInt)
attributeAsInt :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Attribute -> m (Maybe AttrInt)
attributeAsInt Attribute
attr = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr Attribute
attr' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Attribute
attr
Ptr AttrInt
result <- Ptr Attribute -> IO (Ptr AttrInt)
pango_attribute_as_int Ptr Attribute
attr'
Maybe AttrInt
maybeResult <- forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr AttrInt
result forall a b. (a -> b) -> a -> b
$ \Ptr AttrInt
result' -> do
AttrInt
result'' <- (forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newPtr ManagedPtr AttrInt -> AttrInt
Pango.AttrInt.AttrInt) Ptr AttrInt
result'
forall (m :: * -> *) a. Monad m => a -> m a
return AttrInt
result''
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Attribute
attr
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe AttrInt
maybeResult
#if defined(ENABLE_OVERLOADING)
data AttributeAsIntMethodInfo
instance (signature ~ (m (Maybe Pango.AttrInt.AttrInt)), MonadIO m) => O.OverloadedMethod AttributeAsIntMethodInfo Attribute signature where
overloadedMethod = attributeAsInt
instance O.OverloadedMethodInfo AttributeAsIntMethodInfo Attribute where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Pango.Structs.Attribute.attributeAsInt",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-pango-1.0.27/docs/GI-Pango-Structs-Attribute.html#v:attributeAsInt"
})
#endif
foreign import ccall "pango_attribute_as_language" pango_attribute_as_language ::
Ptr Attribute ->
IO (Ptr Pango.AttrLanguage.AttrLanguage)
attributeAsLanguage ::
(B.CallStack.HasCallStack, MonadIO m) =>
Attribute
-> m (Maybe Pango.AttrLanguage.AttrLanguage)
attributeAsLanguage :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Attribute -> m (Maybe AttrLanguage)
attributeAsLanguage Attribute
attr = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr Attribute
attr' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Attribute
attr
Ptr AttrLanguage
result <- Ptr Attribute -> IO (Ptr AttrLanguage)
pango_attribute_as_language Ptr Attribute
attr'
Maybe AttrLanguage
maybeResult <- forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr AttrLanguage
result forall a b. (a -> b) -> a -> b
$ \Ptr AttrLanguage
result' -> do
AttrLanguage
result'' <- (forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newPtr ManagedPtr AttrLanguage -> AttrLanguage
Pango.AttrLanguage.AttrLanguage) Ptr AttrLanguage
result'
forall (m :: * -> *) a. Monad m => a -> m a
return AttrLanguage
result''
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Attribute
attr
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe AttrLanguage
maybeResult
#if defined(ENABLE_OVERLOADING)
data AttributeAsLanguageMethodInfo
instance (signature ~ (m (Maybe Pango.AttrLanguage.AttrLanguage)), MonadIO m) => O.OverloadedMethod AttributeAsLanguageMethodInfo Attribute signature where
overloadedMethod = attributeAsLanguage
instance O.OverloadedMethodInfo AttributeAsLanguageMethodInfo Attribute where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Pango.Structs.Attribute.attributeAsLanguage",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-pango-1.0.27/docs/GI-Pango-Structs-Attribute.html#v:attributeAsLanguage"
})
#endif
foreign import ccall "pango_attribute_as_shape" pango_attribute_as_shape ::
Ptr Attribute ->
IO (Ptr Pango.AttrShape.AttrShape)
attributeAsShape ::
(B.CallStack.HasCallStack, MonadIO m) =>
Attribute
-> m (Maybe Pango.AttrShape.AttrShape)
attributeAsShape :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Attribute -> m (Maybe AttrShape)
attributeAsShape Attribute
attr = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr Attribute
attr' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Attribute
attr
Ptr AttrShape
result <- Ptr Attribute -> IO (Ptr AttrShape)
pango_attribute_as_shape Ptr Attribute
attr'
Maybe AttrShape
maybeResult <- forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr AttrShape
result forall a b. (a -> b) -> a -> b
$ \Ptr AttrShape
result' -> do
AttrShape
result'' <- (forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newPtr ManagedPtr AttrShape -> AttrShape
Pango.AttrShape.AttrShape) Ptr AttrShape
result'
forall (m :: * -> *) a. Monad m => a -> m a
return AttrShape
result''
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Attribute
attr
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe AttrShape
maybeResult
#if defined(ENABLE_OVERLOADING)
data AttributeAsShapeMethodInfo
instance (signature ~ (m (Maybe Pango.AttrShape.AttrShape)), MonadIO m) => O.OverloadedMethod AttributeAsShapeMethodInfo Attribute signature where
overloadedMethod = attributeAsShape
instance O.OverloadedMethodInfo AttributeAsShapeMethodInfo Attribute where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Pango.Structs.Attribute.attributeAsShape",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-pango-1.0.27/docs/GI-Pango-Structs-Attribute.html#v:attributeAsShape"
})
#endif
foreign import ccall "pango_attribute_as_size" pango_attribute_as_size ::
Ptr Attribute ->
IO (Ptr Pango.AttrSize.AttrSize)
attributeAsSize ::
(B.CallStack.HasCallStack, MonadIO m) =>
Attribute
-> m (Maybe Pango.AttrSize.AttrSize)
attributeAsSize :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Attribute -> m (Maybe AttrSize)
attributeAsSize Attribute
attr = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr Attribute
attr' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Attribute
attr
Ptr AttrSize
result <- Ptr Attribute -> IO (Ptr AttrSize)
pango_attribute_as_size Ptr Attribute
attr'
Maybe AttrSize
maybeResult <- forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr AttrSize
result forall a b. (a -> b) -> a -> b
$ \Ptr AttrSize
result' -> do
AttrSize
result'' <- (forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newPtr ManagedPtr AttrSize -> AttrSize
Pango.AttrSize.AttrSize) Ptr AttrSize
result'
forall (m :: * -> *) a. Monad m => a -> m a
return AttrSize
result''
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Attribute
attr
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe AttrSize
maybeResult
#if defined(ENABLE_OVERLOADING)
data AttributeAsSizeMethodInfo
instance (signature ~ (m (Maybe Pango.AttrSize.AttrSize)), MonadIO m) => O.OverloadedMethod AttributeAsSizeMethodInfo Attribute signature where
overloadedMethod = attributeAsSize
instance O.OverloadedMethodInfo AttributeAsSizeMethodInfo Attribute where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Pango.Structs.Attribute.attributeAsSize",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-pango-1.0.27/docs/GI-Pango-Structs-Attribute.html#v:attributeAsSize"
})
#endif
foreign import ccall "pango_attribute_as_string" pango_attribute_as_string ::
Ptr Attribute ->
IO (Ptr Pango.AttrString.AttrString)
attributeAsString ::
(B.CallStack.HasCallStack, MonadIO m) =>
Attribute
-> m (Maybe Pango.AttrString.AttrString)
attributeAsString :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Attribute -> m (Maybe AttrString)
attributeAsString Attribute
attr = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr Attribute
attr' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Attribute
attr
Ptr AttrString
result <- Ptr Attribute -> IO (Ptr AttrString)
pango_attribute_as_string Ptr Attribute
attr'
Maybe AttrString
maybeResult <- forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr AttrString
result forall a b. (a -> b) -> a -> b
$ \Ptr AttrString
result' -> do
AttrString
result'' <- (forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newPtr ManagedPtr AttrString -> AttrString
Pango.AttrString.AttrString) Ptr AttrString
result'
forall (m :: * -> *) a. Monad m => a -> m a
return AttrString
result''
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Attribute
attr
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe AttrString
maybeResult
#if defined(ENABLE_OVERLOADING)
data AttributeAsStringMethodInfo
instance (signature ~ (m (Maybe Pango.AttrString.AttrString)), MonadIO m) => O.OverloadedMethod AttributeAsStringMethodInfo Attribute signature where
overloadedMethod = attributeAsString
instance O.OverloadedMethodInfo AttributeAsStringMethodInfo Attribute where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Pango.Structs.Attribute.attributeAsString",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-pango-1.0.27/docs/GI-Pango-Structs-Attribute.html#v:attributeAsString"
})
#endif
foreign import ccall "pango_attribute_copy" pango_attribute_copy ::
Ptr Attribute ->
IO (Ptr Attribute)
attributeCopy ::
(B.CallStack.HasCallStack, MonadIO m) =>
Attribute
-> m Attribute
attributeCopy :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Attribute -> m Attribute
attributeCopy Attribute
attr = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr Attribute
attr' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Attribute
attr
Ptr Attribute
result <- Ptr Attribute -> IO (Ptr Attribute)
pango_attribute_copy Ptr Attribute
attr'
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"attributeCopy" Ptr Attribute
result
Attribute
result' <- (forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Attribute -> Attribute
Attribute) Ptr Attribute
result
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Attribute
attr
forall (m :: * -> *) a. Monad m => a -> m a
return Attribute
result'
#if defined(ENABLE_OVERLOADING)
data AttributeCopyMethodInfo
instance (signature ~ (m Attribute), MonadIO m) => O.OverloadedMethod AttributeCopyMethodInfo Attribute signature where
overloadedMethod = attributeCopy
instance O.OverloadedMethodInfo AttributeCopyMethodInfo Attribute where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Pango.Structs.Attribute.attributeCopy",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-pango-1.0.27/docs/GI-Pango-Structs-Attribute.html#v:attributeCopy"
})
#endif
foreign import ccall "pango_attribute_destroy" pango_attribute_destroy ::
Ptr Attribute ->
IO ()
attributeDestroy ::
(B.CallStack.HasCallStack, MonadIO m) =>
Attribute
-> m ()
attributeDestroy :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Attribute -> m ()
attributeDestroy Attribute
attr = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr Attribute
attr' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Attribute
attr
Ptr Attribute -> IO ()
pango_attribute_destroy Ptr Attribute
attr'
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Attribute
attr
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data AttributeDestroyMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.OverloadedMethod AttributeDestroyMethodInfo Attribute signature where
overloadedMethod = attributeDestroy
instance O.OverloadedMethodInfo AttributeDestroyMethodInfo Attribute where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Pango.Structs.Attribute.attributeDestroy",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-pango-1.0.27/docs/GI-Pango-Structs-Attribute.html#v:attributeDestroy"
})
#endif
foreign import ccall "pango_attribute_equal" pango_attribute_equal ::
Ptr Attribute ->
Ptr Attribute ->
IO CInt
attributeEqual ::
(B.CallStack.HasCallStack, MonadIO m) =>
Attribute
-> Attribute
-> m Bool
attributeEqual :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Attribute -> Attribute -> m Bool
attributeEqual Attribute
attr1 Attribute
attr2 = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr Attribute
attr1' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Attribute
attr1
Ptr Attribute
attr2' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Attribute
attr2
CInt
result <- Ptr Attribute -> Ptr Attribute -> IO CInt
pango_attribute_equal Ptr Attribute
attr1' Ptr Attribute
attr2'
let result' :: Bool
result' = (forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Attribute
attr1
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Attribute
attr2
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data AttributeEqualMethodInfo
instance (signature ~ (Attribute -> m Bool), MonadIO m) => O.OverloadedMethod AttributeEqualMethodInfo Attribute signature where
overloadedMethod = attributeEqual
instance O.OverloadedMethodInfo AttributeEqualMethodInfo Attribute where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Pango.Structs.Attribute.attributeEqual",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-pango-1.0.27/docs/GI-Pango-Structs-Attribute.html#v:attributeEqual"
})
#endif
foreign import ccall "pango_attribute_init" pango_attribute_init ::
Ptr Attribute ->
Ptr Pango.AttrClass.AttrClass ->
IO ()
attributeInit ::
(B.CallStack.HasCallStack, MonadIO m) =>
Attribute
-> Pango.AttrClass.AttrClass
-> m ()
attributeInit :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Attribute -> AttrClass -> m ()
attributeInit Attribute
attr AttrClass
klass = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr Attribute
attr' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Attribute
attr
Ptr AttrClass
klass' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr AttrClass
klass
Ptr Attribute -> Ptr AttrClass -> IO ()
pango_attribute_init Ptr Attribute
attr' Ptr AttrClass
klass'
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Attribute
attr
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr AttrClass
klass
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data AttributeInitMethodInfo
instance (signature ~ (Pango.AttrClass.AttrClass -> m ()), MonadIO m) => O.OverloadedMethod AttributeInitMethodInfo Attribute signature where
overloadedMethod = attributeInit
instance O.OverloadedMethodInfo AttributeInitMethodInfo Attribute where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Pango.Structs.Attribute.attributeInit",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-pango-1.0.27/docs/GI-Pango-Structs-Attribute.html#v:attributeInit"
})
#endif
#if defined(ENABLE_OVERLOADING)
type family ResolveAttributeMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
ResolveAttributeMethod "asColor" o = AttributeAsColorMethodInfo
ResolveAttributeMethod "asFloat" o = AttributeAsFloatMethodInfo
ResolveAttributeMethod "asFontDesc" o = AttributeAsFontDescMethodInfo
ResolveAttributeMethod "asFontFeatures" o = AttributeAsFontFeaturesMethodInfo
ResolveAttributeMethod "asInt" o = AttributeAsIntMethodInfo
ResolveAttributeMethod "asLanguage" o = AttributeAsLanguageMethodInfo
ResolveAttributeMethod "asShape" o = AttributeAsShapeMethodInfo
ResolveAttributeMethod "asSize" o = AttributeAsSizeMethodInfo
ResolveAttributeMethod "asString" o = AttributeAsStringMethodInfo
ResolveAttributeMethod "copy" o = AttributeCopyMethodInfo
ResolveAttributeMethod "destroy" o = AttributeDestroyMethodInfo
ResolveAttributeMethod "equal" o = AttributeEqualMethodInfo
ResolveAttributeMethod "init" o = AttributeInitMethodInfo
ResolveAttributeMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveAttributeMethod t Attribute, O.OverloadedMethod info Attribute p) => OL.IsLabel t (Attribute -> 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 ~ ResolveAttributeMethod t Attribute, O.OverloadedMethod info Attribute p, R.HasField t Attribute p) => R.HasField t Attribute p where
getField = O.overloadedMethod @info
#endif
instance (info ~ ResolveAttributeMethod t Attribute, O.OverloadedMethodInfo info Attribute) => OL.IsLabel t (O.MethodProxy info Attribute) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.MethodProxy
#else
fromLabel _ = O.MethodProxy
#endif
#endif