{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- Struct defining a pad action entry.

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

module GI.Gtk.Structs.PadActionEntry
    ( 

-- * Exported types
    PadActionEntry(..)                      ,
    newZeroPadActionEntry                   ,
    noPadActionEntry                        ,


 -- * Methods
-- ** Overloaded methods #method:Overloaded methods#

#if defined(ENABLE_OVERLOADING)
    ResolvePadActionEntryMethod             ,
#endif




 -- * Properties
-- ** actionName #attr:actionName#
-- | action name that will be activated in the t'GI.Gio.Interfaces.ActionGroup.ActionGroup'.

    clearPadActionEntryActionName           ,
    getPadActionEntryActionName             ,
#if defined(ENABLE_OVERLOADING)
    padActionEntry_actionName               ,
#endif
    setPadActionEntryActionName             ,


-- ** index #attr:index#
-- | the 0-indexed button\/ring\/strip number that will trigger this action
--   entry.

    getPadActionEntryIndex                  ,
#if defined(ENABLE_OVERLOADING)
    padActionEntry_index                    ,
#endif
    setPadActionEntryIndex                  ,


-- ** label #attr:label#
-- | Human readable description of this action entry, this string should
--   be deemed user-visible.

    clearPadActionEntryLabel                ,
    getPadActionEntryLabel                  ,
#if defined(ENABLE_OVERLOADING)
    padActionEntry_label                    ,
#endif
    setPadActionEntryLabel                  ,


-- ** mode #attr:mode#
-- | the mode that will trigger this action entry, or -1 for all modes.

    getPadActionEntryMode                   ,
#if defined(ENABLE_OVERLOADING)
    padActionEntry_mode                     ,
#endif
    setPadActionEntryMode                   ,


-- ** type #attr:type#
-- | the type of pad feature that will trigger this action entry.

    getPadActionEntryType                   ,
#if defined(ENABLE_OVERLOADING)
    padActionEntry_type                     ,
#endif
    setPadActionEntryType                   ,




    ) 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.ManagedPtr as B.ManagedPtr
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 Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL

import {-# SOURCE #-} qualified GI.Gtk.Enums as Gtk.Enums

-- | Memory-managed wrapper type.
newtype PadActionEntry = PadActionEntry (ManagedPtr PadActionEntry)
    deriving (PadActionEntry -> PadActionEntry -> Bool
(PadActionEntry -> PadActionEntry -> Bool)
-> (PadActionEntry -> PadActionEntry -> Bool) -> Eq PadActionEntry
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PadActionEntry -> PadActionEntry -> Bool
$c/= :: PadActionEntry -> PadActionEntry -> Bool
== :: PadActionEntry -> PadActionEntry -> Bool
$c== :: PadActionEntry -> PadActionEntry -> Bool
Eq)
instance WrappedPtr PadActionEntry where
    wrappedPtrCalloc :: IO (Ptr PadActionEntry)
wrappedPtrCalloc = Int -> IO (Ptr PadActionEntry)
forall a. Int -> IO (Ptr a)
callocBytes 32
    wrappedPtrCopy :: PadActionEntry -> IO PadActionEntry
wrappedPtrCopy = \p :: PadActionEntry
p -> PadActionEntry
-> (Ptr PadActionEntry -> IO PadActionEntry) -> IO PadActionEntry
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr PadActionEntry
p (Int -> Ptr PadActionEntry -> IO (Ptr PadActionEntry)
forall a. WrappedPtr a => Int -> Ptr a -> IO (Ptr a)
copyBytes 32 (Ptr PadActionEntry -> IO (Ptr PadActionEntry))
-> (Ptr PadActionEntry -> IO PadActionEntry)
-> Ptr PadActionEntry
-> IO PadActionEntry
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (ManagedPtr PadActionEntry -> PadActionEntry)
-> Ptr PadActionEntry -> IO PadActionEntry
forall a.
(HasCallStack, WrappedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapPtr ManagedPtr PadActionEntry -> PadActionEntry
PadActionEntry)
    wrappedPtrFree :: Maybe (GDestroyNotify PadActionEntry)
wrappedPtrFree = GDestroyNotify PadActionEntry
-> Maybe (GDestroyNotify PadActionEntry)
forall a. a -> Maybe a
Just GDestroyNotify PadActionEntry
forall a. FunPtr (Ptr a -> IO ())
ptr_to_g_free

-- | Construct a `PadActionEntry` struct initialized to zero.
newZeroPadActionEntry :: MonadIO m => m PadActionEntry
newZeroPadActionEntry :: m PadActionEntry
newZeroPadActionEntry = IO PadActionEntry -> m PadActionEntry
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO PadActionEntry -> m PadActionEntry)
-> IO PadActionEntry -> m PadActionEntry
forall a b. (a -> b) -> a -> b
$ IO (Ptr PadActionEntry)
forall a. WrappedPtr a => IO (Ptr a)
wrappedPtrCalloc IO (Ptr PadActionEntry)
-> (Ptr PadActionEntry -> IO PadActionEntry) -> IO PadActionEntry
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (ManagedPtr PadActionEntry -> PadActionEntry)
-> Ptr PadActionEntry -> IO PadActionEntry
forall a.
(HasCallStack, WrappedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapPtr ManagedPtr PadActionEntry -> PadActionEntry
PadActionEntry

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


-- | A convenience alias for `Nothing` :: `Maybe` `PadActionEntry`.
noPadActionEntry :: Maybe PadActionEntry
noPadActionEntry :: Maybe PadActionEntry
noPadActionEntry = Maybe PadActionEntry
forall a. Maybe a
Nothing

-- | Get the value of the “@type@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' padActionEntry #type
-- @
getPadActionEntryType :: MonadIO m => PadActionEntry -> m Gtk.Enums.PadActionType
getPadActionEntryType :: PadActionEntry -> m PadActionType
getPadActionEntryType s :: PadActionEntry
s = IO PadActionType -> m PadActionType
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO PadActionType -> m PadActionType)
-> IO PadActionType -> m PadActionType
forall a b. (a -> b) -> a -> b
$ PadActionEntry
-> (Ptr PadActionEntry -> IO PadActionType) -> IO PadActionType
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr PadActionEntry
s ((Ptr PadActionEntry -> IO PadActionType) -> IO PadActionType)
-> (Ptr PadActionEntry -> IO PadActionType) -> IO PadActionType
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr PadActionEntry
ptr -> do
    CUInt
val <- Ptr CUInt -> IO CUInt
forall a. Storable a => Ptr a -> IO a
peek (Ptr PadActionEntry
ptr Ptr PadActionEntry -> Int -> Ptr CUInt
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 0) :: IO CUInt
    let val' :: PadActionType
val' = (Int -> PadActionType
forall a. Enum a => Int -> a
toEnum (Int -> PadActionType) -> (CUInt -> Int) -> CUInt -> PadActionType
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
val
    PadActionType -> IO PadActionType
forall (m :: * -> *) a. Monad m => a -> m a
return PadActionType
val'

-- | Set the value of the “@type@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' padActionEntry [ #type 'Data.GI.Base.Attributes.:=' value ]
-- @
setPadActionEntryType :: MonadIO m => PadActionEntry -> Gtk.Enums.PadActionType -> m ()
setPadActionEntryType :: PadActionEntry -> PadActionType -> m ()
setPadActionEntryType s :: PadActionEntry
s val :: PadActionType
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ PadActionEntry -> (Ptr PadActionEntry -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr PadActionEntry
s ((Ptr PadActionEntry -> IO ()) -> IO ())
-> (Ptr PadActionEntry -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr PadActionEntry
ptr -> do
    let val' :: CUInt
val' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (PadActionType -> Int) -> PadActionType -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PadActionType -> Int
forall a. Enum a => a -> Int
fromEnum) PadActionType
val
    Ptr CUInt -> CUInt -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr PadActionEntry
ptr Ptr PadActionEntry -> Int -> Ptr CUInt
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 0) (CUInt
val' :: CUInt)

#if defined(ENABLE_OVERLOADING)
data PadActionEntryTypeFieldInfo
instance AttrInfo PadActionEntryTypeFieldInfo where
    type AttrBaseTypeConstraint PadActionEntryTypeFieldInfo = (~) PadActionEntry
    type AttrAllowedOps PadActionEntryTypeFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint PadActionEntryTypeFieldInfo = (~) Gtk.Enums.PadActionType
    type AttrTransferTypeConstraint PadActionEntryTypeFieldInfo = (~)Gtk.Enums.PadActionType
    type AttrTransferType PadActionEntryTypeFieldInfo = Gtk.Enums.PadActionType
    type AttrGetType PadActionEntryTypeFieldInfo = Gtk.Enums.PadActionType
    type AttrLabel PadActionEntryTypeFieldInfo = "type"
    type AttrOrigin PadActionEntryTypeFieldInfo = PadActionEntry
    attrGet = getPadActionEntryType
    attrSet = setPadActionEntryType
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer _ v = do
        return v

padActionEntry_type :: AttrLabelProxy "type"
padActionEntry_type = AttrLabelProxy

#endif


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

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

#if defined(ENABLE_OVERLOADING)
data PadActionEntryIndexFieldInfo
instance AttrInfo PadActionEntryIndexFieldInfo where
    type AttrBaseTypeConstraint PadActionEntryIndexFieldInfo = (~) PadActionEntry
    type AttrAllowedOps PadActionEntryIndexFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint PadActionEntryIndexFieldInfo = (~) Int32
    type AttrTransferTypeConstraint PadActionEntryIndexFieldInfo = (~)Int32
    type AttrTransferType PadActionEntryIndexFieldInfo = Int32
    type AttrGetType PadActionEntryIndexFieldInfo = Int32
    type AttrLabel PadActionEntryIndexFieldInfo = "index"
    type AttrOrigin PadActionEntryIndexFieldInfo = PadActionEntry
    attrGet = getPadActionEntryIndex
    attrSet = setPadActionEntryIndex
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer _ v = do
        return v

padActionEntry_index :: AttrLabelProxy "index"
padActionEntry_index = AttrLabelProxy

#endif


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

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

#if defined(ENABLE_OVERLOADING)
data PadActionEntryModeFieldInfo
instance AttrInfo PadActionEntryModeFieldInfo where
    type AttrBaseTypeConstraint PadActionEntryModeFieldInfo = (~) PadActionEntry
    type AttrAllowedOps PadActionEntryModeFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint PadActionEntryModeFieldInfo = (~) Int32
    type AttrTransferTypeConstraint PadActionEntryModeFieldInfo = (~)Int32
    type AttrTransferType PadActionEntryModeFieldInfo = Int32
    type AttrGetType PadActionEntryModeFieldInfo = Int32
    type AttrLabel PadActionEntryModeFieldInfo = "mode"
    type AttrOrigin PadActionEntryModeFieldInfo = PadActionEntry
    attrGet = getPadActionEntryMode
    attrSet = setPadActionEntryMode
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer _ v = do
        return v

padActionEntry_mode :: AttrLabelProxy "mode"
padActionEntry_mode = 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' padActionEntry #label
-- @
getPadActionEntryLabel :: MonadIO m => PadActionEntry -> m (Maybe T.Text)
getPadActionEntryLabel :: PadActionEntry -> m (Maybe Text)
getPadActionEntryLabel s :: PadActionEntry
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
$ PadActionEntry
-> (Ptr PadActionEntry -> IO (Maybe Text)) -> IO (Maybe Text)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr PadActionEntry
s ((Ptr PadActionEntry -> IO (Maybe Text)) -> IO (Maybe Text))
-> (Ptr PadActionEntry -> IO (Maybe Text)) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr PadActionEntry
ptr -> do
    CString
val <- Ptr CString -> IO CString
forall a. Storable a => Ptr a -> IO a
peek (Ptr PadActionEntry
ptr Ptr PadActionEntry -> Int -> Ptr CString
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 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
$ \val' :: 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' padActionEntry [ #label 'Data.GI.Base.Attributes.:=' value ]
-- @
setPadActionEntryLabel :: MonadIO m => PadActionEntry -> CString -> m ()
setPadActionEntryLabel :: PadActionEntry -> CString -> m ()
setPadActionEntryLabel s :: PadActionEntry
s val :: 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
$ PadActionEntry -> (Ptr PadActionEntry -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr PadActionEntry
s ((Ptr PadActionEntry -> IO ()) -> IO ())
-> (Ptr PadActionEntry -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr PadActionEntry
ptr -> do
    Ptr CString -> CString -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr PadActionEntry
ptr Ptr PadActionEntry -> Int -> Ptr CString
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 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
-- @
clearPadActionEntryLabel :: MonadIO m => PadActionEntry -> m ()
clearPadActionEntryLabel :: PadActionEntry -> m ()
clearPadActionEntryLabel s :: PadActionEntry
s = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ PadActionEntry -> (Ptr PadActionEntry -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr PadActionEntry
s ((Ptr PadActionEntry -> IO ()) -> IO ())
-> (Ptr PadActionEntry -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr PadActionEntry
ptr -> do
    Ptr CString -> CString -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr PadActionEntry
ptr Ptr PadActionEntry -> Int -> Ptr CString
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 16) (CString
forall a. Ptr a
FP.nullPtr :: CString)

#if defined(ENABLE_OVERLOADING)
data PadActionEntryLabelFieldInfo
instance AttrInfo PadActionEntryLabelFieldInfo where
    type AttrBaseTypeConstraint PadActionEntryLabelFieldInfo = (~) PadActionEntry
    type AttrAllowedOps PadActionEntryLabelFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint PadActionEntryLabelFieldInfo = (~) CString
    type AttrTransferTypeConstraint PadActionEntryLabelFieldInfo = (~)CString
    type AttrTransferType PadActionEntryLabelFieldInfo = CString
    type AttrGetType PadActionEntryLabelFieldInfo = Maybe T.Text
    type AttrLabel PadActionEntryLabelFieldInfo = "label"
    type AttrOrigin PadActionEntryLabelFieldInfo = PadActionEntry
    attrGet = getPadActionEntryLabel
    attrSet = setPadActionEntryLabel
    attrConstruct = undefined
    attrClear = clearPadActionEntryLabel
    attrTransfer _ v = do
        return v

padActionEntry_label :: AttrLabelProxy "label"
padActionEntry_label = AttrLabelProxy

#endif


-- | Get the value of the “@action_name@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' padActionEntry #actionName
-- @
getPadActionEntryActionName :: MonadIO m => PadActionEntry -> m (Maybe T.Text)
getPadActionEntryActionName :: PadActionEntry -> m (Maybe Text)
getPadActionEntryActionName s :: PadActionEntry
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
$ PadActionEntry
-> (Ptr PadActionEntry -> IO (Maybe Text)) -> IO (Maybe Text)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr PadActionEntry
s ((Ptr PadActionEntry -> IO (Maybe Text)) -> IO (Maybe Text))
-> (Ptr PadActionEntry -> IO (Maybe Text)) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr PadActionEntry
ptr -> do
    CString
val <- Ptr CString -> IO CString
forall a. Storable a => Ptr a -> IO a
peek (Ptr PadActionEntry
ptr Ptr PadActionEntry -> Int -> Ptr CString
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 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
$ \val' :: 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 “@action_name@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' padActionEntry [ #actionName 'Data.GI.Base.Attributes.:=' value ]
-- @
setPadActionEntryActionName :: MonadIO m => PadActionEntry -> CString -> m ()
setPadActionEntryActionName :: PadActionEntry -> CString -> m ()
setPadActionEntryActionName s :: PadActionEntry
s val :: 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
$ PadActionEntry -> (Ptr PadActionEntry -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr PadActionEntry
s ((Ptr PadActionEntry -> IO ()) -> IO ())
-> (Ptr PadActionEntry -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr PadActionEntry
ptr -> do
    Ptr CString -> CString -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr PadActionEntry
ptr Ptr PadActionEntry -> Int -> Ptr CString
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 24) (CString
val :: CString)

-- | Set the value of the “@action_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' #actionName
-- @
clearPadActionEntryActionName :: MonadIO m => PadActionEntry -> m ()
clearPadActionEntryActionName :: PadActionEntry -> m ()
clearPadActionEntryActionName s :: PadActionEntry
s = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ PadActionEntry -> (Ptr PadActionEntry -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr PadActionEntry
s ((Ptr PadActionEntry -> IO ()) -> IO ())
-> (Ptr PadActionEntry -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr PadActionEntry
ptr -> do
    Ptr CString -> CString -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr PadActionEntry
ptr Ptr PadActionEntry -> Int -> Ptr CString
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 24) (CString
forall a. Ptr a
FP.nullPtr :: CString)

#if defined(ENABLE_OVERLOADING)
data PadActionEntryActionNameFieldInfo
instance AttrInfo PadActionEntryActionNameFieldInfo where
    type AttrBaseTypeConstraint PadActionEntryActionNameFieldInfo = (~) PadActionEntry
    type AttrAllowedOps PadActionEntryActionNameFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint PadActionEntryActionNameFieldInfo = (~) CString
    type AttrTransferTypeConstraint PadActionEntryActionNameFieldInfo = (~)CString
    type AttrTransferType PadActionEntryActionNameFieldInfo = CString
    type AttrGetType PadActionEntryActionNameFieldInfo = Maybe T.Text
    type AttrLabel PadActionEntryActionNameFieldInfo = "action_name"
    type AttrOrigin PadActionEntryActionNameFieldInfo = PadActionEntry
    attrGet = getPadActionEntryActionName
    attrSet = setPadActionEntryActionName
    attrConstruct = undefined
    attrClear = clearPadActionEntryActionName
    attrTransfer _ v = do
        return v

padActionEntry_actionName :: AttrLabelProxy "actionName"
padActionEntry_actionName = AttrLabelProxy

#endif



#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList PadActionEntry
type instance O.AttributeList PadActionEntry = PadActionEntryAttributeList
type PadActionEntryAttributeList = ('[ '("type", PadActionEntryTypeFieldInfo), '("index", PadActionEntryIndexFieldInfo), '("mode", PadActionEntryModeFieldInfo), '("label", PadActionEntryLabelFieldInfo), '("actionName", PadActionEntryActionNameFieldInfo)] :: [(Symbol, *)])
#endif

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

instance (info ~ ResolvePadActionEntryMethod t PadActionEntry, O.MethodInfo info PadActionEntry p) => OL.IsLabel t (PadActionEntry -> p) where
#if MIN_VERSION_base(4,10,0)
    fromLabel = O.overloadedMethod @info
#else
    fromLabel _ = O.overloadedMethod @info
#endif

#endif