{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- t'GI.Gtk.Structs.RadioActionEntry.RadioActionEntry' structs are used with
-- @/gtk_action_group_add_radio_actions()/@ to construct groups of radio actions.

#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif

module GI.Gtk.Structs.RadioActionEntry
    ( 

-- * Exported types
    RadioActionEntry(..)                    ,
    newZeroRadioActionEntry                 ,


 -- * Methods

#if defined(ENABLE_OVERLOADING)
    ResolveRadioActionEntryMethod           ,
#endif



 -- * Properties


-- ** accelerator #attr:accelerator#
-- | The accelerator for the action, in the format understood by
--  'GI.Gtk.Functions.acceleratorParse'.

    clearRadioActionEntryAccelerator        ,
    getRadioActionEntryAccelerator          ,
#if defined(ENABLE_OVERLOADING)
    radioActionEntry_accelerator            ,
#endif
    setRadioActionEntryAccelerator          ,


-- ** label #attr:label#
-- | The label for the action. This field should typically be marked
--  for translation, see 'GI.Gtk.Objects.ActionGroup.actionGroupSetTranslationDomain'.

    clearRadioActionEntryLabel              ,
    getRadioActionEntryLabel                ,
#if defined(ENABLE_OVERLOADING)
    radioActionEntry_label                  ,
#endif
    setRadioActionEntryLabel                ,


-- ** name #attr:name#
-- | The name of the action.

    clearRadioActionEntryName               ,
    getRadioActionEntryName                 ,
#if defined(ENABLE_OVERLOADING)
    radioActionEntry_name                   ,
#endif
    setRadioActionEntryName                 ,


-- ** stockId #attr:stockId#
-- | The stock id for the action, or the name of an icon from the
--  icon theme.

    clearRadioActionEntryStockId            ,
    getRadioActionEntryStockId              ,
#if defined(ENABLE_OVERLOADING)
    radioActionEntry_stockId                ,
#endif
    setRadioActionEntryStockId              ,


-- ** tooltip #attr:tooltip#
-- | The tooltip for the action. This field should typically be
--  marked for translation, see 'GI.Gtk.Objects.ActionGroup.actionGroupSetTranslationDomain'.

    clearRadioActionEntryTooltip            ,
    getRadioActionEntryTooltip              ,
#if defined(ENABLE_OVERLOADING)
    radioActionEntry_tooltip                ,
#endif
    setRadioActionEntryTooltip              ,


-- ** value #attr:value#
-- | The value to set on the radio action. See
--  'GI.Gtk.Objects.RadioAction.radioActionGetCurrentValue'.

    getRadioActionEntryValue                ,
#if defined(ENABLE_OVERLOADING)
    radioActionEntry_value                  ,
#endif
    setRadioActionEntryValue                ,




    ) 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


-- | Memory-managed wrapper type.
newtype RadioActionEntry = RadioActionEntry (SP.ManagedPtr RadioActionEntry)
    deriving (RadioActionEntry -> RadioActionEntry -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: RadioActionEntry -> RadioActionEntry -> Bool
$c/= :: RadioActionEntry -> RadioActionEntry -> Bool
== :: RadioActionEntry -> RadioActionEntry -> Bool
$c== :: RadioActionEntry -> RadioActionEntry -> Bool
Eq)

instance SP.ManagedPtrNewtype RadioActionEntry where
    toManagedPtr :: RadioActionEntry -> ManagedPtr RadioActionEntry
toManagedPtr (RadioActionEntry ManagedPtr RadioActionEntry
p) = ManagedPtr RadioActionEntry
p

instance BoxedPtr RadioActionEntry where
    boxedPtrCopy :: RadioActionEntry -> IO RadioActionEntry
boxedPtrCopy = \RadioActionEntry
p -> forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr RadioActionEntry
p (forall a. (HasCallStack, CallocPtr a) => Int -> Ptr a -> IO (Ptr a)
copyBytes Int
48 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 RadioActionEntry -> RadioActionEntry
RadioActionEntry)
    boxedPtrFree :: RadioActionEntry -> IO ()
boxedPtrFree = \RadioActionEntry
x -> forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
SP.withManagedPtr RadioActionEntry
x forall a. Ptr a -> IO ()
SP.freeMem
instance CallocPtr RadioActionEntry where
    boxedPtrCalloc :: IO (Ptr RadioActionEntry)
boxedPtrCalloc = forall a. Int -> IO (Ptr a)
callocBytes Int
48


-- | Construct a `RadioActionEntry` struct initialized to zero.
newZeroRadioActionEntry :: MonadIO m => m RadioActionEntry
newZeroRadioActionEntry :: forall (m :: * -> *). MonadIO m => m RadioActionEntry
newZeroRadioActionEntry = 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 RadioActionEntry -> RadioActionEntry
RadioActionEntry

instance tag ~ 'AttrSet => Constructible RadioActionEntry tag where
    new :: forall (m :: * -> *).
MonadIO m =>
(ManagedPtr RadioActionEntry -> RadioActionEntry)
-> [AttrOp RadioActionEntry tag] -> m RadioActionEntry
new ManagedPtr RadioActionEntry -> RadioActionEntry
_ [AttrOp RadioActionEntry tag]
attrs = do
        RadioActionEntry
o <- forall (m :: * -> *). MonadIO m => m RadioActionEntry
newZeroRadioActionEntry
        forall o (m :: * -> *).
MonadIO m =>
o -> [AttrOp o 'AttrSet] -> m ()
GI.Attributes.set RadioActionEntry
o [AttrOp RadioActionEntry tag]
attrs
        forall (m :: * -> *) a. Monad m => a -> m a
return RadioActionEntry
o


-- | Get the value of the “@name@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' radioActionEntry #name
-- @
getRadioActionEntryName :: MonadIO m => RadioActionEntry -> m (Maybe T.Text)
getRadioActionEntryName :: forall (m :: * -> *).
MonadIO m =>
RadioActionEntry -> m (Maybe Text)
getRadioActionEntryName RadioActionEntry
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 RadioActionEntry
s forall a b. (a -> b) -> a -> b
$ \Ptr RadioActionEntry
ptr -> do
    CString
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr RadioActionEntry
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

-- | Set the value of the “@name@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' radioActionEntry [ #name 'Data.GI.Base.Attributes.:=' value ]
-- @
setRadioActionEntryName :: MonadIO m => RadioActionEntry -> CString -> m ()
setRadioActionEntryName :: forall (m :: * -> *).
MonadIO m =>
RadioActionEntry -> CString -> m ()
setRadioActionEntryName RadioActionEntry
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 RadioActionEntry
s forall a b. (a -> b) -> a -> b
$ \Ptr RadioActionEntry
ptr -> do
    forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr RadioActionEntry
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0) (CString
val :: CString)

-- | Set the value of the “@name@” field to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #name
-- @
clearRadioActionEntryName :: MonadIO m => RadioActionEntry -> m ()
clearRadioActionEntryName :: forall (m :: * -> *). MonadIO m => RadioActionEntry -> m ()
clearRadioActionEntryName RadioActionEntry
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 RadioActionEntry
s forall a b. (a -> b) -> a -> b
$ \Ptr RadioActionEntry
ptr -> do
    forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr RadioActionEntry
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0) (forall a. Ptr a
FP.nullPtr :: CString)

#if defined(ENABLE_OVERLOADING)
data RadioActionEntryNameFieldInfo
instance AttrInfo RadioActionEntryNameFieldInfo where
    type AttrBaseTypeConstraint RadioActionEntryNameFieldInfo = (~) RadioActionEntry
    type AttrAllowedOps RadioActionEntryNameFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint RadioActionEntryNameFieldInfo = (~) CString
    type AttrTransferTypeConstraint RadioActionEntryNameFieldInfo = (~)CString
    type AttrTransferType RadioActionEntryNameFieldInfo = CString
    type AttrGetType RadioActionEntryNameFieldInfo = Maybe T.Text
    type AttrLabel RadioActionEntryNameFieldInfo = "name"
    type AttrOrigin RadioActionEntryNameFieldInfo = RadioActionEntry
    attrGet = getRadioActionEntryName
    attrSet = setRadioActionEntryName
    attrConstruct = undefined
    attrClear = clearRadioActionEntryName
    attrTransfer _ v = do
        return v
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Structs.RadioActionEntry.name"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.39/docs/GI-Gtk-Structs-RadioActionEntry.html#g:attr:name"
        })

radioActionEntry_name :: AttrLabelProxy "name"
radioActionEntry_name = AttrLabelProxy

#endif


-- | Get the value of the “@stock_id@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' radioActionEntry #stockId
-- @
getRadioActionEntryStockId :: MonadIO m => RadioActionEntry -> m (Maybe T.Text)
getRadioActionEntryStockId :: forall (m :: * -> *).
MonadIO m =>
RadioActionEntry -> m (Maybe Text)
getRadioActionEntryStockId RadioActionEntry
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 RadioActionEntry
s forall a b. (a -> b) -> a -> b
$ \Ptr RadioActionEntry
ptr -> do
    CString
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr RadioActionEntry
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
8) :: 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

-- | Set the value of the “@stock_id@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' radioActionEntry [ #stockId 'Data.GI.Base.Attributes.:=' value ]
-- @
setRadioActionEntryStockId :: MonadIO m => RadioActionEntry -> CString -> m ()
setRadioActionEntryStockId :: forall (m :: * -> *).
MonadIO m =>
RadioActionEntry -> CString -> m ()
setRadioActionEntryStockId RadioActionEntry
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 RadioActionEntry
s forall a b. (a -> b) -> a -> b
$ \Ptr RadioActionEntry
ptr -> do
    forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr RadioActionEntry
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
8) (CString
val :: CString)

-- | Set the value of the “@stock_id@” field to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #stockId
-- @
clearRadioActionEntryStockId :: MonadIO m => RadioActionEntry -> m ()
clearRadioActionEntryStockId :: forall (m :: * -> *). MonadIO m => RadioActionEntry -> m ()
clearRadioActionEntryStockId RadioActionEntry
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 RadioActionEntry
s forall a b. (a -> b) -> a -> b
$ \Ptr RadioActionEntry
ptr -> do
    forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr RadioActionEntry
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
8) (forall a. Ptr a
FP.nullPtr :: CString)

#if defined(ENABLE_OVERLOADING)
data RadioActionEntryStockIdFieldInfo
instance AttrInfo RadioActionEntryStockIdFieldInfo where
    type AttrBaseTypeConstraint RadioActionEntryStockIdFieldInfo = (~) RadioActionEntry
    type AttrAllowedOps RadioActionEntryStockIdFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint RadioActionEntryStockIdFieldInfo = (~) CString
    type AttrTransferTypeConstraint RadioActionEntryStockIdFieldInfo = (~)CString
    type AttrTransferType RadioActionEntryStockIdFieldInfo = CString
    type AttrGetType RadioActionEntryStockIdFieldInfo = Maybe T.Text
    type AttrLabel RadioActionEntryStockIdFieldInfo = "stock_id"
    type AttrOrigin RadioActionEntryStockIdFieldInfo = RadioActionEntry
    attrGet = getRadioActionEntryStockId
    attrSet = setRadioActionEntryStockId
    attrConstruct = undefined
    attrClear = clearRadioActionEntryStockId
    attrTransfer _ v = do
        return v
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Structs.RadioActionEntry.stockId"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.39/docs/GI-Gtk-Structs-RadioActionEntry.html#g:attr:stockId"
        })

radioActionEntry_stockId :: AttrLabelProxy "stockId"
radioActionEntry_stockId = AttrLabelProxy

#endif


-- | Get the value of the “@label@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' radioActionEntry #label
-- @
getRadioActionEntryLabel :: MonadIO m => RadioActionEntry -> m (Maybe T.Text)
getRadioActionEntryLabel :: forall (m :: * -> *).
MonadIO m =>
RadioActionEntry -> m (Maybe Text)
getRadioActionEntryLabel RadioActionEntry
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 RadioActionEntry
s forall a b. (a -> b) -> a -> b
$ \Ptr RadioActionEntry
ptr -> do
    CString
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr RadioActionEntry
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
16) :: 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

-- | Set the value of the “@label@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' radioActionEntry [ #label 'Data.GI.Base.Attributes.:=' value ]
-- @
setRadioActionEntryLabel :: MonadIO m => RadioActionEntry -> CString -> m ()
setRadioActionEntryLabel :: forall (m :: * -> *).
MonadIO m =>
RadioActionEntry -> CString -> m ()
setRadioActionEntryLabel RadioActionEntry
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 RadioActionEntry
s forall a b. (a -> b) -> a -> b
$ \Ptr RadioActionEntry
ptr -> do
    forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr RadioActionEntry
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
16) (CString
val :: CString)

-- | Set the value of the “@label@” field to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #label
-- @
clearRadioActionEntryLabel :: MonadIO m => RadioActionEntry -> m ()
clearRadioActionEntryLabel :: forall (m :: * -> *). MonadIO m => RadioActionEntry -> m ()
clearRadioActionEntryLabel RadioActionEntry
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 RadioActionEntry
s forall a b. (a -> b) -> a -> b
$ \Ptr RadioActionEntry
ptr -> do
    forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr RadioActionEntry
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
16) (forall a. Ptr a
FP.nullPtr :: CString)

#if defined(ENABLE_OVERLOADING)
data RadioActionEntryLabelFieldInfo
instance AttrInfo RadioActionEntryLabelFieldInfo where
    type AttrBaseTypeConstraint RadioActionEntryLabelFieldInfo = (~) RadioActionEntry
    type AttrAllowedOps RadioActionEntryLabelFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint RadioActionEntryLabelFieldInfo = (~) CString
    type AttrTransferTypeConstraint RadioActionEntryLabelFieldInfo = (~)CString
    type AttrTransferType RadioActionEntryLabelFieldInfo = CString
    type AttrGetType RadioActionEntryLabelFieldInfo = Maybe T.Text
    type AttrLabel RadioActionEntryLabelFieldInfo = "label"
    type AttrOrigin RadioActionEntryLabelFieldInfo = RadioActionEntry
    attrGet = getRadioActionEntryLabel
    attrSet = setRadioActionEntryLabel
    attrConstruct = undefined
    attrClear = clearRadioActionEntryLabel
    attrTransfer _ v = do
        return v
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Structs.RadioActionEntry.label"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.39/docs/GI-Gtk-Structs-RadioActionEntry.html#g:attr:label"
        })

radioActionEntry_label :: AttrLabelProxy "label"
radioActionEntry_label = AttrLabelProxy

#endif


-- | Get the value of the “@accelerator@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' radioActionEntry #accelerator
-- @
getRadioActionEntryAccelerator :: MonadIO m => RadioActionEntry -> m (Maybe T.Text)
getRadioActionEntryAccelerator :: forall (m :: * -> *).
MonadIO m =>
RadioActionEntry -> m (Maybe Text)
getRadioActionEntryAccelerator RadioActionEntry
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 RadioActionEntry
s forall a b. (a -> b) -> a -> b
$ \Ptr RadioActionEntry
ptr -> do
    CString
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr RadioActionEntry
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
24) :: 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

-- | Set the value of the “@accelerator@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' radioActionEntry [ #accelerator 'Data.GI.Base.Attributes.:=' value ]
-- @
setRadioActionEntryAccelerator :: MonadIO m => RadioActionEntry -> CString -> m ()
setRadioActionEntryAccelerator :: forall (m :: * -> *).
MonadIO m =>
RadioActionEntry -> CString -> m ()
setRadioActionEntryAccelerator RadioActionEntry
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 RadioActionEntry
s forall a b. (a -> b) -> a -> b
$ \Ptr RadioActionEntry
ptr -> do
    forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr RadioActionEntry
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
24) (CString
val :: CString)

-- | Set the value of the “@accelerator@” field to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #accelerator
-- @
clearRadioActionEntryAccelerator :: MonadIO m => RadioActionEntry -> m ()
clearRadioActionEntryAccelerator :: forall (m :: * -> *). MonadIO m => RadioActionEntry -> m ()
clearRadioActionEntryAccelerator RadioActionEntry
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 RadioActionEntry
s forall a b. (a -> b) -> a -> b
$ \Ptr RadioActionEntry
ptr -> do
    forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr RadioActionEntry
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
24) (forall a. Ptr a
FP.nullPtr :: CString)

#if defined(ENABLE_OVERLOADING)
data RadioActionEntryAcceleratorFieldInfo
instance AttrInfo RadioActionEntryAcceleratorFieldInfo where
    type AttrBaseTypeConstraint RadioActionEntryAcceleratorFieldInfo = (~) RadioActionEntry
    type AttrAllowedOps RadioActionEntryAcceleratorFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint RadioActionEntryAcceleratorFieldInfo = (~) CString
    type AttrTransferTypeConstraint RadioActionEntryAcceleratorFieldInfo = (~)CString
    type AttrTransferType RadioActionEntryAcceleratorFieldInfo = CString
    type AttrGetType RadioActionEntryAcceleratorFieldInfo = Maybe T.Text
    type AttrLabel RadioActionEntryAcceleratorFieldInfo = "accelerator"
    type AttrOrigin RadioActionEntryAcceleratorFieldInfo = RadioActionEntry
    attrGet = getRadioActionEntryAccelerator
    attrSet = setRadioActionEntryAccelerator
    attrConstruct = undefined
    attrClear = clearRadioActionEntryAccelerator
    attrTransfer _ v = do
        return v
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Structs.RadioActionEntry.accelerator"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.39/docs/GI-Gtk-Structs-RadioActionEntry.html#g:attr:accelerator"
        })

radioActionEntry_accelerator :: AttrLabelProxy "accelerator"
radioActionEntry_accelerator = AttrLabelProxy

#endif


-- | Get the value of the “@tooltip@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' radioActionEntry #tooltip
-- @
getRadioActionEntryTooltip :: MonadIO m => RadioActionEntry -> m (Maybe T.Text)
getRadioActionEntryTooltip :: forall (m :: * -> *).
MonadIO m =>
RadioActionEntry -> m (Maybe Text)
getRadioActionEntryTooltip RadioActionEntry
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 RadioActionEntry
s forall a b. (a -> b) -> a -> b
$ \Ptr RadioActionEntry
ptr -> do
    CString
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr RadioActionEntry
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
32) :: 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

-- | Set the value of the “@tooltip@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' radioActionEntry [ #tooltip 'Data.GI.Base.Attributes.:=' value ]
-- @
setRadioActionEntryTooltip :: MonadIO m => RadioActionEntry -> CString -> m ()
setRadioActionEntryTooltip :: forall (m :: * -> *).
MonadIO m =>
RadioActionEntry -> CString -> m ()
setRadioActionEntryTooltip RadioActionEntry
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 RadioActionEntry
s forall a b. (a -> b) -> a -> b
$ \Ptr RadioActionEntry
ptr -> do
    forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr RadioActionEntry
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
32) (CString
val :: CString)

-- | Set the value of the “@tooltip@” field to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #tooltip
-- @
clearRadioActionEntryTooltip :: MonadIO m => RadioActionEntry -> m ()
clearRadioActionEntryTooltip :: forall (m :: * -> *). MonadIO m => RadioActionEntry -> m ()
clearRadioActionEntryTooltip RadioActionEntry
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 RadioActionEntry
s forall a b. (a -> b) -> a -> b
$ \Ptr RadioActionEntry
ptr -> do
    forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr RadioActionEntry
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
32) (forall a. Ptr a
FP.nullPtr :: CString)

#if defined(ENABLE_OVERLOADING)
data RadioActionEntryTooltipFieldInfo
instance AttrInfo RadioActionEntryTooltipFieldInfo where
    type AttrBaseTypeConstraint RadioActionEntryTooltipFieldInfo = (~) RadioActionEntry
    type AttrAllowedOps RadioActionEntryTooltipFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint RadioActionEntryTooltipFieldInfo = (~) CString
    type AttrTransferTypeConstraint RadioActionEntryTooltipFieldInfo = (~)CString
    type AttrTransferType RadioActionEntryTooltipFieldInfo = CString
    type AttrGetType RadioActionEntryTooltipFieldInfo = Maybe T.Text
    type AttrLabel RadioActionEntryTooltipFieldInfo = "tooltip"
    type AttrOrigin RadioActionEntryTooltipFieldInfo = RadioActionEntry
    attrGet = getRadioActionEntryTooltip
    attrSet = setRadioActionEntryTooltip
    attrConstruct = undefined
    attrClear = clearRadioActionEntryTooltip
    attrTransfer _ v = do
        return v
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Structs.RadioActionEntry.tooltip"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.39/docs/GI-Gtk-Structs-RadioActionEntry.html#g:attr:tooltip"
        })

radioActionEntry_tooltip :: AttrLabelProxy "tooltip"
radioActionEntry_tooltip = AttrLabelProxy

#endif


-- | Get the value of the “@value@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' radioActionEntry #value
-- @
getRadioActionEntryValue :: MonadIO m => RadioActionEntry -> m Int32
getRadioActionEntryValue :: forall (m :: * -> *). MonadIO m => RadioActionEntry -> m Int32
getRadioActionEntryValue RadioActionEntry
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 RadioActionEntry
s forall a b. (a -> b) -> a -> b
$ \Ptr RadioActionEntry
ptr -> do
    Int32
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr RadioActionEntry
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
40) :: IO Int32
    forall (m :: * -> *) a. Monad m => a -> m a
return Int32
val

-- | Set the value of the “@value@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' radioActionEntry [ #value 'Data.GI.Base.Attributes.:=' value ]
-- @
setRadioActionEntryValue :: MonadIO m => RadioActionEntry -> Int32 -> m ()
setRadioActionEntryValue :: forall (m :: * -> *).
MonadIO m =>
RadioActionEntry -> Int32 -> m ()
setRadioActionEntryValue RadioActionEntry
s Int32
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 RadioActionEntry
s forall a b. (a -> b) -> a -> b
$ \Ptr RadioActionEntry
ptr -> do
    forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr RadioActionEntry
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
40) (Int32
val :: Int32)

#if defined(ENABLE_OVERLOADING)
data RadioActionEntryValueFieldInfo
instance AttrInfo RadioActionEntryValueFieldInfo where
    type AttrBaseTypeConstraint RadioActionEntryValueFieldInfo = (~) RadioActionEntry
    type AttrAllowedOps RadioActionEntryValueFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint RadioActionEntryValueFieldInfo = (~) Int32
    type AttrTransferTypeConstraint RadioActionEntryValueFieldInfo = (~)Int32
    type AttrTransferType RadioActionEntryValueFieldInfo = Int32
    type AttrGetType RadioActionEntryValueFieldInfo = Int32
    type AttrLabel RadioActionEntryValueFieldInfo = "value"
    type AttrOrigin RadioActionEntryValueFieldInfo = RadioActionEntry
    attrGet = getRadioActionEntryValue
    attrSet = setRadioActionEntryValue
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer _ v = do
        return v
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Structs.RadioActionEntry.value"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.39/docs/GI-Gtk-Structs-RadioActionEntry.html#g:attr:value"
        })

radioActionEntry_value :: AttrLabelProxy "value"
radioActionEntry_value = AttrLabelProxy

#endif



#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList RadioActionEntry
type instance O.AttributeList RadioActionEntry = RadioActionEntryAttributeList
type RadioActionEntryAttributeList = ('[ '("name", RadioActionEntryNameFieldInfo), '("stockId", RadioActionEntryStockIdFieldInfo), '("label", RadioActionEntryLabelFieldInfo), '("accelerator", RadioActionEntryAcceleratorFieldInfo), '("tooltip", RadioActionEntryTooltipFieldInfo), '("value", RadioActionEntryValueFieldInfo)] :: [(Symbol, DK.Type)])
#endif

#if defined(ENABLE_OVERLOADING)
type family ResolveRadioActionEntryMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
    ResolveRadioActionEntryMethod l o = O.MethodResolutionFailed l o

instance (info ~ ResolveRadioActionEntryMethod t RadioActionEntry, O.OverloadedMethod info RadioActionEntry p) => OL.IsLabel t (RadioActionEntry -> 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 ~ ResolveRadioActionEntryMethod t RadioActionEntry, O.OverloadedMethod info RadioActionEntry p, R.HasField t RadioActionEntry p) => R.HasField t RadioActionEntry p where
    getField = O.overloadedMethod @info

#endif

instance (info ~ ResolveRadioActionEntryMethod t RadioActionEntry, O.OverloadedMethodInfo info RadioActionEntry) => OL.IsLabel t (O.MethodProxy info RadioActionEntry) where
#if MIN_VERSION_base(4,10,0)
    fromLabel = O.MethodProxy
#else
    fromLabel _ = O.MethodProxy
#endif

#endif