{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.GObject.Structs.FlagsClass
(
FlagsClass(..) ,
newZeroFlagsClass ,
#if defined(ENABLE_OVERLOADING)
ResolveFlagsClassMethod ,
#endif
#if defined(ENABLE_OVERLOADING)
flagsClass_gTypeClass ,
#endif
getFlagsClassGTypeClass ,
#if defined(ENABLE_OVERLOADING)
flagsClass_mask ,
#endif
getFlagsClassMask ,
setFlagsClassMask ,
#if defined(ENABLE_OVERLOADING)
flagsClass_nValues ,
#endif
getFlagsClassNValues ,
setFlagsClassNValues ,
clearFlagsClassValues ,
#if defined(ENABLE_OVERLOADING)
flagsClass_values ,
#endif
getFlagsClassValues ,
setFlagsClassValues ,
) 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 Data.Word as DW
import qualified Data.Int as DI
import qualified Data.Bits as DB
import qualified System.Posix.Types as SPT
import qualified Foreign.C.Types as FCT
#if MIN_VERSION_base(4,18,0)
import {-# SOURCE #-} qualified GI.GObject.Structs.FlagsValue as GObject.FlagsValue
import {-# SOURCE #-} qualified GI.GObject.Structs.TypeClass as GObject.TypeClass
#else
import {-# SOURCE #-} qualified GI.GObject.Structs.FlagsValue as GObject.FlagsValue
import {-# SOURCE #-} qualified GI.GObject.Structs.TypeClass as GObject.TypeClass
#endif
newtype FlagsClass = FlagsClass (SP.ManagedPtr FlagsClass)
deriving (FlagsClass -> FlagsClass -> Bool
(FlagsClass -> FlagsClass -> Bool)
-> (FlagsClass -> FlagsClass -> Bool) -> Eq FlagsClass
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: FlagsClass -> FlagsClass -> Bool
== :: FlagsClass -> FlagsClass -> Bool
$c/= :: FlagsClass -> FlagsClass -> Bool
/= :: FlagsClass -> FlagsClass -> Bool
Eq)
instance SP.ManagedPtrNewtype FlagsClass where
toManagedPtr :: FlagsClass -> ManagedPtr FlagsClass
toManagedPtr (FlagsClass ManagedPtr FlagsClass
p) = ManagedPtr FlagsClass
p
instance BoxedPtr FlagsClass where
boxedPtrCopy :: FlagsClass -> IO FlagsClass
boxedPtrCopy = \FlagsClass
p -> FlagsClass -> (Ptr FlagsClass -> IO FlagsClass) -> IO FlagsClass
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr FlagsClass
p (Int -> Ptr FlagsClass -> IO (Ptr FlagsClass)
forall a. (HasCallStack, CallocPtr a) => Int -> Ptr a -> IO (Ptr a)
copyBytes Int
24 (Ptr FlagsClass -> IO (Ptr FlagsClass))
-> (Ptr FlagsClass -> IO FlagsClass)
-> Ptr FlagsClass
-> IO FlagsClass
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (ManagedPtr FlagsClass -> FlagsClass)
-> Ptr FlagsClass -> IO FlagsClass
forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
B.ManagedPtr.wrapPtr ManagedPtr FlagsClass -> FlagsClass
FlagsClass)
boxedPtrFree :: FlagsClass -> IO ()
boxedPtrFree = \FlagsClass
x -> FlagsClass -> (Ptr FlagsClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
SP.withManagedPtr FlagsClass
x Ptr FlagsClass -> IO ()
forall a. Ptr a -> IO ()
SP.freeMem
instance CallocPtr FlagsClass where
boxedPtrCalloc :: IO (Ptr FlagsClass)
boxedPtrCalloc = Int -> IO (Ptr FlagsClass)
forall a. Int -> IO (Ptr a)
callocBytes Int
24
newZeroFlagsClass :: MonadIO m => m FlagsClass
newZeroFlagsClass :: forall (m :: * -> *). MonadIO m => m FlagsClass
newZeroFlagsClass = IO FlagsClass -> m FlagsClass
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO FlagsClass -> m FlagsClass) -> IO FlagsClass -> m FlagsClass
forall a b. (a -> b) -> a -> b
$ IO (Ptr FlagsClass)
forall a. CallocPtr a => IO (Ptr a)
boxedPtrCalloc IO (Ptr FlagsClass)
-> (Ptr FlagsClass -> IO FlagsClass) -> IO FlagsClass
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (ManagedPtr FlagsClass -> FlagsClass)
-> Ptr FlagsClass -> IO FlagsClass
forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapPtr ManagedPtr FlagsClass -> FlagsClass
FlagsClass
instance tag ~ 'AttrSet => Constructible FlagsClass tag where
new :: forall (m :: * -> *).
MonadIO m =>
(ManagedPtr FlagsClass -> FlagsClass)
-> [AttrOp FlagsClass tag] -> m FlagsClass
new ManagedPtr FlagsClass -> FlagsClass
_ [AttrOp FlagsClass tag]
attrs = do
o <- m FlagsClass
forall (m :: * -> *). MonadIO m => m FlagsClass
newZeroFlagsClass
GI.Attributes.set o attrs
return o
getFlagsClassGTypeClass :: MonadIO m => FlagsClass -> m GObject.TypeClass.TypeClass
getFlagsClassGTypeClass :: forall (m :: * -> *). MonadIO m => FlagsClass -> m TypeClass
getFlagsClassGTypeClass FlagsClass
s = IO TypeClass -> m TypeClass
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO TypeClass -> m TypeClass) -> IO TypeClass -> m TypeClass
forall a b. (a -> b) -> a -> b
$ FlagsClass -> (Ptr FlagsClass -> IO TypeClass) -> IO TypeClass
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr FlagsClass
s ((Ptr FlagsClass -> IO TypeClass) -> IO TypeClass)
-> (Ptr FlagsClass -> IO TypeClass) -> IO TypeClass
forall a b. (a -> b) -> a -> b
$ \Ptr FlagsClass
ptr -> do
let val :: Ptr TypeClass
val = Ptr FlagsClass
ptr Ptr FlagsClass -> Int -> Ptr TypeClass
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0 :: (Ptr GObject.TypeClass.TypeClass)
val' <- ((ManagedPtr TypeClass -> TypeClass)
-> Ptr TypeClass -> IO TypeClass
forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newPtr ManagedPtr TypeClass -> TypeClass
GObject.TypeClass.TypeClass) Ptr TypeClass
val
return val'
#if defined(ENABLE_OVERLOADING)
data FlagsClassGTypeClassFieldInfo
instance AttrInfo FlagsClassGTypeClassFieldInfo where
type AttrBaseTypeConstraint FlagsClassGTypeClassFieldInfo = (~) FlagsClass
type AttrAllowedOps FlagsClassGTypeClassFieldInfo = '[ 'AttrGet]
type AttrSetTypeConstraint FlagsClassGTypeClassFieldInfo = (~) (Ptr GObject.TypeClass.TypeClass)
type AttrTransferTypeConstraint FlagsClassGTypeClassFieldInfo = (~)(Ptr GObject.TypeClass.TypeClass)
type AttrTransferType FlagsClassGTypeClassFieldInfo = (Ptr GObject.TypeClass.TypeClass)
type AttrGetType FlagsClassGTypeClassFieldInfo = GObject.TypeClass.TypeClass
type AttrLabel FlagsClassGTypeClassFieldInfo = "g_type_class"
type AttrOrigin FlagsClassGTypeClassFieldInfo = FlagsClass
attrGet :: forall o.
AttrBaseTypeConstraint FlagsClassGTypeClassFieldInfo o =>
o -> IO (AttrGetType FlagsClassGTypeClassFieldInfo)
attrGet = o -> IO (AttrGetType FlagsClassGTypeClassFieldInfo)
FlagsClass -> IO TypeClass
forall (m :: * -> *). MonadIO m => FlagsClass -> m TypeClass
getFlagsClassGTypeClass
attrSet :: forall o b.
(AttrBaseTypeConstraint FlagsClassGTypeClassFieldInfo o,
AttrSetTypeConstraint FlagsClassGTypeClassFieldInfo b) =>
o -> b -> IO ()
attrSet = o -> b -> IO ()
forall a. HasCallStack => a
undefined
attrConstruct :: forall o b.
(AttrBaseTypeConstraint FlagsClassGTypeClassFieldInfo o,
AttrSetTypeConstraint FlagsClassGTypeClassFieldInfo b) =>
b -> IO (GValueConstruct o)
attrConstruct = b -> IO (GValueConstruct o)
forall a. HasCallStack => a
undefined
attrClear :: forall o.
AttrBaseTypeConstraint FlagsClassGTypeClassFieldInfo o =>
o -> IO ()
attrClear = o -> IO ()
forall a. HasCallStack => a
undefined
attrTransfer :: forall o b.
(AttrBaseTypeConstraint FlagsClassGTypeClassFieldInfo o,
AttrTransferTypeConstraint FlagsClassGTypeClassFieldInfo b) =>
Proxy o -> b -> IO (AttrTransferType FlagsClassGTypeClassFieldInfo)
attrTransfer = Proxy o -> b -> IO (Ptr TypeClass)
Proxy o -> b -> IO (AttrTransferType FlagsClassGTypeClassFieldInfo)
forall a. HasCallStack => a
undefined
dbgAttrInfo :: Maybe ResolvedSymbolInfo
dbgAttrInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.GObject.Structs.FlagsClass.gTypeClass"
, resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-gobject-2.0.32/docs/GI-GObject-Structs-FlagsClass.html#g:attr:gTypeClass"
})
flagsClass_gTypeClass :: AttrLabelProxy "gTypeClass"
flagsClass_gTypeClass :: AttrLabelProxy "gTypeClass"
flagsClass_gTypeClass = AttrLabelProxy "gTypeClass"
forall (a :: Symbol). AttrLabelProxy a
AttrLabelProxy
#endif
getFlagsClassMask :: MonadIO m => FlagsClass -> m Word32
getFlagsClassMask :: forall (m :: * -> *). MonadIO m => FlagsClass -> m Word32
getFlagsClassMask FlagsClass
s = IO Word32 -> m Word32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
forall a b. (a -> b) -> a -> b
$ FlagsClass -> (Ptr FlagsClass -> IO Word32) -> IO Word32
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr FlagsClass
s ((Ptr FlagsClass -> IO Word32) -> IO Word32)
-> (Ptr FlagsClass -> IO Word32) -> IO Word32
forall a b. (a -> b) -> a -> b
$ \Ptr FlagsClass
ptr -> do
val <- Ptr Word32 -> IO Word32
forall a. Storable a => Ptr a -> IO a
peek (Ptr FlagsClass
ptr Ptr FlagsClass -> Int -> Ptr Word32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
8) :: IO Word32
return val
setFlagsClassMask :: MonadIO m => FlagsClass -> Word32 -> m ()
setFlagsClassMask :: forall (m :: * -> *). MonadIO m => FlagsClass -> Word32 -> m ()
setFlagsClassMask FlagsClass
s Word32
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FlagsClass -> (Ptr FlagsClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr FlagsClass
s ((Ptr FlagsClass -> IO ()) -> IO ())
-> (Ptr FlagsClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr FlagsClass
ptr -> do
Ptr Word32 -> Word32 -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr FlagsClass
ptr Ptr FlagsClass -> Int -> Ptr Word32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
8) (Word32
val :: Word32)
#if defined(ENABLE_OVERLOADING)
data FlagsClassMaskFieldInfo
instance AttrInfo FlagsClassMaskFieldInfo where
type AttrBaseTypeConstraint FlagsClassMaskFieldInfo = (~) FlagsClass
type AttrAllowedOps FlagsClassMaskFieldInfo = '[ 'AttrSet, 'AttrGet]
type AttrSetTypeConstraint FlagsClassMaskFieldInfo = (~) Word32
type AttrTransferTypeConstraint FlagsClassMaskFieldInfo = (~)Word32
type AttrTransferType FlagsClassMaskFieldInfo = Word32
type AttrGetType FlagsClassMaskFieldInfo = Word32
type AttrLabel FlagsClassMaskFieldInfo = "mask"
type AttrOrigin FlagsClassMaskFieldInfo = FlagsClass
attrGet :: forall o.
AttrBaseTypeConstraint FlagsClassMaskFieldInfo o =>
o -> IO (AttrGetType FlagsClassMaskFieldInfo)
attrGet = o -> IO (AttrGetType FlagsClassMaskFieldInfo)
FlagsClass -> IO Word32
forall (m :: * -> *). MonadIO m => FlagsClass -> m Word32
getFlagsClassMask
attrSet :: forall o b.
(AttrBaseTypeConstraint FlagsClassMaskFieldInfo o,
AttrSetTypeConstraint FlagsClassMaskFieldInfo b) =>
o -> b -> IO ()
attrSet = o -> b -> IO ()
FlagsClass -> Word32 -> IO ()
forall (m :: * -> *). MonadIO m => FlagsClass -> Word32 -> m ()
setFlagsClassMask
attrConstruct :: forall o b.
(AttrBaseTypeConstraint FlagsClassMaskFieldInfo o,
AttrSetTypeConstraint FlagsClassMaskFieldInfo b) =>
b -> IO (GValueConstruct o)
attrConstruct = b -> IO (GValueConstruct o)
forall a. HasCallStack => a
undefined
attrClear :: forall o.
AttrBaseTypeConstraint FlagsClassMaskFieldInfo o =>
o -> IO ()
attrClear = o -> IO ()
forall a. HasCallStack => a
undefined
attrTransfer :: forall o b.
(AttrBaseTypeConstraint FlagsClassMaskFieldInfo o,
AttrTransferTypeConstraint FlagsClassMaskFieldInfo b) =>
Proxy o -> b -> IO (AttrTransferType FlagsClassMaskFieldInfo)
attrTransfer Proxy o
_ b
v = do
b -> IO b
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return b
v
dbgAttrInfo :: Maybe ResolvedSymbolInfo
dbgAttrInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.GObject.Structs.FlagsClass.mask"
, resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-gobject-2.0.32/docs/GI-GObject-Structs-FlagsClass.html#g:attr:mask"
})
flagsClass_mask :: AttrLabelProxy "mask"
flagsClass_mask :: AttrLabelProxy "mask"
flagsClass_mask = AttrLabelProxy "mask"
forall (a :: Symbol). AttrLabelProxy a
AttrLabelProxy
#endif
getFlagsClassNValues :: MonadIO m => FlagsClass -> m Word32
getFlagsClassNValues :: forall (m :: * -> *). MonadIO m => FlagsClass -> m Word32
getFlagsClassNValues FlagsClass
s = IO Word32 -> m Word32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
forall a b. (a -> b) -> a -> b
$ FlagsClass -> (Ptr FlagsClass -> IO Word32) -> IO Word32
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr FlagsClass
s ((Ptr FlagsClass -> IO Word32) -> IO Word32)
-> (Ptr FlagsClass -> IO Word32) -> IO Word32
forall a b. (a -> b) -> a -> b
$ \Ptr FlagsClass
ptr -> do
val <- Ptr Word32 -> IO Word32
forall a. Storable a => Ptr a -> IO a
peek (Ptr FlagsClass
ptr Ptr FlagsClass -> Int -> Ptr Word32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
12) :: IO Word32
return val
setFlagsClassNValues :: MonadIO m => FlagsClass -> Word32 -> m ()
setFlagsClassNValues :: forall (m :: * -> *). MonadIO m => FlagsClass -> Word32 -> m ()
setFlagsClassNValues FlagsClass
s Word32
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FlagsClass -> (Ptr FlagsClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr FlagsClass
s ((Ptr FlagsClass -> IO ()) -> IO ())
-> (Ptr FlagsClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr FlagsClass
ptr -> do
Ptr Word32 -> Word32 -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr FlagsClass
ptr Ptr FlagsClass -> Int -> Ptr Word32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
12) (Word32
val :: Word32)
#if defined(ENABLE_OVERLOADING)
data FlagsClassNValuesFieldInfo
instance AttrInfo FlagsClassNValuesFieldInfo where
type AttrBaseTypeConstraint FlagsClassNValuesFieldInfo = (~) FlagsClass
type AttrAllowedOps FlagsClassNValuesFieldInfo = '[ 'AttrSet, 'AttrGet]
type AttrSetTypeConstraint FlagsClassNValuesFieldInfo = (~) Word32
type AttrTransferTypeConstraint FlagsClassNValuesFieldInfo = (~)Word32
type AttrTransferType FlagsClassNValuesFieldInfo = Word32
type AttrGetType FlagsClassNValuesFieldInfo = Word32
type AttrLabel FlagsClassNValuesFieldInfo = "n_values"
type AttrOrigin FlagsClassNValuesFieldInfo = FlagsClass
attrGet :: forall o.
AttrBaseTypeConstraint FlagsClassNValuesFieldInfo o =>
o -> IO (AttrGetType FlagsClassNValuesFieldInfo)
attrGet = o -> IO (AttrGetType FlagsClassNValuesFieldInfo)
FlagsClass -> IO Word32
forall (m :: * -> *). MonadIO m => FlagsClass -> m Word32
getFlagsClassNValues
attrSet :: forall o b.
(AttrBaseTypeConstraint FlagsClassNValuesFieldInfo o,
AttrSetTypeConstraint FlagsClassNValuesFieldInfo b) =>
o -> b -> IO ()
attrSet = o -> b -> IO ()
FlagsClass -> Word32 -> IO ()
forall (m :: * -> *). MonadIO m => FlagsClass -> Word32 -> m ()
setFlagsClassNValues
attrConstruct :: forall o b.
(AttrBaseTypeConstraint FlagsClassNValuesFieldInfo o,
AttrSetTypeConstraint FlagsClassNValuesFieldInfo b) =>
b -> IO (GValueConstruct o)
attrConstruct = b -> IO (GValueConstruct o)
forall a. HasCallStack => a
undefined
attrClear :: forall o.
AttrBaseTypeConstraint FlagsClassNValuesFieldInfo o =>
o -> IO ()
attrClear = o -> IO ()
forall a. HasCallStack => a
undefined
attrTransfer :: forall o b.
(AttrBaseTypeConstraint FlagsClassNValuesFieldInfo o,
AttrTransferTypeConstraint FlagsClassNValuesFieldInfo b) =>
Proxy o -> b -> IO (AttrTransferType FlagsClassNValuesFieldInfo)
attrTransfer Proxy o
_ b
v = do
b -> IO b
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return b
v
dbgAttrInfo :: Maybe ResolvedSymbolInfo
dbgAttrInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.GObject.Structs.FlagsClass.nValues"
, resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-gobject-2.0.32/docs/GI-GObject-Structs-FlagsClass.html#g:attr:nValues"
})
flagsClass_nValues :: AttrLabelProxy "nValues"
flagsClass_nValues :: AttrLabelProxy "nValues"
flagsClass_nValues = AttrLabelProxy "nValues"
forall (a :: Symbol). AttrLabelProxy a
AttrLabelProxy
#endif
getFlagsClassValues :: MonadIO m => FlagsClass -> m (Maybe [GObject.FlagsValue.FlagsValue])
getFlagsClassValues :: forall (m :: * -> *).
MonadIO m =>
FlagsClass -> m (Maybe [FlagsValue])
getFlagsClassValues FlagsClass
s = IO (Maybe [FlagsValue]) -> m (Maybe [FlagsValue])
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe [FlagsValue]) -> m (Maybe [FlagsValue]))
-> IO (Maybe [FlagsValue]) -> m (Maybe [FlagsValue])
forall a b. (a -> b) -> a -> b
$ FlagsClass
-> (Ptr FlagsClass -> IO (Maybe [FlagsValue]))
-> IO (Maybe [FlagsValue])
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr FlagsClass
s ((Ptr FlagsClass -> IO (Maybe [FlagsValue]))
-> IO (Maybe [FlagsValue]))
-> (Ptr FlagsClass -> IO (Maybe [FlagsValue]))
-> IO (Maybe [FlagsValue])
forall a b. (a -> b) -> a -> b
$ \Ptr FlagsClass
ptr -> do
val <- Ptr (Ptr FlagsValue) -> IO (Ptr FlagsValue)
forall a. Storable a => Ptr a -> IO a
peek (Ptr FlagsClass
ptr Ptr FlagsClass -> Int -> Ptr (Ptr FlagsValue)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
16) :: IO (Ptr GObject.FlagsValue.FlagsValue)
len <- peek (ptr `plusPtr` 12) :: IO Word32
result <- SP.convertIfNonNull val $ \Ptr FlagsValue
val' -> do
val'' <- (Int -> Word32 -> Ptr FlagsValue -> IO [Ptr FlagsValue]
forall a b. Integral a => Int -> a -> Ptr b -> IO [Ptr b]
unpackBlockArrayWithLength Int
24 Word32
len) Ptr FlagsValue
val'
val''' <- mapM (wrapPtr GObject.FlagsValue.FlagsValue) val''
return val'''
return result
setFlagsClassValues :: MonadIO m => FlagsClass -> Ptr GObject.FlagsValue.FlagsValue -> m ()
setFlagsClassValues :: forall (m :: * -> *).
MonadIO m =>
FlagsClass -> Ptr FlagsValue -> m ()
setFlagsClassValues FlagsClass
s Ptr FlagsValue
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FlagsClass -> (Ptr FlagsClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr FlagsClass
s ((Ptr FlagsClass -> IO ()) -> IO ())
-> (Ptr FlagsClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr FlagsClass
ptr -> do
Ptr (Ptr FlagsValue) -> Ptr FlagsValue -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr FlagsClass
ptr Ptr FlagsClass -> Int -> Ptr (Ptr FlagsValue)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
16) (Ptr FlagsValue
val :: Ptr GObject.FlagsValue.FlagsValue)
clearFlagsClassValues :: MonadIO m => FlagsClass -> m ()
clearFlagsClassValues :: forall (m :: * -> *). MonadIO m => FlagsClass -> m ()
clearFlagsClassValues FlagsClass
s = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FlagsClass -> (Ptr FlagsClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr FlagsClass
s ((Ptr FlagsClass -> IO ()) -> IO ())
-> (Ptr FlagsClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr FlagsClass
ptr -> do
Ptr (Ptr FlagsValue) -> Ptr FlagsValue -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr FlagsClass
ptr Ptr FlagsClass -> Int -> Ptr (Ptr FlagsValue)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
16) (Ptr FlagsValue
forall a. Ptr a
FP.nullPtr :: Ptr GObject.FlagsValue.FlagsValue)
#if defined(ENABLE_OVERLOADING)
data FlagsClassValuesFieldInfo
instance AttrInfo FlagsClassValuesFieldInfo where
type AttrBaseTypeConstraint FlagsClassValuesFieldInfo = (~) FlagsClass
type AttrAllowedOps FlagsClassValuesFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint FlagsClassValuesFieldInfo = (~) (Ptr GObject.FlagsValue.FlagsValue)
type AttrTransferTypeConstraint FlagsClassValuesFieldInfo = (~)(Ptr GObject.FlagsValue.FlagsValue)
type AttrTransferType FlagsClassValuesFieldInfo = (Ptr GObject.FlagsValue.FlagsValue)
type AttrGetType FlagsClassValuesFieldInfo = Maybe [GObject.FlagsValue.FlagsValue]
type AttrLabel FlagsClassValuesFieldInfo = "values"
type AttrOrigin FlagsClassValuesFieldInfo = FlagsClass
attrGet :: forall o.
AttrBaseTypeConstraint FlagsClassValuesFieldInfo o =>
o -> IO (AttrGetType FlagsClassValuesFieldInfo)
attrGet = o -> IO (AttrGetType FlagsClassValuesFieldInfo)
FlagsClass -> IO (Maybe [FlagsValue])
forall (m :: * -> *).
MonadIO m =>
FlagsClass -> m (Maybe [FlagsValue])
getFlagsClassValues
attrSet :: forall o b.
(AttrBaseTypeConstraint FlagsClassValuesFieldInfo o,
AttrSetTypeConstraint FlagsClassValuesFieldInfo b) =>
o -> b -> IO ()
attrSet = o -> b -> IO ()
FlagsClass -> Ptr FlagsValue -> IO ()
forall (m :: * -> *).
MonadIO m =>
FlagsClass -> Ptr FlagsValue -> m ()
setFlagsClassValues
attrConstruct :: forall o b.
(AttrBaseTypeConstraint FlagsClassValuesFieldInfo o,
AttrSetTypeConstraint FlagsClassValuesFieldInfo b) =>
b -> IO (GValueConstruct o)
attrConstruct = b -> IO (GValueConstruct o)
forall a. HasCallStack => a
undefined
attrClear :: forall o.
AttrBaseTypeConstraint FlagsClassValuesFieldInfo o =>
o -> IO ()
attrClear = o -> IO ()
FlagsClass -> IO ()
forall (m :: * -> *). MonadIO m => FlagsClass -> m ()
clearFlagsClassValues
attrTransfer :: forall o b.
(AttrBaseTypeConstraint FlagsClassValuesFieldInfo o,
AttrTransferTypeConstraint FlagsClassValuesFieldInfo b) =>
Proxy o -> b -> IO (AttrTransferType FlagsClassValuesFieldInfo)
attrTransfer Proxy o
_ b
v = do
b -> IO b
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return b
v
dbgAttrInfo :: Maybe ResolvedSymbolInfo
dbgAttrInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.GObject.Structs.FlagsClass.values"
, resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-gobject-2.0.32/docs/GI-GObject-Structs-FlagsClass.html#g:attr:values"
})
flagsClass_values :: AttrLabelProxy "values"
flagsClass_values :: AttrLabelProxy "values"
flagsClass_values = AttrLabelProxy "values"
forall (a :: Symbol). AttrLabelProxy a
AttrLabelProxy
#endif
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList FlagsClass
type instance O.AttributeList FlagsClass = FlagsClassAttributeList
type FlagsClassAttributeList = ('[ '("gTypeClass", FlagsClassGTypeClassFieldInfo), '("mask", FlagsClassMaskFieldInfo), '("nValues", FlagsClassNValuesFieldInfo), '("values", FlagsClassValuesFieldInfo)] :: [(Symbol, DK.Type)])
#endif
#if defined(ENABLE_OVERLOADING)
type family ResolveFlagsClassMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
ResolveFlagsClassMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveFlagsClassMethod t FlagsClass, O.OverloadedMethod info FlagsClass p) => OL.IsLabel t (FlagsClass -> p) where
#if MIN_VERSION_base(4,10,0)
fromLabel :: FlagsClass -> p
fromLabel = forall {k} (i :: k) o s. OverloadedMethod i o s => o -> s
forall i o s. OverloadedMethod i o s => o -> s
O.overloadedMethod @info
#else
fromLabel _ = O.overloadedMethod @info
#endif
#if MIN_VERSION_base(4,13,0)
instance (info ~ ResolveFlagsClassMethod t FlagsClass, O.OverloadedMethod info FlagsClass p, R.HasField t FlagsClass p) => R.HasField t FlagsClass p where
getField :: FlagsClass -> p
getField = forall {k} (i :: k) o s. OverloadedMethod i o s => o -> s
forall i o s. OverloadedMethod i o s => o -> s
O.overloadedMethod @info
#endif
instance (info ~ ResolveFlagsClassMethod t FlagsClass, O.OverloadedMethodInfo info FlagsClass) => OL.IsLabel t (O.MethodProxy info FlagsClass) where
#if MIN_VERSION_base(4,10,0)
fromLabel :: MethodProxy info FlagsClass
fromLabel = MethodProxy info FlagsClass
forall info obj. MethodProxy info obj
O.MethodProxy
#else
fromLabel _ = O.MethodProxy
#endif
#endif