{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Atk.Structs.Attribute
(
Attribute(..) ,
newZeroAttribute ,
#if defined(ENABLE_OVERLOADING)
ResolveAttributeMethod ,
#endif
attributeSetFree ,
#if defined(ENABLE_OVERLOADING)
attribute_name ,
#endif
clearAttributeName ,
getAttributeName ,
setAttributeName ,
#if defined(ENABLE_OVERLOADING)
attribute_value ,
#endif
clearAttributeValue ,
getAttributeValue ,
setAttributeValue ,
) 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.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
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
instance BoxedPtr Attribute where
boxedPtrCopy :: Attribute -> IO Attribute
boxedPtrCopy = \Attribute
p -> forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr Attribute
p (forall a. (HasCallStack, CallocPtr a) => Int -> Ptr a -> IO (Ptr a)
copyBytes Int
8 forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
B.ManagedPtr.wrapPtr ManagedPtr Attribute -> Attribute
Attribute)
boxedPtrFree :: Attribute -> IO ()
boxedPtrFree = \Attribute
x -> forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
SP.withManagedPtr Attribute
x forall a. Ptr a -> IO ()
SP.freeMem
instance CallocPtr Attribute where
boxedPtrCalloc :: IO (Ptr Attribute)
boxedPtrCalloc = forall a. Int -> IO (Ptr a)
callocBytes Int
8
newZeroAttribute :: MonadIO m => m Attribute
newZeroAttribute :: forall (m :: * -> *). MonadIO m => m Attribute
newZeroAttribute = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a. CallocPtr a => IO (Ptr a)
boxedPtrCalloc forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapPtr ManagedPtr Attribute -> Attribute
Attribute
instance tag ~ 'AttrSet => Constructible Attribute tag where
new :: forall (m :: * -> *).
MonadIO m =>
(ManagedPtr Attribute -> Attribute)
-> [AttrOp Attribute tag] -> m Attribute
new ManagedPtr Attribute -> Attribute
_ [AttrOp Attribute tag]
attrs = do
Attribute
o <- forall (m :: * -> *). MonadIO m => m Attribute
newZeroAttribute
forall o (m :: * -> *).
MonadIO m =>
o -> [AttrOp o 'AttrSet] -> m ()
GI.Attributes.set Attribute
o [AttrOp Attribute tag]
attrs
forall (m :: * -> *) a. Monad m => a -> m a
return Attribute
o
getAttributeName :: MonadIO m => Attribute -> m (Maybe T.Text)
getAttributeName :: forall (m :: * -> *). MonadIO m => Attribute -> m (Maybe Text)
getAttributeName 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
CString
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 CString
Maybe Text
result <- forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
SP.convertIfNonNull CString
val forall a b. (a -> b) -> a -> b
$ \CString
val' -> do
Text
val'' <- HasCallStack => CString -> IO Text
cstringToText CString
val'
forall (m :: * -> *) a. Monad m => a -> m a
return Text
val''
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
result
setAttributeName :: MonadIO m => Attribute -> CString -> m ()
setAttributeName :: forall (m :: * -> *). MonadIO m => Attribute -> CString -> m ()
setAttributeName Attribute
s CString
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) (CString
val :: CString)
clearAttributeName :: MonadIO m => Attribute -> m ()
clearAttributeName :: forall (m :: * -> *). MonadIO m => Attribute -> m ()
clearAttributeName 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 :: CString)
#if defined(ENABLE_OVERLOADING)
data AttributeNameFieldInfo
instance AttrInfo AttributeNameFieldInfo where
type AttrBaseTypeConstraint AttributeNameFieldInfo = (~) Attribute
type AttrAllowedOps AttributeNameFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint AttributeNameFieldInfo = (~) CString
type AttrTransferTypeConstraint AttributeNameFieldInfo = (~)CString
type AttrTransferType AttributeNameFieldInfo = CString
type AttrGetType AttributeNameFieldInfo = Maybe T.Text
type AttrLabel AttributeNameFieldInfo = "name"
type AttrOrigin AttributeNameFieldInfo = Attribute
attrGet = getAttributeName
attrSet = setAttributeName
attrConstruct = undefined
attrClear = clearAttributeName
attrTransfer _ v = do
return v
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Atk.Structs.Attribute.name"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-atk-2.0.25/docs/GI-Atk-Structs-Attribute.html#g:attr:name"
})
attribute_name :: AttrLabelProxy "name"
attribute_name = AttrLabelProxy
#endif
getAttributeValue :: MonadIO m => Attribute -> m (Maybe T.Text)
getAttributeValue :: forall (m :: * -> *). MonadIO m => Attribute -> m (Maybe Text)
getAttributeValue 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
CString
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr Attribute
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
4) :: IO CString
Maybe Text
result <- forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
SP.convertIfNonNull CString
val forall a b. (a -> b) -> a -> b
$ \CString
val' -> do
Text
val'' <- HasCallStack => CString -> IO Text
cstringToText CString
val'
forall (m :: * -> *) a. Monad m => a -> m a
return Text
val''
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
result
setAttributeValue :: MonadIO m => Attribute -> CString -> m ()
setAttributeValue :: forall (m :: * -> *). MonadIO m => Attribute -> CString -> m ()
setAttributeValue Attribute
s CString
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
4) (CString
val :: CString)
clearAttributeValue :: MonadIO m => Attribute -> m ()
clearAttributeValue :: forall (m :: * -> *). MonadIO m => Attribute -> m ()
clearAttributeValue 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
4) (forall a. Ptr a
FP.nullPtr :: CString)
#if defined(ENABLE_OVERLOADING)
data AttributeValueFieldInfo
instance AttrInfo AttributeValueFieldInfo where
type AttrBaseTypeConstraint AttributeValueFieldInfo = (~) Attribute
type AttrAllowedOps AttributeValueFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint AttributeValueFieldInfo = (~) CString
type AttrTransferTypeConstraint AttributeValueFieldInfo = (~)CString
type AttrTransferType AttributeValueFieldInfo = CString
type AttrGetType AttributeValueFieldInfo = Maybe T.Text
type AttrLabel AttributeValueFieldInfo = "value"
type AttrOrigin AttributeValueFieldInfo = Attribute
attrGet = getAttributeValue
attrSet = setAttributeValue
attrConstruct = undefined
attrClear = clearAttributeValue
attrTransfer _ v = do
return v
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Atk.Structs.Attribute.value"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-atk-2.0.25/docs/GI-Atk-Structs-Attribute.html#g:attr:value"
})
attribute_value :: AttrLabelProxy "value"
attribute_value = AttrLabelProxy
#endif
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList Attribute
type instance O.AttributeList Attribute = AttributeAttributeList
type AttributeAttributeList = ('[ '("name", AttributeNameFieldInfo), '("value", AttributeValueFieldInfo)] :: [(Symbol, *)])
#endif
foreign import ccall "atk_attribute_set_free" atk_attribute_set_free ::
Ptr (GSList (Ptr ())) ->
IO ()
attributeSetFree ::
(B.CallStack.HasCallStack, MonadIO m) =>
[Ptr ()]
-> m ()
attributeSetFree :: forall (m :: * -> *). (HasCallStack, MonadIO m) => [Ptr ()] -> m ()
attributeSetFree [Ptr ()]
attribSet = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr (GSList (Ptr ()))
attribSet' <- forall a. [Ptr a] -> IO (Ptr (GSList (Ptr a)))
packGSList [Ptr ()]
attribSet
Ptr (GSList (Ptr ())) -> IO ()
atk_attribute_set_free Ptr (GSList (Ptr ()))
attribSet'
forall a. Ptr (GSList a) -> IO ()
g_slist_free Ptr (GSList (Ptr ()))
attribSet'
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
#endif
#if defined(ENABLE_OVERLOADING)
type family ResolveAttributeMethod (t :: Symbol) (o :: *) :: * where
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