{-# LANGUAGE ImplicitParams, RankNTypes, TypeApplications #-}


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- The base object class for the Accessibility Toolkit API.
-- 
-- This class is the primary class for accessibility support via the
-- Accessibility ToolKit (ATK).  Objects which are instances of
-- t'GI.Atk.Objects.Object.Object' (or instances of AtkObject-derived types) are queried
-- for properties which relate basic (and generic) properties of a UI
-- component such as name and description.  Instances of t'GI.Atk.Objects.Object.Object'
-- may also be queried as to whether they implement other ATK
-- interfaces (e.g. t'GI.Atk.Interfaces.Action.Action', t'GI.Atk.Interfaces.Component.Component', etc.), as appropriate
-- to the role which a given UI component plays in a user interface.
-- 
-- All UI components in an application which provide useful
-- information or services to the user must provide corresponding
-- t'GI.Atk.Objects.Object.Object' instances on request (in GTK+, for instance, usually on
-- a call to @/gtk_widget_get_accessible/@ ()), either via ATK support
-- built into the toolkit for the widget class or ancestor class, or
-- in the case of custom widgets, if the inherited t'GI.Atk.Objects.Object.Object'
-- implementation is insufficient, via instances of a new t'GI.Atk.Objects.Object.Object'
-- subclass.
-- 
-- See @/Atk.AtkObjectFactory/@, @/Atk.AtkRegistry/@.  (GTK+ users see also
-- @/GtkAccessible/@).

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

module GI.Atk.Objects.Object
    ( 

-- * Exported types
    Object(..)                              ,
    IsObject                                ,
    toObject                                ,


 -- * Methods
-- | 
-- 
--  === __Click to display all available methods, including inherited ones__
-- ==== Methods
-- [addRelationship]("GI.Atk.Objects.Object#g:method:addRelationship"), [bindProperty]("GI.GObject.Objects.Object#g:method:bindProperty"), [bindPropertyFull]("GI.GObject.Objects.Object#g:method:bindPropertyFull"), [forceFloating]("GI.GObject.Objects.Object#g:method:forceFloating"), [freezeNotify]("GI.GObject.Objects.Object#g:method:freezeNotify"), [getv]("GI.GObject.Objects.Object#g:method:getv"), [initialize]("GI.Atk.Objects.Object#g:method:initialize"), [isFloating]("GI.GObject.Objects.Object#g:method:isFloating"), [notify]("GI.GObject.Objects.Object#g:method:notify"), [notifyByPspec]("GI.GObject.Objects.Object#g:method:notifyByPspec"), [notifyStateChange]("GI.Atk.Objects.Object#g:method:notifyStateChange"), [peekParent]("GI.Atk.Objects.Object#g:method:peekParent"), [ref]("GI.GObject.Objects.Object#g:method:ref"), [refAccessibleChild]("GI.Atk.Objects.Object#g:method:refAccessibleChild"), [refRelationSet]("GI.Atk.Objects.Object#g:method:refRelationSet"), [refSink]("GI.GObject.Objects.Object#g:method:refSink"), [refStateSet]("GI.Atk.Objects.Object#g:method:refStateSet"), [removePropertyChangeHandler]("GI.Atk.Objects.Object#g:method:removePropertyChangeHandler"), [removeRelationship]("GI.Atk.Objects.Object#g:method:removeRelationship"), [runDispose]("GI.GObject.Objects.Object#g:method:runDispose"), [stealData]("GI.GObject.Objects.Object#g:method:stealData"), [stealQdata]("GI.GObject.Objects.Object#g:method:stealQdata"), [thawNotify]("GI.GObject.Objects.Object#g:method:thawNotify"), [unref]("GI.GObject.Objects.Object#g:method:unref"), [watchClosure]("GI.GObject.Objects.Object#g:method:watchClosure").
-- 
-- ==== Getters
-- [getAccessibleId]("GI.Atk.Objects.Object#g:method:getAccessibleId"), [getAttributes]("GI.Atk.Objects.Object#g:method:getAttributes"), [getData]("GI.GObject.Objects.Object#g:method:getData"), [getDescription]("GI.Atk.Objects.Object#g:method:getDescription"), [getHelpText]("GI.Atk.Objects.Object#g:method:getHelpText"), [getIndexInParent]("GI.Atk.Objects.Object#g:method:getIndexInParent"), [getLayer]("GI.Atk.Objects.Object#g:method:getLayer"), [getMdiZorder]("GI.Atk.Objects.Object#g:method:getMdiZorder"), [getNAccessibleChildren]("GI.Atk.Objects.Object#g:method:getNAccessibleChildren"), [getName]("GI.Atk.Objects.Object#g:method:getName"), [getObjectLocale]("GI.Atk.Objects.Object#g:method:getObjectLocale"), [getParent]("GI.Atk.Objects.Object#g:method:getParent"), [getProperty]("GI.GObject.Objects.Object#g:method:getProperty"), [getQdata]("GI.GObject.Objects.Object#g:method:getQdata"), [getRole]("GI.Atk.Objects.Object#g:method:getRole").
-- 
-- ==== Setters
-- [setAccessibleId]("GI.Atk.Objects.Object#g:method:setAccessibleId"), [setData]("GI.GObject.Objects.Object#g:method:setData"), [setDataFull]("GI.GObject.Objects.Object#g:method:setDataFull"), [setDescription]("GI.Atk.Objects.Object#g:method:setDescription"), [setHelpText]("GI.Atk.Objects.Object#g:method:setHelpText"), [setName]("GI.Atk.Objects.Object#g:method:setName"), [setParent]("GI.Atk.Objects.Object#g:method:setParent"), [setProperty]("GI.GObject.Objects.Object#g:method:setProperty"), [setRole]("GI.Atk.Objects.Object#g:method:setRole").

#if defined(ENABLE_OVERLOADING)
    ResolveObjectMethod                     ,
#endif

-- ** addRelationship #method:addRelationship#

#if defined(ENABLE_OVERLOADING)
    ObjectAddRelationshipMethodInfo         ,
#endif
    objectAddRelationship                   ,


-- ** getAccessibleId #method:getAccessibleId#

#if defined(ENABLE_OVERLOADING)
    ObjectGetAccessibleIdMethodInfo         ,
#endif
    objectGetAccessibleId                   ,


-- ** getAttributes #method:getAttributes#

#if defined(ENABLE_OVERLOADING)
    ObjectGetAttributesMethodInfo           ,
#endif
    objectGetAttributes                     ,


-- ** getDescription #method:getDescription#

#if defined(ENABLE_OVERLOADING)
    ObjectGetDescriptionMethodInfo          ,
#endif
    objectGetDescription                    ,


-- ** getHelpText #method:getHelpText#

#if defined(ENABLE_OVERLOADING)
    ObjectGetHelpTextMethodInfo             ,
#endif
    objectGetHelpText                       ,


-- ** getIndexInParent #method:getIndexInParent#

#if defined(ENABLE_OVERLOADING)
    ObjectGetIndexInParentMethodInfo        ,
#endif
    objectGetIndexInParent                  ,


-- ** getLayer #method:getLayer#

#if defined(ENABLE_OVERLOADING)
    ObjectGetLayerMethodInfo                ,
#endif
    objectGetLayer                          ,


-- ** getMdiZorder #method:getMdiZorder#

#if defined(ENABLE_OVERLOADING)
    ObjectGetMdiZorderMethodInfo            ,
#endif
    objectGetMdiZorder                      ,


-- ** getNAccessibleChildren #method:getNAccessibleChildren#

#if defined(ENABLE_OVERLOADING)
    ObjectGetNAccessibleChildrenMethodInfo  ,
#endif
    objectGetNAccessibleChildren            ,


-- ** getName #method:getName#

#if defined(ENABLE_OVERLOADING)
    ObjectGetNameMethodInfo                 ,
#endif
    objectGetName                           ,


-- ** getObjectLocale #method:getObjectLocale#

#if defined(ENABLE_OVERLOADING)
    ObjectGetObjectLocaleMethodInfo         ,
#endif
    objectGetObjectLocale                   ,


-- ** getParent #method:getParent#

#if defined(ENABLE_OVERLOADING)
    ObjectGetParentMethodInfo               ,
#endif
    objectGetParent                         ,


-- ** getRole #method:getRole#

#if defined(ENABLE_OVERLOADING)
    ObjectGetRoleMethodInfo                 ,
#endif
    objectGetRole                           ,


-- ** initialize #method:initialize#

#if defined(ENABLE_OVERLOADING)
    ObjectInitializeMethodInfo              ,
#endif
    objectInitialize                        ,


-- ** notifyStateChange #method:notifyStateChange#

#if defined(ENABLE_OVERLOADING)
    ObjectNotifyStateChangeMethodInfo       ,
#endif
    objectNotifyStateChange                 ,


-- ** peekParent #method:peekParent#

#if defined(ENABLE_OVERLOADING)
    ObjectPeekParentMethodInfo              ,
#endif
    objectPeekParent                        ,


-- ** refAccessibleChild #method:refAccessibleChild#

#if defined(ENABLE_OVERLOADING)
    ObjectRefAccessibleChildMethodInfo      ,
#endif
    objectRefAccessibleChild                ,


-- ** refRelationSet #method:refRelationSet#

#if defined(ENABLE_OVERLOADING)
    ObjectRefRelationSetMethodInfo          ,
#endif
    objectRefRelationSet                    ,


-- ** refStateSet #method:refStateSet#

#if defined(ENABLE_OVERLOADING)
    ObjectRefStateSetMethodInfo             ,
#endif
    objectRefStateSet                       ,


-- ** removePropertyChangeHandler #method:removePropertyChangeHandler#

#if defined(ENABLE_OVERLOADING)
    ObjectRemovePropertyChangeHandlerMethodInfo,
#endif
    objectRemovePropertyChangeHandler       ,


-- ** removeRelationship #method:removeRelationship#

#if defined(ENABLE_OVERLOADING)
    ObjectRemoveRelationshipMethodInfo      ,
#endif
    objectRemoveRelationship                ,


-- ** setAccessibleId #method:setAccessibleId#

#if defined(ENABLE_OVERLOADING)
    ObjectSetAccessibleIdMethodInfo         ,
#endif
    objectSetAccessibleId                   ,


-- ** setDescription #method:setDescription#

#if defined(ENABLE_OVERLOADING)
    ObjectSetDescriptionMethodInfo          ,
#endif
    objectSetDescription                    ,


-- ** setHelpText #method:setHelpText#

#if defined(ENABLE_OVERLOADING)
    ObjectSetHelpTextMethodInfo             ,
#endif
    objectSetHelpText                       ,


-- ** setName #method:setName#

#if defined(ENABLE_OVERLOADING)
    ObjectSetNameMethodInfo                 ,
#endif
    objectSetName                           ,


-- ** setParent #method:setParent#

#if defined(ENABLE_OVERLOADING)
    ObjectSetParentMethodInfo               ,
#endif
    objectSetParent                         ,


-- ** setRole #method:setRole#

#if defined(ENABLE_OVERLOADING)
    ObjectSetRoleMethodInfo                 ,
#endif
    objectSetRole                           ,




 -- * Properties


-- ** accessibleComponentLayer #attr:accessibleComponentLayer#
-- | /No description available in the introspection data./

#if defined(ENABLE_OVERLOADING)
    ObjectAccessibleComponentLayerPropertyInfo,
#endif
    getObjectAccessibleComponentLayer       ,
#if defined(ENABLE_OVERLOADING)
    objectAccessibleComponentLayer          ,
#endif


-- ** accessibleComponentMdiZorder #attr:accessibleComponentMdiZorder#
-- | /No description available in the introspection data./

#if defined(ENABLE_OVERLOADING)
    ObjectAccessibleComponentMdiZorderPropertyInfo,
#endif
    getObjectAccessibleComponentMdiZorder   ,
#if defined(ENABLE_OVERLOADING)
    objectAccessibleComponentMdiZorder      ,
#endif


-- ** accessibleDescription #attr:accessibleDescription#
-- | /No description available in the introspection data./

#if defined(ENABLE_OVERLOADING)
    ObjectAccessibleDescriptionPropertyInfo ,
#endif
    clearObjectAccessibleDescription        ,
    constructObjectAccessibleDescription    ,
    getObjectAccessibleDescription          ,
#if defined(ENABLE_OVERLOADING)
    objectAccessibleDescription             ,
#endif
    setObjectAccessibleDescription          ,


-- ** accessibleHelpText #attr:accessibleHelpText#
-- | /No description available in the introspection data./

#if defined(ENABLE_OVERLOADING)
    ObjectAccessibleHelpTextPropertyInfo    ,
#endif
    clearObjectAccessibleHelpText           ,
    constructObjectAccessibleHelpText       ,
    getObjectAccessibleHelpText             ,
#if defined(ENABLE_OVERLOADING)
    objectAccessibleHelpText                ,
#endif
    setObjectAccessibleHelpText             ,


-- ** accessibleHypertextNlinks #attr:accessibleHypertextNlinks#
-- | /No description available in the introspection data./

#if defined(ENABLE_OVERLOADING)
    ObjectAccessibleHypertextNlinksPropertyInfo,
#endif
    getObjectAccessibleHypertextNlinks      ,
#if defined(ENABLE_OVERLOADING)
    objectAccessibleHypertextNlinks         ,
#endif


-- ** accessibleId #attr:accessibleId#
-- | /No description available in the introspection data./

#if defined(ENABLE_OVERLOADING)
    ObjectAccessibleIdPropertyInfo          ,
#endif
    constructObjectAccessibleId             ,
    getObjectAccessibleId                   ,
#if defined(ENABLE_OVERLOADING)
    objectAccessibleId                      ,
#endif
    setObjectAccessibleId                   ,


-- ** accessibleName #attr:accessibleName#
-- | /No description available in the introspection data./

#if defined(ENABLE_OVERLOADING)
    ObjectAccessibleNamePropertyInfo        ,
#endif
    clearObjectAccessibleName               ,
    constructObjectAccessibleName           ,
    getObjectAccessibleName                 ,
#if defined(ENABLE_OVERLOADING)
    objectAccessibleName                    ,
#endif
    setObjectAccessibleName                 ,


-- ** accessibleParent #attr:accessibleParent#
-- | /No description available in the introspection data./

#if defined(ENABLE_OVERLOADING)
    ObjectAccessibleParentPropertyInfo      ,
#endif
    clearObjectAccessibleParent             ,
    constructObjectAccessibleParent         ,
    getObjectAccessibleParent               ,
#if defined(ENABLE_OVERLOADING)
    objectAccessibleParent                  ,
#endif
    setObjectAccessibleParent               ,


-- ** accessibleRole #attr:accessibleRole#
-- | /No description available in the introspection data./

#if defined(ENABLE_OVERLOADING)
    ObjectAccessibleRolePropertyInfo        ,
#endif
    constructObjectAccessibleRole           ,
    getObjectAccessibleRole                 ,
#if defined(ENABLE_OVERLOADING)
    objectAccessibleRole                    ,
#endif
    setObjectAccessibleRole                 ,


-- ** accessibleTableCaption #attr:accessibleTableCaption#
-- | Table caption.

#if defined(ENABLE_OVERLOADING)
    ObjectAccessibleTableCaptionPropertyInfo,
#endif
    clearObjectAccessibleTableCaption       ,
    constructObjectAccessibleTableCaption   ,
    getObjectAccessibleTableCaption         ,
#if defined(ENABLE_OVERLOADING)
    objectAccessibleTableCaption            ,
#endif
    setObjectAccessibleTableCaption         ,


-- ** accessibleTableCaptionObject #attr:accessibleTableCaptionObject#
-- | /No description available in the introspection data./

#if defined(ENABLE_OVERLOADING)
    ObjectAccessibleTableCaptionObjectPropertyInfo,
#endif
    clearObjectAccessibleTableCaptionObject ,
    constructObjectAccessibleTableCaptionObject,
    getObjectAccessibleTableCaptionObject   ,
#if defined(ENABLE_OVERLOADING)
    objectAccessibleTableCaptionObject      ,
#endif
    setObjectAccessibleTableCaptionObject   ,


-- ** accessibleTableColumnDescription #attr:accessibleTableColumnDescription#
-- | Accessible table column description.

#if defined(ENABLE_OVERLOADING)
    ObjectAccessibleTableColumnDescriptionPropertyInfo,
#endif
    clearObjectAccessibleTableColumnDescription,
    constructObjectAccessibleTableColumnDescription,
    getObjectAccessibleTableColumnDescription,
#if defined(ENABLE_OVERLOADING)
    objectAccessibleTableColumnDescription  ,
#endif
    setObjectAccessibleTableColumnDescription,


-- ** accessibleTableColumnHeader #attr:accessibleTableColumnHeader#
-- | Accessible table column header.

#if defined(ENABLE_OVERLOADING)
    ObjectAccessibleTableColumnHeaderPropertyInfo,
#endif
    clearObjectAccessibleTableColumnHeader  ,
    constructObjectAccessibleTableColumnHeader,
    getObjectAccessibleTableColumnHeader    ,
#if defined(ENABLE_OVERLOADING)
    objectAccessibleTableColumnHeader       ,
#endif
    setObjectAccessibleTableColumnHeader    ,


-- ** accessibleTableRowDescription #attr:accessibleTableRowDescription#
-- | Accessible table row description.

#if defined(ENABLE_OVERLOADING)
    ObjectAccessibleTableRowDescriptionPropertyInfo,
#endif
    clearObjectAccessibleTableRowDescription,
    constructObjectAccessibleTableRowDescription,
    getObjectAccessibleTableRowDescription  ,
#if defined(ENABLE_OVERLOADING)
    objectAccessibleTableRowDescription     ,
#endif
    setObjectAccessibleTableRowDescription  ,


-- ** accessibleTableRowHeader #attr:accessibleTableRowHeader#
-- | Accessible table row header.

#if defined(ENABLE_OVERLOADING)
    ObjectAccessibleTableRowHeaderPropertyInfo,
#endif
    clearObjectAccessibleTableRowHeader     ,
    constructObjectAccessibleTableRowHeader ,
    getObjectAccessibleTableRowHeader       ,
#if defined(ENABLE_OVERLOADING)
    objectAccessibleTableRowHeader          ,
#endif
    setObjectAccessibleTableRowHeader       ,


-- ** accessibleTableSummary #attr:accessibleTableSummary#
-- | /No description available in the introspection data./

#if defined(ENABLE_OVERLOADING)
    ObjectAccessibleTableSummaryPropertyInfo,
#endif
    clearObjectAccessibleTableSummary       ,
    constructObjectAccessibleTableSummary   ,
    getObjectAccessibleTableSummary         ,
#if defined(ENABLE_OVERLOADING)
    objectAccessibleTableSummary            ,
#endif
    setObjectAccessibleTableSummary         ,


-- ** accessibleValue #attr:accessibleValue#
-- | Numeric value of this object, in case being and AtkValue.

#if defined(ENABLE_OVERLOADING)
    ObjectAccessibleValuePropertyInfo       ,
#endif
    constructObjectAccessibleValue          ,
    getObjectAccessibleValue                ,
#if defined(ENABLE_OVERLOADING)
    objectAccessibleValue                   ,
#endif
    setObjectAccessibleValue                ,




 -- * Signals


-- ** activeDescendantChanged #signal:activeDescendantChanged#

    ObjectActiveDescendantChangedCallback   ,
#if defined(ENABLE_OVERLOADING)
    ObjectActiveDescendantChangedSignalInfo ,
#endif
    afterObjectActiveDescendantChanged      ,
    onObjectActiveDescendantChanged         ,


-- ** announcement #signal:announcement#

    ObjectAnnouncementCallback              ,
#if defined(ENABLE_OVERLOADING)
    ObjectAnnouncementSignalInfo            ,
#endif
    afterObjectAnnouncement                 ,
    onObjectAnnouncement                    ,


-- ** attributeChanged #signal:attributeChanged#

    ObjectAttributeChangedCallback          ,
#if defined(ENABLE_OVERLOADING)
    ObjectAttributeChangedSignalInfo        ,
#endif
    afterObjectAttributeChanged             ,
    onObjectAttributeChanged                ,


-- ** childrenChanged #signal:childrenChanged#

    ObjectChildrenChangedCallback           ,
#if defined(ENABLE_OVERLOADING)
    ObjectChildrenChangedSignalInfo         ,
#endif
    afterObjectChildrenChanged              ,
    onObjectChildrenChanged                 ,


-- ** focusEvent #signal:focusEvent#

    ObjectFocusEventCallback                ,
#if defined(ENABLE_OVERLOADING)
    ObjectFocusEventSignalInfo              ,
#endif
    afterObjectFocusEvent                   ,
    onObjectFocusEvent                      ,


-- ** notification #signal:notification#

    ObjectNotificationCallback              ,
#if defined(ENABLE_OVERLOADING)
    ObjectNotificationSignalInfo            ,
#endif
    afterObjectNotification                 ,
    onObjectNotification                    ,


-- ** propertyChange #signal:propertyChange#

    ObjectPropertyChangeCallback            ,
#if defined(ENABLE_OVERLOADING)
    ObjectPropertyChangeSignalInfo          ,
#endif
    afterObjectPropertyChange               ,
    onObjectPropertyChange                  ,


-- ** stateChange #signal:stateChange#

    ObjectStateChangeCallback               ,
#if defined(ENABLE_OVERLOADING)
    ObjectStateChangeSignalInfo             ,
#endif
    afterObjectStateChange                  ,
    onObjectStateChange                     ,


-- ** visibleDataChanged #signal:visibleDataChanged#

    ObjectVisibleDataChangedCallback        ,
#if defined(ENABLE_OVERLOADING)
    ObjectVisibleDataChangedSignalInfo      ,
#endif
    afterObjectVisibleDataChanged           ,
    onObjectVisibleDataChanged              ,




    ) where

import Data.GI.Base.ShortPrelude
import qualified Data.GI.Base.ShortPrelude as SP
import qualified Data.GI.Base.Overloading as O
import qualified Prelude as P

import qualified Data.GI.Base.Attributes as GI.Attributes
import qualified Data.GI.Base.BasicTypes as B.Types
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GArray as B.GArray
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GHashTable as B.GHT
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.GI.Base.Signals as B.Signals
import qualified Control.Monad.IO.Class as MIO
import qualified Data.Coerce as Coerce
import qualified Data.Text as T
import qualified Data.Kind as DK
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL
import qualified GHC.Records as R
import qualified Data.Word as DW
import qualified Data.Int as DI
import qualified Data.Bits as DB
import qualified System.Posix.Types as SPT
import qualified Foreign.C.Types as FCT

-- Workaround for https://gitlab.haskell.org/ghc/ghc/-/issues/23392
#if MIN_VERSION_base(4,18,0)
import {-# SOURCE #-} qualified GI.Atk.Enums as Atk.Enums
import {-# SOURCE #-} qualified GI.Atk.Objects.Relation as Atk.Relation
import {-# SOURCE #-} qualified GI.Atk.Objects.RelationSet as Atk.RelationSet
import {-# SOURCE #-} qualified GI.Atk.Objects.StateSet as Atk.StateSet
import {-# SOURCE #-} qualified GI.Atk.Structs.PropertyValues as Atk.PropertyValues
import qualified GI.GObject.Objects.Object as GObject.Object
import qualified GI.GObject.Structs.ValueArray as GObject.ValueArray

#else
import {-# SOURCE #-} qualified GI.Atk.Enums as Atk.Enums
import {-# SOURCE #-} qualified GI.Atk.Objects.RelationSet as Atk.RelationSet
import {-# SOURCE #-} qualified GI.Atk.Objects.StateSet as Atk.StateSet
import {-# SOURCE #-} qualified GI.Atk.Structs.PropertyValues as Atk.PropertyValues
import qualified GI.GObject.Objects.Object as GObject.Object

#endif

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

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

foreign import ccall "atk_object_get_type"
    c_atk_object_get_type :: IO B.Types.GType

instance B.Types.TypedObject Object where
    glibType :: IO GType
glibType = IO GType
c_atk_object_get_type

instance B.Types.GObject Object

-- | Type class for types which can be safely cast to t'Object', for instance with `toObject`.
class (SP.GObject o, O.IsDescendantOf Object o) => IsObject o
instance (SP.GObject o, O.IsDescendantOf Object o) => IsObject o

instance O.HasParentTypes Object
type instance O.ParentTypes Object = '[GObject.Object.Object]

-- | Cast to t'Object', for types for which this is known to be safe. For general casts, use 'Data.GI.Base.ManagedPtr.castTo'.
toObject :: (MIO.MonadIO m, IsObject o) => o -> m Object
toObject :: forall (m :: * -> *) o. (MonadIO m, IsObject o) => o -> m Object
toObject = IO Object -> m Object
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Object -> m Object) -> (o -> IO Object) -> o -> m Object
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ManagedPtr Object -> Object) -> o -> IO Object
forall o o'.
(HasCallStack, ManagedPtrNewtype o, TypedObject o,
 ManagedPtrNewtype o', TypedObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
B.ManagedPtr.unsafeCastTo ManagedPtr Object -> Object
Object

-- | Convert t'Object' to and from t'Data.GI.Base.GValue.GValue'. See 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'.
instance B.GValue.IsGValue (Maybe Object) where
    gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_atk_object_get_type
    gvalueSet_ :: Ptr GValue -> Maybe Object -> IO ()
gvalueSet_ Ptr GValue
gv Maybe Object
P.Nothing = Ptr GValue -> Ptr Object -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv (Ptr Object
forall a. Ptr a
FP.nullPtr :: FP.Ptr Object)
    gvalueSet_ Ptr GValue
gv (P.Just Object
obj) = Object -> (Ptr Object -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr Object
obj (Ptr GValue -> Ptr Object -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv)
    gvalueGet_ :: Ptr GValue -> IO (Maybe Object)
gvalueGet_ Ptr GValue
gv = do
        ptr <- Ptr GValue -> IO (Ptr Object)
forall a. GObject a => Ptr GValue -> IO (Ptr a)
B.GValue.get_object Ptr GValue
gv :: IO (FP.Ptr Object)
        if ptr /= FP.nullPtr
        then P.Just <$> B.ManagedPtr.newObject Object ptr
        else return P.Nothing
        
    

#if defined(ENABLE_OVERLOADING)
type family ResolveObjectMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
    ResolveObjectMethod "addRelationship" o = ObjectAddRelationshipMethodInfo
    ResolveObjectMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveObjectMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveObjectMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveObjectMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveObjectMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
    ResolveObjectMethod "initialize" o = ObjectInitializeMethodInfo
    ResolveObjectMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveObjectMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveObjectMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveObjectMethod "notifyStateChange" o = ObjectNotifyStateChangeMethodInfo
    ResolveObjectMethod "peekParent" o = ObjectPeekParentMethodInfo
    ResolveObjectMethod "ref" o = GObject.Object.ObjectRefMethodInfo
    ResolveObjectMethod "refAccessibleChild" o = ObjectRefAccessibleChildMethodInfo
    ResolveObjectMethod "refRelationSet" o = ObjectRefRelationSetMethodInfo
    ResolveObjectMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveObjectMethod "refStateSet" o = ObjectRefStateSetMethodInfo
    ResolveObjectMethod "removePropertyChangeHandler" o = ObjectRemovePropertyChangeHandlerMethodInfo
    ResolveObjectMethod "removeRelationship" o = ObjectRemoveRelationshipMethodInfo
    ResolveObjectMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveObjectMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveObjectMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveObjectMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveObjectMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
    ResolveObjectMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveObjectMethod "getAccessibleId" o = ObjectGetAccessibleIdMethodInfo
    ResolveObjectMethod "getAttributes" o = ObjectGetAttributesMethodInfo
    ResolveObjectMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveObjectMethod "getDescription" o = ObjectGetDescriptionMethodInfo
    ResolveObjectMethod "getHelpText" o = ObjectGetHelpTextMethodInfo
    ResolveObjectMethod "getIndexInParent" o = ObjectGetIndexInParentMethodInfo
    ResolveObjectMethod "getLayer" o = ObjectGetLayerMethodInfo
    ResolveObjectMethod "getMdiZorder" o = ObjectGetMdiZorderMethodInfo
    ResolveObjectMethod "getNAccessibleChildren" o = ObjectGetNAccessibleChildrenMethodInfo
    ResolveObjectMethod "getName" o = ObjectGetNameMethodInfo
    ResolveObjectMethod "getObjectLocale" o = ObjectGetObjectLocaleMethodInfo
    ResolveObjectMethod "getParent" o = ObjectGetParentMethodInfo
    ResolveObjectMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveObjectMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveObjectMethod "getRole" o = ObjectGetRoleMethodInfo
    ResolveObjectMethod "setAccessibleId" o = ObjectSetAccessibleIdMethodInfo
    ResolveObjectMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveObjectMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
    ResolveObjectMethod "setDescription" o = ObjectSetDescriptionMethodInfo
    ResolveObjectMethod "setHelpText" o = ObjectSetHelpTextMethodInfo
    ResolveObjectMethod "setName" o = ObjectSetNameMethodInfo
    ResolveObjectMethod "setParent" o = ObjectSetParentMethodInfo
    ResolveObjectMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveObjectMethod "setRole" o = ObjectSetRoleMethodInfo
    ResolveObjectMethod l o = O.MethodResolutionFailed l o

instance (info ~ ResolveObjectMethod t Object, O.OverloadedMethod info Object p) => OL.IsLabel t (Object -> p) where
#if MIN_VERSION_base(4,10,0)
    fromLabel :: Object -> p
fromLabel = forall {k} (i :: k) o s. OverloadedMethod i o s => o -> s
forall i o s. OverloadedMethod i o s => o -> s
O.overloadedMethod @info
#else
    fromLabel _ = O.overloadedMethod @info
#endif

#if MIN_VERSION_base(4,13,0)
instance (info ~ ResolveObjectMethod t Object, O.OverloadedMethod info Object p, R.HasField t Object p) => R.HasField t Object p where
    getField :: Object -> p
getField = forall {k} (i :: k) o s. OverloadedMethod i o s => o -> s
forall i o s. OverloadedMethod i o s => o -> s
O.overloadedMethod @info

#endif

instance (info ~ ResolveObjectMethod t Object, O.OverloadedMethodInfo info Object) => OL.IsLabel t (O.MethodProxy info Object) where
#if MIN_VERSION_base(4,10,0)
    fromLabel :: MethodProxy info Object
fromLabel = MethodProxy info Object
forall info obj. MethodProxy info obj
O.MethodProxy
#else
    fromLabel _ = O.MethodProxy
#endif

#endif

-- signal Object::active-descendant-changed
-- | The \"active-descendant-changed\" signal is emitted by an object
-- which has the state ATK_STATE_MANAGES_DESCENDANTS when the focus
-- object in the object changes. For instance, a table will emit the
-- signal when the cell in the table which has focus changes.
type ObjectActiveDescendantChangedCallback =
    Maybe Object
    -- ^ /@arg1@/: the newly focused object.
    -> IO ()

type C_ObjectActiveDescendantChangedCallback =
    Ptr Object ->                           -- object
    Ptr Object ->
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_ObjectActiveDescendantChangedCallback`.
foreign import ccall "wrapper"
    mk_ObjectActiveDescendantChangedCallback :: C_ObjectActiveDescendantChangedCallback -> IO (FunPtr C_ObjectActiveDescendantChangedCallback)

wrap_ObjectActiveDescendantChangedCallback :: 
    GObject a => (a -> ObjectActiveDescendantChangedCallback) ->
    C_ObjectActiveDescendantChangedCallback
wrap_ObjectActiveDescendantChangedCallback :: forall a.
GObject a =>
(a -> Maybe Object -> IO ())
-> C_ObjectActiveDescendantChangedCallback
wrap_ObjectActiveDescendantChangedCallback a -> Maybe Object -> IO ()
gi'cb Ptr Object
gi'selfPtr Ptr Object
arg1 Ptr ()
_ = do
    maybeArg1 <-
        if Ptr Object
arg1 Ptr Object -> Ptr Object -> Bool
forall a. Eq a => a -> a -> Bool
== Ptr Object
forall a. Ptr a
FP.nullPtr
        then Maybe Object -> IO (Maybe Object)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Object
forall a. Maybe a
Nothing
        else do
            arg1' <- ((ManagedPtr Object -> Object) -> Ptr Object -> IO Object
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Object -> Object
Object) Ptr Object
arg1
            return $ Just arg1'
    B.ManagedPtr.withNewObject gi'selfPtr $ \Object
gi'self -> a -> Maybe Object -> IO ()
gi'cb (Object -> a
forall a b. Coercible a b => a -> b
Coerce.coerce Object
gi'self)  Maybe Object
maybeArg1


-- | Connect a signal handler for the [activeDescendantChanged](#signal:activeDescendantChanged) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' object #activeDescendantChanged callback
-- @
-- 
-- This signal admits a optional parameter @detail@.
-- If it's not @Nothing@, we will connect to “@active-descendant-changed::detail@” instead.
-- 
onObjectActiveDescendantChanged :: (IsObject a, MonadIO m) => a -> P.Maybe T.Text -> ((?self :: a) => ObjectActiveDescendantChangedCallback) -> m SignalHandlerId
onObjectActiveDescendantChanged :: forall a (m :: * -> *).
(IsObject a, MonadIO m) =>
a
-> Maybe Text
-> ((?self::a) => Maybe Object -> IO ())
-> m SignalHandlerId
onObjectActiveDescendantChanged a
obj Maybe Text
detail (?self::a) => Maybe Object -> IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> Maybe Object -> IO ()
wrapped a
self = let ?self = a
self in (?self::a) => Maybe Object -> IO ()
Maybe Object -> IO ()
cb
    let wrapped' :: C_ObjectActiveDescendantChangedCallback
wrapped' = (a -> Maybe Object -> IO ())
-> C_ObjectActiveDescendantChangedCallback
forall a.
GObject a =>
(a -> Maybe Object -> IO ())
-> C_ObjectActiveDescendantChangedCallback
wrap_ObjectActiveDescendantChangedCallback a -> Maybe Object -> IO ()
wrapped
    wrapped'' <- C_ObjectActiveDescendantChangedCallback
-> IO (FunPtr C_ObjectActiveDescendantChangedCallback)
mk_ObjectActiveDescendantChangedCallback C_ObjectActiveDescendantChangedCallback
wrapped'
    connectSignalFunPtr obj "active-descendant-changed" wrapped'' SignalConnectBefore detail

-- | Connect a signal handler for the [activeDescendantChanged](#signal:activeDescendantChanged) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' object #activeDescendantChanged callback
-- @
-- 
-- This signal admits a optional parameter @detail@.
-- If it's not @Nothing@, we will connect to “@active-descendant-changed::detail@” instead.
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterObjectActiveDescendantChanged :: (IsObject a, MonadIO m) => a -> P.Maybe T.Text -> ((?self :: a) => ObjectActiveDescendantChangedCallback) -> m SignalHandlerId
afterObjectActiveDescendantChanged :: forall a (m :: * -> *).
(IsObject a, MonadIO m) =>
a
-> Maybe Text
-> ((?self::a) => Maybe Object -> IO ())
-> m SignalHandlerId
afterObjectActiveDescendantChanged a
obj Maybe Text
detail (?self::a) => Maybe Object -> IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> Maybe Object -> IO ()
wrapped a
self = let ?self = a
self in (?self::a) => Maybe Object -> IO ()
Maybe Object -> IO ()
cb
    let wrapped' :: C_ObjectActiveDescendantChangedCallback
wrapped' = (a -> Maybe Object -> IO ())
-> C_ObjectActiveDescendantChangedCallback
forall a.
GObject a =>
(a -> Maybe Object -> IO ())
-> C_ObjectActiveDescendantChangedCallback
wrap_ObjectActiveDescendantChangedCallback a -> Maybe Object -> IO ()
wrapped
    wrapped'' <- C_ObjectActiveDescendantChangedCallback
-> IO (FunPtr C_ObjectActiveDescendantChangedCallback)
mk_ObjectActiveDescendantChangedCallback C_ObjectActiveDescendantChangedCallback
wrapped'
    connectSignalFunPtr obj "active-descendant-changed" wrapped'' SignalConnectAfter detail


#if defined(ENABLE_OVERLOADING)
data ObjectActiveDescendantChangedSignalInfo
instance SignalInfo ObjectActiveDescendantChangedSignalInfo where
    type HaskellCallbackType ObjectActiveDescendantChangedSignalInfo = ObjectActiveDescendantChangedCallback
    connectSignal :: forall o.
GObject o =>
o
-> (o
    -> HaskellCallbackType ObjectActiveDescendantChangedSignalInfo)
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignal o
obj o -> HaskellCallbackType ObjectActiveDescendantChangedSignalInfo
cb SignalConnectMode
connectMode Maybe Text
detail = do
        let cb' :: C_ObjectActiveDescendantChangedCallback
cb' = (o -> Maybe Object -> IO ())
-> C_ObjectActiveDescendantChangedCallback
forall a.
GObject a =>
(a -> Maybe Object -> IO ())
-> C_ObjectActiveDescendantChangedCallback
wrap_ObjectActiveDescendantChangedCallback o -> HaskellCallbackType ObjectActiveDescendantChangedSignalInfo
o -> Maybe Object -> IO ()
cb
        cb'' <- C_ObjectActiveDescendantChangedCallback
-> IO (FunPtr C_ObjectActiveDescendantChangedCallback)
mk_ObjectActiveDescendantChangedCallback C_ObjectActiveDescendantChangedCallback
cb'
        connectSignalFunPtr obj "active-descendant-changed" cb'' connectMode detail
    dbgSignalInfo :: Maybe ResolvedSymbolInfo
dbgSignalInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
        resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.Atk.Objects.Object::active-descendant-changed"
        , resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-atk-2.0.29/docs/GI-Atk-Objects-Object.html#g:signal:activeDescendantChanged"})

#endif

-- signal Object::announcement
-- | The \"announcement\" signal can be emitted to pass an announcement on to
-- be read by a screen reader.
-- 
-- Depcrecated (2.50): Use AtkObject[notification](#g:signal:notification) instead.
-- 
-- /Since: 2.46/
type ObjectAnnouncementCallback =
    T.Text
    -- ^ /@arg1@/: the text to be announced.
    -> IO ()

type C_ObjectAnnouncementCallback =
    Ptr Object ->                           -- object
    CString ->
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_ObjectAnnouncementCallback`.
foreign import ccall "wrapper"
    mk_ObjectAnnouncementCallback :: C_ObjectAnnouncementCallback -> IO (FunPtr C_ObjectAnnouncementCallback)

wrap_ObjectAnnouncementCallback :: 
    GObject a => (a -> ObjectAnnouncementCallback) ->
    C_ObjectAnnouncementCallback
wrap_ObjectAnnouncementCallback :: forall a.
GObject a =>
(a -> ObjectAnnouncementCallback) -> C_ObjectAnnouncementCallback
wrap_ObjectAnnouncementCallback a -> ObjectAnnouncementCallback
gi'cb Ptr Object
gi'selfPtr CString
arg1 Ptr ()
_ = do
    arg1' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
arg1
    B.ManagedPtr.withNewObject gi'selfPtr $ \Object
gi'self -> a -> ObjectAnnouncementCallback
gi'cb (Object -> a
forall a b. Coercible a b => a -> b
Coerce.coerce Object
gi'self)  Text
arg1'


-- | Connect a signal handler for the [announcement](#signal:announcement) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' object #announcement callback
-- @
-- 
-- 
onObjectAnnouncement :: (IsObject a, MonadIO m) => a -> ((?self :: a) => ObjectAnnouncementCallback) -> m SignalHandlerId
onObjectAnnouncement :: forall a (m :: * -> *).
(IsObject a, MonadIO m) =>
a
-> ((?self::a) => ObjectAnnouncementCallback) -> m SignalHandlerId
onObjectAnnouncement a
obj (?self::a) => ObjectAnnouncementCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> ObjectAnnouncementCallback
wrapped a
self = let ?self = a
self in (?self::a) => ObjectAnnouncementCallback
ObjectAnnouncementCallback
cb
    let wrapped' :: C_ObjectAnnouncementCallback
wrapped' = (a -> ObjectAnnouncementCallback) -> C_ObjectAnnouncementCallback
forall a.
GObject a =>
(a -> ObjectAnnouncementCallback) -> C_ObjectAnnouncementCallback
wrap_ObjectAnnouncementCallback a -> ObjectAnnouncementCallback
wrapped
    wrapped'' <- C_ObjectAnnouncementCallback
-> IO (FunPtr C_ObjectAnnouncementCallback)
mk_ObjectAnnouncementCallback C_ObjectAnnouncementCallback
wrapped'
    connectSignalFunPtr obj "announcement" wrapped'' SignalConnectBefore Nothing

-- | Connect a signal handler for the [announcement](#signal:announcement) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' object #announcement callback
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterObjectAnnouncement :: (IsObject a, MonadIO m) => a -> ((?self :: a) => ObjectAnnouncementCallback) -> m SignalHandlerId
afterObjectAnnouncement :: forall a (m :: * -> *).
(IsObject a, MonadIO m) =>
a
-> ((?self::a) => ObjectAnnouncementCallback) -> m SignalHandlerId
afterObjectAnnouncement a
obj (?self::a) => ObjectAnnouncementCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> ObjectAnnouncementCallback
wrapped a
self = let ?self = a
self in (?self::a) => ObjectAnnouncementCallback
ObjectAnnouncementCallback
cb
    let wrapped' :: C_ObjectAnnouncementCallback
wrapped' = (a -> ObjectAnnouncementCallback) -> C_ObjectAnnouncementCallback
forall a.
GObject a =>
(a -> ObjectAnnouncementCallback) -> C_ObjectAnnouncementCallback
wrap_ObjectAnnouncementCallback a -> ObjectAnnouncementCallback
wrapped
    wrapped'' <- C_ObjectAnnouncementCallback
-> IO (FunPtr C_ObjectAnnouncementCallback)
mk_ObjectAnnouncementCallback C_ObjectAnnouncementCallback
wrapped'
    connectSignalFunPtr obj "announcement" wrapped'' SignalConnectAfter Nothing


#if defined(ENABLE_OVERLOADING)
data ObjectAnnouncementSignalInfo
instance SignalInfo ObjectAnnouncementSignalInfo where
    type HaskellCallbackType ObjectAnnouncementSignalInfo = ObjectAnnouncementCallback
    connectSignal :: forall o.
GObject o =>
o
-> (o -> HaskellCallbackType ObjectAnnouncementSignalInfo)
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignal o
obj o -> HaskellCallbackType ObjectAnnouncementSignalInfo
cb SignalConnectMode
connectMode Maybe Text
detail = do
        let cb' :: C_ObjectAnnouncementCallback
cb' = (o -> ObjectAnnouncementCallback) -> C_ObjectAnnouncementCallback
forall a.
GObject a =>
(a -> ObjectAnnouncementCallback) -> C_ObjectAnnouncementCallback
wrap_ObjectAnnouncementCallback o -> HaskellCallbackType ObjectAnnouncementSignalInfo
o -> ObjectAnnouncementCallback
cb
        cb'' <- C_ObjectAnnouncementCallback
-> IO (FunPtr C_ObjectAnnouncementCallback)
mk_ObjectAnnouncementCallback C_ObjectAnnouncementCallback
cb'
        connectSignalFunPtr obj "announcement" cb'' connectMode detail
    dbgSignalInfo :: Maybe ResolvedSymbolInfo
dbgSignalInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
        resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.Atk.Objects.Object::announcement"
        , resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-atk-2.0.29/docs/GI-Atk-Objects-Object.html#g:signal:announcement"})

#endif

-- signal Object::attribute-changed
-- | The \"attribute-changed\" signal should be emitted when one of an object\'s
-- attributes changes.
-- 
-- /Since: 2.52/
type ObjectAttributeChangedCallback =
    T.Text
    -- ^ /@arg1@/: the name of the attribute being modified, or 'P.Nothing' if not
    --          available.
    -> T.Text
    -- ^ /@arg2@/: the attribute\'s new value, or @/null/@ if not available.
    -> IO ()

type C_ObjectAttributeChangedCallback =
    Ptr Object ->                           -- object
    CString ->
    CString ->
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_ObjectAttributeChangedCallback`.
foreign import ccall "wrapper"
    mk_ObjectAttributeChangedCallback :: C_ObjectAttributeChangedCallback -> IO (FunPtr C_ObjectAttributeChangedCallback)

wrap_ObjectAttributeChangedCallback :: 
    GObject a => (a -> ObjectAttributeChangedCallback) ->
    C_ObjectAttributeChangedCallback
wrap_ObjectAttributeChangedCallback :: forall a.
GObject a =>
(a -> ObjectAttributeChangedCallback)
-> C_ObjectAttributeChangedCallback
wrap_ObjectAttributeChangedCallback a -> ObjectAttributeChangedCallback
gi'cb Ptr Object
gi'selfPtr CString
arg1 CString
arg2 Ptr ()
_ = do
    arg1' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
arg1
    arg2' <- cstringToText arg2
    B.ManagedPtr.withNewObject gi'selfPtr $ \Object
gi'self -> a -> ObjectAttributeChangedCallback
gi'cb (Object -> a
forall a b. Coercible a b => a -> b
Coerce.coerce Object
gi'self)  Text
arg1' Text
arg2'


-- | Connect a signal handler for the [attributeChanged](#signal:attributeChanged) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' object #attributeChanged callback
-- @
-- 
-- 
onObjectAttributeChanged :: (IsObject a, MonadIO m) => a -> ((?self :: a) => ObjectAttributeChangedCallback) -> m SignalHandlerId
onObjectAttributeChanged :: forall a (m :: * -> *).
(IsObject a, MonadIO m) =>
a
-> ((?self::a) => ObjectAttributeChangedCallback)
-> m SignalHandlerId
onObjectAttributeChanged a
obj (?self::a) => ObjectAttributeChangedCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> ObjectAttributeChangedCallback
wrapped a
self = let ?self = a
self in (?self::a) => ObjectAttributeChangedCallback
ObjectAttributeChangedCallback
cb
    let wrapped' :: C_ObjectAttributeChangedCallback
wrapped' = (a -> ObjectAttributeChangedCallback)
-> C_ObjectAttributeChangedCallback
forall a.
GObject a =>
(a -> ObjectAttributeChangedCallback)
-> C_ObjectAttributeChangedCallback
wrap_ObjectAttributeChangedCallback a -> ObjectAttributeChangedCallback
wrapped
    wrapped'' <- C_ObjectAttributeChangedCallback
-> IO (FunPtr C_ObjectAttributeChangedCallback)
mk_ObjectAttributeChangedCallback C_ObjectAttributeChangedCallback
wrapped'
    connectSignalFunPtr obj "attribute-changed" wrapped'' SignalConnectBefore Nothing

-- | Connect a signal handler for the [attributeChanged](#signal:attributeChanged) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' object #attributeChanged callback
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterObjectAttributeChanged :: (IsObject a, MonadIO m) => a -> ((?self :: a) => ObjectAttributeChangedCallback) -> m SignalHandlerId
afterObjectAttributeChanged :: forall a (m :: * -> *).
(IsObject a, MonadIO m) =>
a
-> ((?self::a) => ObjectAttributeChangedCallback)
-> m SignalHandlerId
afterObjectAttributeChanged a
obj (?self::a) => ObjectAttributeChangedCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> ObjectAttributeChangedCallback
wrapped a
self = let ?self = a
self in (?self::a) => ObjectAttributeChangedCallback
ObjectAttributeChangedCallback
cb
    let wrapped' :: C_ObjectAttributeChangedCallback
wrapped' = (a -> ObjectAttributeChangedCallback)
-> C_ObjectAttributeChangedCallback
forall a.
GObject a =>
(a -> ObjectAttributeChangedCallback)
-> C_ObjectAttributeChangedCallback
wrap_ObjectAttributeChangedCallback a -> ObjectAttributeChangedCallback
wrapped
    wrapped'' <- C_ObjectAttributeChangedCallback
-> IO (FunPtr C_ObjectAttributeChangedCallback)
mk_ObjectAttributeChangedCallback C_ObjectAttributeChangedCallback
wrapped'
    connectSignalFunPtr obj "attribute-changed" wrapped'' SignalConnectAfter Nothing


#if defined(ENABLE_OVERLOADING)
data ObjectAttributeChangedSignalInfo
instance SignalInfo ObjectAttributeChangedSignalInfo where
    type HaskellCallbackType ObjectAttributeChangedSignalInfo = ObjectAttributeChangedCallback
    connectSignal :: forall o.
GObject o =>
o
-> (o -> HaskellCallbackType ObjectAttributeChangedSignalInfo)
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignal o
obj o -> HaskellCallbackType ObjectAttributeChangedSignalInfo
cb SignalConnectMode
connectMode Maybe Text
detail = do
        let cb' :: C_ObjectAttributeChangedCallback
cb' = (o -> ObjectAttributeChangedCallback)
-> C_ObjectAttributeChangedCallback
forall a.
GObject a =>
(a -> ObjectAttributeChangedCallback)
-> C_ObjectAttributeChangedCallback
wrap_ObjectAttributeChangedCallback o -> HaskellCallbackType ObjectAttributeChangedSignalInfo
o -> ObjectAttributeChangedCallback
cb
        cb'' <- C_ObjectAttributeChangedCallback
-> IO (FunPtr C_ObjectAttributeChangedCallback)
mk_ObjectAttributeChangedCallback C_ObjectAttributeChangedCallback
cb'
        connectSignalFunPtr obj "attribute-changed" cb'' connectMode detail
    dbgSignalInfo :: Maybe ResolvedSymbolInfo
dbgSignalInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
        resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.Atk.Objects.Object::attribute-changed"
        , resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-atk-2.0.29/docs/GI-Atk-Objects-Object.html#g:signal:attributeChanged"})

#endif

-- signal Object::children-changed
-- | The signal \"children-changed\" is emitted when a child is added or
-- removed from an object. It supports two details: \"add\" and
-- \"remove\"
type ObjectChildrenChangedCallback =
    Word32
    -- ^ /@arg1@/: The index of the added or removed child. The value can be
    -- -1. This is used if the value is not known by the implementor
    -- when the child is added\/removed or irrelevant.
    -> Maybe Object
    -- ^ /@arg2@/: A gpointer to the child AtkObject which was added or
    -- removed. If the child was removed, it is possible that it is not
    -- available for the implementor. In that case this pointer can be
    -- NULL.
    -> IO ()

type C_ObjectChildrenChangedCallback =
    Ptr Object ->                           -- object
    Word32 ->
    Ptr Object ->
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_ObjectChildrenChangedCallback`.
foreign import ccall "wrapper"
    mk_ObjectChildrenChangedCallback :: C_ObjectChildrenChangedCallback -> IO (FunPtr C_ObjectChildrenChangedCallback)

wrap_ObjectChildrenChangedCallback :: 
    GObject a => (a -> ObjectChildrenChangedCallback) ->
    C_ObjectChildrenChangedCallback
wrap_ObjectChildrenChangedCallback :: forall a.
GObject a =>
(a -> ObjectChildrenChangedCallback)
-> C_ObjectChildrenChangedCallback
wrap_ObjectChildrenChangedCallback a -> ObjectChildrenChangedCallback
gi'cb Ptr Object
gi'selfPtr Word32
arg1 Ptr Object
arg2 Ptr ()
_ = do
    maybeArg2 <-
        if Ptr Object
arg2 Ptr Object -> Ptr Object -> Bool
forall a. Eq a => a -> a -> Bool
== Ptr Object
forall a. Ptr a
FP.nullPtr
        then Maybe Object -> IO (Maybe Object)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Object
forall a. Maybe a
Nothing
        else do
            arg2' <- ((ManagedPtr Object -> Object) -> Ptr Object -> IO Object
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Object -> Object
Object) Ptr Object
arg2
            return $ Just arg2'
    B.ManagedPtr.withNewObject gi'selfPtr $ \Object
gi'self -> a -> ObjectChildrenChangedCallback
gi'cb (Object -> a
forall a b. Coercible a b => a -> b
Coerce.coerce Object
gi'self)  Word32
arg1 Maybe Object
maybeArg2


-- | Connect a signal handler for the [childrenChanged](#signal:childrenChanged) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' object #childrenChanged callback
-- @
-- 
-- This signal admits a optional parameter @detail@.
-- If it's not @Nothing@, we will connect to “@children-changed::detail@” instead.
-- 
onObjectChildrenChanged :: (IsObject a, MonadIO m) => a -> P.Maybe T.Text -> ((?self :: a) => ObjectChildrenChangedCallback) -> m SignalHandlerId
onObjectChildrenChanged :: forall a (m :: * -> *).
(IsObject a, MonadIO m) =>
a
-> Maybe Text
-> ((?self::a) => ObjectChildrenChangedCallback)
-> m SignalHandlerId
onObjectChildrenChanged a
obj Maybe Text
detail (?self::a) => ObjectChildrenChangedCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> ObjectChildrenChangedCallback
wrapped a
self = let ?self = a
self in (?self::a) => ObjectChildrenChangedCallback
ObjectChildrenChangedCallback
cb
    let wrapped' :: C_ObjectChildrenChangedCallback
wrapped' = (a -> ObjectChildrenChangedCallback)
-> C_ObjectChildrenChangedCallback
forall a.
GObject a =>
(a -> ObjectChildrenChangedCallback)
-> C_ObjectChildrenChangedCallback
wrap_ObjectChildrenChangedCallback a -> ObjectChildrenChangedCallback
wrapped
    wrapped'' <- C_ObjectChildrenChangedCallback
-> IO (FunPtr C_ObjectChildrenChangedCallback)
mk_ObjectChildrenChangedCallback C_ObjectChildrenChangedCallback
wrapped'
    connectSignalFunPtr obj "children-changed" wrapped'' SignalConnectBefore detail

-- | Connect a signal handler for the [childrenChanged](#signal:childrenChanged) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' object #childrenChanged callback
-- @
-- 
-- This signal admits a optional parameter @detail@.
-- If it's not @Nothing@, we will connect to “@children-changed::detail@” instead.
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterObjectChildrenChanged :: (IsObject a, MonadIO m) => a -> P.Maybe T.Text -> ((?self :: a) => ObjectChildrenChangedCallback) -> m SignalHandlerId
afterObjectChildrenChanged :: forall a (m :: * -> *).
(IsObject a, MonadIO m) =>
a
-> Maybe Text
-> ((?self::a) => ObjectChildrenChangedCallback)
-> m SignalHandlerId
afterObjectChildrenChanged a
obj Maybe Text
detail (?self::a) => ObjectChildrenChangedCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> ObjectChildrenChangedCallback
wrapped a
self = let ?self = a
self in (?self::a) => ObjectChildrenChangedCallback
ObjectChildrenChangedCallback
cb
    let wrapped' :: C_ObjectChildrenChangedCallback
wrapped' = (a -> ObjectChildrenChangedCallback)
-> C_ObjectChildrenChangedCallback
forall a.
GObject a =>
(a -> ObjectChildrenChangedCallback)
-> C_ObjectChildrenChangedCallback
wrap_ObjectChildrenChangedCallback a -> ObjectChildrenChangedCallback
wrapped
    wrapped'' <- C_ObjectChildrenChangedCallback
-> IO (FunPtr C_ObjectChildrenChangedCallback)
mk_ObjectChildrenChangedCallback C_ObjectChildrenChangedCallback
wrapped'
    connectSignalFunPtr obj "children-changed" wrapped'' SignalConnectAfter detail


#if defined(ENABLE_OVERLOADING)
data ObjectChildrenChangedSignalInfo
instance SignalInfo ObjectChildrenChangedSignalInfo where
    type HaskellCallbackType ObjectChildrenChangedSignalInfo = ObjectChildrenChangedCallback
    connectSignal :: forall o.
GObject o =>
o
-> (o -> HaskellCallbackType ObjectChildrenChangedSignalInfo)
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignal o
obj o -> HaskellCallbackType ObjectChildrenChangedSignalInfo
cb SignalConnectMode
connectMode Maybe Text
detail = do
        let cb' :: C_ObjectChildrenChangedCallback
cb' = (o -> ObjectChildrenChangedCallback)
-> C_ObjectChildrenChangedCallback
forall a.
GObject a =>
(a -> ObjectChildrenChangedCallback)
-> C_ObjectChildrenChangedCallback
wrap_ObjectChildrenChangedCallback o -> HaskellCallbackType ObjectChildrenChangedSignalInfo
o -> ObjectChildrenChangedCallback
cb
        cb'' <- C_ObjectChildrenChangedCallback
-> IO (FunPtr C_ObjectChildrenChangedCallback)
mk_ObjectChildrenChangedCallback C_ObjectChildrenChangedCallback
cb'
        connectSignalFunPtr obj "children-changed" cb'' connectMode detail
    dbgSignalInfo :: Maybe ResolvedSymbolInfo
dbgSignalInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
        resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.Atk.Objects.Object::children-changed"
        , resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-atk-2.0.29/docs/GI-Atk-Objects-Object.html#g:signal:childrenChanged"})

#endif

-- signal Object::focus-event
{-# DEPRECATED ObjectFocusEventCallback ["(Since version 2.9.4)","Use the [Object::stateChange](\"GI.Atk.Objects.Object#g:signal:stateChange\") signal instead."] #-}
-- | The signal \"focus-event\" is emitted when an object gained or lost
-- focus.
type ObjectFocusEventCallback =
    Bool
    -- ^ /@arg1@/: a boolean value which indicates whether the object gained
    -- or lost focus.
    -> IO ()

type C_ObjectFocusEventCallback =
    Ptr Object ->                           -- object
    CInt ->
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_ObjectFocusEventCallback`.
foreign import ccall "wrapper"
    mk_ObjectFocusEventCallback :: C_ObjectFocusEventCallback -> IO (FunPtr C_ObjectFocusEventCallback)

wrap_ObjectFocusEventCallback :: 
    GObject a => (a -> ObjectFocusEventCallback) ->
    C_ObjectFocusEventCallback
wrap_ObjectFocusEventCallback :: forall a.
GObject a =>
(a -> ObjectFocusEventCallback) -> C_ObjectFocusEventCallback
wrap_ObjectFocusEventCallback a -> ObjectFocusEventCallback
gi'cb Ptr Object
gi'selfPtr CInt
arg1 Ptr ()
_ = do
    let arg1' :: Bool
arg1' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
arg1
    Ptr Object -> (Object -> IO ()) -> IO ()
forall o b.
(HasCallStack, GObject o) =>
Ptr o -> (o -> IO b) -> IO b
B.ManagedPtr.withNewObject Ptr Object
gi'selfPtr ((Object -> IO ()) -> IO ()) -> (Object -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Object
gi'self -> a -> ObjectFocusEventCallback
gi'cb (Object -> a
forall a b. Coercible a b => a -> b
Coerce.coerce Object
gi'self)  Bool
arg1'


-- | Connect a signal handler for the [focusEvent](#signal:focusEvent) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' object #focusEvent callback
-- @
-- 
-- 
onObjectFocusEvent :: (IsObject a, MonadIO m) => a -> ((?self :: a) => ObjectFocusEventCallback) -> m SignalHandlerId
onObjectFocusEvent :: forall a (m :: * -> *).
(IsObject a, MonadIO m) =>
a -> ((?self::a) => ObjectFocusEventCallback) -> m SignalHandlerId
onObjectFocusEvent a
obj (?self::a) => ObjectFocusEventCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> ObjectFocusEventCallback
wrapped a
self = let ?self = a
self in (?self::a) => ObjectFocusEventCallback
ObjectFocusEventCallback
cb
    let wrapped' :: C_ObjectFocusEventCallback
wrapped' = (a -> ObjectFocusEventCallback) -> C_ObjectFocusEventCallback
forall a.
GObject a =>
(a -> ObjectFocusEventCallback) -> C_ObjectFocusEventCallback
wrap_ObjectFocusEventCallback a -> ObjectFocusEventCallback
wrapped
    wrapped'' <- C_ObjectFocusEventCallback
-> IO (FunPtr C_ObjectFocusEventCallback)
mk_ObjectFocusEventCallback C_ObjectFocusEventCallback
wrapped'
    connectSignalFunPtr obj "focus-event" wrapped'' SignalConnectBefore Nothing

-- | Connect a signal handler for the [focusEvent](#signal:focusEvent) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' object #focusEvent callback
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterObjectFocusEvent :: (IsObject a, MonadIO m) => a -> ((?self :: a) => ObjectFocusEventCallback) -> m SignalHandlerId
afterObjectFocusEvent :: forall a (m :: * -> *).
(IsObject a, MonadIO m) =>
a -> ((?self::a) => ObjectFocusEventCallback) -> m SignalHandlerId
afterObjectFocusEvent a
obj (?self::a) => ObjectFocusEventCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> ObjectFocusEventCallback
wrapped a
self = let ?self = a
self in (?self::a) => ObjectFocusEventCallback
ObjectFocusEventCallback
cb
    let wrapped' :: C_ObjectFocusEventCallback
wrapped' = (a -> ObjectFocusEventCallback) -> C_ObjectFocusEventCallback
forall a.
GObject a =>
(a -> ObjectFocusEventCallback) -> C_ObjectFocusEventCallback
wrap_ObjectFocusEventCallback a -> ObjectFocusEventCallback
wrapped
    wrapped'' <- C_ObjectFocusEventCallback
-> IO (FunPtr C_ObjectFocusEventCallback)
mk_ObjectFocusEventCallback C_ObjectFocusEventCallback
wrapped'
    connectSignalFunPtr obj "focus-event" wrapped'' SignalConnectAfter Nothing


#if defined(ENABLE_OVERLOADING)
data ObjectFocusEventSignalInfo
instance SignalInfo ObjectFocusEventSignalInfo where
    type HaskellCallbackType ObjectFocusEventSignalInfo = ObjectFocusEventCallback
    connectSignal :: forall o.
GObject o =>
o
-> (o -> HaskellCallbackType ObjectFocusEventSignalInfo)
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignal o
obj o -> HaskellCallbackType ObjectFocusEventSignalInfo
cb SignalConnectMode
connectMode Maybe Text
detail = do
        let cb' :: C_ObjectFocusEventCallback
cb' = (o -> ObjectFocusEventCallback) -> C_ObjectFocusEventCallback
forall a.
GObject a =>
(a -> ObjectFocusEventCallback) -> C_ObjectFocusEventCallback
wrap_ObjectFocusEventCallback o -> HaskellCallbackType ObjectFocusEventSignalInfo
o -> ObjectFocusEventCallback
cb
        cb'' <- C_ObjectFocusEventCallback
-> IO (FunPtr C_ObjectFocusEventCallback)
mk_ObjectFocusEventCallback C_ObjectFocusEventCallback
cb'
        connectSignalFunPtr obj "focus-event" cb'' connectMode detail
    dbgSignalInfo :: Maybe ResolvedSymbolInfo
dbgSignalInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
        resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.Atk.Objects.Object::focus-event"
        , resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-atk-2.0.29/docs/GI-Atk-Objects-Object.html#g:signal:focusEvent"})

#endif

-- signal Object::notification
-- | The \"notification\" signal can be emitted to pass an announcement on to
-- be read by a screen reader.
-- 
-- /Since: 2.50/
type ObjectNotificationCallback =
    T.Text
    -- ^ /@arg1@/: the text to be announced.
    -> Int32
    -- ^ /@arg2@/: an t'GI.Atk.Enums.Live' specifying the politeness of the notification.
    -- Should be either ATK_LIVE_POLITE or ATK_LIVE_ASSERTIVE.
    -> IO ()

type C_ObjectNotificationCallback =
    Ptr Object ->                           -- object
    CString ->
    Int32 ->
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_ObjectNotificationCallback`.
foreign import ccall "wrapper"
    mk_ObjectNotificationCallback :: C_ObjectNotificationCallback -> IO (FunPtr C_ObjectNotificationCallback)

wrap_ObjectNotificationCallback :: 
    GObject a => (a -> ObjectNotificationCallback) ->
    C_ObjectNotificationCallback
wrap_ObjectNotificationCallback :: forall a.
GObject a =>
(a -> ObjectNotificationCallback) -> C_ObjectNotificationCallback
wrap_ObjectNotificationCallback a -> ObjectNotificationCallback
gi'cb Ptr Object
gi'selfPtr CString
arg1 Int32
arg2 Ptr ()
_ = do
    arg1' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
arg1
    B.ManagedPtr.withNewObject gi'selfPtr $ \Object
gi'self -> a -> ObjectNotificationCallback
gi'cb (Object -> a
forall a b. Coercible a b => a -> b
Coerce.coerce Object
gi'self)  Text
arg1' Int32
arg2


-- | Connect a signal handler for the [notification](#signal:notification) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' object #notification callback
-- @
-- 
-- 
onObjectNotification :: (IsObject a, MonadIO m) => a -> ((?self :: a) => ObjectNotificationCallback) -> m SignalHandlerId
onObjectNotification :: forall a (m :: * -> *).
(IsObject a, MonadIO m) =>
a
-> ((?self::a) => ObjectNotificationCallback) -> m SignalHandlerId
onObjectNotification a
obj (?self::a) => ObjectNotificationCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> ObjectNotificationCallback
wrapped a
self = let ?self = a
self in (?self::a) => ObjectNotificationCallback
ObjectNotificationCallback
cb
    let wrapped' :: C_ObjectNotificationCallback
wrapped' = (a -> ObjectNotificationCallback) -> C_ObjectNotificationCallback
forall a.
GObject a =>
(a -> ObjectNotificationCallback) -> C_ObjectNotificationCallback
wrap_ObjectNotificationCallback a -> ObjectNotificationCallback
wrapped
    wrapped'' <- C_ObjectNotificationCallback
-> IO (FunPtr C_ObjectNotificationCallback)
mk_ObjectNotificationCallback C_ObjectNotificationCallback
wrapped'
    connectSignalFunPtr obj "notification" wrapped'' SignalConnectBefore Nothing

-- | Connect a signal handler for the [notification](#signal:notification) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' object #notification callback
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterObjectNotification :: (IsObject a, MonadIO m) => a -> ((?self :: a) => ObjectNotificationCallback) -> m SignalHandlerId
afterObjectNotification :: forall a (m :: * -> *).
(IsObject a, MonadIO m) =>
a
-> ((?self::a) => ObjectNotificationCallback) -> m SignalHandlerId
afterObjectNotification a
obj (?self::a) => ObjectNotificationCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> ObjectNotificationCallback
wrapped a
self = let ?self = a
self in (?self::a) => ObjectNotificationCallback
ObjectNotificationCallback
cb
    let wrapped' :: C_ObjectNotificationCallback
wrapped' = (a -> ObjectNotificationCallback) -> C_ObjectNotificationCallback
forall a.
GObject a =>
(a -> ObjectNotificationCallback) -> C_ObjectNotificationCallback
wrap_ObjectNotificationCallback a -> ObjectNotificationCallback
wrapped
    wrapped'' <- C_ObjectNotificationCallback
-> IO (FunPtr C_ObjectNotificationCallback)
mk_ObjectNotificationCallback C_ObjectNotificationCallback
wrapped'
    connectSignalFunPtr obj "notification" wrapped'' SignalConnectAfter Nothing


#if defined(ENABLE_OVERLOADING)
data ObjectNotificationSignalInfo
instance SignalInfo ObjectNotificationSignalInfo where
    type HaskellCallbackType ObjectNotificationSignalInfo = ObjectNotificationCallback
    connectSignal :: forall o.
GObject o =>
o
-> (o -> HaskellCallbackType ObjectNotificationSignalInfo)
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignal o
obj o -> HaskellCallbackType ObjectNotificationSignalInfo
cb SignalConnectMode
connectMode Maybe Text
detail = do
        let cb' :: C_ObjectNotificationCallback
cb' = (o -> ObjectNotificationCallback) -> C_ObjectNotificationCallback
forall a.
GObject a =>
(a -> ObjectNotificationCallback) -> C_ObjectNotificationCallback
wrap_ObjectNotificationCallback o -> HaskellCallbackType ObjectNotificationSignalInfo
o -> ObjectNotificationCallback
cb
        cb'' <- C_ObjectNotificationCallback
-> IO (FunPtr C_ObjectNotificationCallback)
mk_ObjectNotificationCallback C_ObjectNotificationCallback
cb'
        connectSignalFunPtr obj "notification" cb'' connectMode detail
    dbgSignalInfo :: Maybe ResolvedSymbolInfo
dbgSignalInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
        resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.Atk.Objects.Object::notification"
        , resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-atk-2.0.29/docs/GI-Atk-Objects-Object.html#g:signal:notification"})

#endif

-- signal Object::property-change
-- | The signal \"property-change\" is emitted when an object\'s property
-- value changes. /@arg1@/ contains an t'GI.Atk.Structs.PropertyValues.PropertyValues' with the name
-- and the new value of the property whose value has changed. Note
-- that, as with GObject notify, getting this signal does not
-- guarantee that the value of the property has actually changed; it
-- may also be emitted when the setter of the property is called to
-- reinstate the previous value.
-- 
-- Toolkit implementor note: ATK implementors should use
-- 'GI.GObject.Objects.Object.objectNotify' to emit property-changed
-- notifications. t'GI.Atk.Objects.Object.Object'::@/property-changed/@ is needed by the
-- implementation of @/atk_add_global_event_listener()/@ because GObject
-- notify doesn\'t support emission hooks.
type ObjectPropertyChangeCallback =
    Maybe Atk.PropertyValues.PropertyValues
    -- ^ /@arg1@/: an t'GI.Atk.Structs.PropertyValues.PropertyValues' containing the new
    -- value of the property which changed.
    -> IO ()

type C_ObjectPropertyChangeCallback =
    Ptr Object ->                           -- object
    Ptr Atk.PropertyValues.PropertyValues ->
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_ObjectPropertyChangeCallback`.
foreign import ccall "wrapper"
    mk_ObjectPropertyChangeCallback :: C_ObjectPropertyChangeCallback -> IO (FunPtr C_ObjectPropertyChangeCallback)

wrap_ObjectPropertyChangeCallback :: 
    GObject a => (a -> ObjectPropertyChangeCallback) ->
    C_ObjectPropertyChangeCallback
wrap_ObjectPropertyChangeCallback :: forall a.
GObject a =>
(a -> ObjectPropertyChangeCallback)
-> C_ObjectPropertyChangeCallback
wrap_ObjectPropertyChangeCallback a -> ObjectPropertyChangeCallback
gi'cb Ptr Object
gi'selfPtr Ptr PropertyValues
arg1 Ptr ()
_ = do
    maybeArg1 <-
        if Ptr PropertyValues
arg1 Ptr PropertyValues -> Ptr PropertyValues -> Bool
forall a. Eq a => a -> a -> Bool
== Ptr PropertyValues
forall a. Ptr a
FP.nullPtr
        then Maybe PropertyValues -> IO (Maybe PropertyValues)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe PropertyValues
forall a. Maybe a
Nothing
        else do
            arg1' <- ((ManagedPtr PropertyValues -> PropertyValues)
-> Ptr PropertyValues -> IO PropertyValues
forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newPtr ManagedPtr PropertyValues -> PropertyValues
Atk.PropertyValues.PropertyValues) Ptr PropertyValues
arg1
            return $ Just arg1'
    B.ManagedPtr.withNewObject gi'selfPtr $ \Object
gi'self -> a -> ObjectPropertyChangeCallback
gi'cb (Object -> a
forall a b. Coercible a b => a -> b
Coerce.coerce Object
gi'self)  Maybe PropertyValues
maybeArg1


-- | Connect a signal handler for the [propertyChange](#signal:propertyChange) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' object #propertyChange callback
-- @
-- 
-- This signal admits a optional parameter @detail@.
-- If it's not @Nothing@, we will connect to “@property-change::detail@” instead.
-- 
onObjectPropertyChange :: (IsObject a, MonadIO m) => a -> P.Maybe T.Text -> ((?self :: a) => ObjectPropertyChangeCallback) -> m SignalHandlerId
onObjectPropertyChange :: forall a (m :: * -> *).
(IsObject a, MonadIO m) =>
a
-> Maybe Text
-> ((?self::a) => ObjectPropertyChangeCallback)
-> m SignalHandlerId
onObjectPropertyChange a
obj Maybe Text
detail (?self::a) => ObjectPropertyChangeCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> ObjectPropertyChangeCallback
wrapped a
self = let ?self = a
self in (?self::a) => ObjectPropertyChangeCallback
ObjectPropertyChangeCallback
cb
    let wrapped' :: C_ObjectPropertyChangeCallback
wrapped' = (a -> ObjectPropertyChangeCallback)
-> C_ObjectPropertyChangeCallback
forall a.
GObject a =>
(a -> ObjectPropertyChangeCallback)
-> C_ObjectPropertyChangeCallback
wrap_ObjectPropertyChangeCallback a -> ObjectPropertyChangeCallback
wrapped
    wrapped'' <- C_ObjectPropertyChangeCallback
-> IO (FunPtr C_ObjectPropertyChangeCallback)
mk_ObjectPropertyChangeCallback C_ObjectPropertyChangeCallback
wrapped'
    connectSignalFunPtr obj "property-change" wrapped'' SignalConnectBefore detail

-- | Connect a signal handler for the [propertyChange](#signal:propertyChange) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' object #propertyChange callback
-- @
-- 
-- This signal admits a optional parameter @detail@.
-- If it's not @Nothing@, we will connect to “@property-change::detail@” instead.
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterObjectPropertyChange :: (IsObject a, MonadIO m) => a -> P.Maybe T.Text -> ((?self :: a) => ObjectPropertyChangeCallback) -> m SignalHandlerId
afterObjectPropertyChange :: forall a (m :: * -> *).
(IsObject a, MonadIO m) =>
a
-> Maybe Text
-> ((?self::a) => ObjectPropertyChangeCallback)
-> m SignalHandlerId
afterObjectPropertyChange a
obj Maybe Text
detail (?self::a) => ObjectPropertyChangeCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> ObjectPropertyChangeCallback
wrapped a
self = let ?self = a
self in (?self::a) => ObjectPropertyChangeCallback
ObjectPropertyChangeCallback
cb
    let wrapped' :: C_ObjectPropertyChangeCallback
wrapped' = (a -> ObjectPropertyChangeCallback)
-> C_ObjectPropertyChangeCallback
forall a.
GObject a =>
(a -> ObjectPropertyChangeCallback)
-> C_ObjectPropertyChangeCallback
wrap_ObjectPropertyChangeCallback a -> ObjectPropertyChangeCallback
wrapped
    wrapped'' <- C_ObjectPropertyChangeCallback
-> IO (FunPtr C_ObjectPropertyChangeCallback)
mk_ObjectPropertyChangeCallback C_ObjectPropertyChangeCallback
wrapped'
    connectSignalFunPtr obj "property-change" wrapped'' SignalConnectAfter detail


#if defined(ENABLE_OVERLOADING)
data ObjectPropertyChangeSignalInfo
instance SignalInfo ObjectPropertyChangeSignalInfo where
    type HaskellCallbackType ObjectPropertyChangeSignalInfo = ObjectPropertyChangeCallback
    connectSignal :: forall o.
GObject o =>
o
-> (o -> HaskellCallbackType ObjectPropertyChangeSignalInfo)
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignal o
obj o -> HaskellCallbackType ObjectPropertyChangeSignalInfo
cb SignalConnectMode
connectMode Maybe Text
detail = do
        let cb' :: C_ObjectPropertyChangeCallback
cb' = (o -> ObjectPropertyChangeCallback)
-> C_ObjectPropertyChangeCallback
forall a.
GObject a =>
(a -> ObjectPropertyChangeCallback)
-> C_ObjectPropertyChangeCallback
wrap_ObjectPropertyChangeCallback o -> HaskellCallbackType ObjectPropertyChangeSignalInfo
o -> ObjectPropertyChangeCallback
cb
        cb'' <- C_ObjectPropertyChangeCallback
-> IO (FunPtr C_ObjectPropertyChangeCallback)
mk_ObjectPropertyChangeCallback C_ObjectPropertyChangeCallback
cb'
        connectSignalFunPtr obj "property-change" cb'' connectMode detail
    dbgSignalInfo :: Maybe ResolvedSymbolInfo
dbgSignalInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
        resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.Atk.Objects.Object::property-change"
        , resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-atk-2.0.29/docs/GI-Atk-Objects-Object.html#g:signal:propertyChange"})

#endif

-- signal Object::state-change
-- | The \"state-change\" signal is emitted when an object\'s state
-- changes.  The detail value identifies the state type which has
-- changed.
type ObjectStateChangeCallback =
    T.Text
    -- ^ /@arg1@/: The name of the state which has changed
    -> Bool
    -- ^ /@arg2@/: A boolean which indicates whether the state has been set or unset.
    -> IO ()

type C_ObjectStateChangeCallback =
    Ptr Object ->                           -- object
    CString ->
    CInt ->
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_ObjectStateChangeCallback`.
foreign import ccall "wrapper"
    mk_ObjectStateChangeCallback :: C_ObjectStateChangeCallback -> IO (FunPtr C_ObjectStateChangeCallback)

wrap_ObjectStateChangeCallback :: 
    GObject a => (a -> ObjectStateChangeCallback) ->
    C_ObjectStateChangeCallback
wrap_ObjectStateChangeCallback :: forall a.
GObject a =>
(a -> ObjectStateChangeCallback) -> C_ObjectStateChangeCallback
wrap_ObjectStateChangeCallback a -> ObjectStateChangeCallback
gi'cb Ptr Object
gi'selfPtr CString
arg1 CInt
arg2 Ptr ()
_ = do
    arg1' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
arg1
    let arg2' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
arg2
    B.ManagedPtr.withNewObject gi'selfPtr $ \Object
gi'self -> a -> ObjectStateChangeCallback
gi'cb (Object -> a
forall a b. Coercible a b => a -> b
Coerce.coerce Object
gi'self)  Text
arg1' Bool
arg2'


-- | Connect a signal handler for the [stateChange](#signal:stateChange) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' object #stateChange callback
-- @
-- 
-- This signal admits a optional parameter @detail@.
-- If it's not @Nothing@, we will connect to “@state-change::detail@” instead.
-- 
onObjectStateChange :: (IsObject a, MonadIO m) => a -> P.Maybe T.Text -> ((?self :: a) => ObjectStateChangeCallback) -> m SignalHandlerId
onObjectStateChange :: forall a (m :: * -> *).
(IsObject a, MonadIO m) =>
a
-> Maybe Text
-> ((?self::a) => ObjectStateChangeCallback)
-> m SignalHandlerId
onObjectStateChange a
obj Maybe Text
detail (?self::a) => ObjectStateChangeCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> ObjectStateChangeCallback
wrapped a
self = let ?self = a
self in (?self::a) => ObjectStateChangeCallback
ObjectStateChangeCallback
cb
    let wrapped' :: C_ObjectStateChangeCallback
wrapped' = (a -> ObjectStateChangeCallback) -> C_ObjectStateChangeCallback
forall a.
GObject a =>
(a -> ObjectStateChangeCallback) -> C_ObjectStateChangeCallback
wrap_ObjectStateChangeCallback a -> ObjectStateChangeCallback
wrapped
    wrapped'' <- C_ObjectStateChangeCallback
-> IO (FunPtr C_ObjectStateChangeCallback)
mk_ObjectStateChangeCallback C_ObjectStateChangeCallback
wrapped'
    connectSignalFunPtr obj "state-change" wrapped'' SignalConnectBefore detail

-- | Connect a signal handler for the [stateChange](#signal:stateChange) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' object #stateChange callback
-- @
-- 
-- This signal admits a optional parameter @detail@.
-- If it's not @Nothing@, we will connect to “@state-change::detail@” instead.
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterObjectStateChange :: (IsObject a, MonadIO m) => a -> P.Maybe T.Text -> ((?self :: a) => ObjectStateChangeCallback) -> m SignalHandlerId
afterObjectStateChange :: forall a (m :: * -> *).
(IsObject a, MonadIO m) =>
a
-> Maybe Text
-> ((?self::a) => ObjectStateChangeCallback)
-> m SignalHandlerId
afterObjectStateChange a
obj Maybe Text
detail (?self::a) => ObjectStateChangeCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> ObjectStateChangeCallback
wrapped a
self = let ?self = a
self in (?self::a) => ObjectStateChangeCallback
ObjectStateChangeCallback
cb
    let wrapped' :: C_ObjectStateChangeCallback
wrapped' = (a -> ObjectStateChangeCallback) -> C_ObjectStateChangeCallback
forall a.
GObject a =>
(a -> ObjectStateChangeCallback) -> C_ObjectStateChangeCallback
wrap_ObjectStateChangeCallback a -> ObjectStateChangeCallback
wrapped
    wrapped'' <- C_ObjectStateChangeCallback
-> IO (FunPtr C_ObjectStateChangeCallback)
mk_ObjectStateChangeCallback C_ObjectStateChangeCallback
wrapped'
    connectSignalFunPtr obj "state-change" wrapped'' SignalConnectAfter detail


#if defined(ENABLE_OVERLOADING)
data ObjectStateChangeSignalInfo
instance SignalInfo ObjectStateChangeSignalInfo where
    type HaskellCallbackType ObjectStateChangeSignalInfo = ObjectStateChangeCallback
    connectSignal :: forall o.
GObject o =>
o
-> (o -> HaskellCallbackType ObjectStateChangeSignalInfo)
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignal o
obj o -> HaskellCallbackType ObjectStateChangeSignalInfo
cb SignalConnectMode
connectMode Maybe Text
detail = do
        let cb' :: C_ObjectStateChangeCallback
cb' = (o -> ObjectStateChangeCallback) -> C_ObjectStateChangeCallback
forall a.
GObject a =>
(a -> ObjectStateChangeCallback) -> C_ObjectStateChangeCallback
wrap_ObjectStateChangeCallback o -> HaskellCallbackType ObjectStateChangeSignalInfo
o -> ObjectStateChangeCallback
cb
        cb'' <- C_ObjectStateChangeCallback
-> IO (FunPtr C_ObjectStateChangeCallback)
mk_ObjectStateChangeCallback C_ObjectStateChangeCallback
cb'
        connectSignalFunPtr obj "state-change" cb'' connectMode detail
    dbgSignalInfo :: Maybe ResolvedSymbolInfo
dbgSignalInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
        resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.Atk.Objects.Object::state-change"
        , resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-atk-2.0.29/docs/GI-Atk-Objects-Object.html#g:signal:stateChange"})

#endif

-- signal Object::visible-data-changed
-- | The \"visible-data-changed\" signal is emitted when the visual
-- appearance of the object changed.
type ObjectVisibleDataChangedCallback =
    IO ()

type C_ObjectVisibleDataChangedCallback =
    Ptr Object ->                           -- object
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_ObjectVisibleDataChangedCallback`.
foreign import ccall "wrapper"
    mk_ObjectVisibleDataChangedCallback :: C_ObjectVisibleDataChangedCallback -> IO (FunPtr C_ObjectVisibleDataChangedCallback)

wrap_ObjectVisibleDataChangedCallback :: 
    GObject a => (a -> ObjectVisibleDataChangedCallback) ->
    C_ObjectVisibleDataChangedCallback
wrap_ObjectVisibleDataChangedCallback :: forall a.
GObject a =>
(a -> IO ()) -> C_ObjectVisibleDataChangedCallback
wrap_ObjectVisibleDataChangedCallback a -> IO ()
gi'cb Ptr Object
gi'selfPtr Ptr ()
_ = do
    Ptr Object -> (Object -> IO ()) -> IO ()
forall o b.
(HasCallStack, GObject o) =>
Ptr o -> (o -> IO b) -> IO b
B.ManagedPtr.withNewObject Ptr Object
gi'selfPtr ((Object -> IO ()) -> IO ()) -> (Object -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Object
gi'self -> a -> IO ()
gi'cb (Object -> a
forall a b. Coercible a b => a -> b
Coerce.coerce Object
gi'self) 


-- | Connect a signal handler for the [visibleDataChanged](#signal:visibleDataChanged) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' object #visibleDataChanged callback
-- @
-- 
-- 
onObjectVisibleDataChanged :: (IsObject a, MonadIO m) => a -> ((?self :: a) => ObjectVisibleDataChangedCallback) -> m SignalHandlerId
onObjectVisibleDataChanged :: forall a (m :: * -> *).
(IsObject a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
onObjectVisibleDataChanged a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> IO ()
wrapped a
self = let ?self = a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_ObjectVisibleDataChangedCallback
wrapped' = (a -> IO ()) -> C_ObjectVisibleDataChangedCallback
forall a.
GObject a =>
(a -> IO ()) -> C_ObjectVisibleDataChangedCallback
wrap_ObjectVisibleDataChangedCallback a -> IO ()
wrapped
    wrapped'' <- C_ObjectVisibleDataChangedCallback
-> IO (FunPtr C_ObjectVisibleDataChangedCallback)
mk_ObjectVisibleDataChangedCallback C_ObjectVisibleDataChangedCallback
wrapped'
    connectSignalFunPtr obj "visible-data-changed" wrapped'' SignalConnectBefore Nothing

-- | Connect a signal handler for the [visibleDataChanged](#signal:visibleDataChanged) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' object #visibleDataChanged callback
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterObjectVisibleDataChanged :: (IsObject a, MonadIO m) => a -> ((?self :: a) => ObjectVisibleDataChangedCallback) -> m SignalHandlerId
afterObjectVisibleDataChanged :: forall a (m :: * -> *).
(IsObject a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
afterObjectVisibleDataChanged a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> IO ()
wrapped a
self = let ?self = a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_ObjectVisibleDataChangedCallback
wrapped' = (a -> IO ()) -> C_ObjectVisibleDataChangedCallback
forall a.
GObject a =>
(a -> IO ()) -> C_ObjectVisibleDataChangedCallback
wrap_ObjectVisibleDataChangedCallback a -> IO ()
wrapped
    wrapped'' <- C_ObjectVisibleDataChangedCallback
-> IO (FunPtr C_ObjectVisibleDataChangedCallback)
mk_ObjectVisibleDataChangedCallback C_ObjectVisibleDataChangedCallback
wrapped'
    connectSignalFunPtr obj "visible-data-changed" wrapped'' SignalConnectAfter Nothing


#if defined(ENABLE_OVERLOADING)
data ObjectVisibleDataChangedSignalInfo
instance SignalInfo ObjectVisibleDataChangedSignalInfo where
    type HaskellCallbackType ObjectVisibleDataChangedSignalInfo = ObjectVisibleDataChangedCallback
    connectSignal :: forall o.
GObject o =>
o
-> (o -> HaskellCallbackType ObjectVisibleDataChangedSignalInfo)
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignal o
obj o -> HaskellCallbackType ObjectVisibleDataChangedSignalInfo
cb SignalConnectMode
connectMode Maybe Text
detail = do
        let cb' :: C_ObjectVisibleDataChangedCallback
cb' = (o -> IO ()) -> C_ObjectVisibleDataChangedCallback
forall a.
GObject a =>
(a -> IO ()) -> C_ObjectVisibleDataChangedCallback
wrap_ObjectVisibleDataChangedCallback o -> IO ()
o -> HaskellCallbackType ObjectVisibleDataChangedSignalInfo
cb
        cb'' <- C_ObjectVisibleDataChangedCallback
-> IO (FunPtr C_ObjectVisibleDataChangedCallback)
mk_ObjectVisibleDataChangedCallback C_ObjectVisibleDataChangedCallback
cb'
        connectSignalFunPtr obj "visible-data-changed" cb'' connectMode detail
    dbgSignalInfo :: Maybe ResolvedSymbolInfo
dbgSignalInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
        resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.Atk.Objects.Object::visible-data-changed"
        , resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-atk-2.0.29/docs/GI-Atk-Objects-Object.html#g:signal:visibleDataChanged"})

#endif

-- VVV Prop "accessible-component-layer"
   -- Type: TBasicType TInt
   -- Flags: [PropertyReadable]
   -- Nullable: (Nothing,Nothing)

-- | Get the value of the “@accessible-component-layer@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' object #accessibleComponentLayer
-- @
getObjectAccessibleComponentLayer :: (MonadIO m, IsObject o) => o -> m Int32
getObjectAccessibleComponentLayer :: forall (m :: * -> *) o. (MonadIO m, IsObject o) => o -> m Int32
getObjectAccessibleComponentLayer o
obj = IO Int32 -> m Int32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Int32
forall a. GObject a => a -> String -> IO Int32
B.Properties.getObjectPropertyInt32 o
obj String
"accessible-component-layer"

#if defined(ENABLE_OVERLOADING)
data ObjectAccessibleComponentLayerPropertyInfo
instance AttrInfo ObjectAccessibleComponentLayerPropertyInfo where
    type AttrAllowedOps ObjectAccessibleComponentLayerPropertyInfo = '[ 'AttrGet]
    type AttrBaseTypeConstraint ObjectAccessibleComponentLayerPropertyInfo = IsObject
    type AttrSetTypeConstraint ObjectAccessibleComponentLayerPropertyInfo = (~) ()
    type AttrTransferTypeConstraint ObjectAccessibleComponentLayerPropertyInfo = (~) ()
    type AttrTransferType ObjectAccessibleComponentLayerPropertyInfo = ()
    type AttrGetType ObjectAccessibleComponentLayerPropertyInfo = Int32
    type AttrLabel ObjectAccessibleComponentLayerPropertyInfo = "accessible-component-layer"
    type AttrOrigin ObjectAccessibleComponentLayerPropertyInfo = Object
    attrGet :: forall o.
AttrBaseTypeConstraint
  ObjectAccessibleComponentLayerPropertyInfo o =>
o -> IO (AttrGetType ObjectAccessibleComponentLayerPropertyInfo)
attrGet = o -> IO Int32
o -> IO (AttrGetType ObjectAccessibleComponentLayerPropertyInfo)
forall (m :: * -> *) o. (MonadIO m, IsObject o) => o -> m Int32
getObjectAccessibleComponentLayer
    attrSet :: forall o b.
(AttrBaseTypeConstraint
   ObjectAccessibleComponentLayerPropertyInfo o,
 AttrSetTypeConstraint
   ObjectAccessibleComponentLayerPropertyInfo b) =>
o -> b -> IO ()
attrSet = o -> b -> IO ()
forall a. HasCallStack => a
undefined
    attrPut :: forall o.
AttrBaseTypeConstraint
  ObjectAccessibleComponentLayerPropertyInfo o =>
o
-> AttrGetType ObjectAccessibleComponentLayerPropertyInfo -> IO ()
attrPut = o -> Int32 -> IO ()
o
-> AttrGetType ObjectAccessibleComponentLayerPropertyInfo -> IO ()
forall a. HasCallStack => a
undefined
    attrTransfer :: forall o b.
(AttrBaseTypeConstraint
   ObjectAccessibleComponentLayerPropertyInfo o,
 AttrTransferTypeConstraint
   ObjectAccessibleComponentLayerPropertyInfo b) =>
Proxy o
-> b
-> IO (AttrTransferType ObjectAccessibleComponentLayerPropertyInfo)
attrTransfer Proxy o
_ = b -> IO ()
b
-> IO (AttrTransferType ObjectAccessibleComponentLayerPropertyInfo)
forall a. HasCallStack => a
undefined
    attrConstruct :: forall o b.
(AttrBaseTypeConstraint
   ObjectAccessibleComponentLayerPropertyInfo o,
 AttrSetTypeConstraint
   ObjectAccessibleComponentLayerPropertyInfo b) =>
b -> IO (GValueConstruct o)
attrConstruct = b -> IO (GValueConstruct o)
forall a. HasCallStack => a
undefined
    attrClear :: forall o.
AttrBaseTypeConstraint
  ObjectAccessibleComponentLayerPropertyInfo o =>
o -> IO ()
attrClear = o -> IO ()
forall a. HasCallStack => a
undefined
    dbgAttrInfo :: Maybe ResolvedSymbolInfo
dbgAttrInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
        resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.Atk.Objects.Object.accessibleComponentLayer"
        , resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-atk-2.0.29/docs/GI-Atk-Objects-Object.html#g:attr:accessibleComponentLayer"
        })
#endif

-- VVV Prop "accessible-component-mdi-zorder"
   -- Type: TBasicType TInt
   -- Flags: [PropertyReadable]
   -- Nullable: (Nothing,Nothing)

-- | Get the value of the “@accessible-component-mdi-zorder@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' object #accessibleComponentMdiZorder
-- @
getObjectAccessibleComponentMdiZorder :: (MonadIO m, IsObject o) => o -> m Int32
getObjectAccessibleComponentMdiZorder :: forall (m :: * -> *) o. (MonadIO m, IsObject o) => o -> m Int32
getObjectAccessibleComponentMdiZorder o
obj = IO Int32 -> m Int32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Int32
forall a. GObject a => a -> String -> IO Int32
B.Properties.getObjectPropertyInt32 o
obj String
"accessible-component-mdi-zorder"

#if defined(ENABLE_OVERLOADING)
data ObjectAccessibleComponentMdiZorderPropertyInfo
instance AttrInfo ObjectAccessibleComponentMdiZorderPropertyInfo where
    type AttrAllowedOps ObjectAccessibleComponentMdiZorderPropertyInfo = '[ 'AttrGet]
    type AttrBaseTypeConstraint ObjectAccessibleComponentMdiZorderPropertyInfo = IsObject
    type AttrSetTypeConstraint ObjectAccessibleComponentMdiZorderPropertyInfo = (~) ()
    type AttrTransferTypeConstraint ObjectAccessibleComponentMdiZorderPropertyInfo = (~) ()
    type AttrTransferType ObjectAccessibleComponentMdiZorderPropertyInfo = ()
    type AttrGetType ObjectAccessibleComponentMdiZorderPropertyInfo = Int32
    type AttrLabel ObjectAccessibleComponentMdiZorderPropertyInfo = "accessible-component-mdi-zorder"
    type AttrOrigin ObjectAccessibleComponentMdiZorderPropertyInfo = Object
    attrGet :: forall o.
AttrBaseTypeConstraint
  ObjectAccessibleComponentMdiZorderPropertyInfo o =>
o
-> IO (AttrGetType ObjectAccessibleComponentMdiZorderPropertyInfo)
attrGet = o -> IO Int32
o
-> IO (AttrGetType ObjectAccessibleComponentMdiZorderPropertyInfo)
forall (m :: * -> *) o. (MonadIO m, IsObject o) => o -> m Int32
getObjectAccessibleComponentMdiZorder
    attrSet :: forall o b.
(AttrBaseTypeConstraint
   ObjectAccessibleComponentMdiZorderPropertyInfo o,
 AttrSetTypeConstraint
   ObjectAccessibleComponentMdiZorderPropertyInfo b) =>
o -> b -> IO ()
attrSet = o -> b -> IO ()
forall a. HasCallStack => a
undefined
    attrPut :: forall o.
AttrBaseTypeConstraint
  ObjectAccessibleComponentMdiZorderPropertyInfo o =>
o
-> AttrGetType ObjectAccessibleComponentMdiZorderPropertyInfo
-> IO ()
attrPut = o -> Int32 -> IO ()
o
-> AttrGetType ObjectAccessibleComponentMdiZorderPropertyInfo
-> IO ()
forall a. HasCallStack => a
undefined
    attrTransfer :: forall o b.
(AttrBaseTypeConstraint
   ObjectAccessibleComponentMdiZorderPropertyInfo o,
 AttrTransferTypeConstraint
   ObjectAccessibleComponentMdiZorderPropertyInfo b) =>
Proxy o
-> b
-> IO
     (AttrTransferType ObjectAccessibleComponentMdiZorderPropertyInfo)
attrTransfer Proxy o
_ = b -> IO ()
b
-> IO
     (AttrTransferType ObjectAccessibleComponentMdiZorderPropertyInfo)
forall a. HasCallStack => a
undefined
    attrConstruct :: forall o b.
(AttrBaseTypeConstraint
   ObjectAccessibleComponentMdiZorderPropertyInfo o,
 AttrSetTypeConstraint
   ObjectAccessibleComponentMdiZorderPropertyInfo b) =>
b -> IO (GValueConstruct o)
attrConstruct = b -> IO (GValueConstruct o)
forall a. HasCallStack => a
undefined
    attrClear :: forall o.
AttrBaseTypeConstraint
  ObjectAccessibleComponentMdiZorderPropertyInfo o =>
o -> IO ()
attrClear = o -> IO ()
forall a. HasCallStack => a
undefined
    dbgAttrInfo :: Maybe ResolvedSymbolInfo
dbgAttrInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
        resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.Atk.Objects.Object.accessibleComponentMdiZorder"
        , resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-atk-2.0.29/docs/GI-Atk-Objects-Object.html#g:attr:accessibleComponentMdiZorder"
        })
#endif

-- VVV Prop "accessible-description"
   -- Type: TBasicType TUTF8
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Nothing,Nothing)

-- | Get the value of the “@accessible-description@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' object #accessibleDescription
-- @
getObjectAccessibleDescription :: (MonadIO m, IsObject o) => o -> m (Maybe T.Text)
getObjectAccessibleDescription :: forall (m :: * -> *) o.
(MonadIO m, IsObject o) =>
o -> m (Maybe Text)
getObjectAccessibleDescription o
obj = IO (Maybe Text) -> m (Maybe Text)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ o -> String -> IO (Maybe Text)
forall a. GObject a => a -> String -> IO (Maybe Text)
B.Properties.getObjectPropertyString o
obj String
"accessible-description"

-- | Set the value of the “@accessible-description@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' object [ #accessibleDescription 'Data.GI.Base.Attributes.:=' value ]
-- @
setObjectAccessibleDescription :: (MonadIO m, IsObject o) => o -> T.Text -> m ()
setObjectAccessibleDescription :: forall (m :: * -> *) o.
(MonadIO m, IsObject o) =>
o -> Text -> m ()
setObjectAccessibleDescription o
obj Text
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Maybe Text -> IO ()
forall a. GObject a => a -> String -> Maybe Text -> IO ()
B.Properties.setObjectPropertyString o
obj String
"accessible-description" (Text -> Maybe Text
forall a. a -> Maybe a
Just Text
val)

-- | Construct a t'GValueConstruct' with valid value for the “@accessible-description@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructObjectAccessibleDescription :: (IsObject o, MIO.MonadIO m) => T.Text -> m (GValueConstruct o)
constructObjectAccessibleDescription :: forall o (m :: * -> *).
(IsObject o, MonadIO m) =>
Text -> m (GValueConstruct o)
constructObjectAccessibleDescription Text
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Maybe Text -> IO (GValueConstruct o)
forall o. String -> Maybe Text -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyString String
"accessible-description" (Text -> Maybe Text
forall a. a -> Maybe a
P.Just Text
val)

-- | Set the value of the “@accessible-description@” property to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #accessibleDescription
-- @
clearObjectAccessibleDescription :: (MonadIO m, IsObject o) => o -> m ()
clearObjectAccessibleDescription :: forall (m :: * -> *) o. (MonadIO m, IsObject o) => o -> m ()
clearObjectAccessibleDescription o
obj = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ o -> String -> Maybe Text -> IO ()
forall a. GObject a => a -> String -> Maybe Text -> IO ()
B.Properties.setObjectPropertyString o
obj String
"accessible-description" (Maybe Text
forall a. Maybe a
Nothing :: Maybe T.Text)

#if defined(ENABLE_OVERLOADING)
data ObjectAccessibleDescriptionPropertyInfo
instance AttrInfo ObjectAccessibleDescriptionPropertyInfo where
    type AttrAllowedOps ObjectAccessibleDescriptionPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint ObjectAccessibleDescriptionPropertyInfo = IsObject
    type AttrSetTypeConstraint ObjectAccessibleDescriptionPropertyInfo = (~) T.Text
    type AttrTransferTypeConstraint ObjectAccessibleDescriptionPropertyInfo = (~) T.Text
    type AttrTransferType ObjectAccessibleDescriptionPropertyInfo = T.Text
    type AttrGetType ObjectAccessibleDescriptionPropertyInfo = (Maybe T.Text)
    type AttrLabel ObjectAccessibleDescriptionPropertyInfo = "accessible-description"
    type AttrOrigin ObjectAccessibleDescriptionPropertyInfo = Object
    attrGet :: forall o.
AttrBaseTypeConstraint ObjectAccessibleDescriptionPropertyInfo o =>
o -> IO (AttrGetType ObjectAccessibleDescriptionPropertyInfo)
attrGet = o -> IO (Maybe Text)
o -> IO (AttrGetType ObjectAccessibleDescriptionPropertyInfo)
forall (m :: * -> *) o.
(MonadIO m, IsObject o) =>
o -> m (Maybe Text)
getObjectAccessibleDescription
    attrSet :: forall o b.
(AttrBaseTypeConstraint ObjectAccessibleDescriptionPropertyInfo o,
 AttrSetTypeConstraint ObjectAccessibleDescriptionPropertyInfo b) =>
o -> b -> IO ()
attrSet = o -> b -> IO ()
o -> ObjectAnnouncementCallback
forall (m :: * -> *) o.
(MonadIO m, IsObject o) =>
o -> Text -> m ()
setObjectAccessibleDescription
    attrPut :: forall o.
AttrBaseTypeConstraint ObjectAccessibleDescriptionPropertyInfo o =>
o -> AttrGetType ObjectAccessibleDescriptionPropertyInfo -> IO ()
attrPut = o -> Maybe Text -> IO ()
o -> AttrGetType ObjectAccessibleDescriptionPropertyInfo -> IO ()
forall a. HasCallStack => a
undefined
    attrTransfer :: forall o b.
(AttrBaseTypeConstraint ObjectAccessibleDescriptionPropertyInfo o,
 AttrTransferTypeConstraint
   ObjectAccessibleDescriptionPropertyInfo b) =>
Proxy o
-> b
-> IO (AttrTransferType ObjectAccessibleDescriptionPropertyInfo)
attrTransfer Proxy o
_ b
v = do
        b -> IO b
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return b
v
    attrConstruct :: forall o b.
(AttrBaseTypeConstraint ObjectAccessibleDescriptionPropertyInfo o,
 AttrSetTypeConstraint ObjectAccessibleDescriptionPropertyInfo b) =>
b -> IO (GValueConstruct o)
attrConstruct = b -> IO (GValueConstruct o)
Text -> IO (GValueConstruct o)
forall o (m :: * -> *).
(IsObject o, MonadIO m) =>
Text -> m (GValueConstruct o)
constructObjectAccessibleDescription
    attrClear :: forall o.
AttrBaseTypeConstraint ObjectAccessibleDescriptionPropertyInfo o =>
o -> IO ()
attrClear = o -> IO ()
forall (m :: * -> *) o. (MonadIO m, IsObject o) => o -> m ()
clearObjectAccessibleDescription
    dbgAttrInfo :: Maybe ResolvedSymbolInfo
dbgAttrInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
        resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.Atk.Objects.Object.accessibleDescription"
        , resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-atk-2.0.29/docs/GI-Atk-Objects-Object.html#g:attr:accessibleDescription"
        })
#endif

-- VVV Prop "accessible-help-text"
   -- Type: TBasicType TUTF8
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Nothing,Nothing)

-- | Get the value of the “@accessible-help-text@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' object #accessibleHelpText
-- @
getObjectAccessibleHelpText :: (MonadIO m, IsObject o) => o -> m (Maybe T.Text)
getObjectAccessibleHelpText :: forall (m :: * -> *) o.
(MonadIO m, IsObject o) =>
o -> m (Maybe Text)
getObjectAccessibleHelpText o
obj = IO (Maybe Text) -> m (Maybe Text)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ o -> String -> IO (Maybe Text)
forall a. GObject a => a -> String -> IO (Maybe Text)
B.Properties.getObjectPropertyString o
obj String
"accessible-help-text"

-- | Set the value of the “@accessible-help-text@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' object [ #accessibleHelpText 'Data.GI.Base.Attributes.:=' value ]
-- @
setObjectAccessibleHelpText :: (MonadIO m, IsObject o) => o -> T.Text -> m ()
setObjectAccessibleHelpText :: forall (m :: * -> *) o.
(MonadIO m, IsObject o) =>
o -> Text -> m ()
setObjectAccessibleHelpText o
obj Text
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Maybe Text -> IO ()
forall a. GObject a => a -> String -> Maybe Text -> IO ()
B.Properties.setObjectPropertyString o
obj String
"accessible-help-text" (Text -> Maybe Text
forall a. a -> Maybe a
Just Text
val)

-- | Construct a t'GValueConstruct' with valid value for the “@accessible-help-text@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructObjectAccessibleHelpText :: (IsObject o, MIO.MonadIO m) => T.Text -> m (GValueConstruct o)
constructObjectAccessibleHelpText :: forall o (m :: * -> *).
(IsObject o, MonadIO m) =>
Text -> m (GValueConstruct o)
constructObjectAccessibleHelpText Text
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Maybe Text -> IO (GValueConstruct o)
forall o. String -> Maybe Text -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyString String
"accessible-help-text" (Text -> Maybe Text
forall a. a -> Maybe a
P.Just Text
val)

-- | Set the value of the “@accessible-help-text@” property to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #accessibleHelpText
-- @
clearObjectAccessibleHelpText :: (MonadIO m, IsObject o) => o -> m ()
clearObjectAccessibleHelpText :: forall (m :: * -> *) o. (MonadIO m, IsObject o) => o -> m ()
clearObjectAccessibleHelpText o
obj = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ o -> String -> Maybe Text -> IO ()
forall a. GObject a => a -> String -> Maybe Text -> IO ()
B.Properties.setObjectPropertyString o
obj String
"accessible-help-text" (Maybe Text
forall a. Maybe a
Nothing :: Maybe T.Text)

#if defined(ENABLE_OVERLOADING)
data ObjectAccessibleHelpTextPropertyInfo
instance AttrInfo ObjectAccessibleHelpTextPropertyInfo where
    type AttrAllowedOps ObjectAccessibleHelpTextPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint ObjectAccessibleHelpTextPropertyInfo = IsObject
    type AttrSetTypeConstraint ObjectAccessibleHelpTextPropertyInfo = (~) T.Text
    type AttrTransferTypeConstraint ObjectAccessibleHelpTextPropertyInfo = (~) T.Text
    type AttrTransferType ObjectAccessibleHelpTextPropertyInfo = T.Text
    type AttrGetType ObjectAccessibleHelpTextPropertyInfo = (Maybe T.Text)
    type AttrLabel ObjectAccessibleHelpTextPropertyInfo = "accessible-help-text"
    type AttrOrigin ObjectAccessibleHelpTextPropertyInfo = Object
    attrGet :: forall o.
AttrBaseTypeConstraint ObjectAccessibleHelpTextPropertyInfo o =>
o -> IO (AttrGetType ObjectAccessibleHelpTextPropertyInfo)
attrGet = o -> IO (Maybe Text)
o -> IO (AttrGetType ObjectAccessibleHelpTextPropertyInfo)
forall (m :: * -> *) o.
(MonadIO m, IsObject o) =>
o -> m (Maybe Text)
getObjectAccessibleHelpText
    attrSet :: forall o b.
(AttrBaseTypeConstraint ObjectAccessibleHelpTextPropertyInfo o,
 AttrSetTypeConstraint ObjectAccessibleHelpTextPropertyInfo b) =>
o -> b -> IO ()
attrSet = o -> b -> IO ()
o -> ObjectAnnouncementCallback
forall (m :: * -> *) o.
(MonadIO m, IsObject o) =>
o -> Text -> m ()
setObjectAccessibleHelpText
    attrPut :: forall o.
AttrBaseTypeConstraint ObjectAccessibleHelpTextPropertyInfo o =>
o -> AttrGetType ObjectAccessibleHelpTextPropertyInfo -> IO ()
attrPut = o -> Maybe Text -> IO ()
o -> AttrGetType ObjectAccessibleHelpTextPropertyInfo -> IO ()
forall a. HasCallStack => a
undefined
    attrTransfer :: forall o b.
(AttrBaseTypeConstraint ObjectAccessibleHelpTextPropertyInfo o,
 AttrTransferTypeConstraint
   ObjectAccessibleHelpTextPropertyInfo b) =>
Proxy o
-> b -> IO (AttrTransferType ObjectAccessibleHelpTextPropertyInfo)
attrTransfer Proxy o
_ b
v = do
        b -> IO b
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return b
v
    attrConstruct :: forall o b.
(AttrBaseTypeConstraint ObjectAccessibleHelpTextPropertyInfo o,
 AttrSetTypeConstraint ObjectAccessibleHelpTextPropertyInfo b) =>
b -> IO (GValueConstruct o)
attrConstruct = b -> IO (GValueConstruct o)
Text -> IO (GValueConstruct o)
forall o (m :: * -> *).
(IsObject o, MonadIO m) =>
Text -> m (GValueConstruct o)
constructObjectAccessibleHelpText
    attrClear :: forall o.
AttrBaseTypeConstraint ObjectAccessibleHelpTextPropertyInfo o =>
o -> IO ()
attrClear = o -> IO ()
forall (m :: * -> *) o. (MonadIO m, IsObject o) => o -> m ()
clearObjectAccessibleHelpText
    dbgAttrInfo :: Maybe ResolvedSymbolInfo
dbgAttrInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
        resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.Atk.Objects.Object.accessibleHelpText"
        , resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-atk-2.0.29/docs/GI-Atk-Objects-Object.html#g:attr:accessibleHelpText"
        })
#endif

-- VVV Prop "accessible-hypertext-nlinks"
   -- Type: TBasicType TInt
   -- Flags: [PropertyReadable]
   -- Nullable: (Nothing,Nothing)

-- | Get the value of the “@accessible-hypertext-nlinks@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' object #accessibleHypertextNlinks
-- @
getObjectAccessibleHypertextNlinks :: (MonadIO m, IsObject o) => o -> m Int32
getObjectAccessibleHypertextNlinks :: forall (m :: * -> *) o. (MonadIO m, IsObject o) => o -> m Int32
getObjectAccessibleHypertextNlinks o
obj = IO Int32 -> m Int32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Int32
forall a. GObject a => a -> String -> IO Int32
B.Properties.getObjectPropertyInt32 o
obj String
"accessible-hypertext-nlinks"

#if defined(ENABLE_OVERLOADING)
data ObjectAccessibleHypertextNlinksPropertyInfo
instance AttrInfo ObjectAccessibleHypertextNlinksPropertyInfo where
    type AttrAllowedOps ObjectAccessibleHypertextNlinksPropertyInfo = '[ 'AttrGet]
    type AttrBaseTypeConstraint ObjectAccessibleHypertextNlinksPropertyInfo = IsObject
    type AttrSetTypeConstraint ObjectAccessibleHypertextNlinksPropertyInfo = (~) ()
    type AttrTransferTypeConstraint ObjectAccessibleHypertextNlinksPropertyInfo = (~) ()
    type AttrTransferType ObjectAccessibleHypertextNlinksPropertyInfo = ()
    type AttrGetType ObjectAccessibleHypertextNlinksPropertyInfo = Int32
    type AttrLabel ObjectAccessibleHypertextNlinksPropertyInfo = "accessible-hypertext-nlinks"
    type AttrOrigin ObjectAccessibleHypertextNlinksPropertyInfo = Object
    attrGet :: forall o.
AttrBaseTypeConstraint
  ObjectAccessibleHypertextNlinksPropertyInfo o =>
o -> IO (AttrGetType ObjectAccessibleHypertextNlinksPropertyInfo)
attrGet = o -> IO Int32
o -> IO (AttrGetType ObjectAccessibleHypertextNlinksPropertyInfo)
forall (m :: * -> *) o. (MonadIO m, IsObject o) => o -> m Int32
getObjectAccessibleHypertextNlinks
    attrSet :: forall o b.
(AttrBaseTypeConstraint
   ObjectAccessibleHypertextNlinksPropertyInfo o,
 AttrSetTypeConstraint
   ObjectAccessibleHypertextNlinksPropertyInfo b) =>
o -> b -> IO ()
attrSet = o -> b -> IO ()
forall a. HasCallStack => a
undefined
    attrPut :: forall o.
AttrBaseTypeConstraint
  ObjectAccessibleHypertextNlinksPropertyInfo o =>
o
-> AttrGetType ObjectAccessibleHypertextNlinksPropertyInfo -> IO ()
attrPut = o -> Int32 -> IO ()
o
-> AttrGetType ObjectAccessibleHypertextNlinksPropertyInfo -> IO ()
forall a. HasCallStack => a
undefined
    attrTransfer :: forall o b.
(AttrBaseTypeConstraint
   ObjectAccessibleHypertextNlinksPropertyInfo o,
 AttrTransferTypeConstraint
   ObjectAccessibleHypertextNlinksPropertyInfo b) =>
Proxy o
-> b
-> IO
     (AttrTransferType ObjectAccessibleHypertextNlinksPropertyInfo)
attrTransfer Proxy o
_ = b -> IO ()
b
-> IO
     (AttrTransferType ObjectAccessibleHypertextNlinksPropertyInfo)
forall a. HasCallStack => a
undefined
    attrConstruct :: forall o b.
(AttrBaseTypeConstraint
   ObjectAccessibleHypertextNlinksPropertyInfo o,
 AttrSetTypeConstraint
   ObjectAccessibleHypertextNlinksPropertyInfo b) =>
b -> IO (GValueConstruct o)
attrConstruct = b -> IO (GValueConstruct o)
forall a. HasCallStack => a
undefined
    attrClear :: forall o.
AttrBaseTypeConstraint
  ObjectAccessibleHypertextNlinksPropertyInfo o =>
o -> IO ()
attrClear = o -> IO ()
forall a. HasCallStack => a
undefined
    dbgAttrInfo :: Maybe ResolvedSymbolInfo
dbgAttrInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
        resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.Atk.Objects.Object.accessibleHypertextNlinks"
        , resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-atk-2.0.29/docs/GI-Atk-Objects-Object.html#g:attr:accessibleHypertextNlinks"
        })
#endif

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

-- | Get the value of the “@accessible-id@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' object #accessibleId
-- @
getObjectAccessibleId :: (MonadIO m, IsObject o) => o -> m T.Text
getObjectAccessibleId :: forall (m :: * -> *) o. (MonadIO m, IsObject o) => o -> m Text
getObjectAccessibleId o
obj = IO Text -> m Text
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ Text -> IO (Maybe Text) -> IO Text
forall a. HasCallStack => Text -> IO (Maybe a) -> IO a
checkUnexpectedNothing Text
"getObjectAccessibleId" (IO (Maybe Text) -> IO Text) -> IO (Maybe Text) -> IO Text
forall a b. (a -> b) -> a -> b
$ o -> String -> IO (Maybe Text)
forall a. GObject a => a -> String -> IO (Maybe Text)
B.Properties.getObjectPropertyString o
obj String
"accessible-id"

-- | Set the value of the “@accessible-id@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' object [ #accessibleId 'Data.GI.Base.Attributes.:=' value ]
-- @
setObjectAccessibleId :: (MonadIO m, IsObject o) => o -> T.Text -> m ()
setObjectAccessibleId :: forall (m :: * -> *) o.
(MonadIO m, IsObject o) =>
o -> Text -> m ()
setObjectAccessibleId o
obj Text
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Maybe Text -> IO ()
forall a. GObject a => a -> String -> Maybe Text -> IO ()
B.Properties.setObjectPropertyString o
obj String
"accessible-id" (Text -> Maybe Text
forall a. a -> Maybe a
Just Text
val)

-- | Construct a t'GValueConstruct' with valid value for the “@accessible-id@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructObjectAccessibleId :: (IsObject o, MIO.MonadIO m) => T.Text -> m (GValueConstruct o)
constructObjectAccessibleId :: forall o (m :: * -> *).
(IsObject o, MonadIO m) =>
Text -> m (GValueConstruct o)
constructObjectAccessibleId Text
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Maybe Text -> IO (GValueConstruct o)
forall o. String -> Maybe Text -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyString String
"accessible-id" (Text -> Maybe Text
forall a. a -> Maybe a
P.Just Text
val)

#if defined(ENABLE_OVERLOADING)
data ObjectAccessibleIdPropertyInfo
instance AttrInfo ObjectAccessibleIdPropertyInfo where
    type AttrAllowedOps ObjectAccessibleIdPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrPut]
    type AttrBaseTypeConstraint ObjectAccessibleIdPropertyInfo = IsObject
    type AttrSetTypeConstraint ObjectAccessibleIdPropertyInfo = (~) T.Text
    type AttrTransferTypeConstraint ObjectAccessibleIdPropertyInfo = (~) T.Text
    type AttrTransferType ObjectAccessibleIdPropertyInfo = T.Text
    type AttrGetType ObjectAccessibleIdPropertyInfo = T.Text
    type AttrLabel ObjectAccessibleIdPropertyInfo = "accessible-id"
    type AttrOrigin ObjectAccessibleIdPropertyInfo = Object
    attrGet :: forall o.
AttrBaseTypeConstraint ObjectAccessibleIdPropertyInfo o =>
o -> IO (AttrGetType ObjectAccessibleIdPropertyInfo)
attrGet = o -> IO Text
o -> IO (AttrGetType ObjectAccessibleIdPropertyInfo)
forall (m :: * -> *) o. (MonadIO m, IsObject o) => o -> m Text
getObjectAccessibleId
    attrSet :: forall o b.
(AttrBaseTypeConstraint ObjectAccessibleIdPropertyInfo o,
 AttrSetTypeConstraint ObjectAccessibleIdPropertyInfo b) =>
o -> b -> IO ()
attrSet = o -> b -> IO ()
o -> ObjectAnnouncementCallback
forall (m :: * -> *) o.
(MonadIO m, IsObject o) =>
o -> Text -> m ()
setObjectAccessibleId
    attrPut :: forall o.
AttrBaseTypeConstraint ObjectAccessibleIdPropertyInfo o =>
o -> AttrGetType ObjectAccessibleIdPropertyInfo -> IO ()
attrPut = o -> ObjectAnnouncementCallback
o -> AttrGetType ObjectAccessibleIdPropertyInfo -> IO ()
forall (m :: * -> *) o.
(MonadIO m, IsObject o) =>
o -> Text -> m ()
setObjectAccessibleId
    attrTransfer :: forall o b.
(AttrBaseTypeConstraint ObjectAccessibleIdPropertyInfo o,
 AttrTransferTypeConstraint ObjectAccessibleIdPropertyInfo b) =>
Proxy o
-> b -> IO (AttrTransferType ObjectAccessibleIdPropertyInfo)
attrTransfer Proxy o
_ b
v = do
        b -> IO b
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return b
v
    attrConstruct :: forall o b.
(AttrBaseTypeConstraint ObjectAccessibleIdPropertyInfo o,
 AttrSetTypeConstraint ObjectAccessibleIdPropertyInfo b) =>
b -> IO (GValueConstruct o)
attrConstruct = b -> IO (GValueConstruct o)
Text -> IO (GValueConstruct o)
forall o (m :: * -> *).
(IsObject o, MonadIO m) =>
Text -> m (GValueConstruct o)
constructObjectAccessibleId
    attrClear :: forall o.
AttrBaseTypeConstraint ObjectAccessibleIdPropertyInfo o =>
o -> IO ()
attrClear = o -> IO ()
forall a. HasCallStack => a
undefined
    dbgAttrInfo :: Maybe ResolvedSymbolInfo
dbgAttrInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
        resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.Atk.Objects.Object.accessibleId"
        , resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-atk-2.0.29/docs/GI-Atk-Objects-Object.html#g:attr:accessibleId"
        })
#endif

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

-- | Get the value of the “@accessible-name@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' object #accessibleName
-- @
getObjectAccessibleName :: (MonadIO m, IsObject o) => o -> m (Maybe T.Text)
getObjectAccessibleName :: forall (m :: * -> *) o.
(MonadIO m, IsObject o) =>
o -> m (Maybe Text)
getObjectAccessibleName o
obj = IO (Maybe Text) -> m (Maybe Text)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ o -> String -> IO (Maybe Text)
forall a. GObject a => a -> String -> IO (Maybe Text)
B.Properties.getObjectPropertyString o
obj String
"accessible-name"

-- | Set the value of the “@accessible-name@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' object [ #accessibleName 'Data.GI.Base.Attributes.:=' value ]
-- @
setObjectAccessibleName :: (MonadIO m, IsObject o) => o -> T.Text -> m ()
setObjectAccessibleName :: forall (m :: * -> *) o.
(MonadIO m, IsObject o) =>
o -> Text -> m ()
setObjectAccessibleName o
obj Text
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Maybe Text -> IO ()
forall a. GObject a => a -> String -> Maybe Text -> IO ()
B.Properties.setObjectPropertyString o
obj String
"accessible-name" (Text -> Maybe Text
forall a. a -> Maybe a
Just Text
val)

-- | Construct a t'GValueConstruct' with valid value for the “@accessible-name@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructObjectAccessibleName :: (IsObject o, MIO.MonadIO m) => T.Text -> m (GValueConstruct o)
constructObjectAccessibleName :: forall o (m :: * -> *).
(IsObject o, MonadIO m) =>
Text -> m (GValueConstruct o)
constructObjectAccessibleName Text
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Maybe Text -> IO (GValueConstruct o)
forall o. String -> Maybe Text -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyString String
"accessible-name" (Text -> Maybe Text
forall a. a -> Maybe a
P.Just Text
val)

-- | Set the value of the “@accessible-name@” property to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #accessibleName
-- @
clearObjectAccessibleName :: (MonadIO m, IsObject o) => o -> m ()
clearObjectAccessibleName :: forall (m :: * -> *) o. (MonadIO m, IsObject o) => o -> m ()
clearObjectAccessibleName o
obj = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ o -> String -> Maybe Text -> IO ()
forall a. GObject a => a -> String -> Maybe Text -> IO ()
B.Properties.setObjectPropertyString o
obj String
"accessible-name" (Maybe Text
forall a. Maybe a
Nothing :: Maybe T.Text)

#if defined(ENABLE_OVERLOADING)
data ObjectAccessibleNamePropertyInfo
instance AttrInfo ObjectAccessibleNamePropertyInfo where
    type AttrAllowedOps ObjectAccessibleNamePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint ObjectAccessibleNamePropertyInfo = IsObject
    type AttrSetTypeConstraint ObjectAccessibleNamePropertyInfo = (~) T.Text
    type AttrTransferTypeConstraint ObjectAccessibleNamePropertyInfo = (~) T.Text
    type AttrTransferType ObjectAccessibleNamePropertyInfo = T.Text
    type AttrGetType ObjectAccessibleNamePropertyInfo = (Maybe T.Text)
    type AttrLabel ObjectAccessibleNamePropertyInfo = "accessible-name"
    type AttrOrigin ObjectAccessibleNamePropertyInfo = Object
    attrGet :: forall o.
AttrBaseTypeConstraint ObjectAccessibleNamePropertyInfo o =>
o -> IO (AttrGetType ObjectAccessibleNamePropertyInfo)
attrGet = o -> IO (Maybe Text)
o -> IO (AttrGetType ObjectAccessibleNamePropertyInfo)
forall (m :: * -> *) o.
(MonadIO m, IsObject o) =>
o -> m (Maybe Text)
getObjectAccessibleName
    attrSet :: forall o b.
(AttrBaseTypeConstraint ObjectAccessibleNamePropertyInfo o,
 AttrSetTypeConstraint ObjectAccessibleNamePropertyInfo b) =>
o -> b -> IO ()
attrSet = o -> b -> IO ()
o -> ObjectAnnouncementCallback
forall (m :: * -> *) o.
(MonadIO m, IsObject o) =>
o -> Text -> m ()
setObjectAccessibleName
    attrPut :: forall o.
AttrBaseTypeConstraint ObjectAccessibleNamePropertyInfo o =>
o -> AttrGetType ObjectAccessibleNamePropertyInfo -> IO ()
attrPut = o -> Maybe Text -> IO ()
o -> AttrGetType ObjectAccessibleNamePropertyInfo -> IO ()
forall a. HasCallStack => a
undefined
    attrTransfer :: forall o b.
(AttrBaseTypeConstraint ObjectAccessibleNamePropertyInfo o,
 AttrTransferTypeConstraint ObjectAccessibleNamePropertyInfo b) =>
Proxy o
-> b -> IO (AttrTransferType ObjectAccessibleNamePropertyInfo)
attrTransfer Proxy o
_ b
v = do
        b -> IO b
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return b
v
    attrConstruct :: forall o b.
(AttrBaseTypeConstraint ObjectAccessibleNamePropertyInfo o,
 AttrSetTypeConstraint ObjectAccessibleNamePropertyInfo b) =>
b -> IO (GValueConstruct o)
attrConstruct = b -> IO (GValueConstruct o)
Text -> IO (GValueConstruct o)
forall o (m :: * -> *).
(IsObject o, MonadIO m) =>
Text -> m (GValueConstruct o)
constructObjectAccessibleName
    attrClear :: forall o.
AttrBaseTypeConstraint ObjectAccessibleNamePropertyInfo o =>
o -> IO ()
attrClear = o -> IO ()
forall (m :: * -> *) o. (MonadIO m, IsObject o) => o -> m ()
clearObjectAccessibleName
    dbgAttrInfo :: Maybe ResolvedSymbolInfo
dbgAttrInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
        resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.Atk.Objects.Object.accessibleName"
        , resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-atk-2.0.29/docs/GI-Atk-Objects-Object.html#g:attr:accessibleName"
        })
#endif

-- VVV Prop "accessible-parent"
   -- Type: TInterface (Name {namespace = "Atk", name = "Object"})
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Nothing,Nothing)

-- | Get the value of the “@accessible-parent@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' object #accessibleParent
-- @
getObjectAccessibleParent :: (MonadIO m, IsObject o) => o -> m (Maybe Object)
getObjectAccessibleParent :: forall (m :: * -> *) o.
(MonadIO m, IsObject o) =>
o -> m (Maybe Object)
getObjectAccessibleParent o
obj = IO (Maybe Object) -> m (Maybe Object)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (Maybe Object) -> m (Maybe Object))
-> IO (Maybe Object) -> m (Maybe Object)
forall a b. (a -> b) -> a -> b
$ o -> String -> (ManagedPtr Object -> Object) -> IO (Maybe Object)
forall a b.
(GObject a, GObject b) =>
a -> String -> (ManagedPtr b -> b) -> IO (Maybe b)
B.Properties.getObjectPropertyObject o
obj String
"accessible-parent" ManagedPtr Object -> Object
Object

-- | Set the value of the “@accessible-parent@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' object [ #accessibleParent 'Data.GI.Base.Attributes.:=' value ]
-- @
setObjectAccessibleParent :: (MonadIO m, IsObject o, IsObject a) => o -> a -> m ()
setObjectAccessibleParent :: forall (m :: * -> *) o a.
(MonadIO m, IsObject o, IsObject a) =>
o -> a -> m ()
setObjectAccessibleParent o
obj a
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Maybe a -> IO ()
forall a b.
(GObject a, GObject b) =>
a -> String -> Maybe b -> IO ()
B.Properties.setObjectPropertyObject o
obj String
"accessible-parent" (a -> Maybe a
forall a. a -> Maybe a
Just a
val)

-- | Construct a t'GValueConstruct' with valid value for the “@accessible-parent@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructObjectAccessibleParent :: (IsObject o, MIO.MonadIO m, IsObject a) => a -> m (GValueConstruct o)
constructObjectAccessibleParent :: forall o (m :: * -> *) a.
(IsObject o, MonadIO m, IsObject a) =>
a -> m (GValueConstruct o)
constructObjectAccessibleParent a
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Maybe a -> IO (GValueConstruct o)
forall a o.
GObject a =>
String -> Maybe a -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyObject String
"accessible-parent" (a -> Maybe a
forall a. a -> Maybe a
P.Just a
val)

-- | Set the value of the “@accessible-parent@” property to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #accessibleParent
-- @
clearObjectAccessibleParent :: (MonadIO m, IsObject o) => o -> m ()
clearObjectAccessibleParent :: forall (m :: * -> *) o. (MonadIO m, IsObject o) => o -> m ()
clearObjectAccessibleParent o
obj = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ o -> String -> Maybe Object -> IO ()
forall a b.
(GObject a, GObject b) =>
a -> String -> Maybe b -> IO ()
B.Properties.setObjectPropertyObject o
obj String
"accessible-parent" (Maybe Object
forall a. Maybe a
Nothing :: Maybe Object)

#if defined(ENABLE_OVERLOADING)
data ObjectAccessibleParentPropertyInfo
instance AttrInfo ObjectAccessibleParentPropertyInfo where
    type AttrAllowedOps ObjectAccessibleParentPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint ObjectAccessibleParentPropertyInfo = IsObject
    type AttrSetTypeConstraint ObjectAccessibleParentPropertyInfo = IsObject
    type AttrTransferTypeConstraint ObjectAccessibleParentPropertyInfo = IsObject
    type AttrTransferType ObjectAccessibleParentPropertyInfo = Object
    type AttrGetType ObjectAccessibleParentPropertyInfo = (Maybe Object)
    type AttrLabel ObjectAccessibleParentPropertyInfo = "accessible-parent"
    type AttrOrigin ObjectAccessibleParentPropertyInfo = Object
    attrGet :: forall o.
AttrBaseTypeConstraint ObjectAccessibleParentPropertyInfo o =>
o -> IO (AttrGetType ObjectAccessibleParentPropertyInfo)
attrGet = o -> IO (Maybe Object)
o -> IO (AttrGetType ObjectAccessibleParentPropertyInfo)
forall (m :: * -> *) o.
(MonadIO m, IsObject o) =>
o -> m (Maybe Object)
getObjectAccessibleParent
    attrSet :: forall o b.
(AttrBaseTypeConstraint ObjectAccessibleParentPropertyInfo o,
 AttrSetTypeConstraint ObjectAccessibleParentPropertyInfo b) =>
o -> b -> IO ()
attrSet = o -> b -> IO ()
forall (m :: * -> *) o a.
(MonadIO m, IsObject o, IsObject a) =>
o -> a -> m ()
setObjectAccessibleParent
    attrPut :: forall o.
AttrBaseTypeConstraint ObjectAccessibleParentPropertyInfo o =>
o -> AttrGetType ObjectAccessibleParentPropertyInfo -> IO ()
attrPut = o -> Maybe Object -> IO ()
o -> AttrGetType ObjectAccessibleParentPropertyInfo -> IO ()
forall a. HasCallStack => a
undefined
    attrTransfer :: forall o b.
(AttrBaseTypeConstraint ObjectAccessibleParentPropertyInfo o,
 AttrTransferTypeConstraint ObjectAccessibleParentPropertyInfo b) =>
Proxy o
-> b -> IO (AttrTransferType ObjectAccessibleParentPropertyInfo)
attrTransfer Proxy o
_ b
v = do
        (ManagedPtr Object -> Object) -> b -> IO Object
forall o o'.
(HasCallStack, ManagedPtrNewtype o, TypedObject o,
 ManagedPtrNewtype o', TypedObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
unsafeCastTo ManagedPtr Object -> Object
Object b
v
    attrConstruct :: forall o b.
(AttrBaseTypeConstraint ObjectAccessibleParentPropertyInfo o,
 AttrSetTypeConstraint ObjectAccessibleParentPropertyInfo b) =>
b -> IO (GValueConstruct o)
attrConstruct = b -> IO (GValueConstruct o)
forall o (m :: * -> *) a.
(IsObject o, MonadIO m, IsObject a) =>
a -> m (GValueConstruct o)
constructObjectAccessibleParent
    attrClear :: forall o.
AttrBaseTypeConstraint ObjectAccessibleParentPropertyInfo o =>
o -> IO ()
attrClear = o -> IO ()
forall (m :: * -> *) o. (MonadIO m, IsObject o) => o -> m ()
clearObjectAccessibleParent
    dbgAttrInfo :: Maybe ResolvedSymbolInfo
dbgAttrInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
        resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.Atk.Objects.Object.accessibleParent"
        , resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-atk-2.0.29/docs/GI-Atk-Objects-Object.html#g:attr:accessibleParent"
        })
#endif

-- VVV Prop "accessible-role"
   -- Type: TInterface (Name {namespace = "Atk", name = "Role"})
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Nothing,Nothing)

-- | Get the value of the “@accessible-role@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' object #accessibleRole
-- @
getObjectAccessibleRole :: (MonadIO m, IsObject o) => o -> m Atk.Enums.Role
getObjectAccessibleRole :: forall (m :: * -> *) o. (MonadIO m, IsObject o) => o -> m Role
getObjectAccessibleRole o
obj = IO Role -> m Role
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Role -> m Role) -> IO Role -> m Role
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Role
forall a b. (GObject a, Enum b, BoxedEnum b) => a -> String -> IO b
B.Properties.getObjectPropertyEnum o
obj String
"accessible-role"

-- | Set the value of the “@accessible-role@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' object [ #accessibleRole 'Data.GI.Base.Attributes.:=' value ]
-- @
setObjectAccessibleRole :: (MonadIO m, IsObject o) => o -> Atk.Enums.Role -> m ()
setObjectAccessibleRole :: forall (m :: * -> *) o.
(MonadIO m, IsObject o) =>
o -> Role -> m ()
setObjectAccessibleRole o
obj Role
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Role -> IO ()
forall a b.
(GObject a, Enum b, BoxedEnum b) =>
a -> String -> b -> IO ()
B.Properties.setObjectPropertyEnum o
obj String
"accessible-role" Role
val

-- | Construct a t'GValueConstruct' with valid value for the “@accessible-role@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructObjectAccessibleRole :: (IsObject o, MIO.MonadIO m) => Atk.Enums.Role -> m (GValueConstruct o)
constructObjectAccessibleRole :: forall o (m :: * -> *).
(IsObject o, MonadIO m) =>
Role -> m (GValueConstruct o)
constructObjectAccessibleRole Role
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Role -> IO (GValueConstruct o)
forall a o.
(Enum a, BoxedEnum a) =>
String -> a -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyEnum String
"accessible-role" Role
val

#if defined(ENABLE_OVERLOADING)
data ObjectAccessibleRolePropertyInfo
instance AttrInfo ObjectAccessibleRolePropertyInfo where
    type AttrAllowedOps ObjectAccessibleRolePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrPut]
    type AttrBaseTypeConstraint ObjectAccessibleRolePropertyInfo = IsObject
    type AttrSetTypeConstraint ObjectAccessibleRolePropertyInfo = (~) Atk.Enums.Role
    type AttrTransferTypeConstraint ObjectAccessibleRolePropertyInfo = (~) Atk.Enums.Role
    type AttrTransferType ObjectAccessibleRolePropertyInfo = Atk.Enums.Role
    type AttrGetType ObjectAccessibleRolePropertyInfo = Atk.Enums.Role
    type AttrLabel ObjectAccessibleRolePropertyInfo = "accessible-role"
    type AttrOrigin ObjectAccessibleRolePropertyInfo = Object
    attrGet :: forall o.
AttrBaseTypeConstraint ObjectAccessibleRolePropertyInfo o =>
o -> IO (AttrGetType ObjectAccessibleRolePropertyInfo)
attrGet = o -> IO (AttrGetType ObjectAccessibleRolePropertyInfo)
o -> IO Role
forall (m :: * -> *) o. (MonadIO m, IsObject o) => o -> m Role
getObjectAccessibleRole
    attrSet :: forall o b.
(AttrBaseTypeConstraint ObjectAccessibleRolePropertyInfo o,
 AttrSetTypeConstraint ObjectAccessibleRolePropertyInfo b) =>
o -> b -> IO ()
attrSet = o -> b -> IO ()
o -> Role -> IO ()
forall (m :: * -> *) o.
(MonadIO m, IsObject o) =>
o -> Role -> m ()
setObjectAccessibleRole
    attrPut :: forall o.
AttrBaseTypeConstraint ObjectAccessibleRolePropertyInfo o =>
o -> AttrGetType ObjectAccessibleRolePropertyInfo -> IO ()
attrPut = o -> AttrGetType ObjectAccessibleRolePropertyInfo -> IO ()
o -> Role -> IO ()
forall (m :: * -> *) o.
(MonadIO m, IsObject o) =>
o -> Role -> m ()
setObjectAccessibleRole
    attrTransfer :: forall o b.
(AttrBaseTypeConstraint ObjectAccessibleRolePropertyInfo o,
 AttrTransferTypeConstraint ObjectAccessibleRolePropertyInfo b) =>
Proxy o
-> b -> IO (AttrTransferType ObjectAccessibleRolePropertyInfo)
attrTransfer Proxy o
_ b
v = do
        b -> IO b
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return b
v
    attrConstruct :: forall o b.
(AttrBaseTypeConstraint ObjectAccessibleRolePropertyInfo o,
 AttrSetTypeConstraint ObjectAccessibleRolePropertyInfo b) =>
b -> IO (GValueConstruct o)
attrConstruct = b -> IO (GValueConstruct o)
Role -> IO (GValueConstruct o)
forall o (m :: * -> *).
(IsObject o, MonadIO m) =>
Role -> m (GValueConstruct o)
constructObjectAccessibleRole
    attrClear :: forall o.
AttrBaseTypeConstraint ObjectAccessibleRolePropertyInfo o =>
o -> IO ()
attrClear = o -> IO ()
forall a. HasCallStack => a
undefined
    dbgAttrInfo :: Maybe ResolvedSymbolInfo
dbgAttrInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
        resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.Atk.Objects.Object.accessibleRole"
        , resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-atk-2.0.29/docs/GI-Atk-Objects-Object.html#g:attr:accessibleRole"
        })
#endif

-- VVV Prop "accessible-table-caption"
   -- Type: TBasicType TUTF8
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Nothing,Nothing)

-- | Get the value of the “@accessible-table-caption@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' object #accessibleTableCaption
-- @
getObjectAccessibleTableCaption :: (MonadIO m, IsObject o) => o -> m (Maybe T.Text)
getObjectAccessibleTableCaption :: forall (m :: * -> *) o.
(MonadIO m, IsObject o) =>
o -> m (Maybe Text)
getObjectAccessibleTableCaption o
obj = IO (Maybe Text) -> m (Maybe Text)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ o -> String -> IO (Maybe Text)
forall a. GObject a => a -> String -> IO (Maybe Text)
B.Properties.getObjectPropertyString o
obj String
"accessible-table-caption"

-- | Set the value of the “@accessible-table-caption@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' object [ #accessibleTableCaption 'Data.GI.Base.Attributes.:=' value ]
-- @
setObjectAccessibleTableCaption :: (MonadIO m, IsObject o) => o -> T.Text -> m ()
setObjectAccessibleTableCaption :: forall (m :: * -> *) o.
(MonadIO m, IsObject o) =>
o -> Text -> m ()
setObjectAccessibleTableCaption o
obj Text
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Maybe Text -> IO ()
forall a. GObject a => a -> String -> Maybe Text -> IO ()
B.Properties.setObjectPropertyString o
obj String
"accessible-table-caption" (Text -> Maybe Text
forall a. a -> Maybe a
Just Text
val)

-- | Construct a t'GValueConstruct' with valid value for the “@accessible-table-caption@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructObjectAccessibleTableCaption :: (IsObject o, MIO.MonadIO m) => T.Text -> m (GValueConstruct o)
constructObjectAccessibleTableCaption :: forall o (m :: * -> *).
(IsObject o, MonadIO m) =>
Text -> m (GValueConstruct o)
constructObjectAccessibleTableCaption Text
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Maybe Text -> IO (GValueConstruct o)
forall o. String -> Maybe Text -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyString String
"accessible-table-caption" (Text -> Maybe Text
forall a. a -> Maybe a
P.Just Text
val)

-- | Set the value of the “@accessible-table-caption@” property to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #accessibleTableCaption
-- @
clearObjectAccessibleTableCaption :: (MonadIO m, IsObject o) => o -> m ()
clearObjectAccessibleTableCaption :: forall (m :: * -> *) o. (MonadIO m, IsObject o) => o -> m ()
clearObjectAccessibleTableCaption o
obj = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ o -> String -> Maybe Text -> IO ()
forall a. GObject a => a -> String -> Maybe Text -> IO ()
B.Properties.setObjectPropertyString o
obj String
"accessible-table-caption" (Maybe Text
forall a. Maybe a
Nothing :: Maybe T.Text)

#if defined(ENABLE_OVERLOADING)
data ObjectAccessibleTableCaptionPropertyInfo
instance AttrInfo ObjectAccessibleTableCaptionPropertyInfo where
    type AttrAllowedOps ObjectAccessibleTableCaptionPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint ObjectAccessibleTableCaptionPropertyInfo = IsObject
    type AttrSetTypeConstraint ObjectAccessibleTableCaptionPropertyInfo = (~) T.Text
    type AttrTransferTypeConstraint ObjectAccessibleTableCaptionPropertyInfo = (~) T.Text
    type AttrTransferType ObjectAccessibleTableCaptionPropertyInfo = T.Text
    type AttrGetType ObjectAccessibleTableCaptionPropertyInfo = (Maybe T.Text)
    type AttrLabel ObjectAccessibleTableCaptionPropertyInfo = "accessible-table-caption"
    type AttrOrigin ObjectAccessibleTableCaptionPropertyInfo = Object
    attrGet :: forall o.
AttrBaseTypeConstraint
  ObjectAccessibleTableCaptionPropertyInfo o =>
o -> IO (AttrGetType ObjectAccessibleTableCaptionPropertyInfo)
attrGet = o -> IO (Maybe Text)
o -> IO (AttrGetType ObjectAccessibleTableCaptionPropertyInfo)
forall (m :: * -> *) o.
(MonadIO m, IsObject o) =>
o -> m (Maybe Text)
getObjectAccessibleTableCaption
    attrSet :: forall o b.
(AttrBaseTypeConstraint ObjectAccessibleTableCaptionPropertyInfo o,
 AttrSetTypeConstraint
   ObjectAccessibleTableCaptionPropertyInfo b) =>
o -> b -> IO ()
attrSet = o -> b -> IO ()
o -> ObjectAnnouncementCallback
forall (m :: * -> *) o.
(MonadIO m, IsObject o) =>
o -> Text -> m ()
setObjectAccessibleTableCaption
    attrPut :: forall o.
AttrBaseTypeConstraint
  ObjectAccessibleTableCaptionPropertyInfo o =>
o -> AttrGetType ObjectAccessibleTableCaptionPropertyInfo -> IO ()
attrPut = o -> Maybe Text -> IO ()
o -> AttrGetType ObjectAccessibleTableCaptionPropertyInfo -> IO ()
forall a. HasCallStack => a
undefined
    attrTransfer :: forall o b.
(AttrBaseTypeConstraint ObjectAccessibleTableCaptionPropertyInfo o,
 AttrTransferTypeConstraint
   ObjectAccessibleTableCaptionPropertyInfo b) =>
Proxy o
-> b
-> IO (AttrTransferType ObjectAccessibleTableCaptionPropertyInfo)
attrTransfer Proxy o
_ b
v = do
        b -> IO b
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return b
v
    attrConstruct :: forall o b.
(AttrBaseTypeConstraint ObjectAccessibleTableCaptionPropertyInfo o,
 AttrSetTypeConstraint
   ObjectAccessibleTableCaptionPropertyInfo b) =>
b -> IO (GValueConstruct o)
attrConstruct = b -> IO (GValueConstruct o)
Text -> IO (GValueConstruct o)
forall o (m :: * -> *).
(IsObject o, MonadIO m) =>
Text -> m (GValueConstruct o)
constructObjectAccessibleTableCaption
    attrClear :: forall o.
AttrBaseTypeConstraint
  ObjectAccessibleTableCaptionPropertyInfo o =>
o -> IO ()
attrClear = o -> IO ()
forall (m :: * -> *) o. (MonadIO m, IsObject o) => o -> m ()
clearObjectAccessibleTableCaption
    dbgAttrInfo :: Maybe ResolvedSymbolInfo
dbgAttrInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
        resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.Atk.Objects.Object.accessibleTableCaption"
        , resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-atk-2.0.29/docs/GI-Atk-Objects-Object.html#g:attr:accessibleTableCaption"
        })
#endif

-- VVV Prop "accessible-table-caption-object"
   -- Type: TInterface (Name {namespace = "Atk", name = "Object"})
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Nothing,Nothing)

-- | Get the value of the “@accessible-table-caption-object@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' object #accessibleTableCaptionObject
-- @
getObjectAccessibleTableCaptionObject :: (MonadIO m, IsObject o) => o -> m (Maybe Object)
getObjectAccessibleTableCaptionObject :: forall (m :: * -> *) o.
(MonadIO m, IsObject o) =>
o -> m (Maybe Object)
getObjectAccessibleTableCaptionObject o
obj = IO (Maybe Object) -> m (Maybe Object)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (Maybe Object) -> m (Maybe Object))
-> IO (Maybe Object) -> m (Maybe Object)
forall a b. (a -> b) -> a -> b
$ o -> String -> (ManagedPtr Object -> Object) -> IO (Maybe Object)
forall a b.
(GObject a, GObject b) =>
a -> String -> (ManagedPtr b -> b) -> IO (Maybe b)
B.Properties.getObjectPropertyObject o
obj String
"accessible-table-caption-object" ManagedPtr Object -> Object
Object

-- | Set the value of the “@accessible-table-caption-object@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' object [ #accessibleTableCaptionObject 'Data.GI.Base.Attributes.:=' value ]
-- @
setObjectAccessibleTableCaptionObject :: (MonadIO m, IsObject o, IsObject a) => o -> a -> m ()
setObjectAccessibleTableCaptionObject :: forall (m :: * -> *) o a.
(MonadIO m, IsObject o, IsObject a) =>
o -> a -> m ()
setObjectAccessibleTableCaptionObject o
obj a
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Maybe a -> IO ()
forall a b.
(GObject a, GObject b) =>
a -> String -> Maybe b -> IO ()
B.Properties.setObjectPropertyObject o
obj String
"accessible-table-caption-object" (a -> Maybe a
forall a. a -> Maybe a
Just a
val)

-- | Construct a t'GValueConstruct' with valid value for the “@accessible-table-caption-object@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructObjectAccessibleTableCaptionObject :: (IsObject o, MIO.MonadIO m, IsObject a) => a -> m (GValueConstruct o)
constructObjectAccessibleTableCaptionObject :: forall o (m :: * -> *) a.
(IsObject o, MonadIO m, IsObject a) =>
a -> m (GValueConstruct o)
constructObjectAccessibleTableCaptionObject a
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Maybe a -> IO (GValueConstruct o)
forall a o.
GObject a =>
String -> Maybe a -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyObject String
"accessible-table-caption-object" (a -> Maybe a
forall a. a -> Maybe a
P.Just a
val)

-- | Set the value of the “@accessible-table-caption-object@” property to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #accessibleTableCaptionObject
-- @
clearObjectAccessibleTableCaptionObject :: (MonadIO m, IsObject o) => o -> m ()
clearObjectAccessibleTableCaptionObject :: forall (m :: * -> *) o. (MonadIO m, IsObject o) => o -> m ()
clearObjectAccessibleTableCaptionObject o
obj = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ o -> String -> Maybe Object -> IO ()
forall a b.
(GObject a, GObject b) =>
a -> String -> Maybe b -> IO ()
B.Properties.setObjectPropertyObject o
obj String
"accessible-table-caption-object" (Maybe Object
forall a. Maybe a
Nothing :: Maybe Object)

#if defined(ENABLE_OVERLOADING)
data ObjectAccessibleTableCaptionObjectPropertyInfo
instance AttrInfo ObjectAccessibleTableCaptionObjectPropertyInfo where
    type AttrAllowedOps ObjectAccessibleTableCaptionObjectPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint ObjectAccessibleTableCaptionObjectPropertyInfo = IsObject
    type AttrSetTypeConstraint ObjectAccessibleTableCaptionObjectPropertyInfo = IsObject
    type AttrTransferTypeConstraint ObjectAccessibleTableCaptionObjectPropertyInfo = IsObject
    type AttrTransferType ObjectAccessibleTableCaptionObjectPropertyInfo = Object
    type AttrGetType ObjectAccessibleTableCaptionObjectPropertyInfo = (Maybe Object)
    type AttrLabel ObjectAccessibleTableCaptionObjectPropertyInfo = "accessible-table-caption-object"
    type AttrOrigin ObjectAccessibleTableCaptionObjectPropertyInfo = Object
    attrGet :: forall o.
AttrBaseTypeConstraint
  ObjectAccessibleTableCaptionObjectPropertyInfo o =>
o
-> IO (AttrGetType ObjectAccessibleTableCaptionObjectPropertyInfo)
attrGet = o -> IO (Maybe Object)
o
-> IO (AttrGetType ObjectAccessibleTableCaptionObjectPropertyInfo)
forall (m :: * -> *) o.
(MonadIO m, IsObject o) =>
o -> m (Maybe Object)
getObjectAccessibleTableCaptionObject
    attrSet :: forall o b.
(AttrBaseTypeConstraint
   ObjectAccessibleTableCaptionObjectPropertyInfo o,
 AttrSetTypeConstraint
   ObjectAccessibleTableCaptionObjectPropertyInfo b) =>
o -> b -> IO ()
attrSet = o -> b -> IO ()
forall (m :: * -> *) o a.
(MonadIO m, IsObject o, IsObject a) =>
o -> a -> m ()
setObjectAccessibleTableCaptionObject
    attrPut :: forall o.
AttrBaseTypeConstraint
  ObjectAccessibleTableCaptionObjectPropertyInfo o =>
o
-> AttrGetType ObjectAccessibleTableCaptionObjectPropertyInfo
-> IO ()
attrPut = o -> Maybe Object -> IO ()
o
-> AttrGetType ObjectAccessibleTableCaptionObjectPropertyInfo
-> IO ()
forall a. HasCallStack => a
undefined
    attrTransfer :: forall o b.
(AttrBaseTypeConstraint
   ObjectAccessibleTableCaptionObjectPropertyInfo o,
 AttrTransferTypeConstraint
   ObjectAccessibleTableCaptionObjectPropertyInfo b) =>
Proxy o
-> b
-> IO
     (AttrTransferType ObjectAccessibleTableCaptionObjectPropertyInfo)
attrTransfer Proxy o
_ b
v = do
        (ManagedPtr Object -> Object) -> b -> IO Object
forall o o'.
(HasCallStack, ManagedPtrNewtype o, TypedObject o,
 ManagedPtrNewtype o', TypedObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
unsafeCastTo ManagedPtr Object -> Object
Object b
v
    attrConstruct :: forall o b.
(AttrBaseTypeConstraint
   ObjectAccessibleTableCaptionObjectPropertyInfo o,
 AttrSetTypeConstraint
   ObjectAccessibleTableCaptionObjectPropertyInfo b) =>
b -> IO (GValueConstruct o)
attrConstruct = b -> IO (GValueConstruct o)
forall o (m :: * -> *) a.
(IsObject o, MonadIO m, IsObject a) =>
a -> m (GValueConstruct o)
constructObjectAccessibleTableCaptionObject
    attrClear :: forall o.
AttrBaseTypeConstraint
  ObjectAccessibleTableCaptionObjectPropertyInfo o =>
o -> IO ()
attrClear = o -> IO ()
forall (m :: * -> *) o. (MonadIO m, IsObject o) => o -> m ()
clearObjectAccessibleTableCaptionObject
    dbgAttrInfo :: Maybe ResolvedSymbolInfo
dbgAttrInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
        resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.Atk.Objects.Object.accessibleTableCaptionObject"
        , resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-atk-2.0.29/docs/GI-Atk-Objects-Object.html#g:attr:accessibleTableCaptionObject"
        })
#endif

-- VVV Prop "accessible-table-column-description"
   -- Type: TBasicType TUTF8
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Nothing,Nothing)

-- | Get the value of the “@accessible-table-column-description@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' object #accessibleTableColumnDescription
-- @
getObjectAccessibleTableColumnDescription :: (MonadIO m, IsObject o) => o -> m (Maybe T.Text)
getObjectAccessibleTableColumnDescription :: forall (m :: * -> *) o.
(MonadIO m, IsObject o) =>
o -> m (Maybe Text)
getObjectAccessibleTableColumnDescription o
obj = IO (Maybe Text) -> m (Maybe Text)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ o -> String -> IO (Maybe Text)
forall a. GObject a => a -> String -> IO (Maybe Text)
B.Properties.getObjectPropertyString o
obj String
"accessible-table-column-description"

-- | Set the value of the “@accessible-table-column-description@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' object [ #accessibleTableColumnDescription 'Data.GI.Base.Attributes.:=' value ]
-- @
setObjectAccessibleTableColumnDescription :: (MonadIO m, IsObject o) => o -> T.Text -> m ()
setObjectAccessibleTableColumnDescription :: forall (m :: * -> *) o.
(MonadIO m, IsObject o) =>
o -> Text -> m ()
setObjectAccessibleTableColumnDescription o
obj Text
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Maybe Text -> IO ()
forall a. GObject a => a -> String -> Maybe Text -> IO ()
B.Properties.setObjectPropertyString o
obj String
"accessible-table-column-description" (Text -> Maybe Text
forall a. a -> Maybe a
Just Text
val)

-- | Construct a t'GValueConstruct' with valid value for the “@accessible-table-column-description@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructObjectAccessibleTableColumnDescription :: (IsObject o, MIO.MonadIO m) => T.Text -> m (GValueConstruct o)
constructObjectAccessibleTableColumnDescription :: forall o (m :: * -> *).
(IsObject o, MonadIO m) =>
Text -> m (GValueConstruct o)
constructObjectAccessibleTableColumnDescription Text
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Maybe Text -> IO (GValueConstruct o)
forall o. String -> Maybe Text -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyString String
"accessible-table-column-description" (Text -> Maybe Text
forall a. a -> Maybe a
P.Just Text
val)

-- | Set the value of the “@accessible-table-column-description@” property to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #accessibleTableColumnDescription
-- @
clearObjectAccessibleTableColumnDescription :: (MonadIO m, IsObject o) => o -> m ()
clearObjectAccessibleTableColumnDescription :: forall (m :: * -> *) o. (MonadIO m, IsObject o) => o -> m ()
clearObjectAccessibleTableColumnDescription o
obj = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ o -> String -> Maybe Text -> IO ()
forall a. GObject a => a -> String -> Maybe Text -> IO ()
B.Properties.setObjectPropertyString o
obj String
"accessible-table-column-description" (Maybe Text
forall a. Maybe a
Nothing :: Maybe T.Text)

#if defined(ENABLE_OVERLOADING)
data ObjectAccessibleTableColumnDescriptionPropertyInfo
instance AttrInfo ObjectAccessibleTableColumnDescriptionPropertyInfo where
    type AttrAllowedOps ObjectAccessibleTableColumnDescriptionPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint ObjectAccessibleTableColumnDescriptionPropertyInfo = IsObject
    type AttrSetTypeConstraint ObjectAccessibleTableColumnDescriptionPropertyInfo = (~) T.Text
    type AttrTransferTypeConstraint ObjectAccessibleTableColumnDescriptionPropertyInfo = (~) T.Text
    type AttrTransferType ObjectAccessibleTableColumnDescriptionPropertyInfo = T.Text
    type AttrGetType ObjectAccessibleTableColumnDescriptionPropertyInfo = (Maybe T.Text)
    type AttrLabel ObjectAccessibleTableColumnDescriptionPropertyInfo = "accessible-table-column-description"
    type AttrOrigin ObjectAccessibleTableColumnDescriptionPropertyInfo = Object
    attrGet :: forall o.
AttrBaseTypeConstraint
  ObjectAccessibleTableColumnDescriptionPropertyInfo o =>
o
-> IO
     (AttrGetType ObjectAccessibleTableColumnDescriptionPropertyInfo)
attrGet = o -> IO (Maybe Text)
o
-> IO
     (AttrGetType ObjectAccessibleTableColumnDescriptionPropertyInfo)
forall (m :: * -> *) o.
(MonadIO m, IsObject o) =>
o -> m (Maybe Text)
getObjectAccessibleTableColumnDescription
    attrSet :: forall o b.
(AttrBaseTypeConstraint
   ObjectAccessibleTableColumnDescriptionPropertyInfo o,
 AttrSetTypeConstraint
   ObjectAccessibleTableColumnDescriptionPropertyInfo b) =>
o -> b -> IO ()
attrSet = o -> b -> IO ()
o -> ObjectAnnouncementCallback
forall (m :: * -> *) o.
(MonadIO m, IsObject o) =>
o -> Text -> m ()
setObjectAccessibleTableColumnDescription
    attrPut :: forall o.
AttrBaseTypeConstraint
  ObjectAccessibleTableColumnDescriptionPropertyInfo o =>
o
-> AttrGetType ObjectAccessibleTableColumnDescriptionPropertyInfo
-> IO ()
attrPut = o -> Maybe Text -> IO ()
o
-> AttrGetType ObjectAccessibleTableColumnDescriptionPropertyInfo
-> IO ()
forall a. HasCallStack => a
undefined
    attrTransfer :: forall o b.
(AttrBaseTypeConstraint
   ObjectAccessibleTableColumnDescriptionPropertyInfo o,
 AttrTransferTypeConstraint
   ObjectAccessibleTableColumnDescriptionPropertyInfo b) =>
Proxy o
-> b
-> IO
     (AttrTransferType
        ObjectAccessibleTableColumnDescriptionPropertyInfo)
attrTransfer Proxy o
_ b
v = do
        b -> IO b
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return b
v
    attrConstruct :: forall o b.
(AttrBaseTypeConstraint
   ObjectAccessibleTableColumnDescriptionPropertyInfo o,
 AttrSetTypeConstraint
   ObjectAccessibleTableColumnDescriptionPropertyInfo b) =>
b -> IO (GValueConstruct o)
attrConstruct = b -> IO (GValueConstruct o)
Text -> IO (GValueConstruct o)
forall o (m :: * -> *).
(IsObject o, MonadIO m) =>
Text -> m (GValueConstruct o)
constructObjectAccessibleTableColumnDescription
    attrClear :: forall o.
AttrBaseTypeConstraint
  ObjectAccessibleTableColumnDescriptionPropertyInfo o =>
o -> IO ()
attrClear = o -> IO ()
forall (m :: * -> *) o. (MonadIO m, IsObject o) => o -> m ()
clearObjectAccessibleTableColumnDescription
    dbgAttrInfo :: Maybe ResolvedSymbolInfo
dbgAttrInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
        resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.Atk.Objects.Object.accessibleTableColumnDescription"
        , resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-atk-2.0.29/docs/GI-Atk-Objects-Object.html#g:attr:accessibleTableColumnDescription"
        })
#endif

-- VVV Prop "accessible-table-column-header"
   -- Type: TInterface (Name {namespace = "Atk", name = "Object"})
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Nothing,Nothing)

-- | Get the value of the “@accessible-table-column-header@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' object #accessibleTableColumnHeader
-- @
getObjectAccessibleTableColumnHeader :: (MonadIO m, IsObject o) => o -> m (Maybe Object)
getObjectAccessibleTableColumnHeader :: forall (m :: * -> *) o.
(MonadIO m, IsObject o) =>
o -> m (Maybe Object)
getObjectAccessibleTableColumnHeader o
obj = IO (Maybe Object) -> m (Maybe Object)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (Maybe Object) -> m (Maybe Object))
-> IO (Maybe Object) -> m (Maybe Object)
forall a b. (a -> b) -> a -> b
$ o -> String -> (ManagedPtr Object -> Object) -> IO (Maybe Object)
forall a b.
(GObject a, GObject b) =>
a -> String -> (ManagedPtr b -> b) -> IO (Maybe b)
B.Properties.getObjectPropertyObject o
obj String
"accessible-table-column-header" ManagedPtr Object -> Object
Object

-- | Set the value of the “@accessible-table-column-header@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' object [ #accessibleTableColumnHeader 'Data.GI.Base.Attributes.:=' value ]
-- @
setObjectAccessibleTableColumnHeader :: (MonadIO m, IsObject o, IsObject a) => o -> a -> m ()
setObjectAccessibleTableColumnHeader :: forall (m :: * -> *) o a.
(MonadIO m, IsObject o, IsObject a) =>
o -> a -> m ()
setObjectAccessibleTableColumnHeader o
obj a
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Maybe a -> IO ()
forall a b.
(GObject a, GObject b) =>
a -> String -> Maybe b -> IO ()
B.Properties.setObjectPropertyObject o
obj String
"accessible-table-column-header" (a -> Maybe a
forall a. a -> Maybe a
Just a
val)

-- | Construct a t'GValueConstruct' with valid value for the “@accessible-table-column-header@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructObjectAccessibleTableColumnHeader :: (IsObject o, MIO.MonadIO m, IsObject a) => a -> m (GValueConstruct o)
constructObjectAccessibleTableColumnHeader :: forall o (m :: * -> *) a.
(IsObject o, MonadIO m, IsObject a) =>
a -> m (GValueConstruct o)
constructObjectAccessibleTableColumnHeader a
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Maybe a -> IO (GValueConstruct o)
forall a o.
GObject a =>
String -> Maybe a -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyObject String
"accessible-table-column-header" (a -> Maybe a
forall a. a -> Maybe a
P.Just a
val)

-- | Set the value of the “@accessible-table-column-header@” property to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #accessibleTableColumnHeader
-- @
clearObjectAccessibleTableColumnHeader :: (MonadIO m, IsObject o) => o -> m ()
clearObjectAccessibleTableColumnHeader :: forall (m :: * -> *) o. (MonadIO m, IsObject o) => o -> m ()
clearObjectAccessibleTableColumnHeader o
obj = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ o -> String -> Maybe Object -> IO ()
forall a b.
(GObject a, GObject b) =>
a -> String -> Maybe b -> IO ()
B.Properties.setObjectPropertyObject o
obj String
"accessible-table-column-header" (Maybe Object
forall a. Maybe a
Nothing :: Maybe Object)

#if defined(ENABLE_OVERLOADING)
data ObjectAccessibleTableColumnHeaderPropertyInfo
instance AttrInfo ObjectAccessibleTableColumnHeaderPropertyInfo where
    type AttrAllowedOps ObjectAccessibleTableColumnHeaderPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint ObjectAccessibleTableColumnHeaderPropertyInfo = IsObject
    type AttrSetTypeConstraint ObjectAccessibleTableColumnHeaderPropertyInfo = IsObject
    type AttrTransferTypeConstraint ObjectAccessibleTableColumnHeaderPropertyInfo = IsObject
    type AttrTransferType ObjectAccessibleTableColumnHeaderPropertyInfo = Object
    type AttrGetType ObjectAccessibleTableColumnHeaderPropertyInfo = (Maybe Object)
    type AttrLabel ObjectAccessibleTableColumnHeaderPropertyInfo = "accessible-table-column-header"
    type AttrOrigin ObjectAccessibleTableColumnHeaderPropertyInfo = Object
    attrGet :: forall o.
AttrBaseTypeConstraint
  ObjectAccessibleTableColumnHeaderPropertyInfo o =>
o -> IO (AttrGetType ObjectAccessibleTableColumnHeaderPropertyInfo)
attrGet = o -> IO (Maybe Object)
o -> IO (AttrGetType ObjectAccessibleTableColumnHeaderPropertyInfo)
forall (m :: * -> *) o.
(MonadIO m, IsObject o) =>
o -> m (Maybe Object)
getObjectAccessibleTableColumnHeader
    attrSet :: forall o b.
(AttrBaseTypeConstraint
   ObjectAccessibleTableColumnHeaderPropertyInfo o,
 AttrSetTypeConstraint
   ObjectAccessibleTableColumnHeaderPropertyInfo b) =>
o -> b -> IO ()
attrSet = o -> b -> IO ()
forall (m :: * -> *) o a.
(MonadIO m, IsObject o, IsObject a) =>
o -> a -> m ()
setObjectAccessibleTableColumnHeader
    attrPut :: forall o.
AttrBaseTypeConstraint
  ObjectAccessibleTableColumnHeaderPropertyInfo o =>
o
-> AttrGetType ObjectAccessibleTableColumnHeaderPropertyInfo
-> IO ()
attrPut = o -> Maybe Object -> IO ()
o
-> AttrGetType ObjectAccessibleTableColumnHeaderPropertyInfo
-> IO ()
forall a. HasCallStack => a
undefined
    attrTransfer :: forall o b.
(AttrBaseTypeConstraint
   ObjectAccessibleTableColumnHeaderPropertyInfo o,
 AttrTransferTypeConstraint
   ObjectAccessibleTableColumnHeaderPropertyInfo b) =>
Proxy o
-> b
-> IO
     (AttrTransferType ObjectAccessibleTableColumnHeaderPropertyInfo)
attrTransfer Proxy o
_ b
v = do
        (ManagedPtr Object -> Object) -> b -> IO Object
forall o o'.
(HasCallStack, ManagedPtrNewtype o, TypedObject o,
 ManagedPtrNewtype o', TypedObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
unsafeCastTo ManagedPtr Object -> Object
Object b
v
    attrConstruct :: forall o b.
(AttrBaseTypeConstraint
   ObjectAccessibleTableColumnHeaderPropertyInfo o,
 AttrSetTypeConstraint
   ObjectAccessibleTableColumnHeaderPropertyInfo b) =>
b -> IO (GValueConstruct o)
attrConstruct = b -> IO (GValueConstruct o)
forall o (m :: * -> *) a.
(IsObject o, MonadIO m, IsObject a) =>
a -> m (GValueConstruct o)
constructObjectAccessibleTableColumnHeader
    attrClear :: forall o.
AttrBaseTypeConstraint
  ObjectAccessibleTableColumnHeaderPropertyInfo o =>
o -> IO ()
attrClear = o -> IO ()
forall (m :: * -> *) o. (MonadIO m, IsObject o) => o -> m ()
clearObjectAccessibleTableColumnHeader
    dbgAttrInfo :: Maybe ResolvedSymbolInfo
dbgAttrInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
        resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.Atk.Objects.Object.accessibleTableColumnHeader"
        , resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-atk-2.0.29/docs/GI-Atk-Objects-Object.html#g:attr:accessibleTableColumnHeader"
        })
#endif

-- VVV Prop "accessible-table-row-description"
   -- Type: TBasicType TUTF8
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Nothing,Nothing)

-- | Get the value of the “@accessible-table-row-description@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' object #accessibleTableRowDescription
-- @
getObjectAccessibleTableRowDescription :: (MonadIO m, IsObject o) => o -> m (Maybe T.Text)
getObjectAccessibleTableRowDescription :: forall (m :: * -> *) o.
(MonadIO m, IsObject o) =>
o -> m (Maybe Text)
getObjectAccessibleTableRowDescription o
obj = IO (Maybe Text) -> m (Maybe Text)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ o -> String -> IO (Maybe Text)
forall a. GObject a => a -> String -> IO (Maybe Text)
B.Properties.getObjectPropertyString o
obj String
"accessible-table-row-description"

-- | Set the value of the “@accessible-table-row-description@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' object [ #accessibleTableRowDescription 'Data.GI.Base.Attributes.:=' value ]
-- @
setObjectAccessibleTableRowDescription :: (MonadIO m, IsObject o) => o -> T.Text -> m ()
setObjectAccessibleTableRowDescription :: forall (m :: * -> *) o.
(MonadIO m, IsObject o) =>
o -> Text -> m ()
setObjectAccessibleTableRowDescription o
obj Text
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Maybe Text -> IO ()
forall a. GObject a => a -> String -> Maybe Text -> IO ()
B.Properties.setObjectPropertyString o
obj String
"accessible-table-row-description" (Text -> Maybe Text
forall a. a -> Maybe a
Just Text
val)

-- | Construct a t'GValueConstruct' with valid value for the “@accessible-table-row-description@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructObjectAccessibleTableRowDescription :: (IsObject o, MIO.MonadIO m) => T.Text -> m (GValueConstruct o)
constructObjectAccessibleTableRowDescription :: forall o (m :: * -> *).
(IsObject o, MonadIO m) =>
Text -> m (GValueConstruct o)
constructObjectAccessibleTableRowDescription Text
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Maybe Text -> IO (GValueConstruct o)
forall o. String -> Maybe Text -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyString String
"accessible-table-row-description" (Text -> Maybe Text
forall a. a -> Maybe a
P.Just Text
val)

-- | Set the value of the “@accessible-table-row-description@” property to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #accessibleTableRowDescription
-- @
clearObjectAccessibleTableRowDescription :: (MonadIO m, IsObject o) => o -> m ()
clearObjectAccessibleTableRowDescription :: forall (m :: * -> *) o. (MonadIO m, IsObject o) => o -> m ()
clearObjectAccessibleTableRowDescription o
obj = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ o -> String -> Maybe Text -> IO ()
forall a. GObject a => a -> String -> Maybe Text -> IO ()
B.Properties.setObjectPropertyString o
obj String
"accessible-table-row-description" (Maybe Text
forall a. Maybe a
Nothing :: Maybe T.Text)

#if defined(ENABLE_OVERLOADING)
data ObjectAccessibleTableRowDescriptionPropertyInfo
instance AttrInfo ObjectAccessibleTableRowDescriptionPropertyInfo where
    type AttrAllowedOps ObjectAccessibleTableRowDescriptionPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint ObjectAccessibleTableRowDescriptionPropertyInfo = IsObject
    type AttrSetTypeConstraint ObjectAccessibleTableRowDescriptionPropertyInfo = (~) T.Text
    type AttrTransferTypeConstraint ObjectAccessibleTableRowDescriptionPropertyInfo = (~) T.Text
    type AttrTransferType ObjectAccessibleTableRowDescriptionPropertyInfo = T.Text
    type AttrGetType ObjectAccessibleTableRowDescriptionPropertyInfo = (Maybe T.Text)
    type AttrLabel ObjectAccessibleTableRowDescriptionPropertyInfo = "accessible-table-row-description"
    type AttrOrigin ObjectAccessibleTableRowDescriptionPropertyInfo = Object
    attrGet :: forall o.
AttrBaseTypeConstraint
  ObjectAccessibleTableRowDescriptionPropertyInfo o =>
o
-> IO (AttrGetType ObjectAccessibleTableRowDescriptionPropertyInfo)
attrGet = o -> IO (Maybe Text)
o
-> IO (AttrGetType ObjectAccessibleTableRowDescriptionPropertyInfo)
forall (m :: * -> *) o.
(MonadIO m, IsObject o) =>
o -> m (Maybe Text)
getObjectAccessibleTableRowDescription
    attrSet :: forall o b.
(AttrBaseTypeConstraint
   ObjectAccessibleTableRowDescriptionPropertyInfo o,
 AttrSetTypeConstraint
   ObjectAccessibleTableRowDescriptionPropertyInfo b) =>
o -> b -> IO ()
attrSet = o -> b -> IO ()
o -> ObjectAnnouncementCallback
forall (m :: * -> *) o.
(MonadIO m, IsObject o) =>
o -> Text -> m ()
setObjectAccessibleTableRowDescription
    attrPut :: forall o.
AttrBaseTypeConstraint
  ObjectAccessibleTableRowDescriptionPropertyInfo o =>
o
-> AttrGetType ObjectAccessibleTableRowDescriptionPropertyInfo
-> IO ()
attrPut = o -> Maybe Text -> IO ()
o
-> AttrGetType ObjectAccessibleTableRowDescriptionPropertyInfo
-> IO ()
forall a. HasCallStack => a
undefined
    attrTransfer :: forall o b.
(AttrBaseTypeConstraint
   ObjectAccessibleTableRowDescriptionPropertyInfo o,
 AttrTransferTypeConstraint
   ObjectAccessibleTableRowDescriptionPropertyInfo b) =>
Proxy o
-> b
-> IO
     (AttrTransferType ObjectAccessibleTableRowDescriptionPropertyInfo)
attrTransfer Proxy o
_ b
v = do
        b -> IO b
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return b
v
    attrConstruct :: forall o b.
(AttrBaseTypeConstraint
   ObjectAccessibleTableRowDescriptionPropertyInfo o,
 AttrSetTypeConstraint
   ObjectAccessibleTableRowDescriptionPropertyInfo b) =>
b -> IO (GValueConstruct o)
attrConstruct = b -> IO (GValueConstruct o)
Text -> IO (GValueConstruct o)
forall o (m :: * -> *).
(IsObject o, MonadIO m) =>
Text -> m (GValueConstruct o)
constructObjectAccessibleTableRowDescription
    attrClear :: forall o.
AttrBaseTypeConstraint
  ObjectAccessibleTableRowDescriptionPropertyInfo o =>
o -> IO ()
attrClear = o -> IO ()
forall (m :: * -> *) o. (MonadIO m, IsObject o) => o -> m ()
clearObjectAccessibleTableRowDescription
    dbgAttrInfo :: Maybe ResolvedSymbolInfo
dbgAttrInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
        resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.Atk.Objects.Object.accessibleTableRowDescription"
        , resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-atk-2.0.29/docs/GI-Atk-Objects-Object.html#g:attr:accessibleTableRowDescription"
        })
#endif

-- VVV Prop "accessible-table-row-header"
   -- Type: TInterface (Name {namespace = "Atk", name = "Object"})
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Nothing,Nothing)

-- | Get the value of the “@accessible-table-row-header@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' object #accessibleTableRowHeader
-- @
getObjectAccessibleTableRowHeader :: (MonadIO m, IsObject o) => o -> m (Maybe Object)
getObjectAccessibleTableRowHeader :: forall (m :: * -> *) o.
(MonadIO m, IsObject o) =>
o -> m (Maybe Object)
getObjectAccessibleTableRowHeader o
obj = IO (Maybe Object) -> m (Maybe Object)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (Maybe Object) -> m (Maybe Object))
-> IO (Maybe Object) -> m (Maybe Object)
forall a b. (a -> b) -> a -> b
$ o -> String -> (ManagedPtr Object -> Object) -> IO (Maybe Object)
forall a b.
(GObject a, GObject b) =>
a -> String -> (ManagedPtr b -> b) -> IO (Maybe b)
B.Properties.getObjectPropertyObject o
obj String
"accessible-table-row-header" ManagedPtr Object -> Object
Object

-- | Set the value of the “@accessible-table-row-header@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' object [ #accessibleTableRowHeader 'Data.GI.Base.Attributes.:=' value ]
-- @
setObjectAccessibleTableRowHeader :: (MonadIO m, IsObject o, IsObject a) => o -> a -> m ()
setObjectAccessibleTableRowHeader :: forall (m :: * -> *) o a.
(MonadIO m, IsObject o, IsObject a) =>
o -> a -> m ()
setObjectAccessibleTableRowHeader o
obj a
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Maybe a -> IO ()
forall a b.
(GObject a, GObject b) =>
a -> String -> Maybe b -> IO ()
B.Properties.setObjectPropertyObject o
obj String
"accessible-table-row-header" (a -> Maybe a
forall a. a -> Maybe a
Just a
val)

-- | Construct a t'GValueConstruct' with valid value for the “@accessible-table-row-header@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructObjectAccessibleTableRowHeader :: (IsObject o, MIO.MonadIO m, IsObject a) => a -> m (GValueConstruct o)
constructObjectAccessibleTableRowHeader :: forall o (m :: * -> *) a.
(IsObject o, MonadIO m, IsObject a) =>
a -> m (GValueConstruct o)
constructObjectAccessibleTableRowHeader a
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Maybe a -> IO (GValueConstruct o)
forall a o.
GObject a =>
String -> Maybe a -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyObject String
"accessible-table-row-header" (a -> Maybe a
forall a. a -> Maybe a
P.Just a
val)

-- | Set the value of the “@accessible-table-row-header@” property to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #accessibleTableRowHeader
-- @
clearObjectAccessibleTableRowHeader :: (MonadIO m, IsObject o) => o -> m ()
clearObjectAccessibleTableRowHeader :: forall (m :: * -> *) o. (MonadIO m, IsObject o) => o -> m ()
clearObjectAccessibleTableRowHeader o
obj = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ o -> String -> Maybe Object -> IO ()
forall a b.
(GObject a, GObject b) =>
a -> String -> Maybe b -> IO ()
B.Properties.setObjectPropertyObject o
obj String
"accessible-table-row-header" (Maybe Object
forall a. Maybe a
Nothing :: Maybe Object)

#if defined(ENABLE_OVERLOADING)
data ObjectAccessibleTableRowHeaderPropertyInfo
instance AttrInfo ObjectAccessibleTableRowHeaderPropertyInfo where
    type AttrAllowedOps ObjectAccessibleTableRowHeaderPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint ObjectAccessibleTableRowHeaderPropertyInfo = IsObject
    type AttrSetTypeConstraint ObjectAccessibleTableRowHeaderPropertyInfo = IsObject
    type AttrTransferTypeConstraint ObjectAccessibleTableRowHeaderPropertyInfo = IsObject
    type AttrTransferType ObjectAccessibleTableRowHeaderPropertyInfo = Object
    type AttrGetType ObjectAccessibleTableRowHeaderPropertyInfo = (Maybe Object)
    type AttrLabel ObjectAccessibleTableRowHeaderPropertyInfo = "accessible-table-row-header"
    type AttrOrigin ObjectAccessibleTableRowHeaderPropertyInfo = Object
    attrGet :: forall o.
AttrBaseTypeConstraint
  ObjectAccessibleTableRowHeaderPropertyInfo o =>
o -> IO (AttrGetType ObjectAccessibleTableRowHeaderPropertyInfo)
attrGet = o -> IO (Maybe Object)
o -> IO (AttrGetType ObjectAccessibleTableRowHeaderPropertyInfo)
forall (m :: * -> *) o.
(MonadIO m, IsObject o) =>
o -> m (Maybe Object)
getObjectAccessibleTableRowHeader
    attrSet :: forall o b.
(AttrBaseTypeConstraint
   ObjectAccessibleTableRowHeaderPropertyInfo o,
 AttrSetTypeConstraint
   ObjectAccessibleTableRowHeaderPropertyInfo b) =>
o -> b -> IO ()
attrSet = o -> b -> IO ()
forall (m :: * -> *) o a.
(MonadIO m, IsObject o, IsObject a) =>
o -> a -> m ()
setObjectAccessibleTableRowHeader
    attrPut :: forall o.
AttrBaseTypeConstraint
  ObjectAccessibleTableRowHeaderPropertyInfo o =>
o
-> AttrGetType ObjectAccessibleTableRowHeaderPropertyInfo -> IO ()
attrPut = o -> Maybe Object -> IO ()
o
-> AttrGetType ObjectAccessibleTableRowHeaderPropertyInfo -> IO ()
forall a. HasCallStack => a
undefined
    attrTransfer :: forall o b.
(AttrBaseTypeConstraint
   ObjectAccessibleTableRowHeaderPropertyInfo o,
 AttrTransferTypeConstraint
   ObjectAccessibleTableRowHeaderPropertyInfo b) =>
Proxy o
-> b
-> IO (AttrTransferType ObjectAccessibleTableRowHeaderPropertyInfo)
attrTransfer Proxy o
_ b
v = do
        (ManagedPtr Object -> Object) -> b -> IO Object
forall o o'.
(HasCallStack, ManagedPtrNewtype o, TypedObject o,
 ManagedPtrNewtype o', TypedObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
unsafeCastTo ManagedPtr Object -> Object
Object b
v
    attrConstruct :: forall o b.
(AttrBaseTypeConstraint
   ObjectAccessibleTableRowHeaderPropertyInfo o,
 AttrSetTypeConstraint
   ObjectAccessibleTableRowHeaderPropertyInfo b) =>
b -> IO (GValueConstruct o)
attrConstruct = b -> IO (GValueConstruct o)
forall o (m :: * -> *) a.
(IsObject o, MonadIO m, IsObject a) =>
a -> m (GValueConstruct o)
constructObjectAccessibleTableRowHeader
    attrClear :: forall o.
AttrBaseTypeConstraint
  ObjectAccessibleTableRowHeaderPropertyInfo o =>
o -> IO ()
attrClear = o -> IO ()
forall (m :: * -> *) o. (MonadIO m, IsObject o) => o -> m ()
clearObjectAccessibleTableRowHeader
    dbgAttrInfo :: Maybe ResolvedSymbolInfo
dbgAttrInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
        resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.Atk.Objects.Object.accessibleTableRowHeader"
        , resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-atk-2.0.29/docs/GI-Atk-Objects-Object.html#g:attr:accessibleTableRowHeader"
        })
#endif

-- VVV Prop "accessible-table-summary"
   -- Type: TInterface (Name {namespace = "Atk", name = "Object"})
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Nothing,Nothing)

-- | Get the value of the “@accessible-table-summary@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' object #accessibleTableSummary
-- @
getObjectAccessibleTableSummary :: (MonadIO m, IsObject o) => o -> m (Maybe Object)
getObjectAccessibleTableSummary :: forall (m :: * -> *) o.
(MonadIO m, IsObject o) =>
o -> m (Maybe Object)
getObjectAccessibleTableSummary o
obj = IO (Maybe Object) -> m (Maybe Object)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (Maybe Object) -> m (Maybe Object))
-> IO (Maybe Object) -> m (Maybe Object)
forall a b. (a -> b) -> a -> b
$ o -> String -> (ManagedPtr Object -> Object) -> IO (Maybe Object)
forall a b.
(GObject a, GObject b) =>
a -> String -> (ManagedPtr b -> b) -> IO (Maybe b)
B.Properties.getObjectPropertyObject o
obj String
"accessible-table-summary" ManagedPtr Object -> Object
Object

-- | Set the value of the “@accessible-table-summary@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' object [ #accessibleTableSummary 'Data.GI.Base.Attributes.:=' value ]
-- @
setObjectAccessibleTableSummary :: (MonadIO m, IsObject o, IsObject a) => o -> a -> m ()
setObjectAccessibleTableSummary :: forall (m :: * -> *) o a.
(MonadIO m, IsObject o, IsObject a) =>
o -> a -> m ()
setObjectAccessibleTableSummary o
obj a
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Maybe a -> IO ()
forall a b.
(GObject a, GObject b) =>
a -> String -> Maybe b -> IO ()
B.Properties.setObjectPropertyObject o
obj String
"accessible-table-summary" (a -> Maybe a
forall a. a -> Maybe a
Just a
val)

-- | Construct a t'GValueConstruct' with valid value for the “@accessible-table-summary@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructObjectAccessibleTableSummary :: (IsObject o, MIO.MonadIO m, IsObject a) => a -> m (GValueConstruct o)
constructObjectAccessibleTableSummary :: forall o (m :: * -> *) a.
(IsObject o, MonadIO m, IsObject a) =>
a -> m (GValueConstruct o)
constructObjectAccessibleTableSummary a
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Maybe a -> IO (GValueConstruct o)
forall a o.
GObject a =>
String -> Maybe a -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyObject String
"accessible-table-summary" (a -> Maybe a
forall a. a -> Maybe a
P.Just a
val)

-- | Set the value of the “@accessible-table-summary@” property to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #accessibleTableSummary
-- @
clearObjectAccessibleTableSummary :: (MonadIO m, IsObject o) => o -> m ()
clearObjectAccessibleTableSummary :: forall (m :: * -> *) o. (MonadIO m, IsObject o) => o -> m ()
clearObjectAccessibleTableSummary o
obj = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ o -> String -> Maybe Object -> IO ()
forall a b.
(GObject a, GObject b) =>
a -> String -> Maybe b -> IO ()
B.Properties.setObjectPropertyObject o
obj String
"accessible-table-summary" (Maybe Object
forall a. Maybe a
Nothing :: Maybe Object)

#if defined(ENABLE_OVERLOADING)
data ObjectAccessibleTableSummaryPropertyInfo
instance AttrInfo ObjectAccessibleTableSummaryPropertyInfo where
    type AttrAllowedOps ObjectAccessibleTableSummaryPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint ObjectAccessibleTableSummaryPropertyInfo = IsObject
    type AttrSetTypeConstraint ObjectAccessibleTableSummaryPropertyInfo = IsObject
    type AttrTransferTypeConstraint ObjectAccessibleTableSummaryPropertyInfo = IsObject
    type AttrTransferType ObjectAccessibleTableSummaryPropertyInfo = Object
    type AttrGetType ObjectAccessibleTableSummaryPropertyInfo = (Maybe Object)
    type AttrLabel ObjectAccessibleTableSummaryPropertyInfo = "accessible-table-summary"
    type AttrOrigin ObjectAccessibleTableSummaryPropertyInfo = Object
    attrGet :: forall o.
AttrBaseTypeConstraint
  ObjectAccessibleTableSummaryPropertyInfo o =>
o -> IO (AttrGetType ObjectAccessibleTableSummaryPropertyInfo)
attrGet = o -> IO (Maybe Object)
o -> IO (AttrGetType ObjectAccessibleTableSummaryPropertyInfo)
forall (m :: * -> *) o.
(MonadIO m, IsObject o) =>
o -> m (Maybe Object)
getObjectAccessibleTableSummary
    attrSet :: forall o b.
(AttrBaseTypeConstraint ObjectAccessibleTableSummaryPropertyInfo o,
 AttrSetTypeConstraint
   ObjectAccessibleTableSummaryPropertyInfo b) =>
o -> b -> IO ()
attrSet = o -> b -> IO ()
forall (m :: * -> *) o a.
(MonadIO m, IsObject o, IsObject a) =>
o -> a -> m ()
setObjectAccessibleTableSummary
    attrPut :: forall o.
AttrBaseTypeConstraint
  ObjectAccessibleTableSummaryPropertyInfo o =>
o -> AttrGetType ObjectAccessibleTableSummaryPropertyInfo -> IO ()
attrPut = o -> Maybe Object -> IO ()
o -> AttrGetType ObjectAccessibleTableSummaryPropertyInfo -> IO ()
forall a. HasCallStack => a
undefined
    attrTransfer :: forall o b.
(AttrBaseTypeConstraint ObjectAccessibleTableSummaryPropertyInfo o,
 AttrTransferTypeConstraint
   ObjectAccessibleTableSummaryPropertyInfo b) =>
Proxy o
-> b
-> IO (AttrTransferType ObjectAccessibleTableSummaryPropertyInfo)
attrTransfer Proxy o
_ b
v = do
        (ManagedPtr Object -> Object) -> b -> IO Object
forall o o'.
(HasCallStack, ManagedPtrNewtype o, TypedObject o,
 ManagedPtrNewtype o', TypedObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
unsafeCastTo ManagedPtr Object -> Object
Object b
v
    attrConstruct :: forall o b.
(AttrBaseTypeConstraint ObjectAccessibleTableSummaryPropertyInfo o,
 AttrSetTypeConstraint
   ObjectAccessibleTableSummaryPropertyInfo b) =>
b -> IO (GValueConstruct o)
attrConstruct = b -> IO (GValueConstruct o)
forall o (m :: * -> *) a.
(IsObject o, MonadIO m, IsObject a) =>
a -> m (GValueConstruct o)
constructObjectAccessibleTableSummary
    attrClear :: forall o.
AttrBaseTypeConstraint
  ObjectAccessibleTableSummaryPropertyInfo o =>
o -> IO ()
attrClear = o -> IO ()
forall (m :: * -> *) o. (MonadIO m, IsObject o) => o -> m ()
clearObjectAccessibleTableSummary
    dbgAttrInfo :: Maybe ResolvedSymbolInfo
dbgAttrInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
        resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.Atk.Objects.Object.accessibleTableSummary"
        , resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-atk-2.0.29/docs/GI-Atk-Objects-Object.html#g:attr:accessibleTableSummary"
        })
#endif

-- VVV Prop "accessible-value"
   -- Type: TBasicType TDouble
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Nothing,Nothing)

-- | Get the value of the “@accessible-value@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' object #accessibleValue
-- @
getObjectAccessibleValue :: (MonadIO m, IsObject o) => o -> m Double
getObjectAccessibleValue :: forall (m :: * -> *) o. (MonadIO m, IsObject o) => o -> m Double
getObjectAccessibleValue o
obj = IO Double -> m Double
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Double -> m Double) -> IO Double -> m Double
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Double
forall a. GObject a => a -> String -> IO Double
B.Properties.getObjectPropertyDouble o
obj String
"accessible-value"

-- | Set the value of the “@accessible-value@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' object [ #accessibleValue 'Data.GI.Base.Attributes.:=' value ]
-- @
setObjectAccessibleValue :: (MonadIO m, IsObject o) => o -> Double -> m ()
setObjectAccessibleValue :: forall (m :: * -> *) o.
(MonadIO m, IsObject o) =>
o -> Double -> m ()
setObjectAccessibleValue o
obj Double
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Double -> IO ()
forall a. GObject a => a -> String -> Double -> IO ()
B.Properties.setObjectPropertyDouble o
obj String
"accessible-value" Double
val

-- | Construct a t'GValueConstruct' with valid value for the “@accessible-value@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructObjectAccessibleValue :: (IsObject o, MIO.MonadIO m) => Double -> m (GValueConstruct o)
constructObjectAccessibleValue :: forall o (m :: * -> *).
(IsObject o, MonadIO m) =>
Double -> m (GValueConstruct o)
constructObjectAccessibleValue Double
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Double -> IO (GValueConstruct o)
forall o. String -> Double -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyDouble String
"accessible-value" Double
val

#if defined(ENABLE_OVERLOADING)
data ObjectAccessibleValuePropertyInfo
instance AttrInfo ObjectAccessibleValuePropertyInfo where
    type AttrAllowedOps ObjectAccessibleValuePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrPut]
    type AttrBaseTypeConstraint ObjectAccessibleValuePropertyInfo = IsObject
    type AttrSetTypeConstraint ObjectAccessibleValuePropertyInfo = (~) Double
    type AttrTransferTypeConstraint ObjectAccessibleValuePropertyInfo = (~) Double
    type AttrTransferType ObjectAccessibleValuePropertyInfo = Double
    type AttrGetType ObjectAccessibleValuePropertyInfo = Double
    type AttrLabel ObjectAccessibleValuePropertyInfo = "accessible-value"
    type AttrOrigin ObjectAccessibleValuePropertyInfo = Object
    attrGet :: forall o.
AttrBaseTypeConstraint ObjectAccessibleValuePropertyInfo o =>
o -> IO (AttrGetType ObjectAccessibleValuePropertyInfo)
attrGet = o -> IO Double
o -> IO (AttrGetType ObjectAccessibleValuePropertyInfo)
forall (m :: * -> *) o. (MonadIO m, IsObject o) => o -> m Double
getObjectAccessibleValue
    attrSet :: forall o b.
(AttrBaseTypeConstraint ObjectAccessibleValuePropertyInfo o,
 AttrSetTypeConstraint ObjectAccessibleValuePropertyInfo b) =>
o -> b -> IO ()
attrSet = o -> b -> IO ()
o -> Double -> IO ()
forall (m :: * -> *) o.
(MonadIO m, IsObject o) =>
o -> Double -> m ()
setObjectAccessibleValue
    attrPut :: forall o.
AttrBaseTypeConstraint ObjectAccessibleValuePropertyInfo o =>
o -> AttrGetType ObjectAccessibleValuePropertyInfo -> IO ()
attrPut = o -> Double -> IO ()
o -> AttrGetType ObjectAccessibleValuePropertyInfo -> IO ()
forall (m :: * -> *) o.
(MonadIO m, IsObject o) =>
o -> Double -> m ()
setObjectAccessibleValue
    attrTransfer :: forall o b.
(AttrBaseTypeConstraint ObjectAccessibleValuePropertyInfo o,
 AttrTransferTypeConstraint ObjectAccessibleValuePropertyInfo b) =>
Proxy o
-> b -> IO (AttrTransferType ObjectAccessibleValuePropertyInfo)
attrTransfer Proxy o
_ b
v = do
        b -> IO b
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return b
v
    attrConstruct :: forall o b.
(AttrBaseTypeConstraint ObjectAccessibleValuePropertyInfo o,
 AttrSetTypeConstraint ObjectAccessibleValuePropertyInfo b) =>
b -> IO (GValueConstruct o)
attrConstruct = b -> IO (GValueConstruct o)
Double -> IO (GValueConstruct o)
forall o (m :: * -> *).
(IsObject o, MonadIO m) =>
Double -> m (GValueConstruct o)
constructObjectAccessibleValue
    attrClear :: forall o.
AttrBaseTypeConstraint ObjectAccessibleValuePropertyInfo o =>
o -> IO ()
attrClear = o -> IO ()
forall a. HasCallStack => a
undefined
    dbgAttrInfo :: Maybe ResolvedSymbolInfo
dbgAttrInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
        resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.Atk.Objects.Object.accessibleValue"
        , resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-atk-2.0.29/docs/GI-Atk-Objects-Object.html#g:attr:accessibleValue"
        })
#endif

#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList Object
type instance O.AttributeList Object = ObjectAttributeList
type ObjectAttributeList = ('[ '("accessibleComponentLayer", ObjectAccessibleComponentLayerPropertyInfo), '("accessibleComponentMdiZorder", ObjectAccessibleComponentMdiZorderPropertyInfo), '("accessibleDescription", ObjectAccessibleDescriptionPropertyInfo), '("accessibleHelpText", ObjectAccessibleHelpTextPropertyInfo), '("accessibleHypertextNlinks", ObjectAccessibleHypertextNlinksPropertyInfo), '("accessibleId", ObjectAccessibleIdPropertyInfo), '("accessibleName", ObjectAccessibleNamePropertyInfo), '("accessibleParent", ObjectAccessibleParentPropertyInfo), '("accessibleRole", ObjectAccessibleRolePropertyInfo), '("accessibleTableCaption", ObjectAccessibleTableCaptionPropertyInfo), '("accessibleTableCaptionObject", ObjectAccessibleTableCaptionObjectPropertyInfo), '("accessibleTableColumnDescription", ObjectAccessibleTableColumnDescriptionPropertyInfo), '("accessibleTableColumnHeader", ObjectAccessibleTableColumnHeaderPropertyInfo), '("accessibleTableRowDescription", ObjectAccessibleTableRowDescriptionPropertyInfo), '("accessibleTableRowHeader", ObjectAccessibleTableRowHeaderPropertyInfo), '("accessibleTableSummary", ObjectAccessibleTableSummaryPropertyInfo), '("accessibleValue", ObjectAccessibleValuePropertyInfo)] :: [(Symbol, DK.Type)])
#endif

#if defined(ENABLE_OVERLOADING)
objectAccessibleComponentLayer :: AttrLabelProxy "accessibleComponentLayer"
objectAccessibleComponentLayer :: AttrLabelProxy "accessibleComponentLayer"
objectAccessibleComponentLayer = AttrLabelProxy "accessibleComponentLayer"
forall (a :: Symbol). AttrLabelProxy a
AttrLabelProxy

objectAccessibleComponentMdiZorder :: AttrLabelProxy "accessibleComponentMdiZorder"
objectAccessibleComponentMdiZorder :: AttrLabelProxy "accessibleComponentMdiZorder"
objectAccessibleComponentMdiZorder = AttrLabelProxy "accessibleComponentMdiZorder"
forall (a :: Symbol). AttrLabelProxy a
AttrLabelProxy

objectAccessibleDescription :: AttrLabelProxy "accessibleDescription"
objectAccessibleDescription :: AttrLabelProxy "accessibleDescription"
objectAccessibleDescription = AttrLabelProxy "accessibleDescription"
forall (a :: Symbol). AttrLabelProxy a
AttrLabelProxy

objectAccessibleHelpText :: AttrLabelProxy "accessibleHelpText"
objectAccessibleHelpText :: AttrLabelProxy "accessibleHelpText"
objectAccessibleHelpText = AttrLabelProxy "accessibleHelpText"
forall (a :: Symbol). AttrLabelProxy a
AttrLabelProxy

objectAccessibleHypertextNlinks :: AttrLabelProxy "accessibleHypertextNlinks"
objectAccessibleHypertextNlinks :: AttrLabelProxy "accessibleHypertextNlinks"
objectAccessibleHypertextNlinks = AttrLabelProxy "accessibleHypertextNlinks"
forall (a :: Symbol). AttrLabelProxy a
AttrLabelProxy

objectAccessibleId :: AttrLabelProxy "accessibleId"
objectAccessibleId :: AttrLabelProxy "accessibleId"
objectAccessibleId = AttrLabelProxy "accessibleId"
forall (a :: Symbol). AttrLabelProxy a
AttrLabelProxy

objectAccessibleName :: AttrLabelProxy "accessibleName"
objectAccessibleName :: AttrLabelProxy "accessibleName"
objectAccessibleName = AttrLabelProxy "accessibleName"
forall (a :: Symbol). AttrLabelProxy a
AttrLabelProxy

objectAccessibleParent :: AttrLabelProxy "accessibleParent"
objectAccessibleParent :: AttrLabelProxy "accessibleParent"
objectAccessibleParent = AttrLabelProxy "accessibleParent"
forall (a :: Symbol). AttrLabelProxy a
AttrLabelProxy

objectAccessibleRole :: AttrLabelProxy "accessibleRole"
objectAccessibleRole :: AttrLabelProxy "accessibleRole"
objectAccessibleRole = AttrLabelProxy "accessibleRole"
forall (a :: Symbol). AttrLabelProxy a
AttrLabelProxy

objectAccessibleTableCaption :: AttrLabelProxy "accessibleTableCaption"
objectAccessibleTableCaption :: AttrLabelProxy "accessibleTableCaption"
objectAccessibleTableCaption = AttrLabelProxy "accessibleTableCaption"
forall (a :: Symbol). AttrLabelProxy a
AttrLabelProxy

objectAccessibleTableCaptionObject :: AttrLabelProxy "accessibleTableCaptionObject"
objectAccessibleTableCaptionObject :: AttrLabelProxy "accessibleTableCaptionObject"
objectAccessibleTableCaptionObject = AttrLabelProxy "accessibleTableCaptionObject"
forall (a :: Symbol). AttrLabelProxy a
AttrLabelProxy

objectAccessibleTableColumnDescription :: AttrLabelProxy "accessibleTableColumnDescription"
objectAccessibleTableColumnDescription :: AttrLabelProxy "accessibleTableColumnDescription"
objectAccessibleTableColumnDescription = AttrLabelProxy "accessibleTableColumnDescription"
forall (a :: Symbol). AttrLabelProxy a
AttrLabelProxy

objectAccessibleTableColumnHeader :: AttrLabelProxy "accessibleTableColumnHeader"
objectAccessibleTableColumnHeader :: AttrLabelProxy "accessibleTableColumnHeader"
objectAccessibleTableColumnHeader = AttrLabelProxy "accessibleTableColumnHeader"
forall (a :: Symbol). AttrLabelProxy a
AttrLabelProxy

objectAccessibleTableRowDescription :: AttrLabelProxy "accessibleTableRowDescription"
objectAccessibleTableRowDescription :: AttrLabelProxy "accessibleTableRowDescription"
objectAccessibleTableRowDescription = AttrLabelProxy "accessibleTableRowDescription"
forall (a :: Symbol). AttrLabelProxy a
AttrLabelProxy

objectAccessibleTableRowHeader :: AttrLabelProxy "accessibleTableRowHeader"
objectAccessibleTableRowHeader :: AttrLabelProxy "accessibleTableRowHeader"
objectAccessibleTableRowHeader = AttrLabelProxy "accessibleTableRowHeader"
forall (a :: Symbol). AttrLabelProxy a
AttrLabelProxy

objectAccessibleTableSummary :: AttrLabelProxy "accessibleTableSummary"
objectAccessibleTableSummary :: AttrLabelProxy "accessibleTableSummary"
objectAccessibleTableSummary = AttrLabelProxy "accessibleTableSummary"
forall (a :: Symbol). AttrLabelProxy a
AttrLabelProxy

objectAccessibleValue :: AttrLabelProxy "accessibleValue"
objectAccessibleValue :: AttrLabelProxy "accessibleValue"
objectAccessibleValue = AttrLabelProxy "accessibleValue"
forall (a :: Symbol). AttrLabelProxy a
AttrLabelProxy

#endif

#if defined(ENABLE_OVERLOADING)
type instance O.SignalList Object = ObjectSignalList
type ObjectSignalList = ('[ '("activeDescendantChanged", ObjectActiveDescendantChangedSignalInfo), '("announcement", ObjectAnnouncementSignalInfo), '("attributeChanged", ObjectAttributeChangedSignalInfo), '("childrenChanged", ObjectChildrenChangedSignalInfo), '("focusEvent", ObjectFocusEventSignalInfo), '("notification", ObjectNotificationSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("propertyChange", ObjectPropertyChangeSignalInfo), '("stateChange", ObjectStateChangeSignalInfo), '("visibleDataChanged", ObjectVisibleDataChangedSignalInfo)] :: [(Symbol, DK.Type)])

#endif

-- method Object::add_relationship
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "object"
--           , argType = TInterface Name { namespace = "Atk" , name = "Object" }
--           , argCType = Just "AtkObject*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "The #AtkObject to which an AtkRelation is to be added."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "relationship"
--           , argType =
--               TInterface Name { namespace = "Atk" , name = "RelationType" }
--           , argCType = Just "AtkRelationType"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "The #AtkRelationType of the relation"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "target"
--           , argType = TInterface Name { namespace = "Atk" , name = "Object" }
--           , argCType = Just "AtkObject*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "The #AtkObject which is to be the target of the relation."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "atk_object_add_relationship" atk_object_add_relationship :: 
    Ptr Object ->                           -- object : TInterface (Name {namespace = "Atk", name = "Object"})
    CUInt ->                                -- relationship : TInterface (Name {namespace = "Atk", name = "RelationType"})
    Ptr Object ->                           -- target : TInterface (Name {namespace = "Atk", name = "Object"})
    IO CInt

-- | Adds a relationship of the specified type with the specified target.
objectAddRelationship ::
    (B.CallStack.HasCallStack, MonadIO m, IsObject a, IsObject b) =>
    a
    -- ^ /@object@/: The t'GI.Atk.Objects.Object.Object' to which an AtkRelation is to be added.
    -> Atk.Enums.RelationType
    -- ^ /@relationship@/: The t'GI.Atk.Enums.RelationType' of the relation
    -> b
    -- ^ /@target@/: The t'GI.Atk.Objects.Object.Object' which is to be the target of the relation.
    -> m Bool
    -- ^ __Returns:__ TRUE if the relationship is added.
objectAddRelationship :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsObject a, IsObject b) =>
a -> RelationType -> b -> m Bool
objectAddRelationship a
object RelationType
relationship b
target = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    object' <- a -> IO (Ptr Object)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
object
    let relationship' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (RelationType -> Int) -> RelationType -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. RelationType -> Int
forall a. Enum a => a -> Int
fromEnum) RelationType
relationship
    target' <- unsafeManagedPtrCastPtr target
    result <- atk_object_add_relationship object' relationship' target'
    let result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    touchManagedPtr object
    touchManagedPtr target
    return result'

#if defined(ENABLE_OVERLOADING)
data ObjectAddRelationshipMethodInfo
instance (signature ~ (Atk.Enums.RelationType -> b -> m Bool), MonadIO m, IsObject a, IsObject b) => O.OverloadedMethod ObjectAddRelationshipMethodInfo a signature where
    overloadedMethod :: a -> signature
overloadedMethod = a -> signature
a -> RelationType -> b -> m Bool
forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsObject a, IsObject b) =>
a -> RelationType -> b -> m Bool
objectAddRelationship

instance O.OverloadedMethodInfo ObjectAddRelationshipMethodInfo a where
    overloadedMethodInfo :: Maybe ResolvedSymbolInfo
overloadedMethodInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
        resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.Atk.Objects.Object.objectAddRelationship",
        resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-atk-2.0.29/docs/GI-Atk-Objects-Object.html#v:objectAddRelationship"
        })


#endif

-- method Object::get_accessible_id
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "accessible"
--           , argType = TInterface Name { namespace = "Atk" , name = "Object" }
--           , argCType = Just "AtkObject*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "an #AtkObject" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TUTF8)
-- throws : False
-- Skip return : False

foreign import ccall "atk_object_get_accessible_id" atk_object_get_accessible_id :: 
    Ptr Object ->                           -- accessible : TInterface (Name {namespace = "Atk", name = "Object"})
    IO CString

-- | Gets the accessible id of the accessible.
-- 
-- /Since: 2.34/
objectGetAccessibleId ::
    (B.CallStack.HasCallStack, MonadIO m, IsObject a) =>
    a
    -- ^ /@accessible@/: an t'GI.Atk.Objects.Object.Object'
    -> m T.Text
    -- ^ __Returns:__ a character string representing the accessible id of the object, or
    -- NULL if no such string was set.
objectGetAccessibleId :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsObject a) =>
a -> m Text
objectGetAccessibleId a
accessible = IO Text -> m Text
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ do
    accessible' <- a -> IO (Ptr Object)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
accessible
    result <- atk_object_get_accessible_id accessible'
    checkUnexpectedReturnNULL "objectGetAccessibleId" result
    result' <- cstringToText result
    touchManagedPtr accessible
    return result'

#if defined(ENABLE_OVERLOADING)
data ObjectGetAccessibleIdMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsObject a) => O.OverloadedMethod ObjectGetAccessibleIdMethodInfo a signature where
    overloadedMethod :: a -> signature
overloadedMethod = a -> signature
a -> m Text
forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsObject a) =>
a -> m Text
objectGetAccessibleId

instance O.OverloadedMethodInfo ObjectGetAccessibleIdMethodInfo a where
    overloadedMethodInfo :: Maybe ResolvedSymbolInfo
overloadedMethodInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
        resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.Atk.Objects.Object.objectGetAccessibleId",
        resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-atk-2.0.29/docs/GI-Atk-Objects-Object.html#v:objectGetAccessibleId"
        })


#endif

-- method Object::get_attributes
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "accessible"
--           , argType = TInterface Name { namespace = "Atk" , name = "Object" }
--           , argCType = Just "AtkObject*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "An #AtkObject." , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TGSList (TBasicType TPtr))
-- throws : False
-- Skip return : False

foreign import ccall "atk_object_get_attributes" atk_object_get_attributes :: 
    Ptr Object ->                           -- accessible : TInterface (Name {namespace = "Atk", name = "Object"})
    IO (Ptr (GSList (Ptr ())))

-- | Get a list of properties applied to this object as a whole, as an @/AtkAttributeSet/@ consisting of
-- name-value pairs. As such these attributes may be considered weakly-typed properties or annotations,
-- as distinct from strongly-typed object data available via other get\/set methods.
-- Not all objects have explicit \"name-value pair\" @/AtkAttributeSet/@ properties.
-- 
-- /Since: 1.12/
objectGetAttributes ::
    (B.CallStack.HasCallStack, MonadIO m, IsObject a) =>
    a
    -- ^ /@accessible@/: An t'GI.Atk.Objects.Object.Object'.
    -> m ([Ptr ()])
    -- ^ __Returns:__ an @/AtkAttributeSet/@ consisting of all
    -- explicit properties\/annotations applied to the object, or an empty
    -- set if the object has no name-value pair attributes assigned to
    -- it. This @/atkattributeset/@ should be freed by a call to
    -- 'GI.Atk.Functions.attributeSetFree'.
objectGetAttributes :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsObject a) =>
a -> m [Ptr ()]
objectGetAttributes a
accessible = IO [Ptr ()] -> m [Ptr ()]
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO [Ptr ()] -> m [Ptr ()]) -> IO [Ptr ()] -> m [Ptr ()]
forall a b. (a -> b) -> a -> b
$ do
    accessible' <- a -> IO (Ptr Object)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
accessible
    result <- atk_object_get_attributes accessible'
    result' <- unpackGSList result
    g_slist_free result
    touchManagedPtr accessible
    return result'

#if defined(ENABLE_OVERLOADING)
data ObjectGetAttributesMethodInfo
instance (signature ~ (m ([Ptr ()])), MonadIO m, IsObject a) => O.OverloadedMethod ObjectGetAttributesMethodInfo a signature where
    overloadedMethod :: a -> signature
overloadedMethod = a -> signature
a -> m [Ptr ()]
forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsObject a) =>
a -> m [Ptr ()]
objectGetAttributes

instance O.OverloadedMethodInfo ObjectGetAttributesMethodInfo a where
    overloadedMethodInfo :: Maybe ResolvedSymbolInfo
overloadedMethodInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
        resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.Atk.Objects.Object.objectGetAttributes",
        resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-atk-2.0.29/docs/GI-Atk-Objects-Object.html#v:objectGetAttributes"
        })


#endif

-- method Object::get_description
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "accessible"
--           , argType = TInterface Name { namespace = "Atk" , name = "Object" }
--           , argCType = Just "AtkObject*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "an #AtkObject" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TUTF8)
-- throws : False
-- Skip return : False

foreign import ccall "atk_object_get_description" atk_object_get_description :: 
    Ptr Object ->                           -- accessible : TInterface (Name {namespace = "Atk", name = "Object"})
    IO CString

-- | Gets the accessible description of the accessible.
objectGetDescription ::
    (B.CallStack.HasCallStack, MonadIO m, IsObject a) =>
    a
    -- ^ /@accessible@/: an t'GI.Atk.Objects.Object.Object'
    -> m T.Text
    -- ^ __Returns:__ a character string representing the accessible description
    -- of the accessible.
objectGetDescription :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsObject a) =>
a -> m Text
objectGetDescription a
accessible = IO Text -> m Text
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ do
    accessible' <- a -> IO (Ptr Object)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
accessible
    result <- atk_object_get_description accessible'
    checkUnexpectedReturnNULL "objectGetDescription" result
    result' <- cstringToText result
    touchManagedPtr accessible
    return result'

#if defined(ENABLE_OVERLOADING)
data ObjectGetDescriptionMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsObject a) => O.OverloadedMethod ObjectGetDescriptionMethodInfo a signature where
    overloadedMethod :: a -> signature
overloadedMethod = a -> signature
a -> m Text
forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsObject a) =>
a -> m Text
objectGetDescription

instance O.OverloadedMethodInfo ObjectGetDescriptionMethodInfo a where
    overloadedMethodInfo :: Maybe ResolvedSymbolInfo
overloadedMethodInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
        resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.Atk.Objects.Object.objectGetDescription",
        resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-atk-2.0.29/docs/GI-Atk-Objects-Object.html#v:objectGetDescription"
        })


#endif

-- method Object::get_help_text
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "accessible"
--           , argType = TInterface Name { namespace = "Atk" , name = "Object" }
--           , argCType = Just "AtkObject*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "an #AtkObject" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TUTF8)
-- throws : False
-- Skip return : False

foreign import ccall "atk_object_get_help_text" atk_object_get_help_text :: 
    Ptr Object ->                           -- accessible : TInterface (Name {namespace = "Atk", name = "Object"})
    IO CString

-- | Gets the help text associated with the accessible.
-- 
-- /Since: 2.52/
objectGetHelpText ::
    (B.CallStack.HasCallStack, MonadIO m, IsObject a) =>
    a
    -- ^ /@accessible@/: an t'GI.Atk.Objects.Object.Object'
    -> m T.Text
    -- ^ __Returns:__ a character string representing the help text or the object, or
    -- NULL if no such string was set.
objectGetHelpText :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsObject a) =>
a -> m Text
objectGetHelpText a
accessible = IO Text -> m Text
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ do
    accessible' <- a -> IO (Ptr Object)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
accessible
    result <- atk_object_get_help_text accessible'
    checkUnexpectedReturnNULL "objectGetHelpText" result
    result' <- cstringToText result
    touchManagedPtr accessible
    return result'

#if defined(ENABLE_OVERLOADING)
data ObjectGetHelpTextMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsObject a) => O.OverloadedMethod ObjectGetHelpTextMethodInfo a signature where
    overloadedMethod :: a -> signature
overloadedMethod = a -> signature
a -> m Text
forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsObject a) =>
a -> m Text
objectGetHelpText

instance O.OverloadedMethodInfo ObjectGetHelpTextMethodInfo a where
    overloadedMethodInfo :: Maybe ResolvedSymbolInfo
overloadedMethodInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
        resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.Atk.Objects.Object.objectGetHelpText",
        resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-atk-2.0.29/docs/GI-Atk-Objects-Object.html#v:objectGetHelpText"
        })


#endif

-- method Object::get_index_in_parent
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "accessible"
--           , argType = TInterface Name { namespace = "Atk" , name = "Object" }
--           , argCType = Just "AtkObject*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "an #AtkObject" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TInt)
-- throws : False
-- Skip return : False

foreign import ccall "atk_object_get_index_in_parent" atk_object_get_index_in_parent :: 
    Ptr Object ->                           -- accessible : TInterface (Name {namespace = "Atk", name = "Object"})
    IO Int32

-- | Gets the 0-based index of this accessible in its parent; returns -1 if the
-- accessible does not have an accessible parent.
objectGetIndexInParent ::
    (B.CallStack.HasCallStack, MonadIO m, IsObject a) =>
    a
    -- ^ /@accessible@/: an t'GI.Atk.Objects.Object.Object'
    -> m Int32
    -- ^ __Returns:__ an integer which is the index of the accessible in its parent
objectGetIndexInParent :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsObject a) =>
a -> m Int32
objectGetIndexInParent a
accessible = IO Int32 -> m Int32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ do
    accessible' <- a -> IO (Ptr Object)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
accessible
    result <- atk_object_get_index_in_parent accessible'
    touchManagedPtr accessible
    return result

#if defined(ENABLE_OVERLOADING)
data ObjectGetIndexInParentMethodInfo
instance (signature ~ (m Int32), MonadIO m, IsObject a) => O.OverloadedMethod ObjectGetIndexInParentMethodInfo a signature where
    overloadedMethod :: a -> signature
overloadedMethod = a -> signature
a -> m Int32
forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsObject a) =>
a -> m Int32
objectGetIndexInParent

instance O.OverloadedMethodInfo ObjectGetIndexInParentMethodInfo a where
    overloadedMethodInfo :: Maybe ResolvedSymbolInfo
overloadedMethodInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
        resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.Atk.Objects.Object.objectGetIndexInParent",
        resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-atk-2.0.29/docs/GI-Atk-Objects-Object.html#v:objectGetIndexInParent"
        })


#endif

-- method Object::get_layer
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "accessible"
--           , argType = TInterface Name { namespace = "Atk" , name = "Object" }
--           , argCType = Just "AtkObject*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "an #AtkObject" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Atk" , name = "Layer" })
-- throws : False
-- Skip return : False

foreign import ccall "atk_object_get_layer" atk_object_get_layer :: 
    Ptr Object ->                           -- accessible : TInterface (Name {namespace = "Atk", name = "Object"})
    IO CUInt

{-# DEPRECATED objectGetLayer ["Use atk_component_get_layer instead."] #-}
-- | Gets the layer of the accessible.
objectGetLayer ::
    (B.CallStack.HasCallStack, MonadIO m, IsObject a) =>
    a
    -- ^ /@accessible@/: an t'GI.Atk.Objects.Object.Object'
    -> m Atk.Enums.Layer
    -- ^ __Returns:__ an t'GI.Atk.Enums.Layer' which is the layer of the accessible
objectGetLayer :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsObject a) =>
a -> m Layer
objectGetLayer a
accessible = IO Layer -> m Layer
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Layer -> m Layer) -> IO Layer -> m Layer
forall a b. (a -> b) -> a -> b
$ do
    accessible' <- a -> IO (Ptr Object)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
accessible
    result <- atk_object_get_layer accessible'
    let result' = (Int -> Layer
forall a. Enum a => Int -> a
toEnum (Int -> Layer) -> (CUInt -> Int) -> CUInt -> Layer
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
result
    touchManagedPtr accessible
    return result'

#if defined(ENABLE_OVERLOADING)
data ObjectGetLayerMethodInfo
instance (signature ~ (m Atk.Enums.Layer), MonadIO m, IsObject a) => O.OverloadedMethod ObjectGetLayerMethodInfo a signature where
    overloadedMethod :: a -> signature
overloadedMethod = a -> signature
a -> m Layer
forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsObject a) =>
a -> m Layer
objectGetLayer

instance O.OverloadedMethodInfo ObjectGetLayerMethodInfo a where
    overloadedMethodInfo :: Maybe ResolvedSymbolInfo
overloadedMethodInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
        resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.Atk.Objects.Object.objectGetLayer",
        resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-atk-2.0.29/docs/GI-Atk-Objects-Object.html#v:objectGetLayer"
        })


#endif

-- method Object::get_mdi_zorder
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "accessible"
--           , argType = TInterface Name { namespace = "Atk" , name = "Object" }
--           , argCType = Just "AtkObject*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "an #AtkObject" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TInt)
-- throws : False
-- Skip return : False

foreign import ccall "atk_object_get_mdi_zorder" atk_object_get_mdi_zorder :: 
    Ptr Object ->                           -- accessible : TInterface (Name {namespace = "Atk", name = "Object"})
    IO Int32

{-# DEPRECATED objectGetMdiZorder ["Use atk_component_get_mdi_zorder instead."] #-}
-- | Gets the zorder of the accessible. The value G_MININT will be returned
-- if the layer of the accessible is not ATK_LAYER_MDI.
objectGetMdiZorder ::
    (B.CallStack.HasCallStack, MonadIO m, IsObject a) =>
    a
    -- ^ /@accessible@/: an t'GI.Atk.Objects.Object.Object'
    -> m Int32
    -- ^ __Returns:__ a gint which is the zorder of the accessible, i.e. the depth at
    -- which the component is shown in relation to other components in the same
    -- container.
objectGetMdiZorder :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsObject a) =>
a -> m Int32
objectGetMdiZorder a
accessible = IO Int32 -> m Int32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ do
    accessible' <- a -> IO (Ptr Object)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
accessible
    result <- atk_object_get_mdi_zorder accessible'
    touchManagedPtr accessible
    return result

#if defined(ENABLE_OVERLOADING)
data ObjectGetMdiZorderMethodInfo
instance (signature ~ (m Int32), MonadIO m, IsObject a) => O.OverloadedMethod ObjectGetMdiZorderMethodInfo a signature where
    overloadedMethod :: a -> signature
overloadedMethod = a -> signature
a -> m Int32
forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsObject a) =>
a -> m Int32
objectGetMdiZorder

instance O.OverloadedMethodInfo ObjectGetMdiZorderMethodInfo a where
    overloadedMethodInfo :: Maybe ResolvedSymbolInfo
overloadedMethodInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
        resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.Atk.Objects.Object.objectGetMdiZorder",
        resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-atk-2.0.29/docs/GI-Atk-Objects-Object.html#v:objectGetMdiZorder"
        })


#endif

-- method Object::get_n_accessible_children
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "accessible"
--           , argType = TInterface Name { namespace = "Atk" , name = "Object" }
--           , argCType = Just "AtkObject*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "an #AtkObject" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TInt)
-- throws : False
-- Skip return : False

foreign import ccall "atk_object_get_n_accessible_children" atk_object_get_n_accessible_children :: 
    Ptr Object ->                           -- accessible : TInterface (Name {namespace = "Atk", name = "Object"})
    IO Int32

-- | Gets the number of accessible children of the accessible.
objectGetNAccessibleChildren ::
    (B.CallStack.HasCallStack, MonadIO m, IsObject a) =>
    a
    -- ^ /@accessible@/: an t'GI.Atk.Objects.Object.Object'
    -> m Int32
    -- ^ __Returns:__ an integer representing the number of accessible children
    -- of the accessible.
objectGetNAccessibleChildren :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsObject a) =>
a -> m Int32
objectGetNAccessibleChildren a
accessible = IO Int32 -> m Int32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ do
    accessible' <- a -> IO (Ptr Object)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
accessible
    result <- atk_object_get_n_accessible_children accessible'
    touchManagedPtr accessible
    return result

#if defined(ENABLE_OVERLOADING)
data ObjectGetNAccessibleChildrenMethodInfo
instance (signature ~ (m Int32), MonadIO m, IsObject a) => O.OverloadedMethod ObjectGetNAccessibleChildrenMethodInfo a signature where
    overloadedMethod :: a -> signature
overloadedMethod = a -> signature
a -> m Int32
forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsObject a) =>
a -> m Int32
objectGetNAccessibleChildren

instance O.OverloadedMethodInfo ObjectGetNAccessibleChildrenMethodInfo a where
    overloadedMethodInfo :: Maybe ResolvedSymbolInfo
overloadedMethodInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
        resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.Atk.Objects.Object.objectGetNAccessibleChildren",
        resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-atk-2.0.29/docs/GI-Atk-Objects-Object.html#v:objectGetNAccessibleChildren"
        })


#endif

-- method Object::get_name
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "accessible"
--           , argType = TInterface Name { namespace = "Atk" , name = "Object" }
--           , argCType = Just "AtkObject*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "an #AtkObject" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TUTF8)
-- throws : False
-- Skip return : False

foreign import ccall "atk_object_get_name" atk_object_get_name :: 
    Ptr Object ->                           -- accessible : TInterface (Name {namespace = "Atk", name = "Object"})
    IO CString

-- | Gets the accessible name of the accessible.
objectGetName ::
    (B.CallStack.HasCallStack, MonadIO m, IsObject a) =>
    a
    -- ^ /@accessible@/: an t'GI.Atk.Objects.Object.Object'
    -> m T.Text
    -- ^ __Returns:__ a character string representing the accessible name of the object.
objectGetName :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsObject a) =>
a -> m Text
objectGetName a
accessible = IO Text -> m Text
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ do
    accessible' <- a -> IO (Ptr Object)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
accessible
    result <- atk_object_get_name accessible'
    checkUnexpectedReturnNULL "objectGetName" result
    result' <- cstringToText result
    touchManagedPtr accessible
    return result'

#if defined(ENABLE_OVERLOADING)
data ObjectGetNameMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsObject a) => O.OverloadedMethod ObjectGetNameMethodInfo a signature where
    overloadedMethod :: a -> signature
overloadedMethod = a -> signature
a -> m Text
forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsObject a) =>
a -> m Text
objectGetName

instance O.OverloadedMethodInfo ObjectGetNameMethodInfo a where
    overloadedMethodInfo :: Maybe ResolvedSymbolInfo
overloadedMethodInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
        resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.Atk.Objects.Object.objectGetName",
        resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-atk-2.0.29/docs/GI-Atk-Objects-Object.html#v:objectGetName"
        })


#endif

-- method Object::get_object_locale
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "accessible"
--           , argType = TInterface Name { namespace = "Atk" , name = "Object" }
--           , argCType = Just "AtkObject*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "an #AtkObject" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TUTF8)
-- throws : False
-- Skip return : False

foreign import ccall "atk_object_get_object_locale" atk_object_get_object_locale :: 
    Ptr Object ->                           -- accessible : TInterface (Name {namespace = "Atk", name = "Object"})
    IO CString

-- | Gets a UTF-8 string indicating the POSIX-style LC_MESSAGES locale
-- of /@accessible@/.
-- 
-- /Since: 2.8/
objectGetObjectLocale ::
    (B.CallStack.HasCallStack, MonadIO m, IsObject a) =>
    a
    -- ^ /@accessible@/: an t'GI.Atk.Objects.Object.Object'
    -> m T.Text
    -- ^ __Returns:__ a UTF-8 string indicating the POSIX-style LC_MESSAGES
    --          locale of /@accessible@/.
objectGetObjectLocale :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsObject a) =>
a -> m Text
objectGetObjectLocale a
accessible = IO Text -> m Text
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ do
    accessible' <- a -> IO (Ptr Object)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
accessible
    result <- atk_object_get_object_locale accessible'
    checkUnexpectedReturnNULL "objectGetObjectLocale" result
    result' <- cstringToText result
    touchManagedPtr accessible
    return result'

#if defined(ENABLE_OVERLOADING)
data ObjectGetObjectLocaleMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsObject a) => O.OverloadedMethod ObjectGetObjectLocaleMethodInfo a signature where
    overloadedMethod :: a -> signature
overloadedMethod = a -> signature
a -> m Text
forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsObject a) =>
a -> m Text
objectGetObjectLocale

instance O.OverloadedMethodInfo ObjectGetObjectLocaleMethodInfo a where
    overloadedMethodInfo :: Maybe ResolvedSymbolInfo
overloadedMethodInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
        resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.Atk.Objects.Object.objectGetObjectLocale",
        resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-atk-2.0.29/docs/GI-Atk-Objects-Object.html#v:objectGetObjectLocale"
        })


#endif

-- method Object::get_parent
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "accessible"
--           , argType = TInterface Name { namespace = "Atk" , name = "Object" }
--           , argCType = Just "AtkObject*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "an #AtkObject" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Atk" , name = "Object" })
-- throws : False
-- Skip return : False

foreign import ccall "atk_object_get_parent" atk_object_get_parent :: 
    Ptr Object ->                           -- accessible : TInterface (Name {namespace = "Atk", name = "Object"})
    IO (Ptr Object)

-- | Gets the accessible parent of the accessible. By default this is
-- the one assigned with 'GI.Atk.Objects.Object.objectSetParent', but it is assumed
-- that ATK implementors have ways to get the parent of the object
-- without the need of assigning it manually with
-- 'GI.Atk.Objects.Object.objectSetParent', and will return it with this method.
-- 
-- If you are only interested on the parent assigned with
-- 'GI.Atk.Objects.Object.objectSetParent', use 'GI.Atk.Objects.Object.objectPeekParent'.
objectGetParent ::
    (B.CallStack.HasCallStack, MonadIO m, IsObject a) =>
    a
    -- ^ /@accessible@/: an t'GI.Atk.Objects.Object.Object'
    -> m Object
    -- ^ __Returns:__ an t'GI.Atk.Objects.Object.Object' representing the accessible
    -- parent of the accessible
objectGetParent :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsObject a) =>
a -> m Object
objectGetParent a
accessible = IO Object -> m Object
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Object -> m Object) -> IO Object -> m Object
forall a b. (a -> b) -> a -> b
$ do
    accessible' <- a -> IO (Ptr Object)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
accessible
    result <- atk_object_get_parent accessible'
    checkUnexpectedReturnNULL "objectGetParent" result
    result' <- (newObject Object) result
    touchManagedPtr accessible
    return result'

#if defined(ENABLE_OVERLOADING)
data ObjectGetParentMethodInfo
instance (signature ~ (m Object), MonadIO m, IsObject a) => O.OverloadedMethod ObjectGetParentMethodInfo a signature where
    overloadedMethod :: a -> signature
overloadedMethod = a -> signature
a -> m Object
forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsObject a) =>
a -> m Object
objectGetParent

instance O.OverloadedMethodInfo ObjectGetParentMethodInfo a where
    overloadedMethodInfo :: Maybe ResolvedSymbolInfo
overloadedMethodInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
        resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.Atk.Objects.Object.objectGetParent",
        resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-atk-2.0.29/docs/GI-Atk-Objects-Object.html#v:objectGetParent"
        })


#endif

-- method Object::get_role
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "accessible"
--           , argType = TInterface Name { namespace = "Atk" , name = "Object" }
--           , argCType = Just "AtkObject*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "an #AtkObject" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Atk" , name = "Role" })
-- throws : False
-- Skip return : False

foreign import ccall "atk_object_get_role" atk_object_get_role :: 
    Ptr Object ->                           -- accessible : TInterface (Name {namespace = "Atk", name = "Object"})
    IO CUInt

-- | Gets the role of the accessible.
objectGetRole ::
    (B.CallStack.HasCallStack, MonadIO m, IsObject a) =>
    a
    -- ^ /@accessible@/: an t'GI.Atk.Objects.Object.Object'
    -> m Atk.Enums.Role
    -- ^ __Returns:__ an t'GI.Atk.Enums.Role' which is the role of the accessible
objectGetRole :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsObject a) =>
a -> m Role
objectGetRole a
accessible = IO Role -> m Role
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Role -> m Role) -> IO Role -> m Role
forall a b. (a -> b) -> a -> b
$ do
    accessible' <- a -> IO (Ptr Object)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
accessible
    result <- atk_object_get_role accessible'
    let result' = (Int -> Role
forall a. Enum a => Int -> a
toEnum (Int -> Role) -> (CUInt -> Int) -> CUInt -> Role
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
result
    touchManagedPtr accessible
    return result'

#if defined(ENABLE_OVERLOADING)
data ObjectGetRoleMethodInfo
instance (signature ~ (m Atk.Enums.Role), MonadIO m, IsObject a) => O.OverloadedMethod ObjectGetRoleMethodInfo a signature where
    overloadedMethod :: a -> signature
overloadedMethod = a -> signature
a -> m Role
forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsObject a) =>
a -> m Role
objectGetRole

instance O.OverloadedMethodInfo ObjectGetRoleMethodInfo a where
    overloadedMethodInfo :: Maybe ResolvedSymbolInfo
overloadedMethodInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
        resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.Atk.Objects.Object.objectGetRole",
        resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-atk-2.0.29/docs/GI-Atk-Objects-Object.html#v:objectGetRole"
        })


#endif

-- method Object::initialize
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "accessible"
--           , argType = TInterface Name { namespace = "Atk" , name = "Object" }
--           , argCType = Just "AtkObject*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #AtkObject" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "data"
--           , argType = TBasicType TPtr
--           , argCType = Just "gpointer"
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "a #gpointer which identifies the object for which the AtkObject was created."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "atk_object_initialize" atk_object_initialize :: 
    Ptr Object ->                           -- accessible : TInterface (Name {namespace = "Atk", name = "Object"})
    Ptr () ->                               -- data : TBasicType TPtr
    IO ()

-- | This function is called when implementing subclasses of t'GI.Atk.Objects.Object.Object'.
-- It does initialization required for the new object. It is intended
-- that this function should called only in the ...@/_new()/@ functions used
-- to create an instance of a subclass of t'GI.Atk.Objects.Object.Object'
objectInitialize ::
    (B.CallStack.HasCallStack, MonadIO m, IsObject a) =>
    a
    -- ^ /@accessible@/: a t'GI.Atk.Objects.Object.Object'
    -> Ptr ()
    -- ^ /@data@/: a @/gpointer/@ which identifies the object for which the AtkObject was created.
    -> m ()
objectInitialize :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsObject a) =>
a -> Ptr () -> m ()
objectInitialize a
accessible Ptr ()
data_ = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    accessible' <- a -> IO (Ptr Object)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
accessible
    atk_object_initialize accessible' data_
    touchManagedPtr accessible
    return ()

#if defined(ENABLE_OVERLOADING)
data ObjectInitializeMethodInfo
instance (signature ~ (Ptr () -> m ()), MonadIO m, IsObject a) => O.OverloadedMethod ObjectInitializeMethodInfo a signature where
    overloadedMethod :: a -> signature
overloadedMethod = a -> signature
a -> Ptr () -> m ()
forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsObject a) =>
a -> Ptr () -> m ()
objectInitialize

instance O.OverloadedMethodInfo ObjectInitializeMethodInfo a where
    overloadedMethodInfo :: Maybe ResolvedSymbolInfo
overloadedMethodInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
        resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.Atk.Objects.Object.objectInitialize",
        resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-atk-2.0.29/docs/GI-Atk-Objects-Object.html#v:objectInitialize"
        })


#endif

-- method Object::notify_state_change
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "accessible"
--           , argType = TInterface Name { namespace = "Atk" , name = "Object" }
--           , argCType = Just "AtkObject*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "an #AtkObject" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "state"
--           , argType = TBasicType TUInt64
--           , argCType = Just "AtkState"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "an #AtkState whose state is changed"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "value"
--           , argType = TBasicType TBoolean
--           , argCType = Just "gboolean"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "a gboolean which indicates whether the state is being set on or off"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "atk_object_notify_state_change" atk_object_notify_state_change :: 
    Ptr Object ->                           -- accessible : TInterface (Name {namespace = "Atk", name = "Object"})
    Word64 ->                               -- state : TBasicType TUInt64
    CInt ->                                 -- value : TBasicType TBoolean
    IO ()

-- | Emits a state-change signal for the specified state.
-- 
-- Note that as a general rule when the state of an existing object changes,
-- emitting a notification is expected.
objectNotifyStateChange ::
    (B.CallStack.HasCallStack, MonadIO m, IsObject a) =>
    a
    -- ^ /@accessible@/: an t'GI.Atk.Objects.Object.Object'
    -> Word64
    -- ^ /@state@/: an @/AtkState/@ whose state is changed
    -> Bool
    -- ^ /@value@/: a gboolean which indicates whether the state is being set on or off
    -> m ()
objectNotifyStateChange :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsObject a) =>
a -> Word64 -> Bool -> m ()
objectNotifyStateChange a
accessible Word64
state Bool
value = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    accessible' <- a -> IO (Ptr Object)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
accessible
    let value' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
P.fromEnum) Bool
value
    atk_object_notify_state_change accessible' state value'
    touchManagedPtr accessible
    return ()

#if defined(ENABLE_OVERLOADING)
data ObjectNotifyStateChangeMethodInfo
instance (signature ~ (Word64 -> Bool -> m ()), MonadIO m, IsObject a) => O.OverloadedMethod ObjectNotifyStateChangeMethodInfo a signature where
    overloadedMethod :: a -> signature
overloadedMethod = a -> signature
a -> Word64 -> Bool -> m ()
forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsObject a) =>
a -> Word64 -> Bool -> m ()
objectNotifyStateChange

instance O.OverloadedMethodInfo ObjectNotifyStateChangeMethodInfo a where
    overloadedMethodInfo :: Maybe ResolvedSymbolInfo
overloadedMethodInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
        resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.Atk.Objects.Object.objectNotifyStateChange",
        resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-atk-2.0.29/docs/GI-Atk-Objects-Object.html#v:objectNotifyStateChange"
        })


#endif

-- method Object::peek_parent
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "accessible"
--           , argType = TInterface Name { namespace = "Atk" , name = "Object" }
--           , argCType = Just "AtkObject*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "an #AtkObject" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Atk" , name = "Object" })
-- throws : False
-- Skip return : False

foreign import ccall "atk_object_peek_parent" atk_object_peek_parent :: 
    Ptr Object ->                           -- accessible : TInterface (Name {namespace = "Atk", name = "Object"})
    IO (Ptr Object)

-- | Gets the accessible parent of the accessible, if it has been
-- manually assigned with atk_object_set_parent. Otherwise, this
-- function returns 'P.Nothing'.
-- 
-- This method is intended as an utility for ATK implementors, and not
-- to be exposed to accessible tools. See 'GI.Atk.Objects.Object.objectGetParent' for
-- further reference.
objectPeekParent ::
    (B.CallStack.HasCallStack, MonadIO m, IsObject a) =>
    a
    -- ^ /@accessible@/: an t'GI.Atk.Objects.Object.Object'
    -> m Object
    -- ^ __Returns:__ an t'GI.Atk.Objects.Object.Object' representing the accessible
    -- parent of the accessible if assigned
objectPeekParent :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsObject a) =>
a -> m Object
objectPeekParent a
accessible = IO Object -> m Object
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Object -> m Object) -> IO Object -> m Object
forall a b. (a -> b) -> a -> b
$ do
    accessible' <- a -> IO (Ptr Object)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
accessible
    result <- atk_object_peek_parent accessible'
    checkUnexpectedReturnNULL "objectPeekParent" result
    result' <- (newObject Object) result
    touchManagedPtr accessible
    return result'

#if defined(ENABLE_OVERLOADING)
data ObjectPeekParentMethodInfo
instance (signature ~ (m Object), MonadIO m, IsObject a) => O.OverloadedMethod ObjectPeekParentMethodInfo a signature where
    overloadedMethod :: a -> signature
overloadedMethod = a -> signature
a -> m Object
forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsObject a) =>
a -> m Object
objectPeekParent

instance O.OverloadedMethodInfo ObjectPeekParentMethodInfo a where
    overloadedMethodInfo :: Maybe ResolvedSymbolInfo
overloadedMethodInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
        resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.Atk.Objects.Object.objectPeekParent",
        resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-atk-2.0.29/docs/GI-Atk-Objects-Object.html#v:objectPeekParent"
        })


#endif

-- method Object::ref_accessible_child
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "accessible"
--           , argType = TInterface Name { namespace = "Atk" , name = "Object" }
--           , argCType = Just "AtkObject*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "an #AtkObject" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "i"
--           , argType = TBasicType TInt
--           , argCType = Just "gint"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "a gint representing the position of the child, starting from 0"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Atk" , name = "Object" })
-- throws : False
-- Skip return : False

foreign import ccall "atk_object_ref_accessible_child" atk_object_ref_accessible_child :: 
    Ptr Object ->                           -- accessible : TInterface (Name {namespace = "Atk", name = "Object"})
    Int32 ->                                -- i : TBasicType TInt
    IO (Ptr Object)

-- | Gets a reference to the specified accessible child of the object.
-- The accessible children are 0-based so the first accessible child is
-- at index 0, the second at index 1 and so on.
objectRefAccessibleChild ::
    (B.CallStack.HasCallStack, MonadIO m, IsObject a) =>
    a
    -- ^ /@accessible@/: an t'GI.Atk.Objects.Object.Object'
    -> Int32
    -- ^ /@i@/: a gint representing the position of the child, starting from 0
    -> m Object
    -- ^ __Returns:__ an t'GI.Atk.Objects.Object.Object' representing the specified
    -- accessible child of the accessible.
objectRefAccessibleChild :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsObject a) =>
a -> Int32 -> m Object
objectRefAccessibleChild a
accessible Int32
i = IO Object -> m Object
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Object -> m Object) -> IO Object -> m Object
forall a b. (a -> b) -> a -> b
$ do
    accessible' <- a -> IO (Ptr Object)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
accessible
    result <- atk_object_ref_accessible_child accessible' i
    checkUnexpectedReturnNULL "objectRefAccessibleChild" result
    result' <- (wrapObject Object) result
    touchManagedPtr accessible
    return result'

#if defined(ENABLE_OVERLOADING)
data ObjectRefAccessibleChildMethodInfo
instance (signature ~ (Int32 -> m Object), MonadIO m, IsObject a) => O.OverloadedMethod ObjectRefAccessibleChildMethodInfo a signature where
    overloadedMethod :: a -> signature
overloadedMethod = a -> signature
a -> Int32 -> m Object
forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsObject a) =>
a -> Int32 -> m Object
objectRefAccessibleChild

instance O.OverloadedMethodInfo ObjectRefAccessibleChildMethodInfo a where
    overloadedMethodInfo :: Maybe ResolvedSymbolInfo
overloadedMethodInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
        resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.Atk.Objects.Object.objectRefAccessibleChild",
        resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-atk-2.0.29/docs/GI-Atk-Objects-Object.html#v:objectRefAccessibleChild"
        })


#endif

-- method Object::ref_relation_set
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "accessible"
--           , argType = TInterface Name { namespace = "Atk" , name = "Object" }
--           , argCType = Just "AtkObject*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "an #AtkObject" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Atk" , name = "RelationSet" })
-- throws : False
-- Skip return : False

foreign import ccall "atk_object_ref_relation_set" atk_object_ref_relation_set :: 
    Ptr Object ->                           -- accessible : TInterface (Name {namespace = "Atk", name = "Object"})
    IO (Ptr Atk.RelationSet.RelationSet)

-- | Gets the t'GI.Atk.Objects.RelationSet.RelationSet' associated with the object.
objectRefRelationSet ::
    (B.CallStack.HasCallStack, MonadIO m, IsObject a) =>
    a
    -- ^ /@accessible@/: an t'GI.Atk.Objects.Object.Object'
    -> m Atk.RelationSet.RelationSet
    -- ^ __Returns:__ an t'GI.Atk.Objects.RelationSet.RelationSet' representing the relation set
    -- of the object.
objectRefRelationSet :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsObject a) =>
a -> m RelationSet
objectRefRelationSet a
accessible = IO RelationSet -> m RelationSet
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO RelationSet -> m RelationSet)
-> IO RelationSet -> m RelationSet
forall a b. (a -> b) -> a -> b
$ do
    accessible' <- a -> IO (Ptr Object)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
accessible
    result <- atk_object_ref_relation_set accessible'
    checkUnexpectedReturnNULL "objectRefRelationSet" result
    result' <- (wrapObject Atk.RelationSet.RelationSet) result
    touchManagedPtr accessible
    return result'

#if defined(ENABLE_OVERLOADING)
data ObjectRefRelationSetMethodInfo
instance (signature ~ (m Atk.RelationSet.RelationSet), MonadIO m, IsObject a) => O.OverloadedMethod ObjectRefRelationSetMethodInfo a signature where
    overloadedMethod :: a -> signature
overloadedMethod = a -> signature
a -> m RelationSet
forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsObject a) =>
a -> m RelationSet
objectRefRelationSet

instance O.OverloadedMethodInfo ObjectRefRelationSetMethodInfo a where
    overloadedMethodInfo :: Maybe ResolvedSymbolInfo
overloadedMethodInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
        resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.Atk.Objects.Object.objectRefRelationSet",
        resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-atk-2.0.29/docs/GI-Atk-Objects-Object.html#v:objectRefRelationSet"
        })


#endif

-- method Object::ref_state_set
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "accessible"
--           , argType = TInterface Name { namespace = "Atk" , name = "Object" }
--           , argCType = Just "AtkObject*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "an #AtkObject" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Atk" , name = "StateSet" })
-- throws : False
-- Skip return : False

foreign import ccall "atk_object_ref_state_set" atk_object_ref_state_set :: 
    Ptr Object ->                           -- accessible : TInterface (Name {namespace = "Atk", name = "Object"})
    IO (Ptr Atk.StateSet.StateSet)

-- | Gets a reference to the state set of the accessible; the caller must
-- unreference it when it is no longer needed.
objectRefStateSet ::
    (B.CallStack.HasCallStack, MonadIO m, IsObject a) =>
    a
    -- ^ /@accessible@/: an t'GI.Atk.Objects.Object.Object'
    -> m Atk.StateSet.StateSet
    -- ^ __Returns:__ a reference to an t'GI.Atk.Objects.StateSet.StateSet' which is the state
    -- set of the accessible
objectRefStateSet :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsObject a) =>
a -> m StateSet
objectRefStateSet a
accessible = IO StateSet -> m StateSet
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO StateSet -> m StateSet) -> IO StateSet -> m StateSet
forall a b. (a -> b) -> a -> b
$ do
    accessible' <- a -> IO (Ptr Object)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
accessible
    result <- atk_object_ref_state_set accessible'
    checkUnexpectedReturnNULL "objectRefStateSet" result
    result' <- (wrapObject Atk.StateSet.StateSet) result
    touchManagedPtr accessible
    return result'

#if defined(ENABLE_OVERLOADING)
data ObjectRefStateSetMethodInfo
instance (signature ~ (m Atk.StateSet.StateSet), MonadIO m, IsObject a) => O.OverloadedMethod ObjectRefStateSetMethodInfo a signature where
    overloadedMethod :: a -> signature
overloadedMethod = a -> signature
a -> m StateSet
forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsObject a) =>
a -> m StateSet
objectRefStateSet

instance O.OverloadedMethodInfo ObjectRefStateSetMethodInfo a where
    overloadedMethodInfo :: Maybe ResolvedSymbolInfo
overloadedMethodInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
        resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.Atk.Objects.Object.objectRefStateSet",
        resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-atk-2.0.29/docs/GI-Atk-Objects-Object.html#v:objectRefStateSet"
        })


#endif

-- method Object::remove_property_change_handler
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "accessible"
--           , argType = TInterface Name { namespace = "Atk" , name = "Object" }
--           , argCType = Just "AtkObject*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "an #AtkObject" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "handler_id"
--           , argType = TBasicType TUInt
--           , argCType = Just "guint"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "a guint which identifies the handler to be removed."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "atk_object_remove_property_change_handler" atk_object_remove_property_change_handler :: 
    Ptr Object ->                           -- accessible : TInterface (Name {namespace = "Atk", name = "Object"})
    Word32 ->                               -- handler_id : TBasicType TUInt
    IO ()

{-# DEPRECATED objectRemovePropertyChangeHandler ["(Since version 2.12)","See @/atk_object_connect_property_change_handler()/@"] #-}
-- | Removes a property change handler.
objectRemovePropertyChangeHandler ::
    (B.CallStack.HasCallStack, MonadIO m, IsObject a) =>
    a
    -- ^ /@accessible@/: an t'GI.Atk.Objects.Object.Object'
    -> Word32
    -- ^ /@handlerId@/: a guint which identifies the handler to be removed.
    -> m ()
objectRemovePropertyChangeHandler :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsObject a) =>
a -> Word32 -> m ()
objectRemovePropertyChangeHandler a
accessible Word32
handlerId = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    accessible' <- a -> IO (Ptr Object)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
accessible
    atk_object_remove_property_change_handler accessible' handlerId
    touchManagedPtr accessible
    return ()

#if defined(ENABLE_OVERLOADING)
data ObjectRemovePropertyChangeHandlerMethodInfo
instance (signature ~ (Word32 -> m ()), MonadIO m, IsObject a) => O.OverloadedMethod ObjectRemovePropertyChangeHandlerMethodInfo a signature where
    overloadedMethod :: a -> signature
overloadedMethod = a -> signature
a -> Word32 -> m ()
forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsObject a) =>
a -> Word32 -> m ()
objectRemovePropertyChangeHandler

instance O.OverloadedMethodInfo ObjectRemovePropertyChangeHandlerMethodInfo a where
    overloadedMethodInfo :: Maybe ResolvedSymbolInfo
overloadedMethodInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
        resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.Atk.Objects.Object.objectRemovePropertyChangeHandler",
        resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-atk-2.0.29/docs/GI-Atk-Objects-Object.html#v:objectRemovePropertyChangeHandler"
        })


#endif

-- method Object::remove_relationship
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "object"
--           , argType = TInterface Name { namespace = "Atk" , name = "Object" }
--           , argCType = Just "AtkObject*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "The #AtkObject from which an AtkRelation is to be removed."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "relationship"
--           , argType =
--               TInterface Name { namespace = "Atk" , name = "RelationType" }
--           , argCType = Just "AtkRelationType"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "The #AtkRelationType of the relation"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "target"
--           , argType = TInterface Name { namespace = "Atk" , name = "Object" }
--           , argCType = Just "AtkObject*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "The #AtkObject which is the target of the relation to be removed."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "atk_object_remove_relationship" atk_object_remove_relationship :: 
    Ptr Object ->                           -- object : TInterface (Name {namespace = "Atk", name = "Object"})
    CUInt ->                                -- relationship : TInterface (Name {namespace = "Atk", name = "RelationType"})
    Ptr Object ->                           -- target : TInterface (Name {namespace = "Atk", name = "Object"})
    IO CInt

-- | Removes a relationship of the specified type with the specified target.
objectRemoveRelationship ::
    (B.CallStack.HasCallStack, MonadIO m, IsObject a, IsObject b) =>
    a
    -- ^ /@object@/: The t'GI.Atk.Objects.Object.Object' from which an AtkRelation is to be removed.
    -> Atk.Enums.RelationType
    -- ^ /@relationship@/: The t'GI.Atk.Enums.RelationType' of the relation
    -> b
    -- ^ /@target@/: The t'GI.Atk.Objects.Object.Object' which is the target of the relation to be removed.
    -> m Bool
    -- ^ __Returns:__ TRUE if the relationship is removed.
objectRemoveRelationship :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsObject a, IsObject b) =>
a -> RelationType -> b -> m Bool
objectRemoveRelationship a
object RelationType
relationship b
target = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    object' <- a -> IO (Ptr Object)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
object
    let relationship' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (RelationType -> Int) -> RelationType -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. RelationType -> Int
forall a. Enum a => a -> Int
fromEnum) RelationType
relationship
    target' <- unsafeManagedPtrCastPtr target
    result <- atk_object_remove_relationship object' relationship' target'
    let result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    touchManagedPtr object
    touchManagedPtr target
    return result'

#if defined(ENABLE_OVERLOADING)
data ObjectRemoveRelationshipMethodInfo
instance (signature ~ (Atk.Enums.RelationType -> b -> m Bool), MonadIO m, IsObject a, IsObject b) => O.OverloadedMethod ObjectRemoveRelationshipMethodInfo a signature where
    overloadedMethod :: a -> signature
overloadedMethod = a -> signature
a -> RelationType -> b -> m Bool
forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsObject a, IsObject b) =>
a -> RelationType -> b -> m Bool
objectRemoveRelationship

instance O.OverloadedMethodInfo ObjectRemoveRelationshipMethodInfo a where
    overloadedMethodInfo :: Maybe ResolvedSymbolInfo
overloadedMethodInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
        resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.Atk.Objects.Object.objectRemoveRelationship",
        resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-atk-2.0.29/docs/GI-Atk-Objects-Object.html#v:objectRemoveRelationship"
        })


#endif

-- method Object::set_accessible_id
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "accessible"
--           , argType = TInterface Name { namespace = "Atk" , name = "Object" }
--           , argCType = Just "AtkObject*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "an #AtkObject" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "id"
--           , argType = TBasicType TUTF8
--           , argCType = Just "const gchar*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "a character string to be set as the accessible id"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "atk_object_set_accessible_id" atk_object_set_accessible_id :: 
    Ptr Object ->                           -- accessible : TInterface (Name {namespace = "Atk", name = "Object"})
    CString ->                              -- id : TBasicType TUTF8
    IO ()

-- | Sets the accessible ID of the accessible.  This is not meant to be presented
-- to the user, but to be an ID which is stable over application development.
-- Typically, this is the gtkbuilder ID. Such an ID will be available for
-- instance to identify a given well-known accessible object for tailored screen
-- reading, or for automatic regression testing.
-- 
-- /Since: 2.34/
objectSetAccessibleId ::
    (B.CallStack.HasCallStack, MonadIO m, IsObject a) =>
    a
    -- ^ /@accessible@/: an t'GI.Atk.Objects.Object.Object'
    -> T.Text
    -- ^ /@id@/: a character string to be set as the accessible id
    -> m ()
objectSetAccessibleId :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsObject a) =>
a -> Text -> m ()
objectSetAccessibleId a
accessible Text
id = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    accessible' <- a -> IO (Ptr Object)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
accessible
    id' <- textToCString id
    atk_object_set_accessible_id accessible' id'
    touchManagedPtr accessible
    freeMem id'
    return ()

#if defined(ENABLE_OVERLOADING)
data ObjectSetAccessibleIdMethodInfo
instance (signature ~ (T.Text -> m ()), MonadIO m, IsObject a) => O.OverloadedMethod ObjectSetAccessibleIdMethodInfo a signature where
    overloadedMethod :: a -> signature
overloadedMethod = a -> signature
a -> Text -> m ()
forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsObject a) =>
a -> Text -> m ()
objectSetAccessibleId

instance O.OverloadedMethodInfo ObjectSetAccessibleIdMethodInfo a where
    overloadedMethodInfo :: Maybe ResolvedSymbolInfo
overloadedMethodInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
        resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.Atk.Objects.Object.objectSetAccessibleId",
        resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-atk-2.0.29/docs/GI-Atk-Objects-Object.html#v:objectSetAccessibleId"
        })


#endif

-- method Object::set_description
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "accessible"
--           , argType = TInterface Name { namespace = "Atk" , name = "Object" }
--           , argCType = Just "AtkObject*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "an #AtkObject" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "description"
--           , argType = TBasicType TUTF8
--           , argCType = Just "const gchar*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "a character string to be set as the accessible description"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "atk_object_set_description" atk_object_set_description :: 
    Ptr Object ->                           -- accessible : TInterface (Name {namespace = "Atk", name = "Object"})
    CString ->                              -- description : TBasicType TUTF8
    IO ()

-- | Sets the accessible description of the accessible. You can\'t set
-- the description to NULL. This is reserved for the initial value. In
-- this aspect NULL is similar to ATK_ROLE_UNKNOWN. If you want to set
-- the name to a empty value you can use \"\".
objectSetDescription ::
    (B.CallStack.HasCallStack, MonadIO m, IsObject a) =>
    a
    -- ^ /@accessible@/: an t'GI.Atk.Objects.Object.Object'
    -> T.Text
    -- ^ /@description@/: a character string to be set as the accessible description
    -> m ()
objectSetDescription :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsObject a) =>
a -> Text -> m ()
objectSetDescription a
accessible Text
description = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    accessible' <- a -> IO (Ptr Object)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
accessible
    description' <- textToCString description
    atk_object_set_description accessible' description'
    touchManagedPtr accessible
    freeMem description'
    return ()

#if defined(ENABLE_OVERLOADING)
data ObjectSetDescriptionMethodInfo
instance (signature ~ (T.Text -> m ()), MonadIO m, IsObject a) => O.OverloadedMethod ObjectSetDescriptionMethodInfo a signature where
    overloadedMethod :: a -> signature
overloadedMethod = a -> signature
a -> Text -> m ()
forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsObject a) =>
a -> Text -> m ()
objectSetDescription

instance O.OverloadedMethodInfo ObjectSetDescriptionMethodInfo a where
    overloadedMethodInfo :: Maybe ResolvedSymbolInfo
overloadedMethodInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
        resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.Atk.Objects.Object.objectSetDescription",
        resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-atk-2.0.29/docs/GI-Atk-Objects-Object.html#v:objectSetDescription"
        })


#endif

-- method Object::set_help_text
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "accessible"
--           , argType = TInterface Name { namespace = "Atk" , name = "Object" }
--           , argCType = Just "AtkObject*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "an #AtkObject" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "help_text"
--           , argType = TBasicType TUTF8
--           , argCType = Just "const gchar*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "a character string to be set as the accessible's help text"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "atk_object_set_help_text" atk_object_set_help_text :: 
    Ptr Object ->                           -- accessible : TInterface (Name {namespace = "Atk", name = "Object"})
    CString ->                              -- help_text : TBasicType TUTF8
    IO ()

-- | Sets the help text associated with the accessible. This can be used to
-- expose context-sensitive information to help a user understand how to
-- interact with the object. You can\'t set the help text to NULL.
-- This is reserved for the initial value. If you want to set the name to
-- an empty value, you can use \"\".
-- 
-- /Since: 2.52/
objectSetHelpText ::
    (B.CallStack.HasCallStack, MonadIO m, IsObject a) =>
    a
    -- ^ /@accessible@/: an t'GI.Atk.Objects.Object.Object'
    -> T.Text
    -- ^ /@helpText@/: a character string to be set as the accessible\'s help text
    -> m ()
objectSetHelpText :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsObject a) =>
a -> Text -> m ()
objectSetHelpText a
accessible Text
helpText = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    accessible' <- a -> IO (Ptr Object)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
accessible
    helpText' <- textToCString helpText
    atk_object_set_help_text accessible' helpText'
    touchManagedPtr accessible
    freeMem helpText'
    return ()

#if defined(ENABLE_OVERLOADING)
data ObjectSetHelpTextMethodInfo
instance (signature ~ (T.Text -> m ()), MonadIO m, IsObject a) => O.OverloadedMethod ObjectSetHelpTextMethodInfo a signature where
    overloadedMethod :: a -> signature
overloadedMethod = a -> signature
a -> Text -> m ()
forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsObject a) =>
a -> Text -> m ()
objectSetHelpText

instance O.OverloadedMethodInfo ObjectSetHelpTextMethodInfo a where
    overloadedMethodInfo :: Maybe ResolvedSymbolInfo
overloadedMethodInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
        resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.Atk.Objects.Object.objectSetHelpText",
        resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-atk-2.0.29/docs/GI-Atk-Objects-Object.html#v:objectSetHelpText"
        })


#endif

-- method Object::set_name
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "accessible"
--           , argType = TInterface Name { namespace = "Atk" , name = "Object" }
--           , argCType = Just "AtkObject*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "an #AtkObject" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "name"
--           , argType = TBasicType TUTF8
--           , argCType = Just "const gchar*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "a character string to be set as the accessible name"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "atk_object_set_name" atk_object_set_name :: 
    Ptr Object ->                           -- accessible : TInterface (Name {namespace = "Atk", name = "Object"})
    CString ->                              -- name : TBasicType TUTF8
    IO ()

-- | Sets the accessible name of the accessible. You can\'t set the name
-- to NULL. This is reserved for the initial value. In this aspect
-- NULL is similar to ATK_ROLE_UNKNOWN. If you want to set the name to
-- a empty value you can use \"\".
objectSetName ::
    (B.CallStack.HasCallStack, MonadIO m, IsObject a) =>
    a
    -- ^ /@accessible@/: an t'GI.Atk.Objects.Object.Object'
    -> T.Text
    -- ^ /@name@/: a character string to be set as the accessible name
    -> m ()
objectSetName :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsObject a) =>
a -> Text -> m ()
objectSetName a
accessible Text
name = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    accessible' <- a -> IO (Ptr Object)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
accessible
    name' <- textToCString name
    atk_object_set_name accessible' name'
    touchManagedPtr accessible
    freeMem name'
    return ()

#if defined(ENABLE_OVERLOADING)
data ObjectSetNameMethodInfo
instance (signature ~ (T.Text -> m ()), MonadIO m, IsObject a) => O.OverloadedMethod ObjectSetNameMethodInfo a signature where
    overloadedMethod :: a -> signature
overloadedMethod = a -> signature
a -> Text -> m ()
forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsObject a) =>
a -> Text -> m ()
objectSetName

instance O.OverloadedMethodInfo ObjectSetNameMethodInfo a where
    overloadedMethodInfo :: Maybe ResolvedSymbolInfo
overloadedMethodInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
        resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.Atk.Objects.Object.objectSetName",
        resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-atk-2.0.29/docs/GI-Atk-Objects-Object.html#v:objectSetName"
        })


#endif

-- method Object::set_parent
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "accessible"
--           , argType = TInterface Name { namespace = "Atk" , name = "Object" }
--           , argCType = Just "AtkObject*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "an #AtkObject" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "parent"
--           , argType = TInterface Name { namespace = "Atk" , name = "Object" }
--           , argCType = Just "AtkObject*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "an #AtkObject to be set as the accessible parent"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "atk_object_set_parent" atk_object_set_parent :: 
    Ptr Object ->                           -- accessible : TInterface (Name {namespace = "Atk", name = "Object"})
    Ptr Object ->                           -- parent : TInterface (Name {namespace = "Atk", name = "Object"})
    IO ()

-- | Sets the accessible parent of the accessible. /@parent@/ can be NULL.
objectSetParent ::
    (B.CallStack.HasCallStack, MonadIO m, IsObject a, IsObject b) =>
    a
    -- ^ /@accessible@/: an t'GI.Atk.Objects.Object.Object'
    -> b
    -- ^ /@parent@/: an t'GI.Atk.Objects.Object.Object' to be set as the accessible parent
    -> m ()
objectSetParent :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsObject a, IsObject b) =>
a -> b -> m ()
objectSetParent a
accessible b
parent = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    accessible' <- a -> IO (Ptr Object)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
accessible
    parent' <- unsafeManagedPtrCastPtr parent
    atk_object_set_parent accessible' parent'
    touchManagedPtr accessible
    touchManagedPtr parent
    return ()

#if defined(ENABLE_OVERLOADING)
data ObjectSetParentMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsObject a, IsObject b) => O.OverloadedMethod ObjectSetParentMethodInfo a signature where
    overloadedMethod :: a -> signature
overloadedMethod = a -> signature
a -> b -> m ()
forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsObject a, IsObject b) =>
a -> b -> m ()
objectSetParent

instance O.OverloadedMethodInfo ObjectSetParentMethodInfo a where
    overloadedMethodInfo :: Maybe ResolvedSymbolInfo
overloadedMethodInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
        resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.Atk.Objects.Object.objectSetParent",
        resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-atk-2.0.29/docs/GI-Atk-Objects-Object.html#v:objectSetParent"
        })


#endif

-- method Object::set_role
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "accessible"
--           , argType = TInterface Name { namespace = "Atk" , name = "Object" }
--           , argCType = Just "AtkObject*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "an #AtkObject" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "role"
--           , argType = TInterface Name { namespace = "Atk" , name = "Role" }
--           , argCType = Just "AtkRole"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "an #AtkRole to be set as the role"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "atk_object_set_role" atk_object_set_role :: 
    Ptr Object ->                           -- accessible : TInterface (Name {namespace = "Atk", name = "Object"})
    CUInt ->                                -- role : TInterface (Name {namespace = "Atk", name = "Role"})
    IO ()

-- | Sets the role of the accessible.
objectSetRole ::
    (B.CallStack.HasCallStack, MonadIO m, IsObject a) =>
    a
    -- ^ /@accessible@/: an t'GI.Atk.Objects.Object.Object'
    -> Atk.Enums.Role
    -- ^ /@role@/: an t'GI.Atk.Enums.Role' to be set as the role
    -> m ()
objectSetRole :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsObject a) =>
a -> Role -> m ()
objectSetRole a
accessible Role
role = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    accessible' <- a -> IO (Ptr Object)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
accessible
    let role' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (Role -> Int) -> Role -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Role -> Int
forall a. Enum a => a -> Int
fromEnum) Role
role
    atk_object_set_role accessible' role'
    touchManagedPtr accessible
    return ()

#if defined(ENABLE_OVERLOADING)
data ObjectSetRoleMethodInfo
instance (signature ~ (Atk.Enums.Role -> m ()), MonadIO m, IsObject a) => O.OverloadedMethod ObjectSetRoleMethodInfo a signature where
    overloadedMethod :: a -> signature
overloadedMethod = a -> signature
a -> Role -> m ()
forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsObject a) =>
a -> Role -> m ()
objectSetRole

instance O.OverloadedMethodInfo ObjectSetRoleMethodInfo a where
    overloadedMethodInfo :: Maybe ResolvedSymbolInfo
overloadedMethodInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
        resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.Atk.Objects.Object.objectSetRole",
        resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-atk-2.0.29/docs/GI-Atk-Objects-Object.html#v:objectSetRole"
        })


#endif