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

This class is the primary class for accessibility support via the
Accessibility ToolKit (ATK).  Objects which are instances of
'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 'GI.Atk.Objects.Object.Object'
may also be queried as to whether they implement other ATK
interfaces (e.g. 'GI.Atk.Interfaces.Action.Action', '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
'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 'GI.Atk.Objects.Object.Object'
implementation is insufficient, via instances of a new 'GI.Atk.Objects.Object.Object'
subclass.

See also: 'GI.Atk.Objects.ObjectFactory.ObjectFactory', 'GI.Atk.Objects.Registry.Registry'.  (GTK+ users see also
@/GtkAccessible/@).
-}

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

module GI.Atk.Objects.Object
    (

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


 -- * Methods
-- ** addRelationship #method:addRelationship#

#if ENABLE_OVERLOADING
    ObjectAddRelationshipMethodInfo         ,
#endif
    objectAddRelationship                   ,


-- ** getAttributes #method:getAttributes#

#if ENABLE_OVERLOADING
    ObjectGetAttributesMethodInfo           ,
#endif
    objectGetAttributes                     ,


-- ** getDescription #method:getDescription#

#if ENABLE_OVERLOADING
    ObjectGetDescriptionMethodInfo          ,
#endif
    objectGetDescription                    ,


-- ** getIndexInParent #method:getIndexInParent#

#if ENABLE_OVERLOADING
    ObjectGetIndexInParentMethodInfo        ,
#endif
    objectGetIndexInParent                  ,


-- ** getLayer #method:getLayer#

#if ENABLE_OVERLOADING
    ObjectGetLayerMethodInfo                ,
#endif
    objectGetLayer                          ,


-- ** getMdiZorder #method:getMdiZorder#

#if ENABLE_OVERLOADING
    ObjectGetMdiZorderMethodInfo            ,
#endif
    objectGetMdiZorder                      ,


-- ** getNAccessibleChildren #method:getNAccessibleChildren#

#if ENABLE_OVERLOADING
    ObjectGetNAccessibleChildrenMethodInfo  ,
#endif
    objectGetNAccessibleChildren            ,


-- ** getName #method:getName#

#if ENABLE_OVERLOADING
    ObjectGetNameMethodInfo                 ,
#endif
    objectGetName                           ,


-- ** getObjectLocale #method:getObjectLocale#

#if ENABLE_OVERLOADING
    ObjectGetObjectLocaleMethodInfo         ,
#endif
    objectGetObjectLocale                   ,


-- ** getParent #method:getParent#

#if ENABLE_OVERLOADING
    ObjectGetParentMethodInfo               ,
#endif
    objectGetParent                         ,


-- ** getRole #method:getRole#

#if ENABLE_OVERLOADING
    ObjectGetRoleMethodInfo                 ,
#endif
    objectGetRole                           ,


-- ** initialize #method:initialize#

#if ENABLE_OVERLOADING
    ObjectInitializeMethodInfo              ,
#endif
    objectInitialize                        ,


-- ** notifyStateChange #method:notifyStateChange#

#if ENABLE_OVERLOADING
    ObjectNotifyStateChangeMethodInfo       ,
#endif
    objectNotifyStateChange                 ,


-- ** peekParent #method:peekParent#

#if ENABLE_OVERLOADING
    ObjectPeekParentMethodInfo              ,
#endif
    objectPeekParent                        ,


-- ** refAccessibleChild #method:refAccessibleChild#

#if ENABLE_OVERLOADING
    ObjectRefAccessibleChildMethodInfo      ,
#endif
    objectRefAccessibleChild                ,


-- ** refRelationSet #method:refRelationSet#

#if ENABLE_OVERLOADING
    ObjectRefRelationSetMethodInfo          ,
#endif
    objectRefRelationSet                    ,


-- ** refStateSet #method:refStateSet#

#if ENABLE_OVERLOADING
    ObjectRefStateSetMethodInfo             ,
#endif
    objectRefStateSet                       ,


-- ** removePropertyChangeHandler #method:removePropertyChangeHandler#

#if ENABLE_OVERLOADING
    ObjectRemovePropertyChangeHandlerMethodInfo,
#endif
    objectRemovePropertyChangeHandler       ,


-- ** removeRelationship #method:removeRelationship#

#if ENABLE_OVERLOADING
    ObjectRemoveRelationshipMethodInfo      ,
#endif
    objectRemoveRelationship                ,


-- ** setDescription #method:setDescription#

#if ENABLE_OVERLOADING
    ObjectSetDescriptionMethodInfo          ,
#endif
    objectSetDescription                    ,


-- ** setName #method:setName#

#if ENABLE_OVERLOADING
    ObjectSetNameMethodInfo                 ,
#endif
    objectSetName                           ,


-- ** setParent #method:setParent#

#if ENABLE_OVERLOADING
    ObjectSetParentMethodInfo               ,
#endif
    objectSetParent                         ,


-- ** setRole #method:setRole#

#if ENABLE_OVERLOADING
    ObjectSetRoleMethodInfo                 ,
#endif
    objectSetRole                           ,




 -- * Properties
-- ** accessibleComponentLayer #attr:accessibleComponentLayer#
{- | /No description available in the introspection data./
-}
#if ENABLE_OVERLOADING
    ObjectAccessibleComponentLayerPropertyInfo,
#endif
    getObjectAccessibleComponentLayer       ,
#if ENABLE_OVERLOADING
    objectAccessibleComponentLayer          ,
#endif


-- ** accessibleComponentMdiZorder #attr:accessibleComponentMdiZorder#
{- | /No description available in the introspection data./
-}
#if ENABLE_OVERLOADING
    ObjectAccessibleComponentMdiZorderPropertyInfo,
#endif
    getObjectAccessibleComponentMdiZorder   ,
#if ENABLE_OVERLOADING
    objectAccessibleComponentMdiZorder      ,
#endif


-- ** accessibleDescription #attr:accessibleDescription#
{- | /No description available in the introspection data./
-}
#if ENABLE_OVERLOADING
    ObjectAccessibleDescriptionPropertyInfo ,
#endif
    clearObjectAccessibleDescription        ,
    constructObjectAccessibleDescription    ,
    getObjectAccessibleDescription          ,
#if ENABLE_OVERLOADING
    objectAccessibleDescription             ,
#endif
    setObjectAccessibleDescription          ,


-- ** accessibleHypertextNlinks #attr:accessibleHypertextNlinks#
{- | /No description available in the introspection data./
-}
#if ENABLE_OVERLOADING
    ObjectAccessibleHypertextNlinksPropertyInfo,
#endif
    getObjectAccessibleHypertextNlinks      ,
#if ENABLE_OVERLOADING
    objectAccessibleHypertextNlinks         ,
#endif


-- ** accessibleName #attr:accessibleName#
{- | /No description available in the introspection data./
-}
#if ENABLE_OVERLOADING
    ObjectAccessibleNamePropertyInfo        ,
#endif
    clearObjectAccessibleName               ,
    constructObjectAccessibleName           ,
    getObjectAccessibleName                 ,
#if ENABLE_OVERLOADING
    objectAccessibleName                    ,
#endif
    setObjectAccessibleName                 ,


-- ** accessibleParent #attr:accessibleParent#
{- | /No description available in the introspection data./
-}
#if ENABLE_OVERLOADING
    ObjectAccessibleParentPropertyInfo      ,
#endif
    clearObjectAccessibleParent             ,
    constructObjectAccessibleParent         ,
    getObjectAccessibleParent               ,
#if ENABLE_OVERLOADING
    objectAccessibleParent                  ,
#endif
    setObjectAccessibleParent               ,


-- ** accessibleRole #attr:accessibleRole#
{- | /No description available in the introspection data./
-}
#if ENABLE_OVERLOADING
    ObjectAccessibleRolePropertyInfo        ,
#endif
    constructObjectAccessibleRole           ,
    getObjectAccessibleRole                 ,
#if ENABLE_OVERLOADING
    objectAccessibleRole                    ,
#endif
    setObjectAccessibleRole                 ,


-- ** accessibleTableCaption #attr:accessibleTableCaption#
{- | Table caption.
-}
#if ENABLE_OVERLOADING
    ObjectAccessibleTableCaptionPropertyInfo,
#endif
    clearObjectAccessibleTableCaption       ,
    constructObjectAccessibleTableCaption   ,
    getObjectAccessibleTableCaption         ,
#if ENABLE_OVERLOADING
    objectAccessibleTableCaption            ,
#endif
    setObjectAccessibleTableCaption         ,


-- ** accessibleTableCaptionObject #attr:accessibleTableCaptionObject#
{- | /No description available in the introspection data./
-}
#if ENABLE_OVERLOADING
    ObjectAccessibleTableCaptionObjectPropertyInfo,
#endif
    clearObjectAccessibleTableCaptionObject ,
    constructObjectAccessibleTableCaptionObject,
    getObjectAccessibleTableCaptionObject   ,
#if ENABLE_OVERLOADING
    objectAccessibleTableCaptionObject      ,
#endif
    setObjectAccessibleTableCaptionObject   ,


-- ** accessibleTableColumnDescription #attr:accessibleTableColumnDescription#
{- | Accessible table column description.
-}
#if ENABLE_OVERLOADING
    ObjectAccessibleTableColumnDescriptionPropertyInfo,
#endif
    clearObjectAccessibleTableColumnDescription,
    constructObjectAccessibleTableColumnDescription,
    getObjectAccessibleTableColumnDescription,
#if ENABLE_OVERLOADING
    objectAccessibleTableColumnDescription  ,
#endif
    setObjectAccessibleTableColumnDescription,


-- ** accessibleTableColumnHeader #attr:accessibleTableColumnHeader#
{- | Accessible table column header.
-}
#if ENABLE_OVERLOADING
    ObjectAccessibleTableColumnHeaderPropertyInfo,
#endif
    clearObjectAccessibleTableColumnHeader  ,
    constructObjectAccessibleTableColumnHeader,
    getObjectAccessibleTableColumnHeader    ,
#if ENABLE_OVERLOADING
    objectAccessibleTableColumnHeader       ,
#endif
    setObjectAccessibleTableColumnHeader    ,


-- ** accessibleTableRowDescription #attr:accessibleTableRowDescription#
{- | Accessible table row description.
-}
#if ENABLE_OVERLOADING
    ObjectAccessibleTableRowDescriptionPropertyInfo,
#endif
    clearObjectAccessibleTableRowDescription,
    constructObjectAccessibleTableRowDescription,
    getObjectAccessibleTableRowDescription  ,
#if ENABLE_OVERLOADING
    objectAccessibleTableRowDescription     ,
#endif
    setObjectAccessibleTableRowDescription  ,


-- ** accessibleTableRowHeader #attr:accessibleTableRowHeader#
{- | Accessible table row header.
-}
#if ENABLE_OVERLOADING
    ObjectAccessibleTableRowHeaderPropertyInfo,
#endif
    clearObjectAccessibleTableRowHeader     ,
    constructObjectAccessibleTableRowHeader ,
    getObjectAccessibleTableRowHeader       ,
#if ENABLE_OVERLOADING
    objectAccessibleTableRowHeader          ,
#endif
    setObjectAccessibleTableRowHeader       ,


-- ** accessibleTableSummary #attr:accessibleTableSummary#
{- | /No description available in the introspection data./
-}
#if ENABLE_OVERLOADING
    ObjectAccessibleTableSummaryPropertyInfo,
#endif
    clearObjectAccessibleTableSummary       ,
    constructObjectAccessibleTableSummary   ,
    getObjectAccessibleTableSummary         ,
#if ENABLE_OVERLOADING
    objectAccessibleTableSummary            ,
#endif
    setObjectAccessibleTableSummary         ,


-- ** accessibleValue #attr:accessibleValue#
{- | Numeric value of this object, in case being and AtkValue.
-}
#if ENABLE_OVERLOADING
    ObjectAccessibleValuePropertyInfo       ,
#endif
    constructObjectAccessibleValue          ,
    getObjectAccessibleValue                ,
#if ENABLE_OVERLOADING
    objectAccessibleValue                   ,
#endif
    setObjectAccessibleValue                ,




 -- * Signals
-- ** activeDescendantChanged #signal:activeDescendantChanged#

    C_ObjectActiveDescendantChangedCallback ,
    ObjectActiveDescendantChangedCallback   ,
#if ENABLE_OVERLOADING
    ObjectActiveDescendantChangedSignalInfo ,
#endif
    afterObjectActiveDescendantChanged      ,
    genClosure_ObjectActiveDescendantChanged,
    mk_ObjectActiveDescendantChangedCallback,
    noObjectActiveDescendantChangedCallback ,
    onObjectActiveDescendantChanged         ,
    wrap_ObjectActiveDescendantChangedCallback,


-- ** childrenChanged #signal:childrenChanged#

    C_ObjectChildrenChangedCallback         ,
    ObjectChildrenChangedCallback           ,
#if ENABLE_OVERLOADING
    ObjectChildrenChangedSignalInfo         ,
#endif
    afterObjectChildrenChanged              ,
    genClosure_ObjectChildrenChanged        ,
    mk_ObjectChildrenChangedCallback        ,
    noObjectChildrenChangedCallback         ,
    onObjectChildrenChanged                 ,
    wrap_ObjectChildrenChangedCallback      ,


-- ** focusEvent #signal:focusEvent#

    C_ObjectFocusEventCallback              ,
    ObjectFocusEventCallback                ,
#if ENABLE_OVERLOADING
    ObjectFocusEventSignalInfo              ,
#endif
    afterObjectFocusEvent                   ,
    genClosure_ObjectFocusEvent             ,
    mk_ObjectFocusEventCallback             ,
    noObjectFocusEventCallback              ,
    onObjectFocusEvent                      ,
    wrap_ObjectFocusEventCallback           ,


-- ** propertyChange #signal:propertyChange#

    C_ObjectPropertyChangeCallback          ,
    ObjectPropertyChangeCallback            ,
#if ENABLE_OVERLOADING
    ObjectPropertyChangeSignalInfo          ,
#endif
    afterObjectPropertyChange               ,
    genClosure_ObjectPropertyChange         ,
    mk_ObjectPropertyChangeCallback         ,
    noObjectPropertyChangeCallback          ,
    onObjectPropertyChange                  ,
    wrap_ObjectPropertyChangeCallback       ,


-- ** stateChange #signal:stateChange#

    C_ObjectStateChangeCallback             ,
    ObjectStateChangeCallback               ,
#if ENABLE_OVERLOADING
    ObjectStateChangeSignalInfo             ,
#endif
    afterObjectStateChange                  ,
    genClosure_ObjectStateChange            ,
    mk_ObjectStateChangeCallback            ,
    noObjectStateChangeCallback             ,
    onObjectStateChange                     ,
    wrap_ObjectStateChangeCallback          ,


-- ** visibleDataChanged #signal:visibleDataChanged#

    C_ObjectVisibleDataChangedCallback      ,
    ObjectVisibleDataChangedCallback        ,
#if ENABLE_OVERLOADING
    ObjectVisibleDataChangedSignalInfo      ,
#endif
    afterObjectVisibleDataChanged           ,
    genClosure_ObjectVisibleDataChanged     ,
    mk_ObjectVisibleDataChangedCallback     ,
    noObjectVisibleDataChangedCallback      ,
    onObjectVisibleDataChanged              ,
    wrap_ObjectVisibleDataChangedCallback   ,




    ) where

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

import qualified Data.GI.Base.Attributes as GI.Attributes
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL

import {-# SOURCE #-} qualified GI.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

-- | Memory-managed wrapper type.
newtype Object = Object (ManagedPtr Object)
foreign import ccall "atk_object_get_type"
    c_atk_object_get_type :: IO GType

instance GObject Object where
    gobjectType = c_atk_object_get_type


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

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

-- | Cast to `Object`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`.
toObject :: (MonadIO m, IsObject o) => o -> m Object
toObject = liftIO . unsafeCastTo Object

-- | A convenience alias for `Nothing` :: `Maybe` `Object`.
noObject :: Maybe Object
noObject = Nothing

#if ENABLE_OVERLOADING
type family ResolveObjectMethod (t :: Symbol) (o :: *) :: * 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 "getAttributes" o = ObjectGetAttributesMethodInfo
    ResolveObjectMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveObjectMethod "getDescription" o = ObjectGetDescriptionMethodInfo
    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 "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveObjectMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
    ResolveObjectMethod "setDescription" o = ObjectSetDescriptionMethodInfo
    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.MethodInfo info Object p) => OL.IsLabel t (Object -> p) where
#if MIN_VERSION_base(4,10,0)
    fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
#else
    fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
#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 ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `ObjectActiveDescendantChangedCallback`@.
noObjectActiveDescendantChangedCallback :: Maybe ObjectActiveDescendantChangedCallback
noObjectActiveDescendantChangedCallback = Nothing

-- | Type for the callback on the (unwrapped) C side.
type C_ObjectActiveDescendantChangedCallback =
    Ptr () ->                               -- 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 the callback into a `GClosure`.
genClosure_ObjectActiveDescendantChanged :: MonadIO m => ObjectActiveDescendantChangedCallback -> m (GClosure C_ObjectActiveDescendantChangedCallback)
genClosure_ObjectActiveDescendantChanged cb = liftIO $ do
    let cb' = wrap_ObjectActiveDescendantChangedCallback cb
    mk_ObjectActiveDescendantChangedCallback cb' >>= B.GClosure.newGClosure


-- | Wrap a `ObjectActiveDescendantChangedCallback` into a `C_ObjectActiveDescendantChangedCallback`.
wrap_ObjectActiveDescendantChangedCallback ::
    ObjectActiveDescendantChangedCallback ->
    C_ObjectActiveDescendantChangedCallback
wrap_ObjectActiveDescendantChangedCallback _cb _ arg1 _ = do
    maybeArg1 <-
        if arg1 == nullPtr
        then return Nothing
        else do
            arg1' <- (newObject Object) arg1
            return $ Just arg1'
    _cb  maybeArg1


{- |
Connect a signal handler for the “@active-descendant-changed@” 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
@
-}
onObjectActiveDescendantChanged :: (IsObject a, MonadIO m) => a -> ObjectActiveDescendantChangedCallback -> m SignalHandlerId
onObjectActiveDescendantChanged obj cb = liftIO $ do
    let cb' = wrap_ObjectActiveDescendantChangedCallback cb
    cb'' <- mk_ObjectActiveDescendantChangedCallback cb'
    connectSignalFunPtr obj "active-descendant-changed" cb'' SignalConnectBefore

{- |
Connect a signal handler for the “@active-descendant-changed@” 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
@
-}
afterObjectActiveDescendantChanged :: (IsObject a, MonadIO m) => a -> ObjectActiveDescendantChangedCallback -> m SignalHandlerId
afterObjectActiveDescendantChanged obj cb = liftIO $ do
    let cb' = wrap_ObjectActiveDescendantChangedCallback cb
    cb'' <- mk_ObjectActiveDescendantChangedCallback cb'
    connectSignalFunPtr obj "active-descendant-changed" cb'' SignalConnectAfter


-- signal Object::children-changed
{- |
The signal \"children-changed\" is emitted when a child is added or
removed form 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 ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `ObjectChildrenChangedCallback`@.
noObjectChildrenChangedCallback :: Maybe ObjectChildrenChangedCallback
noObjectChildrenChangedCallback = Nothing

-- | Type for the callback on the (unwrapped) C side.
type C_ObjectChildrenChangedCallback =
    Ptr () ->                               -- 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 the callback into a `GClosure`.
genClosure_ObjectChildrenChanged :: MonadIO m => ObjectChildrenChangedCallback -> m (GClosure C_ObjectChildrenChangedCallback)
genClosure_ObjectChildrenChanged cb = liftIO $ do
    let cb' = wrap_ObjectChildrenChangedCallback cb
    mk_ObjectChildrenChangedCallback cb' >>= B.GClosure.newGClosure


-- | Wrap a `ObjectChildrenChangedCallback` into a `C_ObjectChildrenChangedCallback`.
wrap_ObjectChildrenChangedCallback ::
    ObjectChildrenChangedCallback ->
    C_ObjectChildrenChangedCallback
wrap_ObjectChildrenChangedCallback _cb _ arg1 arg2 _ = do
    maybeArg2 <-
        if arg2 == nullPtr
        then return Nothing
        else do
            arg2' <- (newObject Object) arg2
            return $ Just arg2'
    _cb  arg1 maybeArg2


{- |
Connect a signal handler for the “@children-changed@” 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
@
-}
onObjectChildrenChanged :: (IsObject a, MonadIO m) => a -> ObjectChildrenChangedCallback -> m SignalHandlerId
onObjectChildrenChanged obj cb = liftIO $ do
    let cb' = wrap_ObjectChildrenChangedCallback cb
    cb'' <- mk_ObjectChildrenChangedCallback cb'
    connectSignalFunPtr obj "children-changed" cb'' SignalConnectBefore

{- |
Connect a signal handler for the “@children-changed@” 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
@
-}
afterObjectChildrenChanged :: (IsObject a, MonadIO m) => a -> ObjectChildrenChangedCallback -> m SignalHandlerId
afterObjectChildrenChanged obj cb = liftIO $ do
    let cb' = wrap_ObjectChildrenChangedCallback cb
    cb'' <- mk_ObjectChildrenChangedCallback cb'
    connectSignalFunPtr obj "children-changed" cb'' SignalConnectAfter


-- signal Object::focus-event
{-# DEPRECATED ObjectFocusEventCallback ["(Since version 2.9.4)","Use the 'GI.Atk.Objects.Object.Object'::@/state-change/@ 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 ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `ObjectFocusEventCallback`@.
noObjectFocusEventCallback :: Maybe ObjectFocusEventCallback
noObjectFocusEventCallback = Nothing

-- | Type for the callback on the (unwrapped) C side.
type C_ObjectFocusEventCallback =
    Ptr () ->                               -- 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 the callback into a `GClosure`.
genClosure_ObjectFocusEvent :: MonadIO m => ObjectFocusEventCallback -> m (GClosure C_ObjectFocusEventCallback)
genClosure_ObjectFocusEvent cb = liftIO $ do
    let cb' = wrap_ObjectFocusEventCallback cb
    mk_ObjectFocusEventCallback cb' >>= B.GClosure.newGClosure


-- | Wrap a `ObjectFocusEventCallback` into a `C_ObjectFocusEventCallback`.
wrap_ObjectFocusEventCallback ::
    ObjectFocusEventCallback ->
    C_ObjectFocusEventCallback
wrap_ObjectFocusEventCallback _cb _ arg1 _ = do
    let arg1' = (/= 0) arg1
    _cb  arg1'


{- |
Connect a signal handler for the “@focus-event@” 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 -> ObjectFocusEventCallback -> m SignalHandlerId
onObjectFocusEvent obj cb = liftIO $ do
    let cb' = wrap_ObjectFocusEventCallback cb
    cb'' <- mk_ObjectFocusEventCallback cb'
    connectSignalFunPtr obj "focus-event" cb'' SignalConnectBefore

{- |
Connect a signal handler for the “@focus-event@” 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
@
-}
afterObjectFocusEvent :: (IsObject a, MonadIO m) => a -> ObjectFocusEventCallback -> m SignalHandlerId
afterObjectFocusEvent obj cb = liftIO $ do
    let cb' = wrap_ObjectFocusEventCallback cb
    cb'' <- mk_ObjectFocusEventCallback cb'
    connectSignalFunPtr obj "focus-event" cb'' SignalConnectAfter


-- signal Object::property-change
{- |
The signal \"property-change\" is emitted when an object\'s property
value changes. /@arg1@/ contains an '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. '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 'GI.Atk.Structs.PropertyValues.PropertyValues' containing the new
value of the property which changed. -}
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `ObjectPropertyChangeCallback`@.
noObjectPropertyChangeCallback :: Maybe ObjectPropertyChangeCallback
noObjectPropertyChangeCallback = Nothing

-- | Type for the callback on the (unwrapped) C side.
type C_ObjectPropertyChangeCallback =
    Ptr () ->                               -- 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 the callback into a `GClosure`.
genClosure_ObjectPropertyChange :: MonadIO m => ObjectPropertyChangeCallback -> m (GClosure C_ObjectPropertyChangeCallback)
genClosure_ObjectPropertyChange cb = liftIO $ do
    let cb' = wrap_ObjectPropertyChangeCallback cb
    mk_ObjectPropertyChangeCallback cb' >>= B.GClosure.newGClosure


-- | Wrap a `ObjectPropertyChangeCallback` into a `C_ObjectPropertyChangeCallback`.
wrap_ObjectPropertyChangeCallback ::
    ObjectPropertyChangeCallback ->
    C_ObjectPropertyChangeCallback
wrap_ObjectPropertyChangeCallback _cb _ arg1 _ = do
    maybeArg1 <-
        if arg1 == nullPtr
        then return Nothing
        else do
            arg1' <- (newPtr Atk.PropertyValues.PropertyValues) arg1
            return $ Just arg1'
    _cb  maybeArg1


{- |
Connect a signal handler for the “@property-change@” 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
@
-}
onObjectPropertyChange :: (IsObject a, MonadIO m) => a -> ObjectPropertyChangeCallback -> m SignalHandlerId
onObjectPropertyChange obj cb = liftIO $ do
    let cb' = wrap_ObjectPropertyChangeCallback cb
    cb'' <- mk_ObjectPropertyChangeCallback cb'
    connectSignalFunPtr obj "property-change" cb'' SignalConnectBefore

{- |
Connect a signal handler for the “@property-change@” 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
@
-}
afterObjectPropertyChange :: (IsObject a, MonadIO m) => a -> ObjectPropertyChangeCallback -> m SignalHandlerId
afterObjectPropertyChange obj cb = liftIO $ do
    let cb' = wrap_ObjectPropertyChangeCallback cb
    cb'' <- mk_ObjectPropertyChangeCallback cb'
    connectSignalFunPtr obj "property-change" cb'' SignalConnectAfter


-- 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 ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `ObjectStateChangeCallback`@.
noObjectStateChangeCallback :: Maybe ObjectStateChangeCallback
noObjectStateChangeCallback = Nothing

-- | Type for the callback on the (unwrapped) C side.
type C_ObjectStateChangeCallback =
    Ptr () ->                               -- 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 the callback into a `GClosure`.
genClosure_ObjectStateChange :: MonadIO m => ObjectStateChangeCallback -> m (GClosure C_ObjectStateChangeCallback)
genClosure_ObjectStateChange cb = liftIO $ do
    let cb' = wrap_ObjectStateChangeCallback cb
    mk_ObjectStateChangeCallback cb' >>= B.GClosure.newGClosure


-- | Wrap a `ObjectStateChangeCallback` into a `C_ObjectStateChangeCallback`.
wrap_ObjectStateChangeCallback ::
    ObjectStateChangeCallback ->
    C_ObjectStateChangeCallback
wrap_ObjectStateChangeCallback _cb _ arg1 arg2 _ = do
    arg1' <- cstringToText arg1
    let arg2' = (/= 0) arg2
    _cb  arg1' arg2'


{- |
Connect a signal handler for the “@state-change@” 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
@
-}
onObjectStateChange :: (IsObject a, MonadIO m) => a -> ObjectStateChangeCallback -> m SignalHandlerId
onObjectStateChange obj cb = liftIO $ do
    let cb' = wrap_ObjectStateChangeCallback cb
    cb'' <- mk_ObjectStateChangeCallback cb'
    connectSignalFunPtr obj "state-change" cb'' SignalConnectBefore

{- |
Connect a signal handler for the “@state-change@” 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
@
-}
afterObjectStateChange :: (IsObject a, MonadIO m) => a -> ObjectStateChangeCallback -> m SignalHandlerId
afterObjectStateChange obj cb = liftIO $ do
    let cb' = wrap_ObjectStateChangeCallback cb
    cb'' <- mk_ObjectStateChangeCallback cb'
    connectSignalFunPtr obj "state-change" cb'' SignalConnectAfter


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

-- | A convenience synonym for @`Nothing` :: `Maybe` `ObjectVisibleDataChangedCallback`@.
noObjectVisibleDataChangedCallback :: Maybe ObjectVisibleDataChangedCallback
noObjectVisibleDataChangedCallback = Nothing

-- | Type for the callback on the (unwrapped) C side.
type C_ObjectVisibleDataChangedCallback =
    Ptr () ->                               -- 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 the callback into a `GClosure`.
genClosure_ObjectVisibleDataChanged :: MonadIO m => ObjectVisibleDataChangedCallback -> m (GClosure C_ObjectVisibleDataChangedCallback)
genClosure_ObjectVisibleDataChanged cb = liftIO $ do
    let cb' = wrap_ObjectVisibleDataChangedCallback cb
    mk_ObjectVisibleDataChangedCallback cb' >>= B.GClosure.newGClosure


-- | Wrap a `ObjectVisibleDataChangedCallback` into a `C_ObjectVisibleDataChangedCallback`.
wrap_ObjectVisibleDataChangedCallback ::
    ObjectVisibleDataChangedCallback ->
    C_ObjectVisibleDataChangedCallback
wrap_ObjectVisibleDataChangedCallback _cb _ _ = do
    _cb


{- |
Connect a signal handler for the “@visible-data-changed@” 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 -> ObjectVisibleDataChangedCallback -> m SignalHandlerId
onObjectVisibleDataChanged obj cb = liftIO $ do
    let cb' = wrap_ObjectVisibleDataChangedCallback cb
    cb'' <- mk_ObjectVisibleDataChangedCallback cb'
    connectSignalFunPtr obj "visible-data-changed" cb'' SignalConnectBefore

{- |
Connect a signal handler for the “@visible-data-changed@” 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
@
-}
afterObjectVisibleDataChanged :: (IsObject a, MonadIO m) => a -> ObjectVisibleDataChangedCallback -> m SignalHandlerId
afterObjectVisibleDataChanged obj cb = liftIO $ do
    let cb' = wrap_ObjectVisibleDataChangedCallback cb
    cb'' <- mk_ObjectVisibleDataChangedCallback cb'
    connectSignalFunPtr obj "visible-data-changed" cb'' SignalConnectAfter


-- 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 obj = liftIO $ B.Properties.getObjectPropertyInt32 obj "accessible-component-layer"

#if ENABLE_OVERLOADING
data ObjectAccessibleComponentLayerPropertyInfo
instance AttrInfo ObjectAccessibleComponentLayerPropertyInfo where
    type AttrAllowedOps ObjectAccessibleComponentLayerPropertyInfo = '[ 'AttrGet]
    type AttrSetTypeConstraint ObjectAccessibleComponentLayerPropertyInfo = (~) ()
    type AttrBaseTypeConstraint ObjectAccessibleComponentLayerPropertyInfo = IsObject
    type AttrGetType ObjectAccessibleComponentLayerPropertyInfo = Int32
    type AttrLabel ObjectAccessibleComponentLayerPropertyInfo = "accessible-component-layer"
    type AttrOrigin ObjectAccessibleComponentLayerPropertyInfo = Object
    attrGet _ = getObjectAccessibleComponentLayer
    attrSet _ = undefined
    attrConstruct _ = undefined
    attrClear _ = undefined
#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 obj = liftIO $ B.Properties.getObjectPropertyInt32 obj "accessible-component-mdi-zorder"

#if ENABLE_OVERLOADING
data ObjectAccessibleComponentMdiZorderPropertyInfo
instance AttrInfo ObjectAccessibleComponentMdiZorderPropertyInfo where
    type AttrAllowedOps ObjectAccessibleComponentMdiZorderPropertyInfo = '[ 'AttrGet]
    type AttrSetTypeConstraint ObjectAccessibleComponentMdiZorderPropertyInfo = (~) ()
    type AttrBaseTypeConstraint ObjectAccessibleComponentMdiZorderPropertyInfo = IsObject
    type AttrGetType ObjectAccessibleComponentMdiZorderPropertyInfo = Int32
    type AttrLabel ObjectAccessibleComponentMdiZorderPropertyInfo = "accessible-component-mdi-zorder"
    type AttrOrigin ObjectAccessibleComponentMdiZorderPropertyInfo = Object
    attrGet _ = getObjectAccessibleComponentMdiZorder
    attrSet _ = undefined
    attrConstruct _ = undefined
    attrClear _ = undefined
#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 obj = liftIO $ B.Properties.getObjectPropertyString obj "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 obj val = liftIO $ B.Properties.setObjectPropertyString obj "accessible-description" (Just val)

{- |
Construct a `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) => T.Text -> IO (GValueConstruct o)
constructObjectAccessibleDescription val = B.Properties.constructObjectPropertyString "accessible-description" (Just 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 obj = liftIO $ B.Properties.setObjectPropertyString obj "accessible-description" (Nothing :: Maybe T.Text)

#if ENABLE_OVERLOADING
data ObjectAccessibleDescriptionPropertyInfo
instance AttrInfo ObjectAccessibleDescriptionPropertyInfo where
    type AttrAllowedOps ObjectAccessibleDescriptionPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint ObjectAccessibleDescriptionPropertyInfo = (~) T.Text
    type AttrBaseTypeConstraint ObjectAccessibleDescriptionPropertyInfo = IsObject
    type AttrGetType ObjectAccessibleDescriptionPropertyInfo = (Maybe T.Text)
    type AttrLabel ObjectAccessibleDescriptionPropertyInfo = "accessible-description"
    type AttrOrigin ObjectAccessibleDescriptionPropertyInfo = Object
    attrGet _ = getObjectAccessibleDescription
    attrSet _ = setObjectAccessibleDescription
    attrConstruct _ = constructObjectAccessibleDescription
    attrClear _ = clearObjectAccessibleDescription
#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 obj = liftIO $ B.Properties.getObjectPropertyInt32 obj "accessible-hypertext-nlinks"

#if ENABLE_OVERLOADING
data ObjectAccessibleHypertextNlinksPropertyInfo
instance AttrInfo ObjectAccessibleHypertextNlinksPropertyInfo where
    type AttrAllowedOps ObjectAccessibleHypertextNlinksPropertyInfo = '[ 'AttrGet]
    type AttrSetTypeConstraint ObjectAccessibleHypertextNlinksPropertyInfo = (~) ()
    type AttrBaseTypeConstraint ObjectAccessibleHypertextNlinksPropertyInfo = IsObject
    type AttrGetType ObjectAccessibleHypertextNlinksPropertyInfo = Int32
    type AttrLabel ObjectAccessibleHypertextNlinksPropertyInfo = "accessible-hypertext-nlinks"
    type AttrOrigin ObjectAccessibleHypertextNlinksPropertyInfo = Object
    attrGet _ = getObjectAccessibleHypertextNlinks
    attrSet _ = undefined
    attrConstruct _ = undefined
    attrClear _ = undefined
#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 obj = liftIO $ B.Properties.getObjectPropertyString obj "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 obj val = liftIO $ B.Properties.setObjectPropertyString obj "accessible-name" (Just val)

{- |
Construct a `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) => T.Text -> IO (GValueConstruct o)
constructObjectAccessibleName val = B.Properties.constructObjectPropertyString "accessible-name" (Just 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 obj = liftIO $ B.Properties.setObjectPropertyString obj "accessible-name" (Nothing :: Maybe T.Text)

#if ENABLE_OVERLOADING
data ObjectAccessibleNamePropertyInfo
instance AttrInfo ObjectAccessibleNamePropertyInfo where
    type AttrAllowedOps ObjectAccessibleNamePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint ObjectAccessibleNamePropertyInfo = (~) T.Text
    type AttrBaseTypeConstraint ObjectAccessibleNamePropertyInfo = IsObject
    type AttrGetType ObjectAccessibleNamePropertyInfo = (Maybe T.Text)
    type AttrLabel ObjectAccessibleNamePropertyInfo = "accessible-name"
    type AttrOrigin ObjectAccessibleNamePropertyInfo = Object
    attrGet _ = getObjectAccessibleName
    attrSet _ = setObjectAccessibleName
    attrConstruct _ = constructObjectAccessibleName
    attrClear _ = clearObjectAccessibleName
#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 obj = liftIO $ B.Properties.getObjectPropertyObject obj "accessible-parent" 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 obj val = liftIO $ B.Properties.setObjectPropertyObject obj "accessible-parent" (Just val)

{- |
Construct a `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, IsObject a) => a -> IO (GValueConstruct o)
constructObjectAccessibleParent val = B.Properties.constructObjectPropertyObject "accessible-parent" (Just 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 obj = liftIO $ B.Properties.setObjectPropertyObject obj "accessible-parent" (Nothing :: Maybe Object)

#if ENABLE_OVERLOADING
data ObjectAccessibleParentPropertyInfo
instance AttrInfo ObjectAccessibleParentPropertyInfo where
    type AttrAllowedOps ObjectAccessibleParentPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint ObjectAccessibleParentPropertyInfo = IsObject
    type AttrBaseTypeConstraint ObjectAccessibleParentPropertyInfo = IsObject
    type AttrGetType ObjectAccessibleParentPropertyInfo = (Maybe Object)
    type AttrLabel ObjectAccessibleParentPropertyInfo = "accessible-parent"
    type AttrOrigin ObjectAccessibleParentPropertyInfo = Object
    attrGet _ = getObjectAccessibleParent
    attrSet _ = setObjectAccessibleParent
    attrConstruct _ = constructObjectAccessibleParent
    attrClear _ = clearObjectAccessibleParent
#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 obj = liftIO $ B.Properties.getObjectPropertyEnum obj "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 obj val = liftIO $ B.Properties.setObjectPropertyEnum obj "accessible-role" val

{- |
Construct a `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) => Atk.Enums.Role -> IO (GValueConstruct o)
constructObjectAccessibleRole val = B.Properties.constructObjectPropertyEnum "accessible-role" val

#if ENABLE_OVERLOADING
data ObjectAccessibleRolePropertyInfo
instance AttrInfo ObjectAccessibleRolePropertyInfo where
    type AttrAllowedOps ObjectAccessibleRolePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint ObjectAccessibleRolePropertyInfo = (~) Atk.Enums.Role
    type AttrBaseTypeConstraint ObjectAccessibleRolePropertyInfo = IsObject
    type AttrGetType ObjectAccessibleRolePropertyInfo = Atk.Enums.Role
    type AttrLabel ObjectAccessibleRolePropertyInfo = "accessible-role"
    type AttrOrigin ObjectAccessibleRolePropertyInfo = Object
    attrGet _ = getObjectAccessibleRole
    attrSet _ = setObjectAccessibleRole
    attrConstruct _ = constructObjectAccessibleRole
    attrClear _ = undefined
#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 obj = liftIO $ B.Properties.getObjectPropertyString obj "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 obj val = liftIO $ B.Properties.setObjectPropertyString obj "accessible-table-caption" (Just val)

{- |
Construct a `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) => T.Text -> IO (GValueConstruct o)
constructObjectAccessibleTableCaption val = B.Properties.constructObjectPropertyString "accessible-table-caption" (Just 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 obj = liftIO $ B.Properties.setObjectPropertyString obj "accessible-table-caption" (Nothing :: Maybe T.Text)

#if ENABLE_OVERLOADING
data ObjectAccessibleTableCaptionPropertyInfo
instance AttrInfo ObjectAccessibleTableCaptionPropertyInfo where
    type AttrAllowedOps ObjectAccessibleTableCaptionPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint ObjectAccessibleTableCaptionPropertyInfo = (~) T.Text
    type AttrBaseTypeConstraint ObjectAccessibleTableCaptionPropertyInfo = IsObject
    type AttrGetType ObjectAccessibleTableCaptionPropertyInfo = (Maybe T.Text)
    type AttrLabel ObjectAccessibleTableCaptionPropertyInfo = "accessible-table-caption"
    type AttrOrigin ObjectAccessibleTableCaptionPropertyInfo = Object
    attrGet _ = getObjectAccessibleTableCaption
    attrSet _ = setObjectAccessibleTableCaption
    attrConstruct _ = constructObjectAccessibleTableCaption
    attrClear _ = clearObjectAccessibleTableCaption
#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 obj = liftIO $ B.Properties.getObjectPropertyObject obj "accessible-table-caption-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 obj val = liftIO $ B.Properties.setObjectPropertyObject obj "accessible-table-caption-object" (Just val)

{- |
Construct a `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, IsObject a) => a -> IO (GValueConstruct o)
constructObjectAccessibleTableCaptionObject val = B.Properties.constructObjectPropertyObject "accessible-table-caption-object" (Just 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 obj = liftIO $ B.Properties.setObjectPropertyObject obj "accessible-table-caption-object" (Nothing :: Maybe Object)

#if ENABLE_OVERLOADING
data ObjectAccessibleTableCaptionObjectPropertyInfo
instance AttrInfo ObjectAccessibleTableCaptionObjectPropertyInfo where
    type AttrAllowedOps ObjectAccessibleTableCaptionObjectPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint ObjectAccessibleTableCaptionObjectPropertyInfo = IsObject
    type AttrBaseTypeConstraint ObjectAccessibleTableCaptionObjectPropertyInfo = IsObject
    type AttrGetType ObjectAccessibleTableCaptionObjectPropertyInfo = (Maybe Object)
    type AttrLabel ObjectAccessibleTableCaptionObjectPropertyInfo = "accessible-table-caption-object"
    type AttrOrigin ObjectAccessibleTableCaptionObjectPropertyInfo = Object
    attrGet _ = getObjectAccessibleTableCaptionObject
    attrSet _ = setObjectAccessibleTableCaptionObject
    attrConstruct _ = constructObjectAccessibleTableCaptionObject
    attrClear _ = clearObjectAccessibleTableCaptionObject
#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 obj = liftIO $ B.Properties.getObjectPropertyString obj "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 obj val = liftIO $ B.Properties.setObjectPropertyString obj "accessible-table-column-description" (Just val)

{- |
Construct a `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) => T.Text -> IO (GValueConstruct o)
constructObjectAccessibleTableColumnDescription val = B.Properties.constructObjectPropertyString "accessible-table-column-description" (Just 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 obj = liftIO $ B.Properties.setObjectPropertyString obj "accessible-table-column-description" (Nothing :: Maybe T.Text)

#if ENABLE_OVERLOADING
data ObjectAccessibleTableColumnDescriptionPropertyInfo
instance AttrInfo ObjectAccessibleTableColumnDescriptionPropertyInfo where
    type AttrAllowedOps ObjectAccessibleTableColumnDescriptionPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint ObjectAccessibleTableColumnDescriptionPropertyInfo = (~) T.Text
    type AttrBaseTypeConstraint ObjectAccessibleTableColumnDescriptionPropertyInfo = IsObject
    type AttrGetType ObjectAccessibleTableColumnDescriptionPropertyInfo = (Maybe T.Text)
    type AttrLabel ObjectAccessibleTableColumnDescriptionPropertyInfo = "accessible-table-column-description"
    type AttrOrigin ObjectAccessibleTableColumnDescriptionPropertyInfo = Object
    attrGet _ = getObjectAccessibleTableColumnDescription
    attrSet _ = setObjectAccessibleTableColumnDescription
    attrConstruct _ = constructObjectAccessibleTableColumnDescription
    attrClear _ = clearObjectAccessibleTableColumnDescription
#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 obj = liftIO $ B.Properties.getObjectPropertyObject obj "accessible-table-column-header" 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 obj val = liftIO $ B.Properties.setObjectPropertyObject obj "accessible-table-column-header" (Just val)

{- |
Construct a `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, IsObject a) => a -> IO (GValueConstruct o)
constructObjectAccessibleTableColumnHeader val = B.Properties.constructObjectPropertyObject "accessible-table-column-header" (Just 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 obj = liftIO $ B.Properties.setObjectPropertyObject obj "accessible-table-column-header" (Nothing :: Maybe Object)

#if ENABLE_OVERLOADING
data ObjectAccessibleTableColumnHeaderPropertyInfo
instance AttrInfo ObjectAccessibleTableColumnHeaderPropertyInfo where
    type AttrAllowedOps ObjectAccessibleTableColumnHeaderPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint ObjectAccessibleTableColumnHeaderPropertyInfo = IsObject
    type AttrBaseTypeConstraint ObjectAccessibleTableColumnHeaderPropertyInfo = IsObject
    type AttrGetType ObjectAccessibleTableColumnHeaderPropertyInfo = (Maybe Object)
    type AttrLabel ObjectAccessibleTableColumnHeaderPropertyInfo = "accessible-table-column-header"
    type AttrOrigin ObjectAccessibleTableColumnHeaderPropertyInfo = Object
    attrGet _ = getObjectAccessibleTableColumnHeader
    attrSet _ = setObjectAccessibleTableColumnHeader
    attrConstruct _ = constructObjectAccessibleTableColumnHeader
    attrClear _ = clearObjectAccessibleTableColumnHeader
#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 obj = liftIO $ B.Properties.getObjectPropertyString obj "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 obj val = liftIO $ B.Properties.setObjectPropertyString obj "accessible-table-row-description" (Just val)

{- |
Construct a `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) => T.Text -> IO (GValueConstruct o)
constructObjectAccessibleTableRowDescription val = B.Properties.constructObjectPropertyString "accessible-table-row-description" (Just 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 obj = liftIO $ B.Properties.setObjectPropertyString obj "accessible-table-row-description" (Nothing :: Maybe T.Text)

#if ENABLE_OVERLOADING
data ObjectAccessibleTableRowDescriptionPropertyInfo
instance AttrInfo ObjectAccessibleTableRowDescriptionPropertyInfo where
    type AttrAllowedOps ObjectAccessibleTableRowDescriptionPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint ObjectAccessibleTableRowDescriptionPropertyInfo = (~) T.Text
    type AttrBaseTypeConstraint ObjectAccessibleTableRowDescriptionPropertyInfo = IsObject
    type AttrGetType ObjectAccessibleTableRowDescriptionPropertyInfo = (Maybe T.Text)
    type AttrLabel ObjectAccessibleTableRowDescriptionPropertyInfo = "accessible-table-row-description"
    type AttrOrigin ObjectAccessibleTableRowDescriptionPropertyInfo = Object
    attrGet _ = getObjectAccessibleTableRowDescription
    attrSet _ = setObjectAccessibleTableRowDescription
    attrConstruct _ = constructObjectAccessibleTableRowDescription
    attrClear _ = clearObjectAccessibleTableRowDescription
#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 obj = liftIO $ B.Properties.getObjectPropertyObject obj "accessible-table-row-header" 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 obj val = liftIO $ B.Properties.setObjectPropertyObject obj "accessible-table-row-header" (Just val)

{- |
Construct a `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, IsObject a) => a -> IO (GValueConstruct o)
constructObjectAccessibleTableRowHeader val = B.Properties.constructObjectPropertyObject "accessible-table-row-header" (Just 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 obj = liftIO $ B.Properties.setObjectPropertyObject obj "accessible-table-row-header" (Nothing :: Maybe Object)

#if ENABLE_OVERLOADING
data ObjectAccessibleTableRowHeaderPropertyInfo
instance AttrInfo ObjectAccessibleTableRowHeaderPropertyInfo where
    type AttrAllowedOps ObjectAccessibleTableRowHeaderPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint ObjectAccessibleTableRowHeaderPropertyInfo = IsObject
    type AttrBaseTypeConstraint ObjectAccessibleTableRowHeaderPropertyInfo = IsObject
    type AttrGetType ObjectAccessibleTableRowHeaderPropertyInfo = (Maybe Object)
    type AttrLabel ObjectAccessibleTableRowHeaderPropertyInfo = "accessible-table-row-header"
    type AttrOrigin ObjectAccessibleTableRowHeaderPropertyInfo = Object
    attrGet _ = getObjectAccessibleTableRowHeader
    attrSet _ = setObjectAccessibleTableRowHeader
    attrConstruct _ = constructObjectAccessibleTableRowHeader
    attrClear _ = clearObjectAccessibleTableRowHeader
#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 obj = liftIO $ B.Properties.getObjectPropertyObject obj "accessible-table-summary" 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 obj val = liftIO $ B.Properties.setObjectPropertyObject obj "accessible-table-summary" (Just val)

{- |
Construct a `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, IsObject a) => a -> IO (GValueConstruct o)
constructObjectAccessibleTableSummary val = B.Properties.constructObjectPropertyObject "accessible-table-summary" (Just 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 obj = liftIO $ B.Properties.setObjectPropertyObject obj "accessible-table-summary" (Nothing :: Maybe Object)

#if ENABLE_OVERLOADING
data ObjectAccessibleTableSummaryPropertyInfo
instance AttrInfo ObjectAccessibleTableSummaryPropertyInfo where
    type AttrAllowedOps ObjectAccessibleTableSummaryPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint ObjectAccessibleTableSummaryPropertyInfo = IsObject
    type AttrBaseTypeConstraint ObjectAccessibleTableSummaryPropertyInfo = IsObject
    type AttrGetType ObjectAccessibleTableSummaryPropertyInfo = (Maybe Object)
    type AttrLabel ObjectAccessibleTableSummaryPropertyInfo = "accessible-table-summary"
    type AttrOrigin ObjectAccessibleTableSummaryPropertyInfo = Object
    attrGet _ = getObjectAccessibleTableSummary
    attrSet _ = setObjectAccessibleTableSummary
    attrConstruct _ = constructObjectAccessibleTableSummary
    attrClear _ = clearObjectAccessibleTableSummary
#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 obj = liftIO $ B.Properties.getObjectPropertyDouble obj "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 obj val = liftIO $ B.Properties.setObjectPropertyDouble obj "accessible-value" val

{- |
Construct a `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) => Double -> IO (GValueConstruct o)
constructObjectAccessibleValue val = B.Properties.constructObjectPropertyDouble "accessible-value" val

#if ENABLE_OVERLOADING
data ObjectAccessibleValuePropertyInfo
instance AttrInfo ObjectAccessibleValuePropertyInfo where
    type AttrAllowedOps ObjectAccessibleValuePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint ObjectAccessibleValuePropertyInfo = (~) Double
    type AttrBaseTypeConstraint ObjectAccessibleValuePropertyInfo = IsObject
    type AttrGetType ObjectAccessibleValuePropertyInfo = Double
    type AttrLabel ObjectAccessibleValuePropertyInfo = "accessible-value"
    type AttrOrigin ObjectAccessibleValuePropertyInfo = Object
    attrGet _ = getObjectAccessibleValue
    attrSet _ = setObjectAccessibleValue
    attrConstruct _ = constructObjectAccessibleValue
    attrClear _ = undefined
#endif

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

#if ENABLE_OVERLOADING
objectAccessibleComponentLayer :: AttrLabelProxy "accessibleComponentLayer"
objectAccessibleComponentLayer = AttrLabelProxy

objectAccessibleComponentMdiZorder :: AttrLabelProxy "accessibleComponentMdiZorder"
objectAccessibleComponentMdiZorder = AttrLabelProxy

objectAccessibleDescription :: AttrLabelProxy "accessibleDescription"
objectAccessibleDescription = AttrLabelProxy

objectAccessibleHypertextNlinks :: AttrLabelProxy "accessibleHypertextNlinks"
objectAccessibleHypertextNlinks = AttrLabelProxy

objectAccessibleName :: AttrLabelProxy "accessibleName"
objectAccessibleName = AttrLabelProxy

objectAccessibleParent :: AttrLabelProxy "accessibleParent"
objectAccessibleParent = AttrLabelProxy

objectAccessibleRole :: AttrLabelProxy "accessibleRole"
objectAccessibleRole = AttrLabelProxy

objectAccessibleTableCaption :: AttrLabelProxy "accessibleTableCaption"
objectAccessibleTableCaption = AttrLabelProxy

objectAccessibleTableCaptionObject :: AttrLabelProxy "accessibleTableCaptionObject"
objectAccessibleTableCaptionObject = AttrLabelProxy

objectAccessibleTableColumnDescription :: AttrLabelProxy "accessibleTableColumnDescription"
objectAccessibleTableColumnDescription = AttrLabelProxy

objectAccessibleTableColumnHeader :: AttrLabelProxy "accessibleTableColumnHeader"
objectAccessibleTableColumnHeader = AttrLabelProxy

objectAccessibleTableRowDescription :: AttrLabelProxy "accessibleTableRowDescription"
objectAccessibleTableRowDescription = AttrLabelProxy

objectAccessibleTableRowHeader :: AttrLabelProxy "accessibleTableRowHeader"
objectAccessibleTableRowHeader = AttrLabelProxy

objectAccessibleTableSummary :: AttrLabelProxy "accessibleTableSummary"
objectAccessibleTableSummary = AttrLabelProxy

objectAccessibleValue :: AttrLabelProxy "accessibleValue"
objectAccessibleValue = AttrLabelProxy

#endif

#if ENABLE_OVERLOADING
data ObjectActiveDescendantChangedSignalInfo
instance SignalInfo ObjectActiveDescendantChangedSignalInfo where
    type HaskellCallbackType ObjectActiveDescendantChangedSignalInfo = ObjectActiveDescendantChangedCallback
    connectSignal _ obj cb connectMode = do
        let cb' = wrap_ObjectActiveDescendantChangedCallback cb
        cb'' <- mk_ObjectActiveDescendantChangedCallback cb'
        connectSignalFunPtr obj "active-descendant-changed" cb'' connectMode

data ObjectChildrenChangedSignalInfo
instance SignalInfo ObjectChildrenChangedSignalInfo where
    type HaskellCallbackType ObjectChildrenChangedSignalInfo = ObjectChildrenChangedCallback
    connectSignal _ obj cb connectMode = do
        let cb' = wrap_ObjectChildrenChangedCallback cb
        cb'' <- mk_ObjectChildrenChangedCallback cb'
        connectSignalFunPtr obj "children-changed" cb'' connectMode

data ObjectFocusEventSignalInfo
instance SignalInfo ObjectFocusEventSignalInfo where
    type HaskellCallbackType ObjectFocusEventSignalInfo = ObjectFocusEventCallback
    connectSignal _ obj cb connectMode = do
        let cb' = wrap_ObjectFocusEventCallback cb
        cb'' <- mk_ObjectFocusEventCallback cb'
        connectSignalFunPtr obj "focus-event" cb'' connectMode

data ObjectPropertyChangeSignalInfo
instance SignalInfo ObjectPropertyChangeSignalInfo where
    type HaskellCallbackType ObjectPropertyChangeSignalInfo = ObjectPropertyChangeCallback
    connectSignal _ obj cb connectMode = do
        let cb' = wrap_ObjectPropertyChangeCallback cb
        cb'' <- mk_ObjectPropertyChangeCallback cb'
        connectSignalFunPtr obj "property-change" cb'' connectMode

data ObjectStateChangeSignalInfo
instance SignalInfo ObjectStateChangeSignalInfo where
    type HaskellCallbackType ObjectStateChangeSignalInfo = ObjectStateChangeCallback
    connectSignal _ obj cb connectMode = do
        let cb' = wrap_ObjectStateChangeCallback cb
        cb'' <- mk_ObjectStateChangeCallback cb'
        connectSignalFunPtr obj "state-change" cb'' connectMode

data ObjectVisibleDataChangedSignalInfo
instance SignalInfo ObjectVisibleDataChangedSignalInfo where
    type HaskellCallbackType ObjectVisibleDataChangedSignalInfo = ObjectVisibleDataChangedCallback
    connectSignal _ obj cb connectMode = do
        let cb' = wrap_ObjectVisibleDataChangedCallback cb
        cb'' <- mk_ObjectVisibleDataChangedCallback cb'
        connectSignalFunPtr obj "visible-data-changed" cb'' connectMode

type instance O.SignalList Object = ObjectSignalList
type ObjectSignalList = ('[ '("activeDescendantChanged", ObjectActiveDescendantChangedSignalInfo), '("childrenChanged", ObjectChildrenChangedSignalInfo), '("focusEvent", ObjectFocusEventSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("propertyChange", ObjectPropertyChangeSignalInfo), '("stateChange", ObjectStateChangeSignalInfo), '("visibleDataChanged", ObjectVisibleDataChangedSignalInfo)] :: [(Symbol, *)])

#endif

-- method Object::add_relationship
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "object", argType = TInterface (Name {namespace = "Atk", name = "Object"}), 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, transfer = TransferNothing},Arg {argCName = "relationship", argType = TInterface (Name {namespace = "Atk", name = "RelationType"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The #AtkRelationType of the relation", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "target", argType = TInterface (Name {namespace = "Atk", name = "Object"}), 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, 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 'GI.Atk.Objects.Object.Object' to which an AtkRelation is to be added. -}
    -> Atk.Enums.RelationType
    {- ^ /@relationship@/: The 'GI.Atk.Enums.RelationType' of the relation -}
    -> b
    {- ^ /@target@/: The 'GI.Atk.Objects.Object.Object' which is to be the target of the relation. -}
    -> m Bool
    {- ^ __Returns:__ TRUE if the relationship is added. -}
objectAddRelationship object relationship target = liftIO $ do
    object' <- unsafeManagedPtrCastPtr object
    let relationship' = (fromIntegral . fromEnum) relationship
    target' <- unsafeManagedPtrCastPtr target
    result <- atk_object_add_relationship object' relationship' target'
    let result' = (/= 0) result
    touchManagedPtr object
    touchManagedPtr target
    return result'

#if ENABLE_OVERLOADING
data ObjectAddRelationshipMethodInfo
instance (signature ~ (Atk.Enums.RelationType -> b -> m Bool), MonadIO m, IsObject a, IsObject b) => O.MethodInfo ObjectAddRelationshipMethodInfo a signature where
    overloadedMethod _ = objectAddRelationship

#endif

-- method Object::get_attributes
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "accessible", argType = TInterface (Name {namespace = "Atk", name = "Object"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "An #AtkObject.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = 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 '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 accessible = liftIO $ do
    accessible' <- unsafeManagedPtrCastPtr accessible
    result <- atk_object_get_attributes accessible'
    result' <- unpackGSList result
    g_slist_free result
    touchManagedPtr accessible
    return result'

#if ENABLE_OVERLOADING
data ObjectGetAttributesMethodInfo
instance (signature ~ (m ([Ptr ()])), MonadIO m, IsObject a) => O.MethodInfo ObjectGetAttributesMethodInfo a signature where
    overloadedMethod _ = objectGetAttributes

#endif

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

foreign import ccall "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 'GI.Atk.Objects.Object.Object' -}
    -> m T.Text
    {- ^ __Returns:__ a character string representing the accessible description
of the accessible. -}
objectGetDescription accessible = liftIO $ do
    accessible' <- unsafeManagedPtrCastPtr accessible
    result <- atk_object_get_description accessible'
    checkUnexpectedReturnNULL "objectGetDescription" result
    result' <- cstringToText result
    touchManagedPtr accessible
    return result'

#if ENABLE_OVERLOADING
data ObjectGetDescriptionMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsObject a) => O.MethodInfo ObjectGetDescriptionMethodInfo a signature where
    overloadedMethod _ = objectGetDescription

#endif

-- method Object::get_index_in_parent
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "accessible", argType = TInterface (Name {namespace = "Atk", name = "Object"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an #AtkObject", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = 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 'GI.Atk.Objects.Object.Object' -}
    -> m Int32
    {- ^ __Returns:__ an integer which is the index of the accessible in its parent -}
objectGetIndexInParent accessible = liftIO $ do
    accessible' <- unsafeManagedPtrCastPtr accessible
    result <- atk_object_get_index_in_parent accessible'
    touchManagedPtr accessible
    return result

#if ENABLE_OVERLOADING
data ObjectGetIndexInParentMethodInfo
instance (signature ~ (m Int32), MonadIO m, IsObject a) => O.MethodInfo ObjectGetIndexInParentMethodInfo a signature where
    overloadedMethod _ = objectGetIndexInParent

#endif

-- method Object::get_layer
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "accessible", argType = TInterface (Name {namespace = "Atk", name = "Object"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an #AtkObject", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = 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 'GI.Atk.Objects.Object.Object' -}
    -> m Atk.Enums.Layer
    {- ^ __Returns:__ an 'GI.Atk.Enums.Layer' which is the layer of the accessible -}
objectGetLayer accessible = liftIO $ do
    accessible' <- unsafeManagedPtrCastPtr accessible
    result <- atk_object_get_layer accessible'
    let result' = (toEnum . fromIntegral) result
    touchManagedPtr accessible
    return result'

#if ENABLE_OVERLOADING
data ObjectGetLayerMethodInfo
instance (signature ~ (m Atk.Enums.Layer), MonadIO m, IsObject a) => O.MethodInfo ObjectGetLayerMethodInfo a signature where
    overloadedMethod _ = objectGetLayer

#endif

-- method Object::get_mdi_zorder
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "accessible", argType = TInterface (Name {namespace = "Atk", name = "Object"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an #AtkObject", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = 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 '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 accessible = liftIO $ do
    accessible' <- unsafeManagedPtrCastPtr accessible
    result <- atk_object_get_mdi_zorder accessible'
    touchManagedPtr accessible
    return result

#if ENABLE_OVERLOADING
data ObjectGetMdiZorderMethodInfo
instance (signature ~ (m Int32), MonadIO m, IsObject a) => O.MethodInfo ObjectGetMdiZorderMethodInfo a signature where
    overloadedMethod _ = objectGetMdiZorder

#endif

-- method Object::get_n_accessible_children
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "accessible", argType = TInterface (Name {namespace = "Atk", name = "Object"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an #AtkObject", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = 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 'GI.Atk.Objects.Object.Object' -}
    -> m Int32
    {- ^ __Returns:__ an integer representing the number of accessible children
of the accessible. -}
objectGetNAccessibleChildren accessible = liftIO $ do
    accessible' <- unsafeManagedPtrCastPtr accessible
    result <- atk_object_get_n_accessible_children accessible'
    touchManagedPtr accessible
    return result

#if ENABLE_OVERLOADING
data ObjectGetNAccessibleChildrenMethodInfo
instance (signature ~ (m Int32), MonadIO m, IsObject a) => O.MethodInfo ObjectGetNAccessibleChildrenMethodInfo a signature where
    overloadedMethod _ = objectGetNAccessibleChildren

#endif

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

foreign import ccall "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 'GI.Atk.Objects.Object.Object' -}
    -> m T.Text
    {- ^ __Returns:__ a character string representing the accessible name of the object. -}
objectGetName accessible = liftIO $ do
    accessible' <- unsafeManagedPtrCastPtr accessible
    result <- atk_object_get_name accessible'
    checkUnexpectedReturnNULL "objectGetName" result
    result' <- cstringToText result
    touchManagedPtr accessible
    return result'

#if ENABLE_OVERLOADING
data ObjectGetNameMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsObject a) => O.MethodInfo ObjectGetNameMethodInfo a signature where
    overloadedMethod _ = objectGetName

#endif

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

foreign import ccall "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 'GI.Atk.Objects.Object.Object' -}
    -> m T.Text
    {- ^ __Returns:__ a UTF-8 string indicating the POSIX-style LC_MESSAGES
         locale of /@accessible@/. -}
objectGetObjectLocale accessible = liftIO $ do
    accessible' <- unsafeManagedPtrCastPtr accessible
    result <- atk_object_get_object_locale accessible'
    checkUnexpectedReturnNULL "objectGetObjectLocale" result
    result' <- cstringToText result
    touchManagedPtr accessible
    return result'

#if ENABLE_OVERLOADING
data ObjectGetObjectLocaleMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsObject a) => O.MethodInfo ObjectGetObjectLocaleMethodInfo a signature where
    overloadedMethod _ = objectGetObjectLocale

#endif

-- method Object::get_parent
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "accessible", argType = TInterface (Name {namespace = "Atk", name = "Object"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an #AtkObject", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = 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 'GI.Atk.Objects.Object.Object' -}
    -> m Object
    {- ^ __Returns:__ an 'GI.Atk.Objects.Object.Object' representing the accessible
parent of the accessible -}
objectGetParent accessible = liftIO $ do
    accessible' <- unsafeManagedPtrCastPtr accessible
    result <- atk_object_get_parent accessible'
    checkUnexpectedReturnNULL "objectGetParent" result
    result' <- (newObject Object) result
    touchManagedPtr accessible
    return result'

#if ENABLE_OVERLOADING
data ObjectGetParentMethodInfo
instance (signature ~ (m Object), MonadIO m, IsObject a) => O.MethodInfo ObjectGetParentMethodInfo a signature where
    overloadedMethod _ = objectGetParent

#endif

-- method Object::get_role
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "accessible", argType = TInterface (Name {namespace = "Atk", name = "Object"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an #AtkObject", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = 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 'GI.Atk.Objects.Object.Object' -}
    -> m Atk.Enums.Role
    {- ^ __Returns:__ an 'GI.Atk.Enums.Role' which is the role of the accessible -}
objectGetRole accessible = liftIO $ do
    accessible' <- unsafeManagedPtrCastPtr accessible
    result <- atk_object_get_role accessible'
    let result' = (toEnum . fromIntegral) result
    touchManagedPtr accessible
    return result'

#if ENABLE_OVERLOADING
data ObjectGetRoleMethodInfo
instance (signature ~ (m Atk.Enums.Role), MonadIO m, IsObject a) => O.MethodInfo ObjectGetRoleMethodInfo a signature where
    overloadedMethod _ = objectGetRole

#endif

-- method Object::initialize
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "accessible", argType = TInterface (Name {namespace = "Atk", name = "Object"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #AtkObject", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "data", argType = TBasicType TPtr, 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, 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 '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 'GI.Atk.Objects.Object.Object'
-}
objectInitialize ::
    (B.CallStack.HasCallStack, MonadIO m, IsObject a) =>
    a
    {- ^ /@accessible@/: a 'GI.Atk.Objects.Object.Object' -}
    -> Ptr ()
    {- ^ /@data@/: a @/gpointer/@ which identifies the object for which the AtkObject was created. -}
    -> m ()
objectInitialize accessible data_ = liftIO $ do
    accessible' <- unsafeManagedPtrCastPtr accessible
    atk_object_initialize accessible' data_
    touchManagedPtr accessible
    return ()

#if ENABLE_OVERLOADING
data ObjectInitializeMethodInfo
instance (signature ~ (Ptr () -> m ()), MonadIO m, IsObject a) => O.MethodInfo ObjectInitializeMethodInfo a signature where
    overloadedMethod _ = objectInitialize

#endif

-- method Object::notify_state_change
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "accessible", argType = TInterface (Name {namespace = "Atk", name = "Object"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an #AtkObject", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "state", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an #AtkState whose state is changed", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TBasicType TBoolean, 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, 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 '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 accessible state value = liftIO $ do
    accessible' <- unsafeManagedPtrCastPtr accessible
    let value' = (fromIntegral . fromEnum) value
    atk_object_notify_state_change accessible' state value'
    touchManagedPtr accessible
    return ()

#if ENABLE_OVERLOADING
data ObjectNotifyStateChangeMethodInfo
instance (signature ~ (Word64 -> Bool -> m ()), MonadIO m, IsObject a) => O.MethodInfo ObjectNotifyStateChangeMethodInfo a signature where
    overloadedMethod _ = objectNotifyStateChange

#endif

-- method Object::peek_parent
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "accessible", argType = TInterface (Name {namespace = "Atk", name = "Object"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an #AtkObject", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = 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 '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 'GI.Atk.Objects.Object.Object' -}
    -> m Object
    {- ^ __Returns:__ an 'GI.Atk.Objects.Object.Object' representing the accessible
parent of the accessible if assigned -}
objectPeekParent accessible = liftIO $ do
    accessible' <- unsafeManagedPtrCastPtr accessible
    result <- atk_object_peek_parent accessible'
    checkUnexpectedReturnNULL "objectPeekParent" result
    result' <- (newObject Object) result
    touchManagedPtr accessible
    return result'

#if ENABLE_OVERLOADING
data ObjectPeekParentMethodInfo
instance (signature ~ (m Object), MonadIO m, IsObject a) => O.MethodInfo ObjectPeekParentMethodInfo a signature where
    overloadedMethod _ = objectPeekParent

#endif

-- method Object::ref_accessible_child
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "accessible", argType = TInterface (Name {namespace = "Atk", name = "Object"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an #AtkObject", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "i", argType = TBasicType TInt, 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, 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 'GI.Atk.Objects.Object.Object' -}
    -> Int32
    {- ^ /@i@/: a gint representing the position of the child, starting from 0 -}
    -> m Object
    {- ^ __Returns:__ an 'GI.Atk.Objects.Object.Object' representing the specified
accessible child of the accessible. -}
objectRefAccessibleChild accessible i = liftIO $ do
    accessible' <- unsafeManagedPtrCastPtr accessible
    result <- atk_object_ref_accessible_child accessible' i
    checkUnexpectedReturnNULL "objectRefAccessibleChild" result
    result' <- (wrapObject Object) result
    touchManagedPtr accessible
    return result'

#if ENABLE_OVERLOADING
data ObjectRefAccessibleChildMethodInfo
instance (signature ~ (Int32 -> m Object), MonadIO m, IsObject a) => O.MethodInfo ObjectRefAccessibleChildMethodInfo a signature where
    overloadedMethod _ = objectRefAccessibleChild

#endif

-- method Object::ref_relation_set
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "accessible", argType = TInterface (Name {namespace = "Atk", name = "Object"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an #AtkObject", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = 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 'GI.Atk.Objects.RelationSet.RelationSet' associated with the object.
-}
objectRefRelationSet ::
    (B.CallStack.HasCallStack, MonadIO m, IsObject a) =>
    a
    {- ^ /@accessible@/: an 'GI.Atk.Objects.Object.Object' -}
    -> m Atk.RelationSet.RelationSet
    {- ^ __Returns:__ an 'GI.Atk.Objects.RelationSet.RelationSet' representing the relation set
of the object. -}
objectRefRelationSet accessible = liftIO $ do
    accessible' <- unsafeManagedPtrCastPtr accessible
    result <- atk_object_ref_relation_set accessible'
    checkUnexpectedReturnNULL "objectRefRelationSet" result
    result' <- (wrapObject Atk.RelationSet.RelationSet) result
    touchManagedPtr accessible
    return result'

#if ENABLE_OVERLOADING
data ObjectRefRelationSetMethodInfo
instance (signature ~ (m Atk.RelationSet.RelationSet), MonadIO m, IsObject a) => O.MethodInfo ObjectRefRelationSetMethodInfo a signature where
    overloadedMethod _ = objectRefRelationSet

#endif

-- method Object::ref_state_set
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "accessible", argType = TInterface (Name {namespace = "Atk", name = "Object"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an #AtkObject", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = 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 'GI.Atk.Objects.Object.Object' -}
    -> m Atk.StateSet.StateSet
    {- ^ __Returns:__ a reference to an 'GI.Atk.Objects.StateSet.StateSet' which is the state
set of the accessible -}
objectRefStateSet accessible = liftIO $ do
    accessible' <- unsafeManagedPtrCastPtr accessible
    result <- atk_object_ref_state_set accessible'
    checkUnexpectedReturnNULL "objectRefStateSet" result
    result' <- (wrapObject Atk.StateSet.StateSet) result
    touchManagedPtr accessible
    return result'

#if ENABLE_OVERLOADING
data ObjectRefStateSetMethodInfo
instance (signature ~ (m Atk.StateSet.StateSet), MonadIO m, IsObject a) => O.MethodInfo ObjectRefStateSetMethodInfo a signature where
    overloadedMethod _ = objectRefStateSet

#endif

-- method Object::remove_property_change_handler
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "accessible", argType = TInterface (Name {namespace = "Atk", name = "Object"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an #AtkObject", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "handler_id", argType = TBasicType TUInt, 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, 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 2.12.","","Removes a property change handler."] #-}
{- |
/No description available in the introspection data./
-}
objectRemovePropertyChangeHandler ::
    (B.CallStack.HasCallStack, MonadIO m, IsObject a) =>
    a
    {- ^ /@accessible@/: an 'GI.Atk.Objects.Object.Object' -}
    -> Word32
    {- ^ /@handlerId@/: a guint which identifies the handler to be removed. -}
    -> m ()
objectRemovePropertyChangeHandler accessible handlerId = liftIO $ do
    accessible' <- unsafeManagedPtrCastPtr accessible
    atk_object_remove_property_change_handler accessible' handlerId
    touchManagedPtr accessible
    return ()

#if ENABLE_OVERLOADING
data ObjectRemovePropertyChangeHandlerMethodInfo
instance (signature ~ (Word32 -> m ()), MonadIO m, IsObject a) => O.MethodInfo ObjectRemovePropertyChangeHandlerMethodInfo a signature where
    overloadedMethod _ = objectRemovePropertyChangeHandler

#endif

-- method Object::remove_relationship
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "object", argType = TInterface (Name {namespace = "Atk", name = "Object"}), 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, transfer = TransferNothing},Arg {argCName = "relationship", argType = TInterface (Name {namespace = "Atk", name = "RelationType"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The #AtkRelationType of the relation", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "target", argType = TInterface (Name {namespace = "Atk", name = "Object"}), 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, 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 'GI.Atk.Objects.Object.Object' from which an AtkRelation is to be removed. -}
    -> Atk.Enums.RelationType
    {- ^ /@relationship@/: The 'GI.Atk.Enums.RelationType' of the relation -}
    -> b
    {- ^ /@target@/: The '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 object relationship target = liftIO $ do
    object' <- unsafeManagedPtrCastPtr object
    let relationship' = (fromIntegral . fromEnum) relationship
    target' <- unsafeManagedPtrCastPtr target
    result <- atk_object_remove_relationship object' relationship' target'
    let result' = (/= 0) result
    touchManagedPtr object
    touchManagedPtr target
    return result'

#if ENABLE_OVERLOADING
data ObjectRemoveRelationshipMethodInfo
instance (signature ~ (Atk.Enums.RelationType -> b -> m Bool), MonadIO m, IsObject a, IsObject b) => O.MethodInfo ObjectRemoveRelationshipMethodInfo a signature where
    overloadedMethod _ = objectRemoveRelationship

#endif

-- method Object::set_description
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "accessible", argType = TInterface (Name {namespace = "Atk", name = "Object"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an #AtkObject", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "description", argType = TBasicType TUTF8, 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, 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 'GI.Atk.Objects.Object.Object' -}
    -> T.Text
    {- ^ /@description@/: a character string to be set as the accessible description -}
    -> m ()
objectSetDescription accessible description = liftIO $ do
    accessible' <- unsafeManagedPtrCastPtr accessible
    description' <- textToCString description
    atk_object_set_description accessible' description'
    touchManagedPtr accessible
    freeMem description'
    return ()

#if ENABLE_OVERLOADING
data ObjectSetDescriptionMethodInfo
instance (signature ~ (T.Text -> m ()), MonadIO m, IsObject a) => O.MethodInfo ObjectSetDescriptionMethodInfo a signature where
    overloadedMethod _ = objectSetDescription

#endif

-- method Object::set_name
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "accessible", argType = TInterface (Name {namespace = "Atk", name = "Object"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an #AtkObject", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, 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, 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 'GI.Atk.Objects.Object.Object' -}
    -> T.Text
    {- ^ /@name@/: a character string to be set as the accessible name -}
    -> m ()
objectSetName accessible name = liftIO $ do
    accessible' <- unsafeManagedPtrCastPtr accessible
    name' <- textToCString name
    atk_object_set_name accessible' name'
    touchManagedPtr accessible
    freeMem name'
    return ()

#if ENABLE_OVERLOADING
data ObjectSetNameMethodInfo
instance (signature ~ (T.Text -> m ()), MonadIO m, IsObject a) => O.MethodInfo ObjectSetNameMethodInfo a signature where
    overloadedMethod _ = objectSetName

#endif

-- method Object::set_parent
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "accessible", argType = TInterface (Name {namespace = "Atk", name = "Object"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an #AtkObject", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "parent", argType = TInterface (Name {namespace = "Atk", name = "Object"}), 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, 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 'GI.Atk.Objects.Object.Object' -}
    -> b
    {- ^ /@parent@/: an 'GI.Atk.Objects.Object.Object' to be set as the accessible parent -}
    -> m ()
objectSetParent accessible parent = liftIO $ do
    accessible' <- unsafeManagedPtrCastPtr accessible
    parent' <- unsafeManagedPtrCastPtr parent
    atk_object_set_parent accessible' parent'
    touchManagedPtr accessible
    touchManagedPtr parent
    return ()

#if ENABLE_OVERLOADING
data ObjectSetParentMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsObject a, IsObject b) => O.MethodInfo ObjectSetParentMethodInfo a signature where
    overloadedMethod _ = objectSetParent

#endif

-- method Object::set_role
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "accessible", argType = TInterface (Name {namespace = "Atk", name = "Object"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an #AtkObject", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "role", argType = TInterface (Name {namespace = "Atk", name = "Role"}), 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, 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 'GI.Atk.Objects.Object.Object' -}
    -> Atk.Enums.Role
    {- ^ /@role@/: an 'GI.Atk.Enums.Role' to be set as the role -}
    -> m ()
objectSetRole accessible role = liftIO $ do
    accessible' <- unsafeManagedPtrCastPtr accessible
    let role' = (fromIntegral . fromEnum) role
    atk_object_set_role accessible' role'
    touchManagedPtr accessible
    return ()

#if ENABLE_OVERLOADING
data ObjectSetRoleMethodInfo
instance (signature ~ (Atk.Enums.Role -> m ()), MonadIO m, IsObject a) => O.MethodInfo ObjectSetRoleMethodInfo a signature where
    overloadedMethod _ = objectSetRole

#endif