{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
-- 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
-- ** Overloaded methods #method:Overloaded 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.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.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


-- | Memory-managed wrapper type.
newtype RadioActionEntry = RadioActionEntry (SP.ManagedPtr RadioActionEntry)
    deriving (RadioActionEntry -> RadioActionEntry -> Bool
(RadioActionEntry -> RadioActionEntry -> Bool)
-> (RadioActionEntry -> RadioActionEntry -> Bool)
-> Eq RadioActionEntry
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 -> RadioActionEntry
-> (Ptr RadioActionEntry -> IO RadioActionEntry)
-> IO RadioActionEntry
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr RadioActionEntry
p (Int -> Ptr RadioActionEntry -> IO (Ptr RadioActionEntry)
forall a. (HasCallStack, CallocPtr a) => Int -> Ptr a -> IO (Ptr a)
copyBytes Int
48 (Ptr RadioActionEntry -> IO (Ptr RadioActionEntry))
-> (Ptr RadioActionEntry -> IO RadioActionEntry)
-> Ptr RadioActionEntry
-> IO RadioActionEntry
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (ManagedPtr RadioActionEntry -> RadioActionEntry)
-> Ptr RadioActionEntry -> IO RadioActionEntry
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 -> RadioActionEntry -> (Ptr RadioActionEntry -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
SP.withManagedPtr RadioActionEntry
x Ptr RadioActionEntry -> IO ()
forall a. Ptr a -> IO ()
SP.freeMem
instance CallocPtr RadioActionEntry where
    boxedPtrCalloc :: IO (Ptr RadioActionEntry)
boxedPtrCalloc = Int -> IO (Ptr RadioActionEntry)
forall a. Int -> IO (Ptr a)
callocBytes Int
48


-- | Construct a `RadioActionEntry` struct initialized to zero.
newZeroRadioActionEntry :: MonadIO m => m RadioActionEntry
newZeroRadioActionEntry :: m RadioActionEntry
newZeroRadioActionEntry = IO RadioActionEntry -> m RadioActionEntry
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO RadioActionEntry -> m RadioActionEntry)
-> IO RadioActionEntry -> m RadioActionEntry
forall a b. (a -> b) -> a -> b
$ IO (Ptr RadioActionEntry)
forall a. CallocPtr a => IO (Ptr a)
boxedPtrCalloc IO (Ptr RadioActionEntry)
-> (Ptr RadioActionEntry -> IO RadioActionEntry)
-> IO RadioActionEntry
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (ManagedPtr RadioActionEntry -> RadioActionEntry)
-> Ptr RadioActionEntry -> IO RadioActionEntry
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 :: (ManagedPtr RadioActionEntry -> RadioActionEntry)
-> [AttrOp RadioActionEntry tag] -> m RadioActionEntry
new ManagedPtr RadioActionEntry -> RadioActionEntry
_ [AttrOp RadioActionEntry tag]
attrs = do
        RadioActionEntry
o <- m RadioActionEntry
forall (m :: * -> *). MonadIO m => m RadioActionEntry
newZeroRadioActionEntry
        RadioActionEntry -> [AttrOp RadioActionEntry 'AttrSet] -> m ()
forall o (m :: * -> *).
MonadIO m =>
o -> [AttrOp o 'AttrSet] -> m ()
GI.Attributes.set RadioActionEntry
o [AttrOp RadioActionEntry tag]
[AttrOp RadioActionEntry 'AttrSet]
attrs
        RadioActionEntry -> m RadioActionEntry
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 :: RadioActionEntry -> m (Maybe Text)
getRadioActionEntryName RadioActionEntry
s = IO (Maybe Text) -> m (Maybe Text)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ RadioActionEntry
-> (Ptr RadioActionEntry -> IO (Maybe Text)) -> IO (Maybe Text)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr RadioActionEntry
s ((Ptr RadioActionEntry -> IO (Maybe Text)) -> IO (Maybe Text))
-> (Ptr RadioActionEntry -> IO (Maybe Text)) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \Ptr RadioActionEntry
ptr -> do
    CString
val <- Ptr CString -> IO CString
forall a. Storable a => Ptr a -> IO a
peek (Ptr RadioActionEntry
ptr Ptr RadioActionEntry -> Int -> Ptr CString
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0) :: IO CString
    Maybe Text
result <- CString -> (CString -> IO Text) -> IO (Maybe Text)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
SP.convertIfNonNull CString
val ((CString -> IO Text) -> IO (Maybe Text))
-> (CString -> IO Text) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \CString
val' -> do
        Text
val'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
val'
        Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
val''
    Maybe Text -> IO (Maybe Text)
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 :: RadioActionEntry -> CString -> m ()
setRadioActionEntryName RadioActionEntry
s CString
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ RadioActionEntry -> (Ptr RadioActionEntry -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr RadioActionEntry
s ((Ptr RadioActionEntry -> IO ()) -> IO ())
-> (Ptr RadioActionEntry -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr RadioActionEntry
ptr -> do
    Ptr CString -> CString -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr RadioActionEntry
ptr Ptr RadioActionEntry -> Int -> Ptr CString
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 :: RadioActionEntry -> m ()
clearRadioActionEntryName RadioActionEntry
s = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ RadioActionEntry -> (Ptr RadioActionEntry -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr RadioActionEntry
s ((Ptr RadioActionEntry -> IO ()) -> IO ())
-> (Ptr RadioActionEntry -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr RadioActionEntry
ptr -> do
    Ptr CString -> CString -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr RadioActionEntry
ptr Ptr RadioActionEntry -> Int -> Ptr CString
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0) (CString
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

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 :: RadioActionEntry -> m (Maybe Text)
getRadioActionEntryStockId RadioActionEntry
s = IO (Maybe Text) -> m (Maybe Text)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ RadioActionEntry
-> (Ptr RadioActionEntry -> IO (Maybe Text)) -> IO (Maybe Text)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr RadioActionEntry
s ((Ptr RadioActionEntry -> IO (Maybe Text)) -> IO (Maybe Text))
-> (Ptr RadioActionEntry -> IO (Maybe Text)) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \Ptr RadioActionEntry
ptr -> do
    CString
val <- Ptr CString -> IO CString
forall a. Storable a => Ptr a -> IO a
peek (Ptr RadioActionEntry
ptr Ptr RadioActionEntry -> Int -> Ptr CString
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
8) :: IO CString
    Maybe Text
result <- CString -> (CString -> IO Text) -> IO (Maybe Text)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
SP.convertIfNonNull CString
val ((CString -> IO Text) -> IO (Maybe Text))
-> (CString -> IO Text) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \CString
val' -> do
        Text
val'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
val'
        Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
val''
    Maybe Text -> IO (Maybe Text)
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 :: RadioActionEntry -> CString -> m ()
setRadioActionEntryStockId RadioActionEntry
s CString
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ RadioActionEntry -> (Ptr RadioActionEntry -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr RadioActionEntry
s ((Ptr RadioActionEntry -> IO ()) -> IO ())
-> (Ptr RadioActionEntry -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr RadioActionEntry
ptr -> do
    Ptr CString -> CString -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr RadioActionEntry
ptr Ptr RadioActionEntry -> Int -> Ptr CString
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 :: RadioActionEntry -> m ()
clearRadioActionEntryStockId RadioActionEntry
s = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ RadioActionEntry -> (Ptr RadioActionEntry -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr RadioActionEntry
s ((Ptr RadioActionEntry -> IO ()) -> IO ())
-> (Ptr RadioActionEntry -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr RadioActionEntry
ptr -> do
    Ptr CString -> CString -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr RadioActionEntry
ptr Ptr RadioActionEntry -> Int -> Ptr CString
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
8) (CString
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

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 :: RadioActionEntry -> m (Maybe Text)
getRadioActionEntryLabel RadioActionEntry
s = IO (Maybe Text) -> m (Maybe Text)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ RadioActionEntry
-> (Ptr RadioActionEntry -> IO (Maybe Text)) -> IO (Maybe Text)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr RadioActionEntry
s ((Ptr RadioActionEntry -> IO (Maybe Text)) -> IO (Maybe Text))
-> (Ptr RadioActionEntry -> IO (Maybe Text)) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \Ptr RadioActionEntry
ptr -> do
    CString
val <- Ptr CString -> IO CString
forall a. Storable a => Ptr a -> IO a
peek (Ptr RadioActionEntry
ptr Ptr RadioActionEntry -> Int -> Ptr CString
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
16) :: IO CString
    Maybe Text
result <- CString -> (CString -> IO Text) -> IO (Maybe Text)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
SP.convertIfNonNull CString
val ((CString -> IO Text) -> IO (Maybe Text))
-> (CString -> IO Text) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \CString
val' -> do
        Text
val'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
val'
        Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
val''
    Maybe Text -> IO (Maybe Text)
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 :: RadioActionEntry -> CString -> m ()
setRadioActionEntryLabel RadioActionEntry
s CString
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ RadioActionEntry -> (Ptr RadioActionEntry -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr RadioActionEntry
s ((Ptr RadioActionEntry -> IO ()) -> IO ())
-> (Ptr RadioActionEntry -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr RadioActionEntry
ptr -> do
    Ptr CString -> CString -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr RadioActionEntry
ptr Ptr RadioActionEntry -> Int -> Ptr CString
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 :: RadioActionEntry -> m ()
clearRadioActionEntryLabel RadioActionEntry
s = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ RadioActionEntry -> (Ptr RadioActionEntry -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr RadioActionEntry
s ((Ptr RadioActionEntry -> IO ()) -> IO ())
-> (Ptr RadioActionEntry -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr RadioActionEntry
ptr -> do
    Ptr CString -> CString -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr RadioActionEntry
ptr Ptr RadioActionEntry -> Int -> Ptr CString
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
16) (CString
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

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 :: RadioActionEntry -> m (Maybe Text)
getRadioActionEntryAccelerator RadioActionEntry
s = IO (Maybe Text) -> m (Maybe Text)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ RadioActionEntry
-> (Ptr RadioActionEntry -> IO (Maybe Text)) -> IO (Maybe Text)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr RadioActionEntry
s ((Ptr RadioActionEntry -> IO (Maybe Text)) -> IO (Maybe Text))
-> (Ptr RadioActionEntry -> IO (Maybe Text)) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \Ptr RadioActionEntry
ptr -> do
    CString
val <- Ptr CString -> IO CString
forall a. Storable a => Ptr a -> IO a
peek (Ptr RadioActionEntry
ptr Ptr RadioActionEntry -> Int -> Ptr CString
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
24) :: IO CString
    Maybe Text
result <- CString -> (CString -> IO Text) -> IO (Maybe Text)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
SP.convertIfNonNull CString
val ((CString -> IO Text) -> IO (Maybe Text))
-> (CString -> IO Text) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \CString
val' -> do
        Text
val'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
val'
        Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
val''
    Maybe Text -> IO (Maybe Text)
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 :: RadioActionEntry -> CString -> m ()
setRadioActionEntryAccelerator RadioActionEntry
s CString
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ RadioActionEntry -> (Ptr RadioActionEntry -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr RadioActionEntry
s ((Ptr RadioActionEntry -> IO ()) -> IO ())
-> (Ptr RadioActionEntry -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr RadioActionEntry
ptr -> do
    Ptr CString -> CString -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr RadioActionEntry
ptr Ptr RadioActionEntry -> Int -> Ptr CString
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 :: RadioActionEntry -> m ()
clearRadioActionEntryAccelerator RadioActionEntry
s = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ RadioActionEntry -> (Ptr RadioActionEntry -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr RadioActionEntry
s ((Ptr RadioActionEntry -> IO ()) -> IO ())
-> (Ptr RadioActionEntry -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr RadioActionEntry
ptr -> do
    Ptr CString -> CString -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr RadioActionEntry
ptr Ptr RadioActionEntry -> Int -> Ptr CString
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
24) (CString
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

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 :: RadioActionEntry -> m (Maybe Text)
getRadioActionEntryTooltip RadioActionEntry
s = IO (Maybe Text) -> m (Maybe Text)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ RadioActionEntry
-> (Ptr RadioActionEntry -> IO (Maybe Text)) -> IO (Maybe Text)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr RadioActionEntry
s ((Ptr RadioActionEntry -> IO (Maybe Text)) -> IO (Maybe Text))
-> (Ptr RadioActionEntry -> IO (Maybe Text)) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \Ptr RadioActionEntry
ptr -> do
    CString
val <- Ptr CString -> IO CString
forall a. Storable a => Ptr a -> IO a
peek (Ptr RadioActionEntry
ptr Ptr RadioActionEntry -> Int -> Ptr CString
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
32) :: IO CString
    Maybe Text
result <- CString -> (CString -> IO Text) -> IO (Maybe Text)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
SP.convertIfNonNull CString
val ((CString -> IO Text) -> IO (Maybe Text))
-> (CString -> IO Text) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \CString
val' -> do
        Text
val'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
val'
        Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
val''
    Maybe Text -> IO (Maybe Text)
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 :: RadioActionEntry -> CString -> m ()
setRadioActionEntryTooltip RadioActionEntry
s CString
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ RadioActionEntry -> (Ptr RadioActionEntry -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr RadioActionEntry
s ((Ptr RadioActionEntry -> IO ()) -> IO ())
-> (Ptr RadioActionEntry -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr RadioActionEntry
ptr -> do
    Ptr CString -> CString -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr RadioActionEntry
ptr Ptr RadioActionEntry -> Int -> Ptr CString
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 :: RadioActionEntry -> m ()
clearRadioActionEntryTooltip RadioActionEntry
s = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ RadioActionEntry -> (Ptr RadioActionEntry -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr RadioActionEntry
s ((Ptr RadioActionEntry -> IO ()) -> IO ())
-> (Ptr RadioActionEntry -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr RadioActionEntry
ptr -> do
    Ptr CString -> CString -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr RadioActionEntry
ptr Ptr RadioActionEntry -> Int -> Ptr CString
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
32) (CString
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

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 :: RadioActionEntry -> m Int32
getRadioActionEntryValue RadioActionEntry
s = IO Int32 -> m Int32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ RadioActionEntry -> (Ptr RadioActionEntry -> IO Int32) -> IO Int32
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr RadioActionEntry
s ((Ptr RadioActionEntry -> IO Int32) -> IO Int32)
-> (Ptr RadioActionEntry -> IO Int32) -> IO Int32
forall a b. (a -> b) -> a -> b
$ \Ptr RadioActionEntry
ptr -> do
    Int32
val <- Ptr Int32 -> IO Int32
forall a. Storable a => Ptr a -> IO a
peek (Ptr RadioActionEntry
ptr Ptr RadioActionEntry -> Int -> Ptr Int32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
40) :: IO Int32
    Int32 -> 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 :: RadioActionEntry -> Int32 -> m ()
setRadioActionEntryValue RadioActionEntry
s Int32
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ RadioActionEntry -> (Ptr RadioActionEntry -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr RadioActionEntry
s ((Ptr RadioActionEntry -> IO ()) -> IO ())
-> (Ptr RadioActionEntry -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr RadioActionEntry
ptr -> do
    Ptr Int32 -> Int32 -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr RadioActionEntry
ptr Ptr RadioActionEntry -> Int -> Ptr Int32
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

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, *)])
#endif

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

instance (info ~ ResolveRadioActionEntryMethod t RadioActionEntry, O.MethodInfo 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

#endif