{- |
Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
License    : LGPL-2.1
Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)

> In GTK+ 3.10, GtkAction has been deprecated. Use 'GI.Gio.Interfaces.Action.Action'
> instead, and associate actions with 'GI.Gtk.Interfaces.Actionable.Actionable' widgets. Use
> 'GI.Gio.Objects.MenuModel.MenuModel' for creating menus with 'GI.Gtk.Objects.Menu.menuNewFromModel'.

Actions represent operations that the user can be perform, along with
some information how it should be presented in the interface. Each action
provides methods to create icons, menu items and toolbar items
representing itself.

As well as the callback that is called when the action gets activated,
the following also gets associated with the action:

* a name (not translated, for path lookup)
* a label (translated, for display)
* an accelerator
* whether label indicates a stock id
* a tooltip (optional, translated)
* a toolbar label (optional, shorter than label)



The action will also have some state information:

* visible (shown\/hidden)
* sensitive (enabled\/disabled)


Apart from regular actions, there are [toggle actions][GtkToggleAction],
which can be toggled between two states and
[radio actions][GtkRadioAction], of which only one in a group
can be in the “active” state. Other actions can be implemented as 'GI.Gtk.Objects.Action.Action'
subclasses.

Each action can have one or more proxy widgets. To act as an action proxy,
widget needs to implement 'GI.Gtk.Interfaces.Activatable.Activatable' interface. Proxies mirror the state
of the action and should change when the action’s state changes. Properties
that are always mirrored by proxies are 'GI.Gtk.Objects.Action.Action':@/sensitive/@ and
'GI.Gtk.Objects.Action.Action':@/visible/@. 'GI.Gtk.Objects.Action.Action':@/gicon/@, 'GI.Gtk.Objects.Action.Action':@/icon-name/@, 'GI.Gtk.Objects.Action.Action':@/label/@,
'GI.Gtk.Objects.Action.Action':@/short-label/@ and 'GI.Gtk.Objects.Action.Action':@/stock-id/@ properties are only mirorred
if proxy widget has 'GI.Gtk.Interfaces.Activatable.Activatable':@/use-action-appearance/@ property set to
'True'.

When the proxy is activated, it should activate its action.
-}

module GI.Gtk.Objects.Action
    ( 

-- * Exported types
    Action(..)                              ,
    IsAction                                ,
    toAction                                ,
    noAction                                ,


 -- * Methods
-- ** activate #method:activate#
    ActionActivateMethodInfo                ,
    actionActivate                          ,


-- ** blockActivate #method:blockActivate#
    ActionBlockActivateMethodInfo           ,
    actionBlockActivate                     ,


-- ** connectAccelerator #method:connectAccelerator#
    ActionConnectAcceleratorMethodInfo      ,
    actionConnectAccelerator                ,


-- ** createIcon #method:createIcon#
    ActionCreateIconMethodInfo              ,
    actionCreateIcon                        ,


-- ** createMenu #method:createMenu#
    ActionCreateMenuMethodInfo              ,
    actionCreateMenu                        ,


-- ** createMenuItem #method:createMenuItem#
    ActionCreateMenuItemMethodInfo          ,
    actionCreateMenuItem                    ,


-- ** createToolItem #method:createToolItem#
    ActionCreateToolItemMethodInfo          ,
    actionCreateToolItem                    ,


-- ** disconnectAccelerator #method:disconnectAccelerator#
    ActionDisconnectAcceleratorMethodInfo   ,
    actionDisconnectAccelerator             ,


-- ** getAccelClosure #method:getAccelClosure#
    ActionGetAccelClosureMethodInfo         ,
    actionGetAccelClosure                   ,


-- ** getAccelPath #method:getAccelPath#
    ActionGetAccelPathMethodInfo            ,
    actionGetAccelPath                      ,


-- ** getAlwaysShowImage #method:getAlwaysShowImage#
    ActionGetAlwaysShowImageMethodInfo      ,
    actionGetAlwaysShowImage                ,


-- ** getGicon #method:getGicon#
    ActionGetGiconMethodInfo                ,
    actionGetGicon                          ,


-- ** getIconName #method:getIconName#
    ActionGetIconNameMethodInfo             ,
    actionGetIconName                       ,


-- ** getIsImportant #method:getIsImportant#
    ActionGetIsImportantMethodInfo          ,
    actionGetIsImportant                    ,


-- ** getLabel #method:getLabel#
    ActionGetLabelMethodInfo                ,
    actionGetLabel                          ,


-- ** getName #method:getName#
    ActionGetNameMethodInfo                 ,
    actionGetName                           ,


-- ** getProxies #method:getProxies#
    ActionGetProxiesMethodInfo              ,
    actionGetProxies                        ,


-- ** getSensitive #method:getSensitive#
    ActionGetSensitiveMethodInfo            ,
    actionGetSensitive                      ,


-- ** getShortLabel #method:getShortLabel#
    ActionGetShortLabelMethodInfo           ,
    actionGetShortLabel                     ,


-- ** getStockId #method:getStockId#
    ActionGetStockIdMethodInfo              ,
    actionGetStockId                        ,


-- ** getTooltip #method:getTooltip#
    ActionGetTooltipMethodInfo              ,
    actionGetTooltip                        ,


-- ** getVisible #method:getVisible#
    ActionGetVisibleMethodInfo              ,
    actionGetVisible                        ,


-- ** getVisibleHorizontal #method:getVisibleHorizontal#
    ActionGetVisibleHorizontalMethodInfo    ,
    actionGetVisibleHorizontal              ,


-- ** getVisibleVertical #method:getVisibleVertical#
    ActionGetVisibleVerticalMethodInfo      ,
    actionGetVisibleVertical                ,


-- ** isSensitive #method:isSensitive#
    ActionIsSensitiveMethodInfo             ,
    actionIsSensitive                       ,


-- ** isVisible #method:isVisible#
    ActionIsVisibleMethodInfo               ,
    actionIsVisible                         ,


-- ** new #method:new#
    actionNew                               ,


-- ** setAccelGroup #method:setAccelGroup#
    ActionSetAccelGroupMethodInfo           ,
    actionSetAccelGroup                     ,


-- ** setAccelPath #method:setAccelPath#
    ActionSetAccelPathMethodInfo            ,
    actionSetAccelPath                      ,


-- ** setAlwaysShowImage #method:setAlwaysShowImage#
    ActionSetAlwaysShowImageMethodInfo      ,
    actionSetAlwaysShowImage                ,


-- ** setGicon #method:setGicon#
    ActionSetGiconMethodInfo                ,
    actionSetGicon                          ,


-- ** setIconName #method:setIconName#
    ActionSetIconNameMethodInfo             ,
    actionSetIconName                       ,


-- ** setIsImportant #method:setIsImportant#
    ActionSetIsImportantMethodInfo          ,
    actionSetIsImportant                    ,


-- ** setLabel #method:setLabel#
    ActionSetLabelMethodInfo                ,
    actionSetLabel                          ,


-- ** setSensitive #method:setSensitive#
    ActionSetSensitiveMethodInfo            ,
    actionSetSensitive                      ,


-- ** setShortLabel #method:setShortLabel#
    ActionSetShortLabelMethodInfo           ,
    actionSetShortLabel                     ,


-- ** setStockId #method:setStockId#
    ActionSetStockIdMethodInfo              ,
    actionSetStockId                        ,


-- ** setTooltip #method:setTooltip#
    ActionSetTooltipMethodInfo              ,
    actionSetTooltip                        ,


-- ** setVisible #method:setVisible#
    ActionSetVisibleMethodInfo              ,
    actionSetVisible                        ,


-- ** setVisibleHorizontal #method:setVisibleHorizontal#
    ActionSetVisibleHorizontalMethodInfo    ,
    actionSetVisibleHorizontal              ,


-- ** setVisibleVertical #method:setVisibleVertical#
    ActionSetVisibleVerticalMethodInfo      ,
    actionSetVisibleVertical                ,


-- ** unblockActivate #method:unblockActivate#
    ActionUnblockActivateMethodInfo         ,
    actionUnblockActivate                   ,




 -- * Properties
-- ** actionGroup #attr:actionGroup#
    ActionActionGroupPropertyInfo           ,
    actionActionGroup                       ,
    clearActionActionGroup                  ,
    constructActionActionGroup              ,
    getActionActionGroup                    ,
    setActionActionGroup                    ,


-- ** alwaysShowImage #attr:alwaysShowImage#
    ActionAlwaysShowImagePropertyInfo       ,
    actionAlwaysShowImage                   ,
    constructActionAlwaysShowImage          ,
    getActionAlwaysShowImage                ,
    setActionAlwaysShowImage                ,


-- ** gicon #attr:gicon#
    ActionGiconPropertyInfo                 ,
    actionGicon                             ,
    constructActionGicon                    ,
    getActionGicon                          ,
    setActionGicon                          ,


-- ** hideIfEmpty #attr:hideIfEmpty#
    ActionHideIfEmptyPropertyInfo           ,
    actionHideIfEmpty                       ,
    constructActionHideIfEmpty              ,
    getActionHideIfEmpty                    ,
    setActionHideIfEmpty                    ,


-- ** iconName #attr:iconName#
    ActionIconNamePropertyInfo              ,
    actionIconName                          ,
    constructActionIconName                 ,
    getActionIconName                       ,
    setActionIconName                       ,


-- ** isImportant #attr:isImportant#
    ActionIsImportantPropertyInfo           ,
    actionIsImportant                       ,
    constructActionIsImportant              ,
    getActionIsImportant                    ,
    setActionIsImportant                    ,


-- ** label #attr:label#
    ActionLabelPropertyInfo                 ,
    actionLabel                             ,
    constructActionLabel                    ,
    getActionLabel                          ,
    setActionLabel                          ,


-- ** name #attr:name#
    ActionNamePropertyInfo                  ,
    actionName                              ,
    constructActionName                     ,
    getActionName                           ,


-- ** sensitive #attr:sensitive#
    ActionSensitivePropertyInfo             ,
    actionSensitive                         ,
    constructActionSensitive                ,
    getActionSensitive                      ,
    setActionSensitive                      ,


-- ** shortLabel #attr:shortLabel#
    ActionShortLabelPropertyInfo            ,
    actionShortLabel                        ,
    constructActionShortLabel               ,
    getActionShortLabel                     ,
    setActionShortLabel                     ,


-- ** stockId #attr:stockId#
    ActionStockIdPropertyInfo               ,
    actionStockId                           ,
    constructActionStockId                  ,
    getActionStockId                        ,
    setActionStockId                        ,


-- ** tooltip #attr:tooltip#
    ActionTooltipPropertyInfo               ,
    actionTooltip                           ,
    constructActionTooltip                  ,
    getActionTooltip                        ,
    setActionTooltip                        ,


-- ** visible #attr:visible#
    ActionVisiblePropertyInfo               ,
    actionVisible                           ,
    constructActionVisible                  ,
    getActionVisible                        ,
    setActionVisible                        ,


-- ** visibleHorizontal #attr:visibleHorizontal#
    ActionVisibleHorizontalPropertyInfo     ,
    actionVisibleHorizontal                 ,
    constructActionVisibleHorizontal        ,
    getActionVisibleHorizontal              ,
    setActionVisibleHorizontal              ,


-- ** visibleOverflown #attr:visibleOverflown#
    ActionVisibleOverflownPropertyInfo      ,
    actionVisibleOverflown                  ,
    constructActionVisibleOverflown         ,
    getActionVisibleOverflown               ,
    setActionVisibleOverflown               ,


-- ** visibleVertical #attr:visibleVertical#
    ActionVisibleVerticalPropertyInfo       ,
    actionVisibleVertical                   ,
    constructActionVisibleVertical          ,
    getActionVisibleVertical                ,
    setActionVisibleVertical                ,




 -- * Signals
-- ** activate #signal:activate#
    ActionActivateCallback                  ,
    ActionActivateSignalInfo                ,
    C_ActionActivateCallback                ,
    afterActionActivate                     ,
    genClosure_ActionActivate               ,
    mk_ActionActivateCallback               ,
    noActionActivateCallback                ,
    onActionActivate                        ,
    wrap_ActionActivateCallback             ,




    ) 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.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
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 GI.GObject.Objects.Object as GObject.Object
import qualified GI.Gio.Interfaces.Icon as Gio.Icon
import {-# SOURCE #-} qualified GI.Gtk.Interfaces.Buildable as Gtk.Buildable
import {-# SOURCE #-} qualified GI.Gtk.Objects.AccelGroup as Gtk.AccelGroup
import {-# SOURCE #-} qualified GI.Gtk.Objects.ActionGroup as Gtk.ActionGroup
import {-# SOURCE #-} qualified GI.Gtk.Objects.Widget as Gtk.Widget

newtype Action = Action (ManagedPtr Action)
foreign import ccall "gtk_action_get_type"
    c_gtk_action_get_type :: IO GType

instance GObject Action where
    gobjectType _ = c_gtk_action_get_type
    

class GObject o => IsAction o
#if MIN_VERSION_base(4,9,0)
instance {-# OVERLAPPABLE #-} (GObject a, O.UnknownAncestorError Action a) =>
    IsAction a
#endif
instance IsAction Action
instance GObject.Object.IsObject Action
instance Gtk.Buildable.IsBuildable Action

toAction :: IsAction o => o -> IO Action
toAction = unsafeCastTo Action

noAction :: Maybe Action
noAction = Nothing

type family ResolveActionMethod (t :: Symbol) (o :: *) :: * where
    ResolveActionMethod "activate" o = ActionActivateMethodInfo
    ResolveActionMethod "addChild" o = Gtk.Buildable.BuildableAddChildMethodInfo
    ResolveActionMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveActionMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveActionMethod "blockActivate" o = ActionBlockActivateMethodInfo
    ResolveActionMethod "connectAccelerator" o = ActionConnectAcceleratorMethodInfo
    ResolveActionMethod "constructChild" o = Gtk.Buildable.BuildableConstructChildMethodInfo
    ResolveActionMethod "createIcon" o = ActionCreateIconMethodInfo
    ResolveActionMethod "createMenu" o = ActionCreateMenuMethodInfo
    ResolveActionMethod "createMenuItem" o = ActionCreateMenuItemMethodInfo
    ResolveActionMethod "createToolItem" o = ActionCreateToolItemMethodInfo
    ResolveActionMethod "customFinished" o = Gtk.Buildable.BuildableCustomFinishedMethodInfo
    ResolveActionMethod "customTagEnd" o = Gtk.Buildable.BuildableCustomTagEndMethodInfo
    ResolveActionMethod "customTagStart" o = Gtk.Buildable.BuildableCustomTagStartMethodInfo
    ResolveActionMethod "disconnectAccelerator" o = ActionDisconnectAcceleratorMethodInfo
    ResolveActionMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveActionMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveActionMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveActionMethod "isSensitive" o = ActionIsSensitiveMethodInfo
    ResolveActionMethod "isVisible" o = ActionIsVisibleMethodInfo
    ResolveActionMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveActionMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveActionMethod "parserFinished" o = Gtk.Buildable.BuildableParserFinishedMethodInfo
    ResolveActionMethod "ref" o = GObject.Object.ObjectRefMethodInfo
    ResolveActionMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveActionMethod "replaceData" o = GObject.Object.ObjectReplaceDataMethodInfo
    ResolveActionMethod "replaceQdata" o = GObject.Object.ObjectReplaceQdataMethodInfo
    ResolveActionMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveActionMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveActionMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveActionMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveActionMethod "unblockActivate" o = ActionUnblockActivateMethodInfo
    ResolveActionMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
    ResolveActionMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveActionMethod "getAccelClosure" o = ActionGetAccelClosureMethodInfo
    ResolveActionMethod "getAccelPath" o = ActionGetAccelPathMethodInfo
    ResolveActionMethod "getAlwaysShowImage" o = ActionGetAlwaysShowImageMethodInfo
    ResolveActionMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveActionMethod "getGicon" o = ActionGetGiconMethodInfo
    ResolveActionMethod "getIconName" o = ActionGetIconNameMethodInfo
    ResolveActionMethod "getInternalChild" o = Gtk.Buildable.BuildableGetInternalChildMethodInfo
    ResolveActionMethod "getIsImportant" o = ActionGetIsImportantMethodInfo
    ResolveActionMethod "getLabel" o = ActionGetLabelMethodInfo
    ResolveActionMethod "getName" o = ActionGetNameMethodInfo
    ResolveActionMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveActionMethod "getProxies" o = ActionGetProxiesMethodInfo
    ResolveActionMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveActionMethod "getSensitive" o = ActionGetSensitiveMethodInfo
    ResolveActionMethod "getShortLabel" o = ActionGetShortLabelMethodInfo
    ResolveActionMethod "getStockId" o = ActionGetStockIdMethodInfo
    ResolveActionMethod "getTooltip" o = ActionGetTooltipMethodInfo
    ResolveActionMethod "getVisible" o = ActionGetVisibleMethodInfo
    ResolveActionMethod "getVisibleHorizontal" o = ActionGetVisibleHorizontalMethodInfo
    ResolveActionMethod "getVisibleVertical" o = ActionGetVisibleVerticalMethodInfo
    ResolveActionMethod "setAccelGroup" o = ActionSetAccelGroupMethodInfo
    ResolveActionMethod "setAccelPath" o = ActionSetAccelPathMethodInfo
    ResolveActionMethod "setAlwaysShowImage" o = ActionSetAlwaysShowImageMethodInfo
    ResolveActionMethod "setBuildableProperty" o = Gtk.Buildable.BuildableSetBuildablePropertyMethodInfo
    ResolveActionMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveActionMethod "setGicon" o = ActionSetGiconMethodInfo
    ResolveActionMethod "setIconName" o = ActionSetIconNameMethodInfo
    ResolveActionMethod "setIsImportant" o = ActionSetIsImportantMethodInfo
    ResolveActionMethod "setLabel" o = ActionSetLabelMethodInfo
    ResolveActionMethod "setName" o = Gtk.Buildable.BuildableSetNameMethodInfo
    ResolveActionMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveActionMethod "setSensitive" o = ActionSetSensitiveMethodInfo
    ResolveActionMethod "setShortLabel" o = ActionSetShortLabelMethodInfo
    ResolveActionMethod "setStockId" o = ActionSetStockIdMethodInfo
    ResolveActionMethod "setTooltip" o = ActionSetTooltipMethodInfo
    ResolveActionMethod "setVisible" o = ActionSetVisibleMethodInfo
    ResolveActionMethod "setVisibleHorizontal" o = ActionSetVisibleHorizontalMethodInfo
    ResolveActionMethod "setVisibleVertical" o = ActionSetVisibleVerticalMethodInfo
    ResolveActionMethod l o = O.MethodResolutionFailed l o

instance (info ~ ResolveActionMethod t Action, O.MethodInfo info Action p) => O.IsLabelProxy t (Action -> p) where
    fromLabelProxy _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)

#if MIN_VERSION_base(4,9,0)
instance (info ~ ResolveActionMethod t Action, O.MethodInfo info Action p) => O.IsLabel t (Action -> p) where
    fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
#endif

-- signal Action::activate
{-# DEPRECATED ActionActivateCallback ["(Since version 3.10)","Use 'GI.Gio.Objects.SimpleAction.SimpleAction'::@/activate/@ instead"] #-}
type ActionActivateCallback =
    IO ()

noActionActivateCallback :: Maybe ActionActivateCallback
noActionActivateCallback = Nothing

type C_ActionActivateCallback =
    Ptr () ->                               -- object
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mk_ActionActivateCallback :: C_ActionActivateCallback -> IO (FunPtr C_ActionActivateCallback)

genClosure_ActionActivate :: ActionActivateCallback -> IO Closure
genClosure_ActionActivate cb = do
    let cb' = wrap_ActionActivateCallback cb
    mk_ActionActivateCallback cb' >>= newCClosure


wrap_ActionActivateCallback ::
    ActionActivateCallback ->
    Ptr () ->
    Ptr () ->
    IO ()
wrap_ActionActivateCallback _cb _ _ = do
    _cb 


onActionActivate :: (IsAction a, MonadIO m) => a -> ActionActivateCallback -> m SignalHandlerId
onActionActivate obj cb = liftIO $ do
    let cb' = wrap_ActionActivateCallback cb
    cb'' <- mk_ActionActivateCallback cb'
    connectSignalFunPtr obj "activate" cb'' SignalConnectBefore

afterActionActivate :: (IsAction a, MonadIO m) => a -> ActionActivateCallback -> m SignalHandlerId
afterActionActivate obj cb = liftIO $ do
    let cb' = wrap_ActionActivateCallback cb
    cb'' <- mk_ActionActivateCallback cb'
    connectSignalFunPtr obj "activate" cb'' SignalConnectAfter


-- VVV Prop "action-group"
   -- Type: TInterface (Name {namespace = "Gtk", name = "ActionGroup"})
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Nothing,Nothing)

getActionActionGroup :: (MonadIO m, IsAction o) => o -> m (Maybe Gtk.ActionGroup.ActionGroup)
getActionActionGroup obj = liftIO $ getObjectPropertyObject obj "action-group" Gtk.ActionGroup.ActionGroup

setActionActionGroup :: (MonadIO m, IsAction o, Gtk.ActionGroup.IsActionGroup a) => o -> a -> m ()
setActionActionGroup obj val = liftIO $ setObjectPropertyObject obj "action-group" (Just val)

constructActionActionGroup :: (IsAction o, Gtk.ActionGroup.IsActionGroup a) => a -> IO (GValueConstruct o)
constructActionActionGroup val = constructObjectPropertyObject "action-group" (Just val)

clearActionActionGroup :: (MonadIO m, IsAction o) => o -> m ()
clearActionActionGroup obj = liftIO $ setObjectPropertyObject obj "action-group" (Nothing :: Maybe Gtk.ActionGroup.ActionGroup)

data ActionActionGroupPropertyInfo
instance AttrInfo ActionActionGroupPropertyInfo where
    type AttrAllowedOps ActionActionGroupPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint ActionActionGroupPropertyInfo = Gtk.ActionGroup.IsActionGroup
    type AttrBaseTypeConstraint ActionActionGroupPropertyInfo = IsAction
    type AttrGetType ActionActionGroupPropertyInfo = (Maybe Gtk.ActionGroup.ActionGroup)
    type AttrLabel ActionActionGroupPropertyInfo = "action-group"
    type AttrOrigin ActionActionGroupPropertyInfo = Action
    attrGet _ = getActionActionGroup
    attrSet _ = setActionActionGroup
    attrConstruct _ = constructActionActionGroup
    attrClear _ = clearActionActionGroup

-- VVV Prop "always-show-image"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct]
   -- Nullable: (Just False,Just False)

getActionAlwaysShowImage :: (MonadIO m, IsAction o) => o -> m Bool
getActionAlwaysShowImage obj = liftIO $ getObjectPropertyBool obj "always-show-image"

setActionAlwaysShowImage :: (MonadIO m, IsAction o) => o -> Bool -> m ()
setActionAlwaysShowImage obj val = liftIO $ setObjectPropertyBool obj "always-show-image" val

constructActionAlwaysShowImage :: (IsAction o) => Bool -> IO (GValueConstruct o)
constructActionAlwaysShowImage val = constructObjectPropertyBool "always-show-image" val

data ActionAlwaysShowImagePropertyInfo
instance AttrInfo ActionAlwaysShowImagePropertyInfo where
    type AttrAllowedOps ActionAlwaysShowImagePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint ActionAlwaysShowImagePropertyInfo = (~) Bool
    type AttrBaseTypeConstraint ActionAlwaysShowImagePropertyInfo = IsAction
    type AttrGetType ActionAlwaysShowImagePropertyInfo = Bool
    type AttrLabel ActionAlwaysShowImagePropertyInfo = "always-show-image"
    type AttrOrigin ActionAlwaysShowImagePropertyInfo = Action
    attrGet _ = getActionAlwaysShowImage
    attrSet _ = setActionAlwaysShowImage
    attrConstruct _ = constructActionAlwaysShowImage
    attrClear _ = undefined

-- VVV Prop "gicon"
   -- Type: TInterface (Name {namespace = "Gio", name = "Icon"})
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

getActionGicon :: (MonadIO m, IsAction o) => o -> m Gio.Icon.Icon
getActionGicon obj = liftIO $ checkUnexpectedNothing "getActionGicon" $ getObjectPropertyObject obj "gicon" Gio.Icon.Icon

setActionGicon :: (MonadIO m, IsAction o, Gio.Icon.IsIcon a) => o -> a -> m ()
setActionGicon obj val = liftIO $ setObjectPropertyObject obj "gicon" (Just val)

constructActionGicon :: (IsAction o, Gio.Icon.IsIcon a) => a -> IO (GValueConstruct o)
constructActionGicon val = constructObjectPropertyObject "gicon" (Just val)

data ActionGiconPropertyInfo
instance AttrInfo ActionGiconPropertyInfo where
    type AttrAllowedOps ActionGiconPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint ActionGiconPropertyInfo = Gio.Icon.IsIcon
    type AttrBaseTypeConstraint ActionGiconPropertyInfo = IsAction
    type AttrGetType ActionGiconPropertyInfo = Gio.Icon.Icon
    type AttrLabel ActionGiconPropertyInfo = "gicon"
    type AttrOrigin ActionGiconPropertyInfo = Action
    attrGet _ = getActionGicon
    attrSet _ = setActionGicon
    attrConstruct _ = constructActionGicon
    attrClear _ = undefined

-- VVV Prop "hide-if-empty"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Nothing,Nothing)

getActionHideIfEmpty :: (MonadIO m, IsAction o) => o -> m Bool
getActionHideIfEmpty obj = liftIO $ getObjectPropertyBool obj "hide-if-empty"

setActionHideIfEmpty :: (MonadIO m, IsAction o) => o -> Bool -> m ()
setActionHideIfEmpty obj val = liftIO $ setObjectPropertyBool obj "hide-if-empty" val

constructActionHideIfEmpty :: (IsAction o) => Bool -> IO (GValueConstruct o)
constructActionHideIfEmpty val = constructObjectPropertyBool "hide-if-empty" val

data ActionHideIfEmptyPropertyInfo
instance AttrInfo ActionHideIfEmptyPropertyInfo where
    type AttrAllowedOps ActionHideIfEmptyPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint ActionHideIfEmptyPropertyInfo = (~) Bool
    type AttrBaseTypeConstraint ActionHideIfEmptyPropertyInfo = IsAction
    type AttrGetType ActionHideIfEmptyPropertyInfo = Bool
    type AttrLabel ActionHideIfEmptyPropertyInfo = "hide-if-empty"
    type AttrOrigin ActionHideIfEmptyPropertyInfo = Action
    attrGet _ = getActionHideIfEmpty
    attrSet _ = setActionHideIfEmpty
    attrConstruct _ = constructActionHideIfEmpty
    attrClear _ = undefined

-- VVV Prop "icon-name"
   -- Type: TBasicType TUTF8
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

getActionIconName :: (MonadIO m, IsAction o) => o -> m T.Text
getActionIconName obj = liftIO $ checkUnexpectedNothing "getActionIconName" $ getObjectPropertyString obj "icon-name"

setActionIconName :: (MonadIO m, IsAction o) => o -> T.Text -> m ()
setActionIconName obj val = liftIO $ setObjectPropertyString obj "icon-name" (Just val)

constructActionIconName :: (IsAction o) => T.Text -> IO (GValueConstruct o)
constructActionIconName val = constructObjectPropertyString "icon-name" (Just val)

data ActionIconNamePropertyInfo
instance AttrInfo ActionIconNamePropertyInfo where
    type AttrAllowedOps ActionIconNamePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint ActionIconNamePropertyInfo = (~) T.Text
    type AttrBaseTypeConstraint ActionIconNamePropertyInfo = IsAction
    type AttrGetType ActionIconNamePropertyInfo = T.Text
    type AttrLabel ActionIconNamePropertyInfo = "icon-name"
    type AttrOrigin ActionIconNamePropertyInfo = Action
    attrGet _ = getActionIconName
    attrSet _ = setActionIconName
    attrConstruct _ = constructActionIconName
    attrClear _ = undefined

-- VVV Prop "is-important"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

getActionIsImportant :: (MonadIO m, IsAction o) => o -> m Bool
getActionIsImportant obj = liftIO $ getObjectPropertyBool obj "is-important"

setActionIsImportant :: (MonadIO m, IsAction o) => o -> Bool -> m ()
setActionIsImportant obj val = liftIO $ setObjectPropertyBool obj "is-important" val

constructActionIsImportant :: (IsAction o) => Bool -> IO (GValueConstruct o)
constructActionIsImportant val = constructObjectPropertyBool "is-important" val

data ActionIsImportantPropertyInfo
instance AttrInfo ActionIsImportantPropertyInfo where
    type AttrAllowedOps ActionIsImportantPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint ActionIsImportantPropertyInfo = (~) Bool
    type AttrBaseTypeConstraint ActionIsImportantPropertyInfo = IsAction
    type AttrGetType ActionIsImportantPropertyInfo = Bool
    type AttrLabel ActionIsImportantPropertyInfo = "is-important"
    type AttrOrigin ActionIsImportantPropertyInfo = Action
    attrGet _ = getActionIsImportant
    attrSet _ = setActionIsImportant
    attrConstruct _ = constructActionIsImportant
    attrClear _ = undefined

-- VVV Prop "label"
   -- Type: TBasicType TUTF8
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

getActionLabel :: (MonadIO m, IsAction o) => o -> m T.Text
getActionLabel obj = liftIO $ checkUnexpectedNothing "getActionLabel" $ getObjectPropertyString obj "label"

setActionLabel :: (MonadIO m, IsAction o) => o -> T.Text -> m ()
setActionLabel obj val = liftIO $ setObjectPropertyString obj "label" (Just val)

constructActionLabel :: (IsAction o) => T.Text -> IO (GValueConstruct o)
constructActionLabel val = constructObjectPropertyString "label" (Just val)

data ActionLabelPropertyInfo
instance AttrInfo ActionLabelPropertyInfo where
    type AttrAllowedOps ActionLabelPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint ActionLabelPropertyInfo = (~) T.Text
    type AttrBaseTypeConstraint ActionLabelPropertyInfo = IsAction
    type AttrGetType ActionLabelPropertyInfo = T.Text
    type AttrLabel ActionLabelPropertyInfo = "label"
    type AttrOrigin ActionLabelPropertyInfo = Action
    attrGet _ = getActionLabel
    attrSet _ = setActionLabel
    attrConstruct _ = constructActionLabel
    attrClear _ = undefined

-- VVV Prop "name"
   -- Type: TBasicType TUTF8
   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]
   -- Nullable: (Just False,Nothing)

getActionName :: (MonadIO m, IsAction o) => o -> m T.Text
getActionName obj = liftIO $ checkUnexpectedNothing "getActionName" $ getObjectPropertyString obj "name"

constructActionName :: (IsAction o) => T.Text -> IO (GValueConstruct o)
constructActionName val = constructObjectPropertyString "name" (Just val)

data ActionNamePropertyInfo
instance AttrInfo ActionNamePropertyInfo where
    type AttrAllowedOps ActionNamePropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint ActionNamePropertyInfo = (~) T.Text
    type AttrBaseTypeConstraint ActionNamePropertyInfo = IsAction
    type AttrGetType ActionNamePropertyInfo = T.Text
    type AttrLabel ActionNamePropertyInfo = "name"
    type AttrOrigin ActionNamePropertyInfo = Action
    attrGet _ = getActionName
    attrSet _ = undefined
    attrConstruct _ = constructActionName
    attrClear _ = undefined

-- VVV Prop "sensitive"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

getActionSensitive :: (MonadIO m, IsAction o) => o -> m Bool
getActionSensitive obj = liftIO $ getObjectPropertyBool obj "sensitive"

setActionSensitive :: (MonadIO m, IsAction o) => o -> Bool -> m ()
setActionSensitive obj val = liftIO $ setObjectPropertyBool obj "sensitive" val

constructActionSensitive :: (IsAction o) => Bool -> IO (GValueConstruct o)
constructActionSensitive val = constructObjectPropertyBool "sensitive" val

data ActionSensitivePropertyInfo
instance AttrInfo ActionSensitivePropertyInfo where
    type AttrAllowedOps ActionSensitivePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint ActionSensitivePropertyInfo = (~) Bool
    type AttrBaseTypeConstraint ActionSensitivePropertyInfo = IsAction
    type AttrGetType ActionSensitivePropertyInfo = Bool
    type AttrLabel ActionSensitivePropertyInfo = "sensitive"
    type AttrOrigin ActionSensitivePropertyInfo = Action
    attrGet _ = getActionSensitive
    attrSet _ = setActionSensitive
    attrConstruct _ = constructActionSensitive
    attrClear _ = undefined

-- VVV Prop "short-label"
   -- Type: TBasicType TUTF8
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

getActionShortLabel :: (MonadIO m, IsAction o) => o -> m T.Text
getActionShortLabel obj = liftIO $ checkUnexpectedNothing "getActionShortLabel" $ getObjectPropertyString obj "short-label"

setActionShortLabel :: (MonadIO m, IsAction o) => o -> T.Text -> m ()
setActionShortLabel obj val = liftIO $ setObjectPropertyString obj "short-label" (Just val)

constructActionShortLabel :: (IsAction o) => T.Text -> IO (GValueConstruct o)
constructActionShortLabel val = constructObjectPropertyString "short-label" (Just val)

data ActionShortLabelPropertyInfo
instance AttrInfo ActionShortLabelPropertyInfo where
    type AttrAllowedOps ActionShortLabelPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint ActionShortLabelPropertyInfo = (~) T.Text
    type AttrBaseTypeConstraint ActionShortLabelPropertyInfo = IsAction
    type AttrGetType ActionShortLabelPropertyInfo = T.Text
    type AttrLabel ActionShortLabelPropertyInfo = "short-label"
    type AttrOrigin ActionShortLabelPropertyInfo = Action
    attrGet _ = getActionShortLabel
    attrSet _ = setActionShortLabel
    attrConstruct _ = constructActionShortLabel
    attrClear _ = undefined

-- VVV Prop "stock-id"
   -- Type: TBasicType TUTF8
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

getActionStockId :: (MonadIO m, IsAction o) => o -> m T.Text
getActionStockId obj = liftIO $ checkUnexpectedNothing "getActionStockId" $ getObjectPropertyString obj "stock-id"

setActionStockId :: (MonadIO m, IsAction o) => o -> T.Text -> m ()
setActionStockId obj val = liftIO $ setObjectPropertyString obj "stock-id" (Just val)

constructActionStockId :: (IsAction o) => T.Text -> IO (GValueConstruct o)
constructActionStockId val = constructObjectPropertyString "stock-id" (Just val)

data ActionStockIdPropertyInfo
instance AttrInfo ActionStockIdPropertyInfo where
    type AttrAllowedOps ActionStockIdPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint ActionStockIdPropertyInfo = (~) T.Text
    type AttrBaseTypeConstraint ActionStockIdPropertyInfo = IsAction
    type AttrGetType ActionStockIdPropertyInfo = T.Text
    type AttrLabel ActionStockIdPropertyInfo = "stock-id"
    type AttrOrigin ActionStockIdPropertyInfo = Action
    attrGet _ = getActionStockId
    attrSet _ = setActionStockId
    attrConstruct _ = constructActionStockId
    attrClear _ = undefined

-- VVV Prop "tooltip"
   -- Type: TBasicType TUTF8
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

getActionTooltip :: (MonadIO m, IsAction o) => o -> m T.Text
getActionTooltip obj = liftIO $ checkUnexpectedNothing "getActionTooltip" $ getObjectPropertyString obj "tooltip"

setActionTooltip :: (MonadIO m, IsAction o) => o -> T.Text -> m ()
setActionTooltip obj val = liftIO $ setObjectPropertyString obj "tooltip" (Just val)

constructActionTooltip :: (IsAction o) => T.Text -> IO (GValueConstruct o)
constructActionTooltip val = constructObjectPropertyString "tooltip" (Just val)

data ActionTooltipPropertyInfo
instance AttrInfo ActionTooltipPropertyInfo where
    type AttrAllowedOps ActionTooltipPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint ActionTooltipPropertyInfo = (~) T.Text
    type AttrBaseTypeConstraint ActionTooltipPropertyInfo = IsAction
    type AttrGetType ActionTooltipPropertyInfo = T.Text
    type AttrLabel ActionTooltipPropertyInfo = "tooltip"
    type AttrOrigin ActionTooltipPropertyInfo = Action
    attrGet _ = getActionTooltip
    attrSet _ = setActionTooltip
    attrConstruct _ = constructActionTooltip
    attrClear _ = undefined

-- VVV Prop "visible"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

getActionVisible :: (MonadIO m, IsAction o) => o -> m Bool
getActionVisible obj = liftIO $ getObjectPropertyBool obj "visible"

setActionVisible :: (MonadIO m, IsAction o) => o -> Bool -> m ()
setActionVisible obj val = liftIO $ setObjectPropertyBool obj "visible" val

constructActionVisible :: (IsAction o) => Bool -> IO (GValueConstruct o)
constructActionVisible val = constructObjectPropertyBool "visible" val

data ActionVisiblePropertyInfo
instance AttrInfo ActionVisiblePropertyInfo where
    type AttrAllowedOps ActionVisiblePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint ActionVisiblePropertyInfo = (~) Bool
    type AttrBaseTypeConstraint ActionVisiblePropertyInfo = IsAction
    type AttrGetType ActionVisiblePropertyInfo = Bool
    type AttrLabel ActionVisiblePropertyInfo = "visible"
    type AttrOrigin ActionVisiblePropertyInfo = Action
    attrGet _ = getActionVisible
    attrSet _ = setActionVisible
    attrConstruct _ = constructActionVisible
    attrClear _ = undefined

-- VVV Prop "visible-horizontal"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

getActionVisibleHorizontal :: (MonadIO m, IsAction o) => o -> m Bool
getActionVisibleHorizontal obj = liftIO $ getObjectPropertyBool obj "visible-horizontal"

setActionVisibleHorizontal :: (MonadIO m, IsAction o) => o -> Bool -> m ()
setActionVisibleHorizontal obj val = liftIO $ setObjectPropertyBool obj "visible-horizontal" val

constructActionVisibleHorizontal :: (IsAction o) => Bool -> IO (GValueConstruct o)
constructActionVisibleHorizontal val = constructObjectPropertyBool "visible-horizontal" val

data ActionVisibleHorizontalPropertyInfo
instance AttrInfo ActionVisibleHorizontalPropertyInfo where
    type AttrAllowedOps ActionVisibleHorizontalPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint ActionVisibleHorizontalPropertyInfo = (~) Bool
    type AttrBaseTypeConstraint ActionVisibleHorizontalPropertyInfo = IsAction
    type AttrGetType ActionVisibleHorizontalPropertyInfo = Bool
    type AttrLabel ActionVisibleHorizontalPropertyInfo = "visible-horizontal"
    type AttrOrigin ActionVisibleHorizontalPropertyInfo = Action
    attrGet _ = getActionVisibleHorizontal
    attrSet _ = setActionVisibleHorizontal
    attrConstruct _ = constructActionVisibleHorizontal
    attrClear _ = undefined

-- VVV Prop "visible-overflown"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Nothing,Nothing)

getActionVisibleOverflown :: (MonadIO m, IsAction o) => o -> m Bool
getActionVisibleOverflown obj = liftIO $ getObjectPropertyBool obj "visible-overflown"

setActionVisibleOverflown :: (MonadIO m, IsAction o) => o -> Bool -> m ()
setActionVisibleOverflown obj val = liftIO $ setObjectPropertyBool obj "visible-overflown" val

constructActionVisibleOverflown :: (IsAction o) => Bool -> IO (GValueConstruct o)
constructActionVisibleOverflown val = constructObjectPropertyBool "visible-overflown" val

data ActionVisibleOverflownPropertyInfo
instance AttrInfo ActionVisibleOverflownPropertyInfo where
    type AttrAllowedOps ActionVisibleOverflownPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint ActionVisibleOverflownPropertyInfo = (~) Bool
    type AttrBaseTypeConstraint ActionVisibleOverflownPropertyInfo = IsAction
    type AttrGetType ActionVisibleOverflownPropertyInfo = Bool
    type AttrLabel ActionVisibleOverflownPropertyInfo = "visible-overflown"
    type AttrOrigin ActionVisibleOverflownPropertyInfo = Action
    attrGet _ = getActionVisibleOverflown
    attrSet _ = setActionVisibleOverflown
    attrConstruct _ = constructActionVisibleOverflown
    attrClear _ = undefined

-- VVV Prop "visible-vertical"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

getActionVisibleVertical :: (MonadIO m, IsAction o) => o -> m Bool
getActionVisibleVertical obj = liftIO $ getObjectPropertyBool obj "visible-vertical"

setActionVisibleVertical :: (MonadIO m, IsAction o) => o -> Bool -> m ()
setActionVisibleVertical obj val = liftIO $ setObjectPropertyBool obj "visible-vertical" val

constructActionVisibleVertical :: (IsAction o) => Bool -> IO (GValueConstruct o)
constructActionVisibleVertical val = constructObjectPropertyBool "visible-vertical" val

data ActionVisibleVerticalPropertyInfo
instance AttrInfo ActionVisibleVerticalPropertyInfo where
    type AttrAllowedOps ActionVisibleVerticalPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint ActionVisibleVerticalPropertyInfo = (~) Bool
    type AttrBaseTypeConstraint ActionVisibleVerticalPropertyInfo = IsAction
    type AttrGetType ActionVisibleVerticalPropertyInfo = Bool
    type AttrLabel ActionVisibleVerticalPropertyInfo = "visible-vertical"
    type AttrOrigin ActionVisibleVerticalPropertyInfo = Action
    attrGet _ = getActionVisibleVertical
    attrSet _ = setActionVisibleVertical
    attrConstruct _ = constructActionVisibleVertical
    attrClear _ = undefined

instance O.HasAttributeList Action
type instance O.AttributeList Action = ActionAttributeList
type ActionAttributeList = ('[ '("actionGroup", ActionActionGroupPropertyInfo), '("alwaysShowImage", ActionAlwaysShowImagePropertyInfo), '("gicon", ActionGiconPropertyInfo), '("hideIfEmpty", ActionHideIfEmptyPropertyInfo), '("iconName", ActionIconNamePropertyInfo), '("isImportant", ActionIsImportantPropertyInfo), '("label", ActionLabelPropertyInfo), '("name", ActionNamePropertyInfo), '("sensitive", ActionSensitivePropertyInfo), '("shortLabel", ActionShortLabelPropertyInfo), '("stockId", ActionStockIdPropertyInfo), '("tooltip", ActionTooltipPropertyInfo), '("visible", ActionVisiblePropertyInfo), '("visibleHorizontal", ActionVisibleHorizontalPropertyInfo), '("visibleOverflown", ActionVisibleOverflownPropertyInfo), '("visibleVertical", ActionVisibleVerticalPropertyInfo)] :: [(Symbol, *)])

actionActionGroup :: AttrLabelProxy "actionGroup"
actionActionGroup = AttrLabelProxy

actionAlwaysShowImage :: AttrLabelProxy "alwaysShowImage"
actionAlwaysShowImage = AttrLabelProxy

actionGicon :: AttrLabelProxy "gicon"
actionGicon = AttrLabelProxy

actionHideIfEmpty :: AttrLabelProxy "hideIfEmpty"
actionHideIfEmpty = AttrLabelProxy

actionIconName :: AttrLabelProxy "iconName"
actionIconName = AttrLabelProxy

actionIsImportant :: AttrLabelProxy "isImportant"
actionIsImportant = AttrLabelProxy

actionLabel :: AttrLabelProxy "label"
actionLabel = AttrLabelProxy

actionName :: AttrLabelProxy "name"
actionName = AttrLabelProxy

actionSensitive :: AttrLabelProxy "sensitive"
actionSensitive = AttrLabelProxy

actionShortLabel :: AttrLabelProxy "shortLabel"
actionShortLabel = AttrLabelProxy

actionStockId :: AttrLabelProxy "stockId"
actionStockId = AttrLabelProxy

actionTooltip :: AttrLabelProxy "tooltip"
actionTooltip = AttrLabelProxy

actionVisible :: AttrLabelProxy "visible"
actionVisible = AttrLabelProxy

actionVisibleHorizontal :: AttrLabelProxy "visibleHorizontal"
actionVisibleHorizontal = AttrLabelProxy

actionVisibleOverflown :: AttrLabelProxy "visibleOverflown"
actionVisibleOverflown = AttrLabelProxy

actionVisibleVertical :: AttrLabelProxy "visibleVertical"
actionVisibleVertical = AttrLabelProxy

data ActionActivateSignalInfo
instance SignalInfo ActionActivateSignalInfo where
    type HaskellCallbackType ActionActivateSignalInfo = ActionActivateCallback
    connectSignal _ obj cb connectMode = do
        let cb' = wrap_ActionActivateCallback cb
        cb'' <- mk_ActionActivateCallback cb'
        connectSignalFunPtr obj "activate" cb'' connectMode

type instance O.SignalList Action = ActionSignalList
type ActionSignalList = ('[ '("activate", ActionActivateSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)])

-- method Action::new
-- method type : Constructor
-- Args : [Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A unique name for the action", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "label", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the label displayed in menu items and on buttons,\n        or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "tooltip", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a tooltip for the action, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "stock_id", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the stock icon to display in widgets representing\n           the action, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gtk", name = "Action"}))
-- throws : False
-- Skip return : False

foreign import ccall "gtk_action_new" gtk_action_new :: 
    CString ->                              -- name : TBasicType TUTF8
    CString ->                              -- label : TBasicType TUTF8
    CString ->                              -- tooltip : TBasicType TUTF8
    CString ->                              -- stock_id : TBasicType TUTF8
    IO (Ptr Action)

{-# DEPRECATED actionNew ["(Since version 3.10)","Use 'GI.Gio.Interfaces.Action.Action' instead, associating it to a widget with","'GI.Gtk.Interfaces.Actionable.Actionable' or creating a 'GI.Gtk.Objects.Menu.Menu' with 'GI.Gtk.Objects.Menu.menuNewFromModel'"] #-}
{- |
Creates a new 'GI.Gtk.Objects.Action.Action' object. To add the action to a
'GI.Gtk.Objects.ActionGroup.ActionGroup' and set the accelerator for the action,
call 'GI.Gtk.Objects.ActionGroup.actionGroupAddActionWithAccel'.
See the [UI Definition section][XML-UI] for information on allowed action
names.

@since 2.4
-}
actionNew ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    T.Text
    {- ^ /@name@/: A unique name for the action -}
    -> Maybe (T.Text)
    {- ^ /@label@/: the label displayed in menu items and on buttons,
        or 'Nothing' -}
    -> Maybe (T.Text)
    {- ^ /@tooltip@/: a tooltip for the action, or 'Nothing' -}
    -> Maybe (T.Text)
    {- ^ /@stockId@/: the stock icon to display in widgets representing
           the action, or 'Nothing' -}
    -> m Action
    {- ^ __Returns:__ a new 'GI.Gtk.Objects.Action.Action' -}
actionNew name label tooltip stockId = liftIO $ do
    name' <- textToCString name
    maybeLabel <- case label of
        Nothing -> return nullPtr
        Just jLabel -> do
            jLabel' <- textToCString jLabel
            return jLabel'
    maybeTooltip <- case tooltip of
        Nothing -> return nullPtr
        Just jTooltip -> do
            jTooltip' <- textToCString jTooltip
            return jTooltip'
    maybeStockId <- case stockId of
        Nothing -> return nullPtr
        Just jStockId -> do
            jStockId' <- textToCString jStockId
            return jStockId'
    result <- gtk_action_new name' maybeLabel maybeTooltip maybeStockId
    checkUnexpectedReturnNULL "actionNew" result
    result' <- (wrapObject Action) result
    freeMem name'
    freeMem maybeLabel
    freeMem maybeTooltip
    freeMem maybeStockId
    return result'

-- method Action::activate
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "action", argType = TInterface (Name {namespace = "Gtk", name = "Action"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the action object", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_action_activate" gtk_action_activate :: 
    Ptr Action ->                           -- action : TInterface (Name {namespace = "Gtk", name = "Action"})
    IO ()

{-# DEPRECATED actionActivate ["(Since version 3.10)","Use 'GI.Gio.Interfaces.ActionGroup.actionGroupActivateAction' on a 'GI.Gio.Interfaces.Action.Action' instead"] #-}
{- |
Emits the “activate” signal on the specified action, if it isn\'t
insensitive. This gets called by the proxy widgets when they get
activated.

It can also be used to manually activate an action.

@since 2.4
-}
actionActivate ::
    (B.CallStack.HasCallStack, MonadIO m, IsAction a) =>
    a
    {- ^ /@action@/: the action object -}
    -> m ()
actionActivate action = liftIO $ do
    action' <- unsafeManagedPtrCastPtr action
    gtk_action_activate action'
    touchManagedPtr action
    return ()

data ActionActivateMethodInfo
instance (signature ~ (m ()), MonadIO m, IsAction a) => O.MethodInfo ActionActivateMethodInfo a signature where
    overloadedMethod _ = actionActivate

-- method Action::block_activate
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "action", argType = TInterface (Name {namespace = "Gtk", name = "Action"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkAction", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_action_block_activate" gtk_action_block_activate :: 
    Ptr Action ->                           -- action : TInterface (Name {namespace = "Gtk", name = "Action"})
    IO ()

{-# DEPRECATED actionBlockActivate ["(Since version 3.10)","Use 'GI.Gio.Objects.SimpleAction.simpleActionSetEnabled' to disable the","'GI.Gio.Objects.SimpleAction.SimpleAction' instead"] #-}
{- |
Disable activation signals from the action

This is needed when updating the state of your proxy
'GI.Gtk.Interfaces.Activatable.Activatable' widget could result in calling 'GI.Gtk.Objects.Action.actionActivate',
this is a convenience function to avoid recursing in those
cases (updating toggle state for instance).

@since 2.16
-}
actionBlockActivate ::
    (B.CallStack.HasCallStack, MonadIO m, IsAction a) =>
    a
    {- ^ /@action@/: a 'GI.Gtk.Objects.Action.Action' -}
    -> m ()
actionBlockActivate action = liftIO $ do
    action' <- unsafeManagedPtrCastPtr action
    gtk_action_block_activate action'
    touchManagedPtr action
    return ()

data ActionBlockActivateMethodInfo
instance (signature ~ (m ()), MonadIO m, IsAction a) => O.MethodInfo ActionBlockActivateMethodInfo a signature where
    overloadedMethod _ = actionBlockActivate

-- method Action::connect_accelerator
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "action", argType = TInterface (Name {namespace = "Gtk", name = "Action"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkAction", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_action_connect_accelerator" gtk_action_connect_accelerator :: 
    Ptr Action ->                           -- action : TInterface (Name {namespace = "Gtk", name = "Action"})
    IO ()

{-# DEPRECATED actionConnectAccelerator ["(Since version 3.10)","Use 'GI.Gio.Interfaces.Action.Action' and the accelerator group on an associated","'GI.Gtk.Objects.Menu.Menu' instead"] #-}
{- |
Installs the accelerator for /@action@/ if /@action@/ has an
accel path and group. See 'GI.Gtk.Objects.Action.actionSetAccelPath' and
'GI.Gtk.Objects.Action.actionSetAccelGroup'

Since multiple proxies may independently trigger the installation
of the accelerator, the /@action@/ counts the number of times this
function has been called and doesn’t remove the accelerator until
'GI.Gtk.Objects.Action.actionDisconnectAccelerator' has been called as many times.

@since 2.4
-}
actionConnectAccelerator ::
    (B.CallStack.HasCallStack, MonadIO m, IsAction a) =>
    a
    {- ^ /@action@/: a 'GI.Gtk.Objects.Action.Action' -}
    -> m ()
actionConnectAccelerator action = liftIO $ do
    action' <- unsafeManagedPtrCastPtr action
    gtk_action_connect_accelerator action'
    touchManagedPtr action
    return ()

data ActionConnectAcceleratorMethodInfo
instance (signature ~ (m ()), MonadIO m, IsAction a) => O.MethodInfo ActionConnectAcceleratorMethodInfo a signature where
    overloadedMethod _ = actionConnectAccelerator

-- method Action::create_icon
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "action", argType = TInterface (Name {namespace = "Gtk", name = "Action"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the action object", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "icon_size", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the size of the icon (#GtkIconSize) that should\n     be created.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gtk", name = "Widget"}))
-- throws : False
-- Skip return : False

foreign import ccall "gtk_action_create_icon" gtk_action_create_icon :: 
    Ptr Action ->                           -- action : TInterface (Name {namespace = "Gtk", name = "Action"})
    Int32 ->                                -- icon_size : TBasicType TInt
    IO (Ptr Gtk.Widget.Widget)

{-# DEPRECATED actionCreateIcon ["(Since version 3.10)","Use 'GI.Gio.Objects.MenuItem.menuItemSetIcon' to set an icon on a 'GI.Gio.Objects.MenuItem.MenuItem',","or 'GI.Gtk.Objects.Container.containerAdd' to add a 'GI.Gtk.Objects.Image.Image' to a 'GI.Gtk.Objects.Button.Button'"] #-}
{- |
This function is intended for use by action implementations to
create icons displayed in the proxy widgets.

@since 2.4
-}
actionCreateIcon ::
    (B.CallStack.HasCallStack, MonadIO m, IsAction a) =>
    a
    {- ^ /@action@/: the action object -}
    -> Int32
    {- ^ /@iconSize@/: the size of the icon ('GI.Gtk.Enums.IconSize') that should
     be created. -}
    -> m Gtk.Widget.Widget
    {- ^ __Returns:__ a widget that displays the icon for this action. -}
actionCreateIcon action iconSize = liftIO $ do
    action' <- unsafeManagedPtrCastPtr action
    result <- gtk_action_create_icon action' iconSize
    checkUnexpectedReturnNULL "actionCreateIcon" result
    result' <- (newObject Gtk.Widget.Widget) result
    touchManagedPtr action
    return result'

data ActionCreateIconMethodInfo
instance (signature ~ (Int32 -> m Gtk.Widget.Widget), MonadIO m, IsAction a) => O.MethodInfo ActionCreateIconMethodInfo a signature where
    overloadedMethod _ = actionCreateIcon

-- method Action::create_menu
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "action", argType = TInterface (Name {namespace = "Gtk", name = "Action"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkAction", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gtk", name = "Widget"}))
-- throws : False
-- Skip return : False

foreign import ccall "gtk_action_create_menu" gtk_action_create_menu :: 
    Ptr Action ->                           -- action : TInterface (Name {namespace = "Gtk", name = "Action"})
    IO (Ptr Gtk.Widget.Widget)

{-# DEPRECATED actionCreateMenu ["(Since version 3.10)","Use 'GI.Gio.Interfaces.Action.Action' and 'GI.Gio.Objects.MenuModel.MenuModel' instead, and create a","'GI.Gtk.Objects.Menu.Menu' with 'GI.Gtk.Objects.Menu.menuNewFromModel'"] #-}
{- |
If /@action@/ provides a 'GI.Gtk.Objects.Menu.Menu' widget as a submenu for the menu
item or the toolbar item it creates, this function returns an
instance of that menu.

@since 2.12
-}
actionCreateMenu ::
    (B.CallStack.HasCallStack, MonadIO m, IsAction a) =>
    a
    {- ^ /@action@/: a 'GI.Gtk.Objects.Action.Action' -}
    -> m Gtk.Widget.Widget
    {- ^ __Returns:__ the menu item provided by the
              action, or 'Nothing'. -}
actionCreateMenu action = liftIO $ do
    action' <- unsafeManagedPtrCastPtr action
    result <- gtk_action_create_menu action'
    checkUnexpectedReturnNULL "actionCreateMenu" result
    result' <- (newObject Gtk.Widget.Widget) result
    touchManagedPtr action
    return result'

data ActionCreateMenuMethodInfo
instance (signature ~ (m Gtk.Widget.Widget), MonadIO m, IsAction a) => O.MethodInfo ActionCreateMenuMethodInfo a signature where
    overloadedMethod _ = actionCreateMenu

-- method Action::create_menu_item
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "action", argType = TInterface (Name {namespace = "Gtk", name = "Action"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the action object", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gtk", name = "Widget"}))
-- throws : False
-- Skip return : False

foreign import ccall "gtk_action_create_menu_item" gtk_action_create_menu_item :: 
    Ptr Action ->                           -- action : TInterface (Name {namespace = "Gtk", name = "Action"})
    IO (Ptr Gtk.Widget.Widget)

{-# DEPRECATED actionCreateMenuItem ["(Since version 3.10)","Use 'GI.Gio.Objects.MenuItem.menuItemNew' and associate it with a 'GI.Gio.Interfaces.Action.Action'","instead."] #-}
{- |
Creates a menu item widget that proxies for the given action.

@since 2.4
-}
actionCreateMenuItem ::
    (B.CallStack.HasCallStack, MonadIO m, IsAction a) =>
    a
    {- ^ /@action@/: the action object -}
    -> m Gtk.Widget.Widget
    {- ^ __Returns:__ a menu item connected to the action. -}
actionCreateMenuItem action = liftIO $ do
    action' <- unsafeManagedPtrCastPtr action
    result <- gtk_action_create_menu_item action'
    checkUnexpectedReturnNULL "actionCreateMenuItem" result
    result' <- (newObject Gtk.Widget.Widget) result
    touchManagedPtr action
    return result'

data ActionCreateMenuItemMethodInfo
instance (signature ~ (m Gtk.Widget.Widget), MonadIO m, IsAction a) => O.MethodInfo ActionCreateMenuItemMethodInfo a signature where
    overloadedMethod _ = actionCreateMenuItem

-- method Action::create_tool_item
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "action", argType = TInterface (Name {namespace = "Gtk", name = "Action"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the action object", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gtk", name = "Widget"}))
-- throws : False
-- Skip return : False

foreign import ccall "gtk_action_create_tool_item" gtk_action_create_tool_item :: 
    Ptr Action ->                           -- action : TInterface (Name {namespace = "Gtk", name = "Action"})
    IO (Ptr Gtk.Widget.Widget)

{-# DEPRECATED actionCreateToolItem ["(Since version 3.10)","Use a 'GI.Gtk.Objects.ToolItem.ToolItem' and associate it with a 'GI.Gio.Interfaces.Action.Action' using","'GI.Gtk.Interfaces.Actionable.actionableSetActionName' instead"] #-}
{- |
Creates a toolbar item widget that proxies for the given action.

@since 2.4
-}
actionCreateToolItem ::
    (B.CallStack.HasCallStack, MonadIO m, IsAction a) =>
    a
    {- ^ /@action@/: the action object -}
    -> m Gtk.Widget.Widget
    {- ^ __Returns:__ a toolbar item connected to the action. -}
actionCreateToolItem action = liftIO $ do
    action' <- unsafeManagedPtrCastPtr action
    result <- gtk_action_create_tool_item action'
    checkUnexpectedReturnNULL "actionCreateToolItem" result
    result' <- (newObject Gtk.Widget.Widget) result
    touchManagedPtr action
    return result'

data ActionCreateToolItemMethodInfo
instance (signature ~ (m Gtk.Widget.Widget), MonadIO m, IsAction a) => O.MethodInfo ActionCreateToolItemMethodInfo a signature where
    overloadedMethod _ = actionCreateToolItem

-- method Action::disconnect_accelerator
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "action", argType = TInterface (Name {namespace = "Gtk", name = "Action"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkAction", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_action_disconnect_accelerator" gtk_action_disconnect_accelerator :: 
    Ptr Action ->                           -- action : TInterface (Name {namespace = "Gtk", name = "Action"})
    IO ()

{-# DEPRECATED actionDisconnectAccelerator ["(Since version 3.10)","Use 'GI.Gio.Interfaces.Action.Action' and the accelerator group on an associated","'GI.Gtk.Objects.Menu.Menu' instead"] #-}
{- |
Undoes the effect of one call to 'GI.Gtk.Objects.Action.actionConnectAccelerator'.

@since 2.4
-}
actionDisconnectAccelerator ::
    (B.CallStack.HasCallStack, MonadIO m, IsAction a) =>
    a
    {- ^ /@action@/: a 'GI.Gtk.Objects.Action.Action' -}
    -> m ()
actionDisconnectAccelerator action = liftIO $ do
    action' <- unsafeManagedPtrCastPtr action
    gtk_action_disconnect_accelerator action'
    touchManagedPtr action
    return ()

data ActionDisconnectAcceleratorMethodInfo
instance (signature ~ (m ()), MonadIO m, IsAction a) => O.MethodInfo ActionDisconnectAcceleratorMethodInfo a signature where
    overloadedMethod _ = actionDisconnectAccelerator

-- method Action::get_accel_closure
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "action", argType = TInterface (Name {namespace = "Gtk", name = "Action"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the action object", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "GObject", name = "Closure"}))
-- throws : False
-- Skip return : False

foreign import ccall "gtk_action_get_accel_closure" gtk_action_get_accel_closure :: 
    Ptr Action ->                           -- action : TInterface (Name {namespace = "Gtk", name = "Action"})
    IO (Ptr Closure)

{-# DEPRECATED actionGetAccelClosure ["(Since version 3.10)","Use 'GI.Gio.Interfaces.Action.Action' and 'GI.Gtk.Objects.Menu.Menu' instead, which have no","equivalent for getting the accel closure"] #-}
{- |
Returns the accel closure for this action.

@since 2.8
-}
actionGetAccelClosure ::
    (B.CallStack.HasCallStack, MonadIO m, IsAction a) =>
    a
    {- ^ /@action@/: the action object -}
    -> m Closure
    {- ^ __Returns:__ the accel closure for this action. The
         returned closure is owned by GTK+ and must not be unreffed
         or modified. -}
actionGetAccelClosure action = liftIO $ do
    action' <- unsafeManagedPtrCastPtr action
    result <- gtk_action_get_accel_closure action'
    checkUnexpectedReturnNULL "actionGetAccelClosure" result
    result' <- (newBoxed Closure) result
    touchManagedPtr action
    return result'

data ActionGetAccelClosureMethodInfo
instance (signature ~ (m Closure), MonadIO m, IsAction a) => O.MethodInfo ActionGetAccelClosureMethodInfo a signature where
    overloadedMethod _ = actionGetAccelClosure

-- method Action::get_accel_path
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "action", argType = TInterface (Name {namespace = "Gtk", name = "Action"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the action object", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TUTF8)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_action_get_accel_path" gtk_action_get_accel_path :: 
    Ptr Action ->                           -- action : TInterface (Name {namespace = "Gtk", name = "Action"})
    IO CString

{-# DEPRECATED actionGetAccelPath ["(Since version 3.10)","Use 'GI.Gio.Interfaces.Action.Action' and the accelerator path on an associated","'GI.Gtk.Objects.Menu.Menu' instead"] #-}
{- |
Returns the accel path for this action.

@since 2.6
-}
actionGetAccelPath ::
    (B.CallStack.HasCallStack, MonadIO m, IsAction a) =>
    a
    {- ^ /@action@/: the action object -}
    -> m T.Text
    {- ^ __Returns:__ the accel path for this action, or 'Nothing'
  if none is set. The returned string is owned by GTK+
  and must not be freed or modified. -}
actionGetAccelPath action = liftIO $ do
    action' <- unsafeManagedPtrCastPtr action
    result <- gtk_action_get_accel_path action'
    checkUnexpectedReturnNULL "actionGetAccelPath" result
    result' <- cstringToText result
    touchManagedPtr action
    return result'

data ActionGetAccelPathMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsAction a) => O.MethodInfo ActionGetAccelPathMethodInfo a signature where
    overloadedMethod _ = actionGetAccelPath

-- method Action::get_always_show_image
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "action", argType = TInterface (Name {namespace = "Gtk", name = "Action"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkAction", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_action_get_always_show_image" gtk_action_get_always_show_image :: 
    Ptr Action ->                           -- action : TInterface (Name {namespace = "Gtk", name = "Action"})
    IO CInt

{-# DEPRECATED actionGetAlwaysShowImage ["(Since version 3.10)","Use 'GI.Gio.Objects.MenuItem.menuItemGetAttributeValue' on a 'GI.Gio.Objects.MenuItem.MenuItem'","instead"] #-}
{- |
Returns whether /@action@/\'s menu item proxies will always
show their image, if available.

@since 2.20
-}
actionGetAlwaysShowImage ::
    (B.CallStack.HasCallStack, MonadIO m, IsAction a) =>
    a
    {- ^ /@action@/: a 'GI.Gtk.Objects.Action.Action' -}
    -> m Bool
    {- ^ __Returns:__ 'True' if the menu item proxies will always show their image -}
actionGetAlwaysShowImage action = liftIO $ do
    action' <- unsafeManagedPtrCastPtr action
    result <- gtk_action_get_always_show_image action'
    let result' = (/= 0) result
    touchManagedPtr action
    return result'

data ActionGetAlwaysShowImageMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsAction a) => O.MethodInfo ActionGetAlwaysShowImageMethodInfo a signature where
    overloadedMethod _ = actionGetAlwaysShowImage

-- method Action::get_gicon
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "action", argType = TInterface (Name {namespace = "Gtk", name = "Action"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkAction", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gio", name = "Icon"}))
-- throws : False
-- Skip return : False

foreign import ccall "gtk_action_get_gicon" gtk_action_get_gicon :: 
    Ptr Action ->                           -- action : TInterface (Name {namespace = "Gtk", name = "Action"})
    IO (Ptr Gio.Icon.Icon)

{-# DEPRECATED actionGetGicon ["(Since version 3.10)","Use 'GI.Gio.Interfaces.Action.Action' instead, and","'GI.Gio.Objects.MenuItem.menuItemGetAttributeValue' to get an icon from a 'GI.Gio.Objects.MenuItem.MenuItem'","associated with a 'GI.Gio.Interfaces.Action.Action'"] #-}
{- |
Gets the gicon of /@action@/.

@since 2.16
-}
actionGetGicon ::
    (B.CallStack.HasCallStack, MonadIO m, IsAction a) =>
    a
    {- ^ /@action@/: a 'GI.Gtk.Objects.Action.Action' -}
    -> m Gio.Icon.Icon
    {- ^ __Returns:__ The action’s 'GI.Gio.Interfaces.Icon.Icon' if one is set. -}
actionGetGicon action = liftIO $ do
    action' <- unsafeManagedPtrCastPtr action
    result <- gtk_action_get_gicon action'
    checkUnexpectedReturnNULL "actionGetGicon" result
    result' <- (newObject Gio.Icon.Icon) result
    touchManagedPtr action
    return result'

data ActionGetGiconMethodInfo
instance (signature ~ (m Gio.Icon.Icon), MonadIO m, IsAction a) => O.MethodInfo ActionGetGiconMethodInfo a signature where
    overloadedMethod _ = actionGetGicon

-- method Action::get_icon_name
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "action", argType = TInterface (Name {namespace = "Gtk", name = "Action"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkAction", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TUTF8)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_action_get_icon_name" gtk_action_get_icon_name :: 
    Ptr Action ->                           -- action : TInterface (Name {namespace = "Gtk", name = "Action"})
    IO CString

{-# DEPRECATED actionGetIconName ["(Since version 3.10)","Use 'GI.Gio.Interfaces.Action.Action' instead, and","'GI.Gio.Objects.MenuItem.menuItemGetAttributeValue' to get an icon from a 'GI.Gio.Objects.MenuItem.MenuItem'","associated with a 'GI.Gio.Interfaces.Action.Action'"] #-}
{- |
Gets the icon name of /@action@/.

@since 2.16
-}
actionGetIconName ::
    (B.CallStack.HasCallStack, MonadIO m, IsAction a) =>
    a
    {- ^ /@action@/: a 'GI.Gtk.Objects.Action.Action' -}
    -> m T.Text
    {- ^ __Returns:__ the icon name -}
actionGetIconName action = liftIO $ do
    action' <- unsafeManagedPtrCastPtr action
    result <- gtk_action_get_icon_name action'
    checkUnexpectedReturnNULL "actionGetIconName" result
    result' <- cstringToText result
    touchManagedPtr action
    return result'

data ActionGetIconNameMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsAction a) => O.MethodInfo ActionGetIconNameMethodInfo a signature where
    overloadedMethod _ = actionGetIconName

-- method Action::get_is_important
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "action", argType = TInterface (Name {namespace = "Gtk", name = "Action"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkAction", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_action_get_is_important" gtk_action_get_is_important :: 
    Ptr Action ->                           -- action : TInterface (Name {namespace = "Gtk", name = "Action"})
    IO CInt

{-# DEPRECATED actionGetIsImportant ["(Since version 3.10)","Use 'GI.Gio.Interfaces.Action.Action' instead, and control and monitor whether","labels are shown directly"] #-}
{- |
Checks whether /@action@/ is important or not

@since 2.16
-}
actionGetIsImportant ::
    (B.CallStack.HasCallStack, MonadIO m, IsAction a) =>
    a
    {- ^ /@action@/: a 'GI.Gtk.Objects.Action.Action' -}
    -> m Bool
    {- ^ __Returns:__ whether /@action@/ is important -}
actionGetIsImportant action = liftIO $ do
    action' <- unsafeManagedPtrCastPtr action
    result <- gtk_action_get_is_important action'
    let result' = (/= 0) result
    touchManagedPtr action
    return result'

data ActionGetIsImportantMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsAction a) => O.MethodInfo ActionGetIsImportantMethodInfo a signature where
    overloadedMethod _ = actionGetIsImportant

-- method Action::get_label
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "action", argType = TInterface (Name {namespace = "Gtk", name = "Action"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkAction", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TUTF8)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_action_get_label" gtk_action_get_label :: 
    Ptr Action ->                           -- action : TInterface (Name {namespace = "Gtk", name = "Action"})
    IO CString

{-# DEPRECATED actionGetLabel ["(Since version 3.10)","Use 'GI.Gio.Interfaces.Action.Action' instead, and get a label from a menu item","with 'GI.Gio.Objects.MenuItem.menuItemGetAttributeValue'. For 'GI.Gtk.Interfaces.Actionable.Actionable' widgets, use the","widget-specific API to get a label"] #-}
{- |
Gets the label text of /@action@/.

@since 2.16
-}
actionGetLabel ::
    (B.CallStack.HasCallStack, MonadIO m, IsAction a) =>
    a
    {- ^ /@action@/: a 'GI.Gtk.Objects.Action.Action' -}
    -> m T.Text
    {- ^ __Returns:__ the label text -}
actionGetLabel action = liftIO $ do
    action' <- unsafeManagedPtrCastPtr action
    result <- gtk_action_get_label action'
    checkUnexpectedReturnNULL "actionGetLabel" result
    result' <- cstringToText result
    touchManagedPtr action
    return result'

data ActionGetLabelMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsAction a) => O.MethodInfo ActionGetLabelMethodInfo a signature where
    overloadedMethod _ = actionGetLabel

-- method Action::get_name
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "action", argType = TInterface (Name {namespace = "Gtk", name = "Action"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the action object", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TUTF8)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_action_get_name" gtk_action_get_name :: 
    Ptr Action ->                           -- action : TInterface (Name {namespace = "Gtk", name = "Action"})
    IO CString

{-# DEPRECATED actionGetName ["(Since version 3.10)","Use 'GI.Gio.Interfaces.Action.actionGetName' on a 'GI.Gio.Interfaces.Action.Action' instead"] #-}
{- |
Returns the name of the action.

@since 2.4
-}
actionGetName ::
    (B.CallStack.HasCallStack, MonadIO m, IsAction a) =>
    a
    {- ^ /@action@/: the action object -}
    -> m T.Text
    {- ^ __Returns:__ the name of the action. The string belongs to GTK+ and should not
  be freed. -}
actionGetName action = liftIO $ do
    action' <- unsafeManagedPtrCastPtr action
    result <- gtk_action_get_name action'
    checkUnexpectedReturnNULL "actionGetName" result
    result' <- cstringToText result
    touchManagedPtr action
    return result'

data ActionGetNameMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsAction a) => O.MethodInfo ActionGetNameMethodInfo a signature where
    overloadedMethod _ = actionGetName

-- method Action::get_proxies
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "action", argType = TInterface (Name {namespace = "Gtk", name = "Action"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the action object", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TGSList (TInterface (Name {namespace = "Gtk", name = "Widget"})))
-- throws : False
-- Skip return : False

foreign import ccall "gtk_action_get_proxies" gtk_action_get_proxies :: 
    Ptr Action ->                           -- action : TInterface (Name {namespace = "Gtk", name = "Action"})
    IO (Ptr (GSList (Ptr Gtk.Widget.Widget)))

{-# DEPRECATED actionGetProxies ["(Since version 3.10)"] #-}
{- |
Returns the proxy widgets for an action.
See also 'GI.Gtk.Interfaces.Activatable.activatableGetRelatedAction'.

@since 2.4
-}
actionGetProxies ::
    (B.CallStack.HasCallStack, MonadIO m, IsAction a) =>
    a
    {- ^ /@action@/: the action object -}
    -> m [Gtk.Widget.Widget]
    {- ^ __Returns:__ a 'GI.GLib.Structs.SList.SList' of proxy widgets. The list is owned by GTK+
and must not be modified. -}
actionGetProxies action = liftIO $ do
    action' <- unsafeManagedPtrCastPtr action
    result <- gtk_action_get_proxies action'
    result' <- unpackGSList result
    result'' <- mapM (newObject Gtk.Widget.Widget) result'
    touchManagedPtr action
    return result''

data ActionGetProxiesMethodInfo
instance (signature ~ (m [Gtk.Widget.Widget]), MonadIO m, IsAction a) => O.MethodInfo ActionGetProxiesMethodInfo a signature where
    overloadedMethod _ = actionGetProxies

-- method Action::get_sensitive
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "action", argType = TInterface (Name {namespace = "Gtk", name = "Action"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the action object", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_action_get_sensitive" gtk_action_get_sensitive :: 
    Ptr Action ->                           -- action : TInterface (Name {namespace = "Gtk", name = "Action"})
    IO CInt

{-# DEPRECATED actionGetSensitive ["(Since version 3.10)","Use 'GI.Gio.Interfaces.Action.actionGetEnabled' on a 'GI.Gio.Interfaces.Action.Action'","instead"] #-}
{- |
Returns whether the action itself is sensitive. Note that this doesn’t
necessarily mean effective sensitivity. See 'GI.Gtk.Objects.Action.actionIsSensitive'
for that.

@since 2.4
-}
actionGetSensitive ::
    (B.CallStack.HasCallStack, MonadIO m, IsAction a) =>
    a
    {- ^ /@action@/: the action object -}
    -> m Bool
    {- ^ __Returns:__ 'True' if the action itself is sensitive. -}
actionGetSensitive action = liftIO $ do
    action' <- unsafeManagedPtrCastPtr action
    result <- gtk_action_get_sensitive action'
    let result' = (/= 0) result
    touchManagedPtr action
    return result'

data ActionGetSensitiveMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsAction a) => O.MethodInfo ActionGetSensitiveMethodInfo a signature where
    overloadedMethod _ = actionGetSensitive

-- method Action::get_short_label
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "action", argType = TInterface (Name {namespace = "Gtk", name = "Action"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkAction", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TUTF8)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_action_get_short_label" gtk_action_get_short_label :: 
    Ptr Action ->                           -- action : TInterface (Name {namespace = "Gtk", name = "Action"})
    IO CString

{-# DEPRECATED actionGetShortLabel ["(Since version 3.10)","Use 'GI.Gio.Interfaces.Action.Action' instead, which has no equivalent of short","labels"] #-}
{- |
Gets the short label text of /@action@/.

@since 2.16
-}
actionGetShortLabel ::
    (B.CallStack.HasCallStack, MonadIO m, IsAction a) =>
    a
    {- ^ /@action@/: a 'GI.Gtk.Objects.Action.Action' -}
    -> m T.Text
    {- ^ __Returns:__ the short label text. -}
actionGetShortLabel action = liftIO $ do
    action' <- unsafeManagedPtrCastPtr action
    result <- gtk_action_get_short_label action'
    checkUnexpectedReturnNULL "actionGetShortLabel" result
    result' <- cstringToText result
    touchManagedPtr action
    return result'

data ActionGetShortLabelMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsAction a) => O.MethodInfo ActionGetShortLabelMethodInfo a signature where
    overloadedMethod _ = actionGetShortLabel

-- method Action::get_stock_id
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "action", argType = TInterface (Name {namespace = "Gtk", name = "Action"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkAction", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TUTF8)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_action_get_stock_id" gtk_action_get_stock_id :: 
    Ptr Action ->                           -- action : TInterface (Name {namespace = "Gtk", name = "Action"})
    IO CString

{-# DEPRECATED actionGetStockId ["(Since version 3.10)","Use 'GI.Gio.Interfaces.Action.Action' instead, which has no equivalent of stock","items"] #-}
{- |
Gets the stock id of /@action@/.

@since 2.16
-}
actionGetStockId ::
    (B.CallStack.HasCallStack, MonadIO m, IsAction a) =>
    a
    {- ^ /@action@/: a 'GI.Gtk.Objects.Action.Action' -}
    -> m T.Text
    {- ^ __Returns:__ the stock id -}
actionGetStockId action = liftIO $ do
    action' <- unsafeManagedPtrCastPtr action
    result <- gtk_action_get_stock_id action'
    checkUnexpectedReturnNULL "actionGetStockId" result
    result' <- cstringToText result
    touchManagedPtr action
    return result'

data ActionGetStockIdMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsAction a) => O.MethodInfo ActionGetStockIdMethodInfo a signature where
    overloadedMethod _ = actionGetStockId

-- method Action::get_tooltip
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "action", argType = TInterface (Name {namespace = "Gtk", name = "Action"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkAction", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TUTF8)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_action_get_tooltip" gtk_action_get_tooltip :: 
    Ptr Action ->                           -- action : TInterface (Name {namespace = "Gtk", name = "Action"})
    IO CString

{-# DEPRECATED actionGetTooltip ["(Since version 3.10)","Use 'GI.Gio.Interfaces.Action.Action' instead, and get tooltips from associated","'GI.Gtk.Interfaces.Actionable.Actionable' widgets with 'GI.Gtk.Objects.Widget.widgetGetTooltipText'"] #-}
{- |
Gets the tooltip text of /@action@/.

@since 2.16
-}
actionGetTooltip ::
    (B.CallStack.HasCallStack, MonadIO m, IsAction a) =>
    a
    {- ^ /@action@/: a 'GI.Gtk.Objects.Action.Action' -}
    -> m T.Text
    {- ^ __Returns:__ the tooltip text -}
actionGetTooltip action = liftIO $ do
    action' <- unsafeManagedPtrCastPtr action
    result <- gtk_action_get_tooltip action'
    checkUnexpectedReturnNULL "actionGetTooltip" result
    result' <- cstringToText result
    touchManagedPtr action
    return result'

data ActionGetTooltipMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsAction a) => O.MethodInfo ActionGetTooltipMethodInfo a signature where
    overloadedMethod _ = actionGetTooltip

-- method Action::get_visible
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "action", argType = TInterface (Name {namespace = "Gtk", name = "Action"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the action object", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_action_get_visible" gtk_action_get_visible :: 
    Ptr Action ->                           -- action : TInterface (Name {namespace = "Gtk", name = "Action"})
    IO CInt

{-# DEPRECATED actionGetVisible ["(Since version 3.10)","Use 'GI.Gio.Interfaces.Action.Action' instead, and control and monitor the state of","'GI.Gtk.Interfaces.Actionable.Actionable' widgets directly"] #-}
{- |
Returns whether the action itself is visible. Note that this doesn’t
necessarily mean effective visibility. See 'GI.Gtk.Objects.Action.actionIsSensitive'
for that.

@since 2.4
-}
actionGetVisible ::
    (B.CallStack.HasCallStack, MonadIO m, IsAction a) =>
    a
    {- ^ /@action@/: the action object -}
    -> m Bool
    {- ^ __Returns:__ 'True' if the action itself is visible. -}
actionGetVisible action = liftIO $ do
    action' <- unsafeManagedPtrCastPtr action
    result <- gtk_action_get_visible action'
    let result' = (/= 0) result
    touchManagedPtr action
    return result'

data ActionGetVisibleMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsAction a) => O.MethodInfo ActionGetVisibleMethodInfo a signature where
    overloadedMethod _ = actionGetVisible

-- method Action::get_visible_horizontal
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "action", argType = TInterface (Name {namespace = "Gtk", name = "Action"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkAction", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_action_get_visible_horizontal" gtk_action_get_visible_horizontal :: 
    Ptr Action ->                           -- action : TInterface (Name {namespace = "Gtk", name = "Action"})
    IO CInt

{-# DEPRECATED actionGetVisibleHorizontal ["(Since version 3.10)","Use 'GI.Gio.Interfaces.Action.Action' instead, and control and monitor the","visibility of associated widgets and menu items directly"] #-}
{- |
Checks whether /@action@/ is visible when horizontal

@since 2.16
-}
actionGetVisibleHorizontal ::
    (B.CallStack.HasCallStack, MonadIO m, IsAction a) =>
    a
    {- ^ /@action@/: a 'GI.Gtk.Objects.Action.Action' -}
    -> m Bool
    {- ^ __Returns:__ whether /@action@/ is visible when horizontal -}
actionGetVisibleHorizontal action = liftIO $ do
    action' <- unsafeManagedPtrCastPtr action
    result <- gtk_action_get_visible_horizontal action'
    let result' = (/= 0) result
    touchManagedPtr action
    return result'

data ActionGetVisibleHorizontalMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsAction a) => O.MethodInfo ActionGetVisibleHorizontalMethodInfo a signature where
    overloadedMethod _ = actionGetVisibleHorizontal

-- method Action::get_visible_vertical
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "action", argType = TInterface (Name {namespace = "Gtk", name = "Action"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkAction", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_action_get_visible_vertical" gtk_action_get_visible_vertical :: 
    Ptr Action ->                           -- action : TInterface (Name {namespace = "Gtk", name = "Action"})
    IO CInt

{-# DEPRECATED actionGetVisibleVertical ["(Since version 3.10)","Use 'GI.Gio.Interfaces.Action.Action' instead, and control and monitor the","visibility of associated widgets and menu items directly"] #-}
{- |
Checks whether /@action@/ is visible when horizontal

@since 2.16
-}
actionGetVisibleVertical ::
    (B.CallStack.HasCallStack, MonadIO m, IsAction a) =>
    a
    {- ^ /@action@/: a 'GI.Gtk.Objects.Action.Action' -}
    -> m Bool
    {- ^ __Returns:__ whether /@action@/ is visible when horizontal -}
actionGetVisibleVertical action = liftIO $ do
    action' <- unsafeManagedPtrCastPtr action
    result <- gtk_action_get_visible_vertical action'
    let result' = (/= 0) result
    touchManagedPtr action
    return result'

data ActionGetVisibleVerticalMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsAction a) => O.MethodInfo ActionGetVisibleVerticalMethodInfo a signature where
    overloadedMethod _ = actionGetVisibleVertical

-- method Action::is_sensitive
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "action", argType = TInterface (Name {namespace = "Gtk", name = "Action"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the action object", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_action_is_sensitive" gtk_action_is_sensitive :: 
    Ptr Action ->                           -- action : TInterface (Name {namespace = "Gtk", name = "Action"})
    IO CInt

{-# DEPRECATED actionIsSensitive ["(Since version 3.10)","Use 'GI.Gio.Interfaces.Action.actionGetEnabled' on a 'GI.Gio.Interfaces.Action.Action'","instead"] #-}
{- |
Returns whether the action is effectively sensitive.

@since 2.4
-}
actionIsSensitive ::
    (B.CallStack.HasCallStack, MonadIO m, IsAction a) =>
    a
    {- ^ /@action@/: the action object -}
    -> m Bool
    {- ^ __Returns:__ 'True' if the action and its associated action group
are both sensitive. -}
actionIsSensitive action = liftIO $ do
    action' <- unsafeManagedPtrCastPtr action
    result <- gtk_action_is_sensitive action'
    let result' = (/= 0) result
    touchManagedPtr action
    return result'

data ActionIsSensitiveMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsAction a) => O.MethodInfo ActionIsSensitiveMethodInfo a signature where
    overloadedMethod _ = actionIsSensitive

-- method Action::is_visible
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "action", argType = TInterface (Name {namespace = "Gtk", name = "Action"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the action object", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_action_is_visible" gtk_action_is_visible :: 
    Ptr Action ->                           -- action : TInterface (Name {namespace = "Gtk", name = "Action"})
    IO CInt

{-# DEPRECATED actionIsVisible ["(Since version 3.10)","Use 'GI.Gio.Interfaces.Action.Action' instead, and control and monitor the state of","'GI.Gtk.Interfaces.Actionable.Actionable' widgets directly"] #-}
{- |
Returns whether the action is effectively visible.

@since 2.4
-}
actionIsVisible ::
    (B.CallStack.HasCallStack, MonadIO m, IsAction a) =>
    a
    {- ^ /@action@/: the action object -}
    -> m Bool
    {- ^ __Returns:__ 'True' if the action and its associated action group
are both visible. -}
actionIsVisible action = liftIO $ do
    action' <- unsafeManagedPtrCastPtr action
    result <- gtk_action_is_visible action'
    let result' = (/= 0) result
    touchManagedPtr action
    return result'

data ActionIsVisibleMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsAction a) => O.MethodInfo ActionIsVisibleMethodInfo a signature where
    overloadedMethod _ = actionIsVisible

-- method Action::set_accel_group
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "action", argType = TInterface (Name {namespace = "Gtk", name = "Action"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the action object", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "accel_group", argType = TInterface (Name {namespace = "Gtk", name = "AccelGroup"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GtkAccelGroup or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_action_set_accel_group" gtk_action_set_accel_group :: 
    Ptr Action ->                           -- action : TInterface (Name {namespace = "Gtk", name = "Action"})
    Ptr Gtk.AccelGroup.AccelGroup ->        -- accel_group : TInterface (Name {namespace = "Gtk", name = "AccelGroup"})
    IO ()

{-# DEPRECATED actionSetAccelGroup ["(Since version 3.10)","Use 'GI.Gio.Interfaces.Action.Action' and the accelerator group on an associated","'GI.Gtk.Objects.Menu.Menu' instead"] #-}
{- |
Sets the 'GI.Gtk.Objects.AccelGroup.AccelGroup' in which the accelerator for this action
will be installed.

@since 2.4
-}
actionSetAccelGroup ::
    (B.CallStack.HasCallStack, MonadIO m, IsAction a, Gtk.AccelGroup.IsAccelGroup b) =>
    a
    {- ^ /@action@/: the action object -}
    -> Maybe (b)
    {- ^ /@accelGroup@/: a 'GI.Gtk.Objects.AccelGroup.AccelGroup' or 'Nothing' -}
    -> m ()
actionSetAccelGroup action accelGroup = liftIO $ do
    action' <- unsafeManagedPtrCastPtr action
    maybeAccelGroup <- case accelGroup of
        Nothing -> return nullPtr
        Just jAccelGroup -> do
            jAccelGroup' <- unsafeManagedPtrCastPtr jAccelGroup
            return jAccelGroup'
    gtk_action_set_accel_group action' maybeAccelGroup
    touchManagedPtr action
    whenJust accelGroup touchManagedPtr
    return ()

data ActionSetAccelGroupMethodInfo
instance (signature ~ (Maybe (b) -> m ()), MonadIO m, IsAction a, Gtk.AccelGroup.IsAccelGroup b) => O.MethodInfo ActionSetAccelGroupMethodInfo a signature where
    overloadedMethod _ = actionSetAccelGroup

-- method Action::set_accel_path
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "action", argType = TInterface (Name {namespace = "Gtk", name = "Action"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the action object", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "accel_path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the accelerator path", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_action_set_accel_path" gtk_action_set_accel_path :: 
    Ptr Action ->                           -- action : TInterface (Name {namespace = "Gtk", name = "Action"})
    CString ->                              -- accel_path : TBasicType TUTF8
    IO ()

{-# DEPRECATED actionSetAccelPath ["(Since version 3.10)","Use 'GI.Gio.Interfaces.Action.Action' and the accelerator path on an associated","'GI.Gtk.Objects.Menu.Menu' instead"] #-}
{- |
Sets the accel path for this action.  All proxy widgets associated
with the action will have this accel path, so that their
accelerators are consistent.

Note that /@accelPath@/ string will be stored in a @/GQuark/@. Therefore, if you
pass a static string, you can save some memory by interning it first with
'GI.GLib.Functions.internStaticString'.

@since 2.4
-}
actionSetAccelPath ::
    (B.CallStack.HasCallStack, MonadIO m, IsAction a) =>
    a
    {- ^ /@action@/: the action object -}
    -> T.Text
    {- ^ /@accelPath@/: the accelerator path -}
    -> m ()
actionSetAccelPath action accelPath = liftIO $ do
    action' <- unsafeManagedPtrCastPtr action
    accelPath' <- textToCString accelPath
    gtk_action_set_accel_path action' accelPath'
    touchManagedPtr action
    freeMem accelPath'
    return ()

data ActionSetAccelPathMethodInfo
instance (signature ~ (T.Text -> m ()), MonadIO m, IsAction a) => O.MethodInfo ActionSetAccelPathMethodInfo a signature where
    overloadedMethod _ = actionSetAccelPath

-- method Action::set_always_show_image
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "action", argType = TInterface (Name {namespace = "Gtk", name = "Action"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkAction", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "always_show", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "%TRUE if menuitem proxies should always show their image", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_action_set_always_show_image" gtk_action_set_always_show_image :: 
    Ptr Action ->                           -- action : TInterface (Name {namespace = "Gtk", name = "Action"})
    CInt ->                                 -- always_show : TBasicType TBoolean
    IO ()

{-# DEPRECATED actionSetAlwaysShowImage ["(Since version 3.10)","Use 'GI.Gio.Objects.MenuItem.menuItemSetIcon' on a 'GI.Gio.Objects.MenuItem.MenuItem' instead, if the","item should have an image"] #-}
{- |
Sets whether /@action@/\'s menu item proxies will ignore the
'GI.Gtk.Objects.Settings.Settings':@/gtk-menu-images/@ setting and always show their image, if available.

Use this if the menu item would be useless or hard to use
without their image.

@since 2.20
-}
actionSetAlwaysShowImage ::
    (B.CallStack.HasCallStack, MonadIO m, IsAction a) =>
    a
    {- ^ /@action@/: a 'GI.Gtk.Objects.Action.Action' -}
    -> Bool
    {- ^ /@alwaysShow@/: 'True' if menuitem proxies should always show their image -}
    -> m ()
actionSetAlwaysShowImage action alwaysShow = liftIO $ do
    action' <- unsafeManagedPtrCastPtr action
    let alwaysShow' = (fromIntegral . fromEnum) alwaysShow
    gtk_action_set_always_show_image action' alwaysShow'
    touchManagedPtr action
    return ()

data ActionSetAlwaysShowImageMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsAction a) => O.MethodInfo ActionSetAlwaysShowImageMethodInfo a signature where
    overloadedMethod _ = actionSetAlwaysShowImage

-- method Action::set_gicon
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "action", argType = TInterface (Name {namespace = "Gtk", name = "Action"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkAction", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "icon", argType = TInterface (Name {namespace = "Gio", name = "Icon"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GIcon to set", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_action_set_gicon" gtk_action_set_gicon :: 
    Ptr Action ->                           -- action : TInterface (Name {namespace = "Gtk", name = "Action"})
    Ptr Gio.Icon.Icon ->                    -- icon : TInterface (Name {namespace = "Gio", name = "Icon"})
    IO ()

{-# DEPRECATED actionSetGicon ["(Since version 3.10)","Use 'GI.Gio.Interfaces.Action.Action' instead, and 'GI.Gio.Objects.MenuItem.menuItemSetIcon' to set an","icon on a 'GI.Gio.Objects.MenuItem.MenuItem' associated with a 'GI.Gio.Interfaces.Action.Action', or 'GI.Gtk.Objects.Container.containerAdd' to","add a 'GI.Gtk.Objects.Image.Image' to a 'GI.Gtk.Objects.Button.Button'"] #-}
{- |
Sets the icon of /@action@/.

@since 2.16
-}
actionSetGicon ::
    (B.CallStack.HasCallStack, MonadIO m, IsAction a, Gio.Icon.IsIcon b) =>
    a
    {- ^ /@action@/: a 'GI.Gtk.Objects.Action.Action' -}
    -> b
    {- ^ /@icon@/: the 'GI.Gio.Interfaces.Icon.Icon' to set -}
    -> m ()
actionSetGicon action icon = liftIO $ do
    action' <- unsafeManagedPtrCastPtr action
    icon' <- unsafeManagedPtrCastPtr icon
    gtk_action_set_gicon action' icon'
    touchManagedPtr action
    touchManagedPtr icon
    return ()

data ActionSetGiconMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsAction a, Gio.Icon.IsIcon b) => O.MethodInfo ActionSetGiconMethodInfo a signature where
    overloadedMethod _ = actionSetGicon

-- method Action::set_icon_name
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "action", argType = TInterface (Name {namespace = "Gtk", name = "Action"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkAction", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "icon_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the icon name to set", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_action_set_icon_name" gtk_action_set_icon_name :: 
    Ptr Action ->                           -- action : TInterface (Name {namespace = "Gtk", name = "Action"})
    CString ->                              -- icon_name : TBasicType TUTF8
    IO ()

{-# DEPRECATED actionSetIconName ["(Since version 3.10)","Use 'GI.Gio.Interfaces.Action.Action' instead, and 'GI.Gio.Objects.MenuItem.menuItemSetIcon' to set an","icon on a 'GI.Gio.Objects.MenuItem.MenuItem' associated with a 'GI.Gio.Interfaces.Action.Action', or 'GI.Gtk.Objects.Container.containerAdd' to","add a 'GI.Gtk.Objects.Image.Image' to a 'GI.Gtk.Objects.Button.Button'"] #-}
{- |
Sets the icon name on /@action@/

@since 2.16
-}
actionSetIconName ::
    (B.CallStack.HasCallStack, MonadIO m, IsAction a) =>
    a
    {- ^ /@action@/: a 'GI.Gtk.Objects.Action.Action' -}
    -> T.Text
    {- ^ /@iconName@/: the icon name to set -}
    -> m ()
actionSetIconName action iconName = liftIO $ do
    action' <- unsafeManagedPtrCastPtr action
    iconName' <- textToCString iconName
    gtk_action_set_icon_name action' iconName'
    touchManagedPtr action
    freeMem iconName'
    return ()

data ActionSetIconNameMethodInfo
instance (signature ~ (T.Text -> m ()), MonadIO m, IsAction a) => O.MethodInfo ActionSetIconNameMethodInfo a signature where
    overloadedMethod _ = actionSetIconName

-- method Action::set_is_important
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "action", argType = TInterface (Name {namespace = "Gtk", name = "Action"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the action object", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "is_important", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "%TRUE to make the action important", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_action_set_is_important" gtk_action_set_is_important :: 
    Ptr Action ->                           -- action : TInterface (Name {namespace = "Gtk", name = "Action"})
    CInt ->                                 -- is_important : TBasicType TBoolean
    IO ()

{-# DEPRECATED actionSetIsImportant ["(Since version 3.10)","Use 'GI.Gio.Interfaces.Action.Action' instead, and control and monitor whether","labels are shown directly"] #-}
{- |
Sets whether the action is important, this attribute is used
primarily by toolbar items to decide whether to show a label
or not.

@since 2.16
-}
actionSetIsImportant ::
    (B.CallStack.HasCallStack, MonadIO m, IsAction a) =>
    a
    {- ^ /@action@/: the action object -}
    -> Bool
    {- ^ /@isImportant@/: 'True' to make the action important -}
    -> m ()
actionSetIsImportant action isImportant = liftIO $ do
    action' <- unsafeManagedPtrCastPtr action
    let isImportant' = (fromIntegral . fromEnum) isImportant
    gtk_action_set_is_important action' isImportant'
    touchManagedPtr action
    return ()

data ActionSetIsImportantMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsAction a) => O.MethodInfo ActionSetIsImportantMethodInfo a signature where
    overloadedMethod _ = actionSetIsImportant

-- method Action::set_label
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "action", argType = TInterface (Name {namespace = "Gtk", name = "Action"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkAction", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "label", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the label text to set", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_action_set_label" gtk_action_set_label :: 
    Ptr Action ->                           -- action : TInterface (Name {namespace = "Gtk", name = "Action"})
    CString ->                              -- label : TBasicType TUTF8
    IO ()

{-# DEPRECATED actionSetLabel ["(Since version 3.10)","Use 'GI.Gio.Interfaces.Action.Action' instead, and set a label on a menu item with","'GI.Gio.Objects.MenuItem.menuItemSetLabel'. For 'GI.Gtk.Interfaces.Actionable.Actionable' widgets, use the widget-specific","API to set a label"] #-}
{- |
Sets the label of /@action@/.

@since 2.16
-}
actionSetLabel ::
    (B.CallStack.HasCallStack, MonadIO m, IsAction a) =>
    a
    {- ^ /@action@/: a 'GI.Gtk.Objects.Action.Action' -}
    -> T.Text
    {- ^ /@label@/: the label text to set -}
    -> m ()
actionSetLabel action label = liftIO $ do
    action' <- unsafeManagedPtrCastPtr action
    label' <- textToCString label
    gtk_action_set_label action' label'
    touchManagedPtr action
    freeMem label'
    return ()

data ActionSetLabelMethodInfo
instance (signature ~ (T.Text -> m ()), MonadIO m, IsAction a) => O.MethodInfo ActionSetLabelMethodInfo a signature where
    overloadedMethod _ = actionSetLabel

-- method Action::set_sensitive
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "action", argType = TInterface (Name {namespace = "Gtk", name = "Action"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the action object", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "sensitive", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "%TRUE to make the action sensitive", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_action_set_sensitive" gtk_action_set_sensitive :: 
    Ptr Action ->                           -- action : TInterface (Name {namespace = "Gtk", name = "Action"})
    CInt ->                                 -- sensitive : TBasicType TBoolean
    IO ()

{-# DEPRECATED actionSetSensitive ["(Since version 3.10)","Use 'GI.Gio.Objects.SimpleAction.simpleActionSetEnabled' on a 'GI.Gio.Objects.SimpleAction.SimpleAction'","instead"] #-}
{- |
Sets the :sensitive property of the action to /@sensitive@/. Note that
this doesn’t necessarily mean effective sensitivity. See
'GI.Gtk.Objects.Action.actionIsSensitive'
for that.

@since 2.6
-}
actionSetSensitive ::
    (B.CallStack.HasCallStack, MonadIO m, IsAction a) =>
    a
    {- ^ /@action@/: the action object -}
    -> Bool
    {- ^ /@sensitive@/: 'True' to make the action sensitive -}
    -> m ()
actionSetSensitive action sensitive = liftIO $ do
    action' <- unsafeManagedPtrCastPtr action
    let sensitive' = (fromIntegral . fromEnum) sensitive
    gtk_action_set_sensitive action' sensitive'
    touchManagedPtr action
    return ()

data ActionSetSensitiveMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsAction a) => O.MethodInfo ActionSetSensitiveMethodInfo a signature where
    overloadedMethod _ = actionSetSensitive

-- method Action::set_short_label
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "action", argType = TInterface (Name {namespace = "Gtk", name = "Action"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkAction", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "short_label", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the label text to set", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_action_set_short_label" gtk_action_set_short_label :: 
    Ptr Action ->                           -- action : TInterface (Name {namespace = "Gtk", name = "Action"})
    CString ->                              -- short_label : TBasicType TUTF8
    IO ()

{-# DEPRECATED actionSetShortLabel ["(Since version 3.10)","Use 'GI.Gio.Interfaces.Action.Action' instead, which has no equivalent of short","labels"] #-}
{- |
Sets a shorter label text on /@action@/.

@since 2.16
-}
actionSetShortLabel ::
    (B.CallStack.HasCallStack, MonadIO m, IsAction a) =>
    a
    {- ^ /@action@/: a 'GI.Gtk.Objects.Action.Action' -}
    -> T.Text
    {- ^ /@shortLabel@/: the label text to set -}
    -> m ()
actionSetShortLabel action shortLabel = liftIO $ do
    action' <- unsafeManagedPtrCastPtr action
    shortLabel' <- textToCString shortLabel
    gtk_action_set_short_label action' shortLabel'
    touchManagedPtr action
    freeMem shortLabel'
    return ()

data ActionSetShortLabelMethodInfo
instance (signature ~ (T.Text -> m ()), MonadIO m, IsAction a) => O.MethodInfo ActionSetShortLabelMethodInfo a signature where
    overloadedMethod _ = actionSetShortLabel

-- method Action::set_stock_id
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "action", argType = TInterface (Name {namespace = "Gtk", name = "Action"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkAction", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "stock_id", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the stock id", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_action_set_stock_id" gtk_action_set_stock_id :: 
    Ptr Action ->                           -- action : TInterface (Name {namespace = "Gtk", name = "Action"})
    CString ->                              -- stock_id : TBasicType TUTF8
    IO ()

{-# DEPRECATED actionSetStockId ["(Since version 3.10)","Use 'GI.Gio.Interfaces.Action.Action' instead, which has no equivalent of stock","items"] #-}
{- |
Sets the stock id on /@action@/

@since 2.16
-}
actionSetStockId ::
    (B.CallStack.HasCallStack, MonadIO m, IsAction a) =>
    a
    {- ^ /@action@/: a 'GI.Gtk.Objects.Action.Action' -}
    -> T.Text
    {- ^ /@stockId@/: the stock id -}
    -> m ()
actionSetStockId action stockId = liftIO $ do
    action' <- unsafeManagedPtrCastPtr action
    stockId' <- textToCString stockId
    gtk_action_set_stock_id action' stockId'
    touchManagedPtr action
    freeMem stockId'
    return ()

data ActionSetStockIdMethodInfo
instance (signature ~ (T.Text -> m ()), MonadIO m, IsAction a) => O.MethodInfo ActionSetStockIdMethodInfo a signature where
    overloadedMethod _ = actionSetStockId

-- method Action::set_tooltip
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "action", argType = TInterface (Name {namespace = "Gtk", name = "Action"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkAction", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "tooltip", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the tooltip text", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_action_set_tooltip" gtk_action_set_tooltip :: 
    Ptr Action ->                           -- action : TInterface (Name {namespace = "Gtk", name = "Action"})
    CString ->                              -- tooltip : TBasicType TUTF8
    IO ()

{-# DEPRECATED actionSetTooltip ["(Since version 3.10)","Use 'GI.Gio.Interfaces.Action.Action' instead, and set tooltips on associated","'GI.Gtk.Interfaces.Actionable.Actionable' widgets with 'GI.Gtk.Objects.Widget.widgetSetTooltipText'"] #-}
{- |
Sets the tooltip text on /@action@/

@since 2.16
-}
actionSetTooltip ::
    (B.CallStack.HasCallStack, MonadIO m, IsAction a) =>
    a
    {- ^ /@action@/: a 'GI.Gtk.Objects.Action.Action' -}
    -> T.Text
    {- ^ /@tooltip@/: the tooltip text -}
    -> m ()
actionSetTooltip action tooltip = liftIO $ do
    action' <- unsafeManagedPtrCastPtr action
    tooltip' <- textToCString tooltip
    gtk_action_set_tooltip action' tooltip'
    touchManagedPtr action
    freeMem tooltip'
    return ()

data ActionSetTooltipMethodInfo
instance (signature ~ (T.Text -> m ()), MonadIO m, IsAction a) => O.MethodInfo ActionSetTooltipMethodInfo a signature where
    overloadedMethod _ = actionSetTooltip

-- method Action::set_visible
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "action", argType = TInterface (Name {namespace = "Gtk", name = "Action"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the action object", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "visible", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "%TRUE to make the action visible", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_action_set_visible" gtk_action_set_visible :: 
    Ptr Action ->                           -- action : TInterface (Name {namespace = "Gtk", name = "Action"})
    CInt ->                                 -- visible : TBasicType TBoolean
    IO ()

{-# DEPRECATED actionSetVisible ["(Since version 3.10)","Use 'GI.Gio.Interfaces.Action.Action' instead, and control and monitor the state of","'GI.Gtk.Interfaces.Actionable.Actionable' widgets directly"] #-}
{- |
Sets the :visible property of the action to /@visible@/. Note that
this doesn’t necessarily mean effective visibility. See
'GI.Gtk.Objects.Action.actionIsVisible'
for that.

@since 2.6
-}
actionSetVisible ::
    (B.CallStack.HasCallStack, MonadIO m, IsAction a) =>
    a
    {- ^ /@action@/: the action object -}
    -> Bool
    {- ^ /@visible@/: 'True' to make the action visible -}
    -> m ()
actionSetVisible action visible = liftIO $ do
    action' <- unsafeManagedPtrCastPtr action
    let visible' = (fromIntegral . fromEnum) visible
    gtk_action_set_visible action' visible'
    touchManagedPtr action
    return ()

data ActionSetVisibleMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsAction a) => O.MethodInfo ActionSetVisibleMethodInfo a signature where
    overloadedMethod _ = actionSetVisible

-- method Action::set_visible_horizontal
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "action", argType = TInterface (Name {namespace = "Gtk", name = "Action"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkAction", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "visible_horizontal", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "whether the action is visible horizontally", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_action_set_visible_horizontal" gtk_action_set_visible_horizontal :: 
    Ptr Action ->                           -- action : TInterface (Name {namespace = "Gtk", name = "Action"})
    CInt ->                                 -- visible_horizontal : TBasicType TBoolean
    IO ()

{-# DEPRECATED actionSetVisibleHorizontal ["(Since version 3.10)","Use 'GI.Gio.Interfaces.Action.Action' instead, and control and monitor the","visibility of associated widgets and menu items directly"] #-}
{- |
Sets whether /@action@/ is visible when horizontal

@since 2.16
-}
actionSetVisibleHorizontal ::
    (B.CallStack.HasCallStack, MonadIO m, IsAction a) =>
    a
    {- ^ /@action@/: a 'GI.Gtk.Objects.Action.Action' -}
    -> Bool
    {- ^ /@visibleHorizontal@/: whether the action is visible horizontally -}
    -> m ()
actionSetVisibleHorizontal action visibleHorizontal = liftIO $ do
    action' <- unsafeManagedPtrCastPtr action
    let visibleHorizontal' = (fromIntegral . fromEnum) visibleHorizontal
    gtk_action_set_visible_horizontal action' visibleHorizontal'
    touchManagedPtr action
    return ()

data ActionSetVisibleHorizontalMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsAction a) => O.MethodInfo ActionSetVisibleHorizontalMethodInfo a signature where
    overloadedMethod _ = actionSetVisibleHorizontal

-- method Action::set_visible_vertical
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "action", argType = TInterface (Name {namespace = "Gtk", name = "Action"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkAction", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "visible_vertical", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "whether the action is visible vertically", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_action_set_visible_vertical" gtk_action_set_visible_vertical :: 
    Ptr Action ->                           -- action : TInterface (Name {namespace = "Gtk", name = "Action"})
    CInt ->                                 -- visible_vertical : TBasicType TBoolean
    IO ()

{-# DEPRECATED actionSetVisibleVertical ["(Since version 3.10)","Use 'GI.Gio.Interfaces.Action.Action' instead, and control and monitor the","visibility of associated widgets and menu items directly"] #-}
{- |
Sets whether /@action@/ is visible when vertical

@since 2.16
-}
actionSetVisibleVertical ::
    (B.CallStack.HasCallStack, MonadIO m, IsAction a) =>
    a
    {- ^ /@action@/: a 'GI.Gtk.Objects.Action.Action' -}
    -> Bool
    {- ^ /@visibleVertical@/: whether the action is visible vertically -}
    -> m ()
actionSetVisibleVertical action visibleVertical = liftIO $ do
    action' <- unsafeManagedPtrCastPtr action
    let visibleVertical' = (fromIntegral . fromEnum) visibleVertical
    gtk_action_set_visible_vertical action' visibleVertical'
    touchManagedPtr action
    return ()

data ActionSetVisibleVerticalMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsAction a) => O.MethodInfo ActionSetVisibleVerticalMethodInfo a signature where
    overloadedMethod _ = actionSetVisibleVertical

-- method Action::unblock_activate
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "action", argType = TInterface (Name {namespace = "Gtk", name = "Action"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkAction", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_action_unblock_activate" gtk_action_unblock_activate :: 
    Ptr Action ->                           -- action : TInterface (Name {namespace = "Gtk", name = "Action"})
    IO ()

{-# DEPRECATED actionUnblockActivate ["(Since version 3.10)","Use 'GI.Gio.Objects.SimpleAction.simpleActionSetEnabled' to enable the","'GI.Gio.Objects.SimpleAction.SimpleAction' instead"] #-}
{- |
Reenable activation signals from the action

@since 2.16
-}
actionUnblockActivate ::
    (B.CallStack.HasCallStack, MonadIO m, IsAction a) =>
    a
    {- ^ /@action@/: a 'GI.Gtk.Objects.Action.Action' -}
    -> m ()
actionUnblockActivate action = liftIO $ do
    action' <- unsafeManagedPtrCastPtr action
    gtk_action_unblock_activate action'
    touchManagedPtr action
    return ()

data ActionUnblockActivateMethodInfo
instance (signature ~ (m ()), MonadIO m, IsAction a) => O.MethodInfo ActionUnblockActivateMethodInfo a signature where
    overloadedMethod _ = actionUnblockActivate