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

    'GI.Atk.Interfaces.Table.Table' should be implemented by components which present
    elements ordered via rows and columns.  It may also be used to
    present tree-structured information if the nodes of the trees can
    be said to contain multiple \"columns\".  Individual elements of an
    'GI.Atk.Interfaces.Table.Table' are typically referred to as \"cells\". Those cells should
    implement the interface 'GI.Atk.Interfaces.TableCell.TableCell', but @/Atk/@ doesn\'t require
    them to be direct children of the current 'GI.Atk.Interfaces.Table.Table'. They can be
    grand-children, grand-grand-children etc. 'GI.Atk.Interfaces.Table.Table' provides the
    API needed to get a individual cell based on the row and column
    numbers.

    Children of 'GI.Atk.Interfaces.Table.Table' are frequently \"lightweight\" objects, that
    is, they may not have backing widgets in the host UI toolkit.  They
    are therefore often transient.

    Since tables are often very complex, 'GI.Atk.Interfaces.Table.Table' includes provision
    for offering simplified summary information, as well as row and
    column headers and captions.  Headers and captions are @/AtkObjects/@
    which may implement other interfaces ('GI.Atk.Interfaces.Text.Text', 'GI.Atk.Interfaces.Image.Image', etc.) as
    appropriate.  'GI.Atk.Interfaces.Table.Table' summaries may themselves be (simplified)
    @/AtkTables/@, etc.

    Note for implementors: in the past, 'GI.Atk.Interfaces.Table.Table' required that all the
    cells should be direct children of 'GI.Atk.Interfaces.Table.Table', and provided some
    index based methods to request the cells. The practice showed that
    that forcing made 'GI.Atk.Interfaces.Table.Table' implementation complex, and hard to
    expose other kind of children, like rows or captions. Right now,
    index-based methods are deprecated.
    -}

    #define ENABLE_OVERLOADING \
           (!defined(__HADDOCK_VERSION__))

    module GI.Atk.Interfaces.Table
        (

    -- * Exported types
        Table(..)                               ,
        noTable                                 ,
        IsTable                                 ,
        toTable                                 ,

     -- * Methods
    -- ** addColumnSelection #method:addColumnSelection#

    #if ENABLE_OVERLOADING
        TableAddColumnSelectionMethodInfo       ,
    #endif
        tableAddColumnSelection                 ,

    -- ** addRowSelection #method:addRowSelection#

    #if ENABLE_OVERLOADING
        TableAddRowSelectionMethodInfo          ,
    #endif
        tableAddRowSelection                    ,

    -- ** getCaption #method:getCaption#

    #if ENABLE_OVERLOADING
        TableGetCaptionMethodInfo               ,
    #endif
        tableGetCaption                         ,

    -- ** getColumnAtIndex #method:getColumnAtIndex#

    #if ENABLE_OVERLOADING
        TableGetColumnAtIndexMethodInfo         ,
    #endif
        tableGetColumnAtIndex                   ,

    -- ** getColumnDescription #method:getColumnDescription#

    #if ENABLE_OVERLOADING
        TableGetColumnDescriptionMethodInfo     ,
    #endif
        tableGetColumnDescription               ,

    -- ** getColumnExtentAt #method:getColumnExtentAt#

    #if ENABLE_OVERLOADING
        TableGetColumnExtentAtMethodInfo        ,
    #endif
        tableGetColumnExtentAt                  ,

    -- ** getColumnHeader #method:getColumnHeader#

    #if ENABLE_OVERLOADING
        TableGetColumnHeaderMethodInfo          ,
    #endif
        tableGetColumnHeader                    ,

    -- ** getIndexAt #method:getIndexAt#

    #if ENABLE_OVERLOADING
        TableGetIndexAtMethodInfo               ,
    #endif
        tableGetIndexAt                         ,

    -- ** getNColumns #method:getNColumns#

    #if ENABLE_OVERLOADING
        TableGetNColumnsMethodInfo              ,
    #endif
        tableGetNColumns                        ,

    -- ** getNRows #method:getNRows#

    #if ENABLE_OVERLOADING
        TableGetNRowsMethodInfo                 ,
    #endif
        tableGetNRows                           ,

    -- ** getRowAtIndex #method:getRowAtIndex#

    #if ENABLE_OVERLOADING
        TableGetRowAtIndexMethodInfo            ,
    #endif
        tableGetRowAtIndex                      ,

    -- ** getRowDescription #method:getRowDescription#

    #if ENABLE_OVERLOADING
        TableGetRowDescriptionMethodInfo        ,
    #endif
        tableGetRowDescription                  ,

    -- ** getRowExtentAt #method:getRowExtentAt#

    #if ENABLE_OVERLOADING
        TableGetRowExtentAtMethodInfo           ,
    #endif
        tableGetRowExtentAt                     ,

    -- ** getRowHeader #method:getRowHeader#

    #if ENABLE_OVERLOADING
        TableGetRowHeaderMethodInfo             ,
    #endif
        tableGetRowHeader                       ,

    -- ** getSelectedColumns #method:getSelectedColumns#

    #if ENABLE_OVERLOADING
        TableGetSelectedColumnsMethodInfo       ,
    #endif
        tableGetSelectedColumns                 ,

    -- ** getSelectedRows #method:getSelectedRows#

    #if ENABLE_OVERLOADING
        TableGetSelectedRowsMethodInfo          ,
    #endif
        tableGetSelectedRows                    ,

    -- ** getSummary #method:getSummary#

    #if ENABLE_OVERLOADING
        TableGetSummaryMethodInfo               ,
    #endif
        tableGetSummary                         ,

    -- ** isColumnSelected #method:isColumnSelected#

    #if ENABLE_OVERLOADING
        TableIsColumnSelectedMethodInfo         ,
    #endif
        tableIsColumnSelected                   ,

    -- ** isRowSelected #method:isRowSelected#

    #if ENABLE_OVERLOADING
        TableIsRowSelectedMethodInfo            ,
    #endif
        tableIsRowSelected                      ,

    -- ** isSelected #method:isSelected#

    #if ENABLE_OVERLOADING
        TableIsSelectedMethodInfo               ,
    #endif
        tableIsSelected                         ,

    -- ** refAt #method:refAt#

    #if ENABLE_OVERLOADING
        TableRefAtMethodInfo                    ,
    #endif
        tableRefAt                              ,

    -- ** removeColumnSelection #method:removeColumnSelection#

    #if ENABLE_OVERLOADING
        TableRemoveColumnSelectionMethodInfo    ,
    #endif
        tableRemoveColumnSelection              ,

    -- ** removeRowSelection #method:removeRowSelection#

    #if ENABLE_OVERLOADING
        TableRemoveRowSelectionMethodInfo       ,
    #endif
        tableRemoveRowSelection                 ,

    -- ** setCaption #method:setCaption#

    #if ENABLE_OVERLOADING
        TableSetCaptionMethodInfo               ,
    #endif
        tableSetCaption                         ,

    -- ** setColumnDescription #method:setColumnDescription#

    #if ENABLE_OVERLOADING
        TableSetColumnDescriptionMethodInfo     ,
    #endif
        tableSetColumnDescription               ,

    -- ** setColumnHeader #method:setColumnHeader#

    #if ENABLE_OVERLOADING
        TableSetColumnHeaderMethodInfo          ,
    #endif
        tableSetColumnHeader                    ,

    -- ** setRowDescription #method:setRowDescription#

    #if ENABLE_OVERLOADING
        TableSetRowDescriptionMethodInfo        ,
    #endif
        tableSetRowDescription                  ,

    -- ** setRowHeader #method:setRowHeader#

    #if ENABLE_OVERLOADING
        TableSetRowHeaderMethodInfo             ,
    #endif
        tableSetRowHeader                       ,

    -- ** setSummary #method:setSummary#

    #if ENABLE_OVERLOADING
        TableSetSummaryMethodInfo               ,
    #endif
        tableSetSummary                         ,

     -- * Signals
    -- ** columnDeleted #signal:columnDeleted#

        C_TableColumnDeletedCallback            ,
        TableColumnDeletedCallback              ,
    #if ENABLE_OVERLOADING
        TableColumnDeletedSignalInfo            ,
    #endif
        afterTableColumnDeleted                 ,
        genClosure_TableColumnDeleted           ,
        mk_TableColumnDeletedCallback           ,
        noTableColumnDeletedCallback            ,
        onTableColumnDeleted                    ,
        wrap_TableColumnDeletedCallback         ,

    -- ** columnInserted #signal:columnInserted#

        C_TableColumnInsertedCallback           ,
        TableColumnInsertedCallback             ,
    #if ENABLE_OVERLOADING
        TableColumnInsertedSignalInfo           ,
    #endif
        afterTableColumnInserted                ,
        genClosure_TableColumnInserted          ,
        mk_TableColumnInsertedCallback          ,
        noTableColumnInsertedCallback           ,
        onTableColumnInserted                   ,
        wrap_TableColumnInsertedCallback        ,

    -- ** columnReordered #signal:columnReordered#

        C_TableColumnReorderedCallback          ,
        TableColumnReorderedCallback            ,
    #if ENABLE_OVERLOADING
        TableColumnReorderedSignalInfo          ,
    #endif
        afterTableColumnReordered               ,
        genClosure_TableColumnReordered         ,
        mk_TableColumnReorderedCallback         ,
        noTableColumnReorderedCallback          ,
        onTableColumnReordered                  ,
        wrap_TableColumnReorderedCallback       ,

    -- ** modelChanged #signal:modelChanged#

        C_TableModelChangedCallback             ,
        TableModelChangedCallback               ,
    #if ENABLE_OVERLOADING
        TableModelChangedSignalInfo             ,
    #endif
        afterTableModelChanged                  ,
        genClosure_TableModelChanged            ,
        mk_TableModelChangedCallback            ,
        noTableModelChangedCallback             ,
        onTableModelChanged                     ,
        wrap_TableModelChangedCallback          ,

    -- ** rowDeleted #signal:rowDeleted#

        C_TableRowDeletedCallback               ,
        TableRowDeletedCallback                 ,
    #if ENABLE_OVERLOADING
        TableRowDeletedSignalInfo               ,
    #endif
        afterTableRowDeleted                    ,
        genClosure_TableRowDeleted              ,
        mk_TableRowDeletedCallback              ,
        noTableRowDeletedCallback               ,
        onTableRowDeleted                       ,
        wrap_TableRowDeletedCallback            ,

    -- ** rowInserted #signal:rowInserted#

        C_TableRowInsertedCallback              ,
        TableRowInsertedCallback                ,
    #if ENABLE_OVERLOADING
        TableRowInsertedSignalInfo              ,
    #endif
        afterTableRowInserted                   ,
        genClosure_TableRowInserted             ,
        mk_TableRowInsertedCallback             ,
        noTableRowInsertedCallback              ,
        onTableRowInserted                      ,
        wrap_TableRowInsertedCallback           ,

    -- ** rowReordered #signal:rowReordered#

        C_TableRowReorderedCallback             ,
        TableRowReorderedCallback               ,
    #if ENABLE_OVERLOADING
        TableRowReorderedSignalInfo             ,
    #endif
        afterTableRowReordered                  ,
        genClosure_TableRowReordered            ,
        mk_TableRowReorderedCallback            ,
        noTableRowReorderedCallback             ,
        onTableRowReordered                     ,
        wrap_TableRowReorderedCallback          ,

        ) where

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

    import qualified Data.GI.Base.Attributes as GI.Attributes
    import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
    import qualified Data.GI.Base.GError as B.GError
    import qualified Data.GI.Base.GVariant as B.GVariant
    import qualified Data.GI.Base.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.Text as T
    import qualified Data.ByteString.Char8 as B
    import qualified Data.Map as Map
    import qualified Foreign.Ptr as FP

    import {-# SOURCE #-} qualified GI.Atk.Objects.Object as Atk.Object
    import qualified GI.GObject.Objects.Object as GObject.Object

    -- interface Table
    -- | Memory-managed wrapper type.
    newtype Table = Table (ManagedPtr Table)
    -- | A convenience alias for `Nothing` :: `Maybe` `Table`.
    noTable :: Maybe Table
    noTable = Nothing

    -- signal Table::column-deleted
    {- |
    The \"column-deleted\" signal is emitted by an object which
    implements the AtkTable interface when a column is deleted.
    -}
    type TableColumnDeletedCallback =
        Int32
        {- ^ /@arg1@/: The index of the first column deleted. -}
        -> Int32
        {- ^ /@arg2@/: The number of columns deleted. -}
        -> IO ()

    -- | A convenience synonym for @`Nothing` :: `Maybe` `TableColumnDeletedCallback`@.
    noTableColumnDeletedCallback :: Maybe TableColumnDeletedCallback
    noTableColumnDeletedCallback = Nothing

    -- | Type for the callback on the (unwrapped) C side.
    type C_TableColumnDeletedCallback =
        Ptr () ->                               -- object
        Int32 ->
        Int32 ->
        Ptr () ->                               -- user_data
        IO ()

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

    -- | Wrap the callback into a `Closure`.
    genClosure_TableColumnDeleted :: TableColumnDeletedCallback -> IO Closure
    genClosure_TableColumnDeleted cb = do
        let cb' = wrap_TableColumnDeletedCallback cb
        mk_TableColumnDeletedCallback cb' >>= newCClosure

    -- | Wrap a `TableColumnDeletedCallback` into a `C_TableColumnDeletedCallback`.
    wrap_TableColumnDeletedCallback ::
        TableColumnDeletedCallback ->
        C_TableColumnDeletedCallback
    wrap_TableColumnDeletedCallback _cb _ arg1 arg2 _ = do
        _cb  arg1 arg2

    {- |
    Connect a signal handler for the “@column-deleted@” 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' table #columnDeleted callback
    @
    -}
    onTableColumnDeleted :: (IsTable a, MonadIO m) => a -> TableColumnDeletedCallback -> m SignalHandlerId
    onTableColumnDeleted obj cb = liftIO $ do
        let cb' = wrap_TableColumnDeletedCallback cb
        cb'' <- mk_TableColumnDeletedCallback cb'
        connectSignalFunPtr obj "column-deleted" cb'' SignalConnectBefore

    {- |
    Connect a signal handler for the “@column-deleted@” 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' table #columnDeleted callback
    @
    -}
    afterTableColumnDeleted :: (IsTable a, MonadIO m) => a -> TableColumnDeletedCallback -> m SignalHandlerId
    afterTableColumnDeleted obj cb = liftIO $ do
        let cb' = wrap_TableColumnDeletedCallback cb
        cb'' <- mk_TableColumnDeletedCallback cb'
        connectSignalFunPtr obj "column-deleted" cb'' SignalConnectAfter

    -- signal Table::column-inserted
    {- |
    The \"column-inserted\" signal is emitted by an object which
    implements the AtkTable interface when a column is inserted.
    -}
    type TableColumnInsertedCallback =
        Int32
        {- ^ /@arg1@/: The index of the column inserted. -}
        -> Int32
        {- ^ /@arg2@/: The number of colums inserted. -}
        -> IO ()

    -- | A convenience synonym for @`Nothing` :: `Maybe` `TableColumnInsertedCallback`@.
    noTableColumnInsertedCallback :: Maybe TableColumnInsertedCallback
    noTableColumnInsertedCallback = Nothing

    -- | Type for the callback on the (unwrapped) C side.
    type C_TableColumnInsertedCallback =
        Ptr () ->                               -- object
        Int32 ->
        Int32 ->
        Ptr () ->                               -- user_data
        IO ()

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

    -- | Wrap the callback into a `Closure`.
    genClosure_TableColumnInserted :: TableColumnInsertedCallback -> IO Closure
    genClosure_TableColumnInserted cb = do
        let cb' = wrap_TableColumnInsertedCallback cb
        mk_TableColumnInsertedCallback cb' >>= newCClosure

    -- | Wrap a `TableColumnInsertedCallback` into a `C_TableColumnInsertedCallback`.
    wrap_TableColumnInsertedCallback ::
        TableColumnInsertedCallback ->
        C_TableColumnInsertedCallback
    wrap_TableColumnInsertedCallback _cb _ arg1 arg2 _ = do
        _cb  arg1 arg2

    {- |
    Connect a signal handler for the “@column-inserted@” 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' table #columnInserted callback
    @
    -}
    onTableColumnInserted :: (IsTable a, MonadIO m) => a -> TableColumnInsertedCallback -> m SignalHandlerId
    onTableColumnInserted obj cb = liftIO $ do
        let cb' = wrap_TableColumnInsertedCallback cb
        cb'' <- mk_TableColumnInsertedCallback cb'
        connectSignalFunPtr obj "column-inserted" cb'' SignalConnectBefore

    {- |
    Connect a signal handler for the “@column-inserted@” 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' table #columnInserted callback
    @
    -}
    afterTableColumnInserted :: (IsTable a, MonadIO m) => a -> TableColumnInsertedCallback -> m SignalHandlerId
    afterTableColumnInserted obj cb = liftIO $ do
        let cb' = wrap_TableColumnInsertedCallback cb
        cb'' <- mk_TableColumnInsertedCallback cb'
        connectSignalFunPtr obj "column-inserted" cb'' SignalConnectAfter

    -- signal Table::column-reordered
    {- |
    The \"column-reordered\" signal is emitted by an object which
    implements the AtkTable interface when the columns are
    reordered.
    -}
    type TableColumnReorderedCallback =
        IO ()

    -- | A convenience synonym for @`Nothing` :: `Maybe` `TableColumnReorderedCallback`@.
    noTableColumnReorderedCallback :: Maybe TableColumnReorderedCallback
    noTableColumnReorderedCallback = Nothing

    -- | Type for the callback on the (unwrapped) C side.
    type C_TableColumnReorderedCallback =
        Ptr () ->                               -- object
        Ptr () ->                               -- user_data
        IO ()

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

    -- | Wrap the callback into a `Closure`.
    genClosure_TableColumnReordered :: TableColumnReorderedCallback -> IO Closure
    genClosure_TableColumnReordered cb = do
        let cb' = wrap_TableColumnReorderedCallback cb
        mk_TableColumnReorderedCallback cb' >>= newCClosure

    -- | Wrap a `TableColumnReorderedCallback` into a `C_TableColumnReorderedCallback`.
    wrap_TableColumnReorderedCallback ::
        TableColumnReorderedCallback ->
        C_TableColumnReorderedCallback
    wrap_TableColumnReorderedCallback _cb _ _ = do
        _cb

    {- |
    Connect a signal handler for the “@column-reordered@” 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' table #columnReordered callback
    @
    -}
    onTableColumnReordered :: (IsTable a, MonadIO m) => a -> TableColumnReorderedCallback -> m SignalHandlerId
    onTableColumnReordered obj cb = liftIO $ do
        let cb' = wrap_TableColumnReorderedCallback cb
        cb'' <- mk_TableColumnReorderedCallback cb'
        connectSignalFunPtr obj "column-reordered" cb'' SignalConnectBefore

    {- |
    Connect a signal handler for the “@column-reordered@” 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' table #columnReordered callback
    @
    -}
    afterTableColumnReordered :: (IsTable a, MonadIO m) => a -> TableColumnReorderedCallback -> m SignalHandlerId
    afterTableColumnReordered obj cb = liftIO $ do
        let cb' = wrap_TableColumnReorderedCallback cb
        cb'' <- mk_TableColumnReorderedCallback cb'
        connectSignalFunPtr obj "column-reordered" cb'' SignalConnectAfter

    -- signal Table::model-changed
    {- |
    The \"model-changed\" signal is emitted by an object which
    implements the AtkTable interface when the model displayed by
    the table changes.
    -}
    type TableModelChangedCallback =
        IO ()

    -- | A convenience synonym for @`Nothing` :: `Maybe` `TableModelChangedCallback`@.
    noTableModelChangedCallback :: Maybe TableModelChangedCallback
    noTableModelChangedCallback = Nothing

    -- | Type for the callback on the (unwrapped) C side.
    type C_TableModelChangedCallback =
        Ptr () ->                               -- object
        Ptr () ->                               -- user_data
        IO ()

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

    -- | Wrap the callback into a `Closure`.
    genClosure_TableModelChanged :: TableModelChangedCallback -> IO Closure
    genClosure_TableModelChanged cb = do
        let cb' = wrap_TableModelChangedCallback cb
        mk_TableModelChangedCallback cb' >>= newCClosure

    -- | Wrap a `TableModelChangedCallback` into a `C_TableModelChangedCallback`.
    wrap_TableModelChangedCallback ::
        TableModelChangedCallback ->
        C_TableModelChangedCallback
    wrap_TableModelChangedCallback _cb _ _ = do
        _cb

    {- |
    Connect a signal handler for the “@model-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' table #modelChanged callback
    @
    -}
    onTableModelChanged :: (IsTable a, MonadIO m) => a -> TableModelChangedCallback -> m SignalHandlerId
    onTableModelChanged obj cb = liftIO $ do
        let cb' = wrap_TableModelChangedCallback cb
        cb'' <- mk_TableModelChangedCallback cb'
        connectSignalFunPtr obj "model-changed" cb'' SignalConnectBefore

    {- |
    Connect a signal handler for the “@model-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' table #modelChanged callback
    @
    -}
    afterTableModelChanged :: (IsTable a, MonadIO m) => a -> TableModelChangedCallback -> m SignalHandlerId
    afterTableModelChanged obj cb = liftIO $ do
        let cb' = wrap_TableModelChangedCallback cb
        cb'' <- mk_TableModelChangedCallback cb'
        connectSignalFunPtr obj "model-changed" cb'' SignalConnectAfter

    -- signal Table::row-deleted
    {- |
    The \"row-deleted\" signal is emitted by an object which
    implements the AtkTable interface when a row is deleted.
    -}
    type TableRowDeletedCallback =
        Int32
        {- ^ /@arg1@/: The index of the first row deleted. -}
        -> Int32
        {- ^ /@arg2@/: The number of rows deleted. -}
        -> IO ()

    -- | A convenience synonym for @`Nothing` :: `Maybe` `TableRowDeletedCallback`@.
    noTableRowDeletedCallback :: Maybe TableRowDeletedCallback
    noTableRowDeletedCallback = Nothing

    -- | Type for the callback on the (unwrapped) C side.
    type C_TableRowDeletedCallback =
        Ptr () ->                               -- object
        Int32 ->
        Int32 ->
        Ptr () ->                               -- user_data
        IO ()

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

    -- | Wrap the callback into a `Closure`.
    genClosure_TableRowDeleted :: TableRowDeletedCallback -> IO Closure
    genClosure_TableRowDeleted cb = do
        let cb' = wrap_TableRowDeletedCallback cb
        mk_TableRowDeletedCallback cb' >>= newCClosure

    -- | Wrap a `TableRowDeletedCallback` into a `C_TableRowDeletedCallback`.
    wrap_TableRowDeletedCallback ::
        TableRowDeletedCallback ->
        C_TableRowDeletedCallback
    wrap_TableRowDeletedCallback _cb _ arg1 arg2 _ = do
        _cb  arg1 arg2

    {- |
    Connect a signal handler for the “@row-deleted@” 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' table #rowDeleted callback
    @
    -}
    onTableRowDeleted :: (IsTable a, MonadIO m) => a -> TableRowDeletedCallback -> m SignalHandlerId
    onTableRowDeleted obj cb = liftIO $ do
        let cb' = wrap_TableRowDeletedCallback cb
        cb'' <- mk_TableRowDeletedCallback cb'
        connectSignalFunPtr obj "row-deleted" cb'' SignalConnectBefore

    {- |
    Connect a signal handler for the “@row-deleted@” 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' table #rowDeleted callback
    @
    -}
    afterTableRowDeleted :: (IsTable a, MonadIO m) => a -> TableRowDeletedCallback -> m SignalHandlerId
    afterTableRowDeleted obj cb = liftIO $ do
        let cb' = wrap_TableRowDeletedCallback cb
        cb'' <- mk_TableRowDeletedCallback cb'
        connectSignalFunPtr obj "row-deleted" cb'' SignalConnectAfter

    -- signal Table::row-inserted
    {- |
    The \"row-inserted\" signal is emitted by an object which
    implements the AtkTable interface when a row is inserted.
    -}
    type TableRowInsertedCallback =
        Int32
        {- ^ /@arg1@/: The index of the first row inserted. -}
        -> Int32
        {- ^ /@arg2@/: The number of rows inserted. -}
        -> IO ()

    -- | A convenience synonym for @`Nothing` :: `Maybe` `TableRowInsertedCallback`@.
    noTableRowInsertedCallback :: Maybe TableRowInsertedCallback
    noTableRowInsertedCallback = Nothing

    -- | Type for the callback on the (unwrapped) C side.
    type C_TableRowInsertedCallback =
        Ptr () ->                               -- object
        Int32 ->
        Int32 ->
        Ptr () ->                               -- user_data
        IO ()

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

    -- | Wrap the callback into a `Closure`.
    genClosure_TableRowInserted :: TableRowInsertedCallback -> IO Closure
    genClosure_TableRowInserted cb = do
        let cb' = wrap_TableRowInsertedCallback cb
        mk_TableRowInsertedCallback cb' >>= newCClosure

    -- | Wrap a `TableRowInsertedCallback` into a `C_TableRowInsertedCallback`.
    wrap_TableRowInsertedCallback ::
        TableRowInsertedCallback ->
        C_TableRowInsertedCallback
    wrap_TableRowInsertedCallback _cb _ arg1 arg2 _ = do
        _cb  arg1 arg2

    {- |
    Connect a signal handler for the “@row-inserted@” 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' table #rowInserted callback
    @
    -}
    onTableRowInserted :: (IsTable a, MonadIO m) => a -> TableRowInsertedCallback -> m SignalHandlerId
    onTableRowInserted obj cb = liftIO $ do
        let cb' = wrap_TableRowInsertedCallback cb
        cb'' <- mk_TableRowInsertedCallback cb'
        connectSignalFunPtr obj "row-inserted" cb'' SignalConnectBefore

    {- |
    Connect a signal handler for the “@row-inserted@” 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' table #rowInserted callback
    @
    -}
    afterTableRowInserted :: (IsTable a, MonadIO m) => a -> TableRowInsertedCallback -> m SignalHandlerId
    afterTableRowInserted obj cb = liftIO $ do
        let cb' = wrap_TableRowInsertedCallback cb
        cb'' <- mk_TableRowInsertedCallback cb'
        connectSignalFunPtr obj "row-inserted" cb'' SignalConnectAfter

    -- signal Table::row-reordered
    {- |
    The \"row-reordered\" signal is emitted by an object which
    implements the AtkTable interface when the rows are
    reordered.
    -}
    type TableRowReorderedCallback =
        IO ()

    -- | A convenience synonym for @`Nothing` :: `Maybe` `TableRowReorderedCallback`@.
    noTableRowReorderedCallback :: Maybe TableRowReorderedCallback
    noTableRowReorderedCallback = Nothing

    -- | Type for the callback on the (unwrapped) C side.
    type C_TableRowReorderedCallback =
        Ptr () ->                               -- object
        Ptr () ->                               -- user_data
        IO ()

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

    -- | Wrap the callback into a `Closure`.
    genClosure_TableRowReordered :: TableRowReorderedCallback -> IO Closure
    genClosure_TableRowReordered cb = do
        let cb' = wrap_TableRowReorderedCallback cb
        mk_TableRowReorderedCallback cb' >>= newCClosure

    -- | Wrap a `TableRowReorderedCallback` into a `C_TableRowReorderedCallback`.
    wrap_TableRowReorderedCallback ::
        TableRowReorderedCallback ->
        C_TableRowReorderedCallback
    wrap_TableRowReorderedCallback _cb _ _ = do
        _cb

    {- |
    Connect a signal handler for the “@row-reordered@” 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' table #rowReordered callback
    @
    -}
    onTableRowReordered :: (IsTable a, MonadIO m) => a -> TableRowReorderedCallback -> m SignalHandlerId
    onTableRowReordered obj cb = liftIO $ do
        let cb' = wrap_TableRowReorderedCallback cb
        cb'' <- mk_TableRowReorderedCallback cb'
        connectSignalFunPtr obj "row-reordered" cb'' SignalConnectBefore

    {- |
    Connect a signal handler for the “@row-reordered@” 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' table #rowReordered callback
    @
    -}
    afterTableRowReordered :: (IsTable a, MonadIO m) => a -> TableRowReorderedCallback -> m SignalHandlerId
    afterTableRowReordered obj cb = liftIO $ do
        let cb' = wrap_TableRowReorderedCallback cb
        cb'' <- mk_TableRowReorderedCallback cb'
        connectSignalFunPtr obj "row-reordered" cb'' SignalConnectAfter

    #if ENABLE_OVERLOADING
    data TableColumnDeletedSignalInfo
    instance SignalInfo TableColumnDeletedSignalInfo where
        type HaskellCallbackType TableColumnDeletedSignalInfo = TableColumnDeletedCallback
        connectSignal _ obj cb connectMode = do
            let cb' = wrap_TableColumnDeletedCallback cb
            cb'' <- mk_TableColumnDeletedCallback cb'
            connectSignalFunPtr obj "column-deleted" cb'' connectMode

    data TableColumnInsertedSignalInfo
    instance SignalInfo TableColumnInsertedSignalInfo where
        type HaskellCallbackType TableColumnInsertedSignalInfo = TableColumnInsertedCallback
        connectSignal _ obj cb connectMode = do
            let cb' = wrap_TableColumnInsertedCallback cb
            cb'' <- mk_TableColumnInsertedCallback cb'
            connectSignalFunPtr obj "column-inserted" cb'' connectMode

    data TableColumnReorderedSignalInfo
    instance SignalInfo TableColumnReorderedSignalInfo where
        type HaskellCallbackType TableColumnReorderedSignalInfo = TableColumnReorderedCallback
        connectSignal _ obj cb connectMode = do
            let cb' = wrap_TableColumnReorderedCallback cb
            cb'' <- mk_TableColumnReorderedCallback cb'
            connectSignalFunPtr obj "column-reordered" cb'' connectMode

    data TableModelChangedSignalInfo
    instance SignalInfo TableModelChangedSignalInfo where
        type HaskellCallbackType TableModelChangedSignalInfo = TableModelChangedCallback
        connectSignal _ obj cb connectMode = do
            let cb' = wrap_TableModelChangedCallback cb
            cb'' <- mk_TableModelChangedCallback cb'
            connectSignalFunPtr obj "model-changed" cb'' connectMode

    data TableRowDeletedSignalInfo
    instance SignalInfo TableRowDeletedSignalInfo where
        type HaskellCallbackType TableRowDeletedSignalInfo = TableRowDeletedCallback
        connectSignal _ obj cb connectMode = do
            let cb' = wrap_TableRowDeletedCallback cb
            cb'' <- mk_TableRowDeletedCallback cb'
            connectSignalFunPtr obj "row-deleted" cb'' connectMode

    data TableRowInsertedSignalInfo
    instance SignalInfo TableRowInsertedSignalInfo where
        type HaskellCallbackType TableRowInsertedSignalInfo = TableRowInsertedCallback
        connectSignal _ obj cb connectMode = do
            let cb' = wrap_TableRowInsertedCallback cb
            cb'' <- mk_TableRowInsertedCallback cb'
            connectSignalFunPtr obj "row-inserted" cb'' connectMode

    data TableRowReorderedSignalInfo
    instance SignalInfo TableRowReorderedSignalInfo where
        type HaskellCallbackType TableRowReorderedSignalInfo = TableRowReorderedCallback
        connectSignal _ obj cb connectMode = do
            let cb' = wrap_TableRowReorderedCallback cb
            cb'' <- mk_TableRowReorderedCallback cb'
            connectSignalFunPtr obj "row-reordered" cb'' connectMode

    type instance O.SignalList Table = TableSignalList
    type TableSignalList = ('[ '("columnDeleted", TableColumnDeletedSignalInfo), '("columnInserted", TableColumnInsertedSignalInfo), '("columnReordered", TableColumnReorderedSignalInfo), '("modelChanged", TableModelChangedSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("rowDeleted", TableRowDeletedSignalInfo), '("rowInserted", TableRowInsertedSignalInfo), '("rowReordered", TableRowReorderedSignalInfo)] :: [(Symbol, *)])

    #endif

    foreign import ccall "atk_table_get_type"
        c_atk_table_get_type :: IO GType

    instance GObject Table where
        gobjectType _ = c_atk_table_get_type

    -- | Type class for types which can be safely cast to `Table`, for instance with `toTable`.
    class GObject o => IsTable o
    #if MIN_VERSION_base(4,9,0)
    instance {-# OVERLAPPABLE #-} (GObject a, O.UnknownAncestorError Table a) =>
        IsTable a
    #endif
    instance IsTable Table
    instance GObject.Object.IsObject Table

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

    #if ENABLE_OVERLOADING
    instance O.HasAttributeList Table
    type instance O.AttributeList Table = TableAttributeList
    type TableAttributeList = ('[ ] :: [(Symbol, *)])
    #endif

    #if ENABLE_OVERLOADING
    #endif

    #if ENABLE_OVERLOADING
    type family ResolveTableMethod (t :: Symbol) (o :: *) :: * where
        ResolveTableMethod "addColumnSelection" o = TableAddColumnSelectionMethodInfo
        ResolveTableMethod "addRowSelection" o = TableAddRowSelectionMethodInfo
        ResolveTableMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
        ResolveTableMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
        ResolveTableMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
        ResolveTableMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
        ResolveTableMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
        ResolveTableMethod "isColumnSelected" o = TableIsColumnSelectedMethodInfo
        ResolveTableMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
        ResolveTableMethod "isRowSelected" o = TableIsRowSelectedMethodInfo
        ResolveTableMethod "isSelected" o = TableIsSelectedMethodInfo
        ResolveTableMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
        ResolveTableMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
        ResolveTableMethod "ref" o = GObject.Object.ObjectRefMethodInfo
        ResolveTableMethod "refAt" o = TableRefAtMethodInfo
        ResolveTableMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
        ResolveTableMethod "removeColumnSelection" o = TableRemoveColumnSelectionMethodInfo
        ResolveTableMethod "removeRowSelection" o = TableRemoveRowSelectionMethodInfo
        ResolveTableMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
        ResolveTableMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
        ResolveTableMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
        ResolveTableMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
        ResolveTableMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
        ResolveTableMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
        ResolveTableMethod "getCaption" o = TableGetCaptionMethodInfo
        ResolveTableMethod "getColumnAtIndex" o = TableGetColumnAtIndexMethodInfo
        ResolveTableMethod "getColumnDescription" o = TableGetColumnDescriptionMethodInfo
        ResolveTableMethod "getColumnExtentAt" o = TableGetColumnExtentAtMethodInfo
        ResolveTableMethod "getColumnHeader" o = TableGetColumnHeaderMethodInfo
        ResolveTableMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
        ResolveTableMethod "getIndexAt" o = TableGetIndexAtMethodInfo
        ResolveTableMethod "getNColumns" o = TableGetNColumnsMethodInfo
        ResolveTableMethod "getNRows" o = TableGetNRowsMethodInfo
        ResolveTableMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
        ResolveTableMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
        ResolveTableMethod "getRowAtIndex" o = TableGetRowAtIndexMethodInfo
        ResolveTableMethod "getRowDescription" o = TableGetRowDescriptionMethodInfo
        ResolveTableMethod "getRowExtentAt" o = TableGetRowExtentAtMethodInfo
        ResolveTableMethod "getRowHeader" o = TableGetRowHeaderMethodInfo
        ResolveTableMethod "getSelectedColumns" o = TableGetSelectedColumnsMethodInfo
        ResolveTableMethod "getSelectedRows" o = TableGetSelectedRowsMethodInfo
        ResolveTableMethod "getSummary" o = TableGetSummaryMethodInfo
        ResolveTableMethod "setCaption" o = TableSetCaptionMethodInfo
        ResolveTableMethod "setColumnDescription" o = TableSetColumnDescriptionMethodInfo
        ResolveTableMethod "setColumnHeader" o = TableSetColumnHeaderMethodInfo
        ResolveTableMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
        ResolveTableMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
        ResolveTableMethod "setRowDescription" o = TableSetRowDescriptionMethodInfo
        ResolveTableMethod "setRowHeader" o = TableSetRowHeaderMethodInfo
        ResolveTableMethod "setSummary" o = TableSetSummaryMethodInfo
        ResolveTableMethod l o = O.MethodResolutionFailed l o

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

    #if MIN_VERSION_base(4,9,0)
    instance (info ~ ResolveTableMethod t Table, O.MethodInfo info Table p) => O.IsLabel t (Table -> 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

    #endif

    -- method Table::add_column_selection
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "table", argType = TInterface (Name {namespace = "Atk", name = "Table"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a GObject instance that implements AtkTableIface", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "column", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #gint representing a column in @table", 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_table_add_column_selection" atk_table_add_column_selection ::
        Ptr Table ->                            -- table : TInterface (Name {namespace = "Atk", name = "Table"})
        Int32 ->                                -- column : TBasicType TInt
        IO CInt

    {- |
    Adds the specified /@column@/ to the selection.
    -}
    tableAddColumnSelection ::
        (B.CallStack.HasCallStack, MonadIO m, IsTable a) =>
        a
        {- ^ /@table@/: a GObject instance that implements AtkTableIface -}
        -> Int32
        {- ^ /@column@/: a @/gint/@ representing a column in /@table@/ -}
        -> m Bool
        {- ^ __Returns:__ a gboolean representing if the column was successfully added to
    the selection, or 0 if value does not implement this interface. -}
    tableAddColumnSelection table column = liftIO $ do
        table' <- unsafeManagedPtrCastPtr table
        result <- atk_table_add_column_selection table' column
        let result' = (/= 0) result
        touchManagedPtr table
        return result'

    #if ENABLE_OVERLOADING
    data TableAddColumnSelectionMethodInfo
    instance (signature ~ (Int32 -> m Bool), MonadIO m, IsTable a) => O.MethodInfo TableAddColumnSelectionMethodInfo a signature where
        overloadedMethod _ = tableAddColumnSelection

    #endif

    -- method Table::add_row_selection
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "table", argType = TInterface (Name {namespace = "Atk", name = "Table"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a GObject instance that implements AtkTableIface", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "row", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #gint representing a row in @table", 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_table_add_row_selection" atk_table_add_row_selection ::
        Ptr Table ->                            -- table : TInterface (Name {namespace = "Atk", name = "Table"})
        Int32 ->                                -- row : TBasicType TInt
        IO CInt

    {- |
    Adds the specified /@row@/ to the selection.
    -}
    tableAddRowSelection ::
        (B.CallStack.HasCallStack, MonadIO m, IsTable a) =>
        a
        {- ^ /@table@/: a GObject instance that implements AtkTableIface -}
        -> Int32
        {- ^ /@row@/: a @/gint/@ representing a row in /@table@/ -}
        -> m Bool
        {- ^ __Returns:__ a gboolean representing if row was successfully added to selection,
    or 0 if value does not implement this interface. -}
    tableAddRowSelection table row = liftIO $ do
        table' <- unsafeManagedPtrCastPtr table
        result <- atk_table_add_row_selection table' row
        let result' = (/= 0) result
        touchManagedPtr table
        return result'

    #if ENABLE_OVERLOADING
    data TableAddRowSelectionMethodInfo
    instance (signature ~ (Int32 -> m Bool), MonadIO m, IsTable a) => O.MethodInfo TableAddRowSelectionMethodInfo a signature where
        overloadedMethod _ = tableAddRowSelection

    #endif

    -- method Table::get_caption
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "table", argType = TInterface (Name {namespace = "Atk", name = "Table"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a GObject instance that implements AtkTableInterface", 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_table_get_caption" atk_table_get_caption ::
        Ptr Table ->                            -- table : TInterface (Name {namespace = "Atk", name = "Table"})
        IO (Ptr Atk.Object.Object)

    {- |
    Gets the caption for the /@table@/.
    -}
    tableGetCaption ::
        (B.CallStack.HasCallStack, MonadIO m, IsTable a) =>
        a
        {- ^ /@table@/: a GObject instance that implements AtkTableInterface -}
        -> m (Maybe Atk.Object.Object)
        {- ^ __Returns:__ a AtkObject* representing the
    table caption, or 'Nothing' if value does not implement this interface. -}
    tableGetCaption table = liftIO $ do
        table' <- unsafeManagedPtrCastPtr table
        result <- atk_table_get_caption table'
        maybeResult <- convertIfNonNull result $ \result' -> do
            result'' <- (newObject Atk.Object.Object) result'
            return result''
        touchManagedPtr table
        return maybeResult

    #if ENABLE_OVERLOADING
    data TableGetCaptionMethodInfo
    instance (signature ~ (m (Maybe Atk.Object.Object)), MonadIO m, IsTable a) => O.MethodInfo TableGetCaptionMethodInfo a signature where
        overloadedMethod _ = tableGetCaption

    #endif

    -- method Table::get_column_at_index
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "table", argType = TInterface (Name {namespace = "Atk", name = "Table"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a GObject instance that implements AtkTableInterface", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "index_", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #gint representing an index in @table", 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_table_get_column_at_index" atk_table_get_column_at_index ::
        Ptr Table ->                            -- table : TInterface (Name {namespace = "Atk", name = "Table"})
        Int32 ->                                -- index_ : TBasicType TInt
        IO Int32

    {-# DEPRECATED tableGetColumnAtIndex ["Since 2.12."] #-}
    {- |
    Gets a @/gint/@ representing the column at the specified /@index_@/.
    -}
    tableGetColumnAtIndex ::
        (B.CallStack.HasCallStack, MonadIO m, IsTable a) =>
        a
        {- ^ /@table@/: a GObject instance that implements AtkTableInterface -}
        -> Int32
        {- ^ /@index_@/: a @/gint/@ representing an index in /@table@/ -}
        -> m Int32
        {- ^ __Returns:__ a gint representing the column at the specified index,
    or -1 if the table does not implement this method. -}
    tableGetColumnAtIndex table index_ = liftIO $ do
        table' <- unsafeManagedPtrCastPtr table
        result <- atk_table_get_column_at_index table' index_
        touchManagedPtr table
        return result

    #if ENABLE_OVERLOADING
    data TableGetColumnAtIndexMethodInfo
    instance (signature ~ (Int32 -> m Int32), MonadIO m, IsTable a) => O.MethodInfo TableGetColumnAtIndexMethodInfo a signature where
        overloadedMethod _ = tableGetColumnAtIndex

    #endif

    -- method Table::get_column_description
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "table", argType = TInterface (Name {namespace = "Atk", name = "Table"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a GObject instance that implements AtkTableIface", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "column", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #gint representing a column in @table", 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_table_get_column_description" atk_table_get_column_description ::
        Ptr Table ->                            -- table : TInterface (Name {namespace = "Atk", name = "Table"})
        Int32 ->                                -- column : TBasicType TInt
        IO CString

    {- |
    Gets the description text of the specified /@column@/ in the table
    -}
    tableGetColumnDescription ::
        (B.CallStack.HasCallStack, MonadIO m, IsTable a) =>
        a
        {- ^ /@table@/: a GObject instance that implements AtkTableIface -}
        -> Int32
        {- ^ /@column@/: a @/gint/@ representing a column in /@table@/ -}
        -> m T.Text
        {- ^ __Returns:__ a gchar* representing the column description, or 'Nothing'
    if value does not implement this interface. -}
    tableGetColumnDescription table column = liftIO $ do
        table' <- unsafeManagedPtrCastPtr table
        result <- atk_table_get_column_description table' column
        checkUnexpectedReturnNULL "tableGetColumnDescription" result
        result' <- cstringToText result
        touchManagedPtr table
        return result'

    #if ENABLE_OVERLOADING
    data TableGetColumnDescriptionMethodInfo
    instance (signature ~ (Int32 -> m T.Text), MonadIO m, IsTable a) => O.MethodInfo TableGetColumnDescriptionMethodInfo a signature where
        overloadedMethod _ = tableGetColumnDescription

    #endif

    -- method Table::get_column_extent_at
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "table", argType = TInterface (Name {namespace = "Atk", name = "Table"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a GObject instance that implements AtkTableIface", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "row", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #gint representing a row in @table", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "column", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #gint representing a column in @table", 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_table_get_column_extent_at" atk_table_get_column_extent_at ::
        Ptr Table ->                            -- table : TInterface (Name {namespace = "Atk", name = "Table"})
        Int32 ->                                -- row : TBasicType TInt
        Int32 ->                                -- column : TBasicType TInt
        IO Int32

    {- |
    Gets the number of columns occupied by the accessible object
    at the specified /@row@/ and /@column@/ in the /@table@/.
    -}
    tableGetColumnExtentAt ::
        (B.CallStack.HasCallStack, MonadIO m, IsTable a) =>
        a
        {- ^ /@table@/: a GObject instance that implements AtkTableIface -}
        -> Int32
        {- ^ /@row@/: a @/gint/@ representing a row in /@table@/ -}
        -> Int32
        {- ^ /@column@/: a @/gint/@ representing a column in /@table@/ -}
        -> m Int32
        {- ^ __Returns:__ a gint representing the column extent at specified position, or 0
    if value does not implement this interface. -}
    tableGetColumnExtentAt table row column = liftIO $ do
        table' <- unsafeManagedPtrCastPtr table
        result <- atk_table_get_column_extent_at table' row column
        touchManagedPtr table
        return result

    #if ENABLE_OVERLOADING
    data TableGetColumnExtentAtMethodInfo
    instance (signature ~ (Int32 -> Int32 -> m Int32), MonadIO m, IsTable a) => O.MethodInfo TableGetColumnExtentAtMethodInfo a signature where
        overloadedMethod _ = tableGetColumnExtentAt

    #endif

    -- method Table::get_column_header
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "table", argType = TInterface (Name {namespace = "Atk", name = "Table"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a GObject instance that implements AtkTableIface", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "column", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #gint representing a column in the table", 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_table_get_column_header" atk_table_get_column_header ::
        Ptr Table ->                            -- table : TInterface (Name {namespace = "Atk", name = "Table"})
        Int32 ->                                -- column : TBasicType TInt
        IO (Ptr Atk.Object.Object)

    {- |
    Gets the column header of a specified column in an accessible table.
    -}
    tableGetColumnHeader ::
        (B.CallStack.HasCallStack, MonadIO m, IsTable a) =>
        a
        {- ^ /@table@/: a GObject instance that implements AtkTableIface -}
        -> Int32
        {- ^ /@column@/: a @/gint/@ representing a column in the table -}
        -> m (Maybe Atk.Object.Object)
        {- ^ __Returns:__ a AtkObject* representing the
    specified column header, or 'Nothing' if value does not implement this
    interface. -}
    tableGetColumnHeader table column = liftIO $ do
        table' <- unsafeManagedPtrCastPtr table
        result <- atk_table_get_column_header table' column
        maybeResult <- convertIfNonNull result $ \result' -> do
            result'' <- (newObject Atk.Object.Object) result'
            return result''
        touchManagedPtr table
        return maybeResult

    #if ENABLE_OVERLOADING
    data TableGetColumnHeaderMethodInfo
    instance (signature ~ (Int32 -> m (Maybe Atk.Object.Object)), MonadIO m, IsTable a) => O.MethodInfo TableGetColumnHeaderMethodInfo a signature where
        overloadedMethod _ = tableGetColumnHeader

    #endif

    -- method Table::get_index_at
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "table", argType = TInterface (Name {namespace = "Atk", name = "Table"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a GObject instance that implements AtkTableIface", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "row", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #gint representing a row in @table", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "column", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #gint representing a column in @table", 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_table_get_index_at" atk_table_get_index_at ::
        Ptr Table ->                            -- table : TInterface (Name {namespace = "Atk", name = "Table"})
        Int32 ->                                -- row : TBasicType TInt
        Int32 ->                                -- column : TBasicType TInt
        IO Int32

    {-# DEPRECATED tableGetIndexAt ["Since 2.12. Use 'GI.Atk.Interfaces.Table.tableRefAt' in order to get the","accessible that represents the cell at (/@row@/, /@column@/)"] #-}
    {- |
    Gets a @/gint/@ representing the index at the specified /@row@/ and
    /@column@/.
    -}
    tableGetIndexAt ::
        (B.CallStack.HasCallStack, MonadIO m, IsTable a) =>
        a
        {- ^ /@table@/: a GObject instance that implements AtkTableIface -}
        -> Int32
        {- ^ /@row@/: a @/gint/@ representing a row in /@table@/ -}
        -> Int32
        {- ^ /@column@/: a @/gint/@ representing a column in /@table@/ -}
        -> m Int32
        {- ^ __Returns:__ a @/gint/@ representing the index at specified position.
    The value -1 is returned if the object at row,column is not a child
    of table or table does not implement this interface. -}
    tableGetIndexAt table row column = liftIO $ do
        table' <- unsafeManagedPtrCastPtr table
        result <- atk_table_get_index_at table' row column
        touchManagedPtr table
        return result

    #if ENABLE_OVERLOADING
    data TableGetIndexAtMethodInfo
    instance (signature ~ (Int32 -> Int32 -> m Int32), MonadIO m, IsTable a) => O.MethodInfo TableGetIndexAtMethodInfo a signature where
        overloadedMethod _ = tableGetIndexAt

    #endif

    -- method Table::get_n_columns
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "table", argType = TInterface (Name {namespace = "Atk", name = "Table"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a GObject instance that implements AtkTableIface", 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_table_get_n_columns" atk_table_get_n_columns ::
        Ptr Table ->                            -- table : TInterface (Name {namespace = "Atk", name = "Table"})
        IO Int32

    {- |
    Gets the number of columns in the table.
    -}
    tableGetNColumns ::
        (B.CallStack.HasCallStack, MonadIO m, IsTable a) =>
        a
        {- ^ /@table@/: a GObject instance that implements AtkTableIface -}
        -> m Int32
        {- ^ __Returns:__ a gint representing the number of columns, or 0
    if value does not implement this interface. -}
    tableGetNColumns table = liftIO $ do
        table' <- unsafeManagedPtrCastPtr table
        result <- atk_table_get_n_columns table'
        touchManagedPtr table
        return result

    #if ENABLE_OVERLOADING
    data TableGetNColumnsMethodInfo
    instance (signature ~ (m Int32), MonadIO m, IsTable a) => O.MethodInfo TableGetNColumnsMethodInfo a signature where
        overloadedMethod _ = tableGetNColumns

    #endif

    -- method Table::get_n_rows
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "table", argType = TInterface (Name {namespace = "Atk", name = "Table"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a GObject instance that implements AtkTableIface", 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_table_get_n_rows" atk_table_get_n_rows ::
        Ptr Table ->                            -- table : TInterface (Name {namespace = "Atk", name = "Table"})
        IO Int32

    {- |
    Gets the number of rows in the table.
    -}
    tableGetNRows ::
        (B.CallStack.HasCallStack, MonadIO m, IsTable a) =>
        a
        {- ^ /@table@/: a GObject instance that implements AtkTableIface -}
        -> m Int32
        {- ^ __Returns:__ a gint representing the number of rows, or 0
    if value does not implement this interface. -}
    tableGetNRows table = liftIO $ do
        table' <- unsafeManagedPtrCastPtr table
        result <- atk_table_get_n_rows table'
        touchManagedPtr table
        return result

    #if ENABLE_OVERLOADING
    data TableGetNRowsMethodInfo
    instance (signature ~ (m Int32), MonadIO m, IsTable a) => O.MethodInfo TableGetNRowsMethodInfo a signature where
        overloadedMethod _ = tableGetNRows

    #endif

    -- method Table::get_row_at_index
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "table", argType = TInterface (Name {namespace = "Atk", name = "Table"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a GObject instance that implements AtkTableInterface", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "index_", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #gint representing an index in @table", 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_table_get_row_at_index" atk_table_get_row_at_index ::
        Ptr Table ->                            -- table : TInterface (Name {namespace = "Atk", name = "Table"})
        Int32 ->                                -- index_ : TBasicType TInt
        IO Int32

    {-# DEPRECATED tableGetRowAtIndex ["since 2.12."] #-}
    {- |
    Gets a @/gint/@ representing the row at the specified /@index_@/.
    -}
    tableGetRowAtIndex ::
        (B.CallStack.HasCallStack, MonadIO m, IsTable a) =>
        a
        {- ^ /@table@/: a GObject instance that implements AtkTableInterface -}
        -> Int32
        {- ^ /@index_@/: a @/gint/@ representing an index in /@table@/ -}
        -> m Int32
        {- ^ __Returns:__ a gint representing the row at the specified index,
    or -1 if the table does not implement this method. -}
    tableGetRowAtIndex table index_ = liftIO $ do
        table' <- unsafeManagedPtrCastPtr table
        result <- atk_table_get_row_at_index table' index_
        touchManagedPtr table
        return result

    #if ENABLE_OVERLOADING
    data TableGetRowAtIndexMethodInfo
    instance (signature ~ (Int32 -> m Int32), MonadIO m, IsTable a) => O.MethodInfo TableGetRowAtIndexMethodInfo a signature where
        overloadedMethod _ = tableGetRowAtIndex

    #endif

    -- method Table::get_row_description
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "table", argType = TInterface (Name {namespace = "Atk", name = "Table"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a GObject instance that implements AtkTableIface", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "row", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #gint representing a row in @table", 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_table_get_row_description" atk_table_get_row_description ::
        Ptr Table ->                            -- table : TInterface (Name {namespace = "Atk", name = "Table"})
        Int32 ->                                -- row : TBasicType TInt
        IO CString

    {- |
    Gets the description text of the specified row in the table
    -}
    tableGetRowDescription ::
        (B.CallStack.HasCallStack, MonadIO m, IsTable a) =>
        a
        {- ^ /@table@/: a GObject instance that implements AtkTableIface -}
        -> Int32
        {- ^ /@row@/: a @/gint/@ representing a row in /@table@/ -}
        -> m (Maybe T.Text)
        {- ^ __Returns:__ a gchar* representing the row description, or
    'Nothing' if value does not implement this interface. -}
    tableGetRowDescription table row = liftIO $ do
        table' <- unsafeManagedPtrCastPtr table
        result <- atk_table_get_row_description table' row
        maybeResult <- convertIfNonNull result $ \result' -> do
            result'' <- cstringToText result'
            return result''
        touchManagedPtr table
        return maybeResult

    #if ENABLE_OVERLOADING
    data TableGetRowDescriptionMethodInfo
    instance (signature ~ (Int32 -> m (Maybe T.Text)), MonadIO m, IsTable a) => O.MethodInfo TableGetRowDescriptionMethodInfo a signature where
        overloadedMethod _ = tableGetRowDescription

    #endif

    -- method Table::get_row_extent_at
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "table", argType = TInterface (Name {namespace = "Atk", name = "Table"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a GObject instance that implements AtkTableIface", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "row", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #gint representing a row in @table", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "column", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #gint representing a column in @table", 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_table_get_row_extent_at" atk_table_get_row_extent_at ::
        Ptr Table ->                            -- table : TInterface (Name {namespace = "Atk", name = "Table"})
        Int32 ->                                -- row : TBasicType TInt
        Int32 ->                                -- column : TBasicType TInt
        IO Int32

    {- |
    Gets the number of rows occupied by the accessible object
    at a specified /@row@/ and /@column@/ in the /@table@/.
    -}
    tableGetRowExtentAt ::
        (B.CallStack.HasCallStack, MonadIO m, IsTable a) =>
        a
        {- ^ /@table@/: a GObject instance that implements AtkTableIface -}
        -> Int32
        {- ^ /@row@/: a @/gint/@ representing a row in /@table@/ -}
        -> Int32
        {- ^ /@column@/: a @/gint/@ representing a column in /@table@/ -}
        -> m Int32
        {- ^ __Returns:__ a gint representing the row extent at specified position, or 0
    if value does not implement this interface. -}
    tableGetRowExtentAt table row column = liftIO $ do
        table' <- unsafeManagedPtrCastPtr table
        result <- atk_table_get_row_extent_at table' row column
        touchManagedPtr table
        return result

    #if ENABLE_OVERLOADING
    data TableGetRowExtentAtMethodInfo
    instance (signature ~ (Int32 -> Int32 -> m Int32), MonadIO m, IsTable a) => O.MethodInfo TableGetRowExtentAtMethodInfo a signature where
        overloadedMethod _ = tableGetRowExtentAt

    #endif

    -- method Table::get_row_header
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "table", argType = TInterface (Name {namespace = "Atk", name = "Table"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a GObject instance that implements AtkTableIface", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "row", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #gint representing a row in the table", 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_table_get_row_header" atk_table_get_row_header ::
        Ptr Table ->                            -- table : TInterface (Name {namespace = "Atk", name = "Table"})
        Int32 ->                                -- row : TBasicType TInt
        IO (Ptr Atk.Object.Object)

    {- |
    Gets the row header of a specified row in an accessible table.
    -}
    tableGetRowHeader ::
        (B.CallStack.HasCallStack, MonadIO m, IsTable a) =>
        a
        {- ^ /@table@/: a GObject instance that implements AtkTableIface -}
        -> Int32
        {- ^ /@row@/: a @/gint/@ representing a row in the table -}
        -> m (Maybe Atk.Object.Object)
        {- ^ __Returns:__ a AtkObject* representing the
    specified row header, or 'Nothing' if value does not implement this
    interface. -}
    tableGetRowHeader table row = liftIO $ do
        table' <- unsafeManagedPtrCastPtr table
        result <- atk_table_get_row_header table' row
        maybeResult <- convertIfNonNull result $ \result' -> do
            result'' <- (newObject Atk.Object.Object) result'
            return result''
        touchManagedPtr table
        return maybeResult

    #if ENABLE_OVERLOADING
    data TableGetRowHeaderMethodInfo
    instance (signature ~ (Int32 -> m (Maybe Atk.Object.Object)), MonadIO m, IsTable a) => O.MethodInfo TableGetRowHeaderMethodInfo a signature where
        overloadedMethod _ = tableGetRowHeader

    #endif

    -- method Table::get_selected_columns
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "table", argType = TInterface (Name {namespace = "Atk", name = "Table"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a GObject instance that implements AtkTableIface", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "selected", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #gint** that is to contain the selected columns numbers", 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_table_get_selected_columns" atk_table_get_selected_columns ::
        Ptr Table ->                            -- table : TInterface (Name {namespace = "Atk", name = "Table"})
        Int32 ->                                -- selected : TBasicType TInt
        IO Int32

    {- |
    Gets the selected columns of the table by initializing **selected with
    the selected column numbers. This array should be freed by the caller.
    -}
    tableGetSelectedColumns ::
        (B.CallStack.HasCallStack, MonadIO m, IsTable a) =>
        a
        {- ^ /@table@/: a GObject instance that implements AtkTableIface -}
        -> Int32
        {- ^ /@selected@/: a @/gint/@** that is to contain the selected columns numbers -}
        -> m Int32
        {- ^ __Returns:__ a gint representing the number of selected columns,
    or @/0/@ if value does not implement this interface. -}
    tableGetSelectedColumns table selected = liftIO $ do
        table' <- unsafeManagedPtrCastPtr table
        result <- atk_table_get_selected_columns table' selected
        touchManagedPtr table
        return result

    #if ENABLE_OVERLOADING
    data TableGetSelectedColumnsMethodInfo
    instance (signature ~ (Int32 -> m Int32), MonadIO m, IsTable a) => O.MethodInfo TableGetSelectedColumnsMethodInfo a signature where
        overloadedMethod _ = tableGetSelectedColumns

    #endif

    -- method Table::get_selected_rows
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "table", argType = TInterface (Name {namespace = "Atk", name = "Table"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a GObject instance that implements AtkTableIface", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "selected", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #gint** that is to contain the selected row numbers", 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_table_get_selected_rows" atk_table_get_selected_rows ::
        Ptr Table ->                            -- table : TInterface (Name {namespace = "Atk", name = "Table"})
        Int32 ->                                -- selected : TBasicType TInt
        IO Int32

    {- |
    Gets the selected rows of the table by initializing **selected with
    the selected row numbers. This array should be freed by the caller.
    -}
    tableGetSelectedRows ::
        (B.CallStack.HasCallStack, MonadIO m, IsTable a) =>
        a
        {- ^ /@table@/: a GObject instance that implements AtkTableIface -}
        -> Int32
        {- ^ /@selected@/: a @/gint/@** that is to contain the selected row numbers -}
        -> m Int32
        {- ^ __Returns:__ a gint representing the number of selected rows,
    or zero if value does not implement this interface. -}
    tableGetSelectedRows table selected = liftIO $ do
        table' <- unsafeManagedPtrCastPtr table
        result <- atk_table_get_selected_rows table' selected
        touchManagedPtr table
        return result

    #if ENABLE_OVERLOADING
    data TableGetSelectedRowsMethodInfo
    instance (signature ~ (Int32 -> m Int32), MonadIO m, IsTable a) => O.MethodInfo TableGetSelectedRowsMethodInfo a signature where
        overloadedMethod _ = tableGetSelectedRows

    #endif

    -- method Table::get_summary
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "table", argType = TInterface (Name {namespace = "Atk", name = "Table"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a GObject instance that implements AtkTableIface", 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_table_get_summary" atk_table_get_summary ::
        Ptr Table ->                            -- table : TInterface (Name {namespace = "Atk", name = "Table"})
        IO (Ptr Atk.Object.Object)

    {- |
    Gets the summary description of the table.
    -}
    tableGetSummary ::
        (B.CallStack.HasCallStack, MonadIO m, IsTable a) =>
        a
        {- ^ /@table@/: a GObject instance that implements AtkTableIface -}
        -> m Atk.Object.Object
        {- ^ __Returns:__ a AtkObject* representing a summary description
    of the table, or zero if value does not implement this interface. -}
    tableGetSummary table = liftIO $ do
        table' <- unsafeManagedPtrCastPtr table
        result <- atk_table_get_summary table'
        checkUnexpectedReturnNULL "tableGetSummary" result
        result' <- (wrapObject Atk.Object.Object) result
        touchManagedPtr table
        return result'

    #if ENABLE_OVERLOADING
    data TableGetSummaryMethodInfo
    instance (signature ~ (m Atk.Object.Object), MonadIO m, IsTable a) => O.MethodInfo TableGetSummaryMethodInfo a signature where
        overloadedMethod _ = tableGetSummary

    #endif

    -- method Table::is_column_selected
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "table", argType = TInterface (Name {namespace = "Atk", name = "Table"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a GObject instance that implements AtkTableIface", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "column", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #gint representing a column in @table", 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_table_is_column_selected" atk_table_is_column_selected ::
        Ptr Table ->                            -- table : TInterface (Name {namespace = "Atk", name = "Table"})
        Int32 ->                                -- column : TBasicType TInt
        IO CInt

    {- |
    Gets a boolean value indicating whether the specified /@column@/
    is selected
    -}
    tableIsColumnSelected ::
        (B.CallStack.HasCallStack, MonadIO m, IsTable a) =>
        a
        {- ^ /@table@/: a GObject instance that implements AtkTableIface -}
        -> Int32
        {- ^ /@column@/: a @/gint/@ representing a column in /@table@/ -}
        -> m Bool
        {- ^ __Returns:__ a gboolean representing if the column is selected, or 0
    if value does not implement this interface. -}
    tableIsColumnSelected table column = liftIO $ do
        table' <- unsafeManagedPtrCastPtr table
        result <- atk_table_is_column_selected table' column
        let result' = (/= 0) result
        touchManagedPtr table
        return result'

    #if ENABLE_OVERLOADING
    data TableIsColumnSelectedMethodInfo
    instance (signature ~ (Int32 -> m Bool), MonadIO m, IsTable a) => O.MethodInfo TableIsColumnSelectedMethodInfo a signature where
        overloadedMethod _ = tableIsColumnSelected

    #endif

    -- method Table::is_row_selected
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "table", argType = TInterface (Name {namespace = "Atk", name = "Table"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a GObject instance that implements AtkTableIface", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "row", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #gint representing a row in @table", 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_table_is_row_selected" atk_table_is_row_selected ::
        Ptr Table ->                            -- table : TInterface (Name {namespace = "Atk", name = "Table"})
        Int32 ->                                -- row : TBasicType TInt
        IO CInt

    {- |
    Gets a boolean value indicating whether the specified /@row@/
    is selected
    -}
    tableIsRowSelected ::
        (B.CallStack.HasCallStack, MonadIO m, IsTable a) =>
        a
        {- ^ /@table@/: a GObject instance that implements AtkTableIface -}
        -> Int32
        {- ^ /@row@/: a @/gint/@ representing a row in /@table@/ -}
        -> m Bool
        {- ^ __Returns:__ a gboolean representing if the row is selected, or 0
    if value does not implement this interface. -}
    tableIsRowSelected table row = liftIO $ do
        table' <- unsafeManagedPtrCastPtr table
        result <- atk_table_is_row_selected table' row
        let result' = (/= 0) result
        touchManagedPtr table
        return result'

    #if ENABLE_OVERLOADING
    data TableIsRowSelectedMethodInfo
    instance (signature ~ (Int32 -> m Bool), MonadIO m, IsTable a) => O.MethodInfo TableIsRowSelectedMethodInfo a signature where
        overloadedMethod _ = tableIsRowSelected

    #endif

    -- method Table::is_selected
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "table", argType = TInterface (Name {namespace = "Atk", name = "Table"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a GObject instance that implements AtkTableIface", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "row", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #gint representing a row in @table", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "column", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #gint representing a column in @table", 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_table_is_selected" atk_table_is_selected ::
        Ptr Table ->                            -- table : TInterface (Name {namespace = "Atk", name = "Table"})
        Int32 ->                                -- row : TBasicType TInt
        Int32 ->                                -- column : TBasicType TInt
        IO CInt

    {- |
    Gets a boolean value indicating whether the accessible object
    at the specified /@row@/ and /@column@/ is selected
    -}
    tableIsSelected ::
        (B.CallStack.HasCallStack, MonadIO m, IsTable a) =>
        a
        {- ^ /@table@/: a GObject instance that implements AtkTableIface -}
        -> Int32
        {- ^ /@row@/: a @/gint/@ representing a row in /@table@/ -}
        -> Int32
        {- ^ /@column@/: a @/gint/@ representing a column in /@table@/ -}
        -> m Bool
        {- ^ __Returns:__ a gboolean representing if the cell is selected, or 0
    if value does not implement this interface. -}
    tableIsSelected table row column = liftIO $ do
        table' <- unsafeManagedPtrCastPtr table
        result <- atk_table_is_selected table' row column
        let result' = (/= 0) result
        touchManagedPtr table
        return result'

    #if ENABLE_OVERLOADING
    data TableIsSelectedMethodInfo
    instance (signature ~ (Int32 -> Int32 -> m Bool), MonadIO m, IsTable a) => O.MethodInfo TableIsSelectedMethodInfo a signature where
        overloadedMethod _ = tableIsSelected

    #endif

    -- method Table::ref_at
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "table", argType = TInterface (Name {namespace = "Atk", name = "Table"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a GObject instance that implements AtkTableIface", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "row", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #gint representing a row in @table", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "column", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #gint representing a column in @table", 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_table_ref_at" atk_table_ref_at ::
        Ptr Table ->                            -- table : TInterface (Name {namespace = "Atk", name = "Table"})
        Int32 ->                                -- row : TBasicType TInt
        Int32 ->                                -- column : TBasicType TInt
        IO (Ptr Atk.Object.Object)

    {- |
    Get a reference to the table cell at /@row@/, /@column@/. This cell
    should implement the interface 'GI.Atk.Interfaces.TableCell.TableCell'
    -}
    tableRefAt ::
        (B.CallStack.HasCallStack, MonadIO m, IsTable a) =>
        a
        {- ^ /@table@/: a GObject instance that implements AtkTableIface -}
        -> Int32
        {- ^ /@row@/: a @/gint/@ representing a row in /@table@/ -}
        -> Int32
        {- ^ /@column@/: a @/gint/@ representing a column in /@table@/ -}
        -> m Atk.Object.Object
        {- ^ __Returns:__ an 'GI.Atk.Objects.Object.Object' representing the referred
    to accessible -}
    tableRefAt table row column = liftIO $ do
        table' <- unsafeManagedPtrCastPtr table
        result <- atk_table_ref_at table' row column
        checkUnexpectedReturnNULL "tableRefAt" result
        result' <- (wrapObject Atk.Object.Object) result
        touchManagedPtr table
        return result'

    #if ENABLE_OVERLOADING
    data TableRefAtMethodInfo
    instance (signature ~ (Int32 -> Int32 -> m Atk.Object.Object), MonadIO m, IsTable a) => O.MethodInfo TableRefAtMethodInfo a signature where
        overloadedMethod _ = tableRefAt

    #endif

    -- method Table::remove_column_selection
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "table", argType = TInterface (Name {namespace = "Atk", name = "Table"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a GObject instance that implements AtkTableIface", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "column", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #gint representing a column in @table", 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_table_remove_column_selection" atk_table_remove_column_selection ::
        Ptr Table ->                            -- table : TInterface (Name {namespace = "Atk", name = "Table"})
        Int32 ->                                -- column : TBasicType TInt
        IO CInt

    {- |
    Adds the specified /@column@/ to the selection.
    -}
    tableRemoveColumnSelection ::
        (B.CallStack.HasCallStack, MonadIO m, IsTable a) =>
        a
        {- ^ /@table@/: a GObject instance that implements AtkTableIface -}
        -> Int32
        {- ^ /@column@/: a @/gint/@ representing a column in /@table@/ -}
        -> m Bool
        {- ^ __Returns:__ a gboolean representing if the column was successfully removed from
    the selection, or 0 if value does not implement this interface. -}
    tableRemoveColumnSelection table column = liftIO $ do
        table' <- unsafeManagedPtrCastPtr table
        result <- atk_table_remove_column_selection table' column
        let result' = (/= 0) result
        touchManagedPtr table
        return result'

    #if ENABLE_OVERLOADING
    data TableRemoveColumnSelectionMethodInfo
    instance (signature ~ (Int32 -> m Bool), MonadIO m, IsTable a) => O.MethodInfo TableRemoveColumnSelectionMethodInfo a signature where
        overloadedMethod _ = tableRemoveColumnSelection

    #endif

    -- method Table::remove_row_selection
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "table", argType = TInterface (Name {namespace = "Atk", name = "Table"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a GObject instance that implements AtkTableIface", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "row", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #gint representing a row in @table", 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_table_remove_row_selection" atk_table_remove_row_selection ::
        Ptr Table ->                            -- table : TInterface (Name {namespace = "Atk", name = "Table"})
        Int32 ->                                -- row : TBasicType TInt
        IO CInt

    {- |
    Removes the specified /@row@/ from the selection.
    -}
    tableRemoveRowSelection ::
        (B.CallStack.HasCallStack, MonadIO m, IsTable a) =>
        a
        {- ^ /@table@/: a GObject instance that implements AtkTableIface -}
        -> Int32
        {- ^ /@row@/: a @/gint/@ representing a row in /@table@/ -}
        -> m Bool
        {- ^ __Returns:__ a gboolean representing if the row was successfully removed from
    the selection, or 0 if value does not implement this interface. -}
    tableRemoveRowSelection table row = liftIO $ do
        table' <- unsafeManagedPtrCastPtr table
        result <- atk_table_remove_row_selection table' row
        let result' = (/= 0) result
        touchManagedPtr table
        return result'

    #if ENABLE_OVERLOADING
    data TableRemoveRowSelectionMethodInfo
    instance (signature ~ (Int32 -> m Bool), MonadIO m, IsTable a) => O.MethodInfo TableRemoveRowSelectionMethodInfo a signature where
        overloadedMethod _ = tableRemoveRowSelection

    #endif

    -- method Table::set_caption
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "table", argType = TInterface (Name {namespace = "Atk", name = "Table"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a GObject instance that implements AtkTableIface", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "caption", argType = TInterface (Name {namespace = "Atk", name = "Object"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #AtkObject representing the caption to set for @table", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "atk_table_set_caption" atk_table_set_caption ::
        Ptr Table ->                            -- table : TInterface (Name {namespace = "Atk", name = "Table"})
        Ptr Atk.Object.Object ->                -- caption : TInterface (Name {namespace = "Atk", name = "Object"})
        IO ()

    {- |
    Sets the caption for the table.
    -}
    tableSetCaption ::
        (B.CallStack.HasCallStack, MonadIO m, IsTable a, Atk.Object.IsObject b) =>
        a
        {- ^ /@table@/: a GObject instance that implements AtkTableIface -}
        -> b
        {- ^ /@caption@/: a 'GI.Atk.Objects.Object.Object' representing the caption to set for /@table@/ -}
        -> m ()
    tableSetCaption table caption = liftIO $ do
        table' <- unsafeManagedPtrCastPtr table
        caption' <- unsafeManagedPtrCastPtr caption
        atk_table_set_caption table' caption'
        touchManagedPtr table
        touchManagedPtr caption
        return ()

    #if ENABLE_OVERLOADING
    data TableSetCaptionMethodInfo
    instance (signature ~ (b -> m ()), MonadIO m, IsTable a, Atk.Object.IsObject b) => O.MethodInfo TableSetCaptionMethodInfo a signature where
        overloadedMethod _ = tableSetCaption

    #endif

    -- method Table::set_column_description
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "table", argType = TInterface (Name {namespace = "Atk", name = "Table"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a GObject instance that implements AtkTableIface", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "column", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #gint representing a column in @table", 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 #gchar representing the description text\nto set for the specified @column of the @table", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "atk_table_set_column_description" atk_table_set_column_description ::
        Ptr Table ->                            -- table : TInterface (Name {namespace = "Atk", name = "Table"})
        Int32 ->                                -- column : TBasicType TInt
        CString ->                              -- description : TBasicType TUTF8
        IO ()

    {- |
    Sets the description text for the specified /@column@/ of the /@table@/.
    -}
    tableSetColumnDescription ::
        (B.CallStack.HasCallStack, MonadIO m, IsTable a) =>
        a
        {- ^ /@table@/: a GObject instance that implements AtkTableIface -}
        -> Int32
        {- ^ /@column@/: a @/gint/@ representing a column in /@table@/ -}
        -> T.Text
        {- ^ /@description@/: a @/gchar/@ representing the description text
    to set for the specified /@column@/ of the /@table@/ -}
        -> m ()
    tableSetColumnDescription table column description = liftIO $ do
        table' <- unsafeManagedPtrCastPtr table
        description' <- textToCString description
        atk_table_set_column_description table' column description'
        touchManagedPtr table
        freeMem description'
        return ()

    #if ENABLE_OVERLOADING
    data TableSetColumnDescriptionMethodInfo
    instance (signature ~ (Int32 -> T.Text -> m ()), MonadIO m, IsTable a) => O.MethodInfo TableSetColumnDescriptionMethodInfo a signature where
        overloadedMethod _ = tableSetColumnDescription

    #endif

    -- method Table::set_column_header
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "table", argType = TInterface (Name {namespace = "Atk", name = "Table"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a GObject instance that implements AtkTableIface", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "column", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #gint representing a column in @table", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "header", argType = TInterface (Name {namespace = "Atk", name = "Object"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an #AtkTable", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "atk_table_set_column_header" atk_table_set_column_header ::
        Ptr Table ->                            -- table : TInterface (Name {namespace = "Atk", name = "Table"})
        Int32 ->                                -- column : TBasicType TInt
        Ptr Atk.Object.Object ->                -- header : TInterface (Name {namespace = "Atk", name = "Object"})
        IO ()

    {- |
    Sets the specified column header to /@header@/.
    -}
    tableSetColumnHeader ::
        (B.CallStack.HasCallStack, MonadIO m, IsTable a, Atk.Object.IsObject b) =>
        a
        {- ^ /@table@/: a GObject instance that implements AtkTableIface -}
        -> Int32
        {- ^ /@column@/: a @/gint/@ representing a column in /@table@/ -}
        -> b
        {- ^ /@header@/: an 'GI.Atk.Interfaces.Table.Table' -}
        -> m ()
    tableSetColumnHeader table column header = liftIO $ do
        table' <- unsafeManagedPtrCastPtr table
        header' <- unsafeManagedPtrCastPtr header
        atk_table_set_column_header table' column header'
        touchManagedPtr table
        touchManagedPtr header
        return ()

    #if ENABLE_OVERLOADING
    data TableSetColumnHeaderMethodInfo
    instance (signature ~ (Int32 -> b -> m ()), MonadIO m, IsTable a, Atk.Object.IsObject b) => O.MethodInfo TableSetColumnHeaderMethodInfo a signature where
        overloadedMethod _ = tableSetColumnHeader

    #endif

    -- method Table::set_row_description
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "table", argType = TInterface (Name {namespace = "Atk", name = "Table"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a GObject instance that implements AtkTableIface", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "row", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #gint representing a row in @table", 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 #gchar representing the description text\nto set for the specified @row of @table", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "atk_table_set_row_description" atk_table_set_row_description ::
        Ptr Table ->                            -- table : TInterface (Name {namespace = "Atk", name = "Table"})
        Int32 ->                                -- row : TBasicType TInt
        CString ->                              -- description : TBasicType TUTF8
        IO ()

    {- |
    Sets the description text for the specified /@row@/ of /@table@/.
    -}
    tableSetRowDescription ::
        (B.CallStack.HasCallStack, MonadIO m, IsTable a) =>
        a
        {- ^ /@table@/: a GObject instance that implements AtkTableIface -}
        -> Int32
        {- ^ /@row@/: a @/gint/@ representing a row in /@table@/ -}
        -> T.Text
        {- ^ /@description@/: a @/gchar/@ representing the description text
    to set for the specified /@row@/ of /@table@/ -}
        -> m ()
    tableSetRowDescription table row description = liftIO $ do
        table' <- unsafeManagedPtrCastPtr table
        description' <- textToCString description
        atk_table_set_row_description table' row description'
        touchManagedPtr table
        freeMem description'
        return ()

    #if ENABLE_OVERLOADING
    data TableSetRowDescriptionMethodInfo
    instance (signature ~ (Int32 -> T.Text -> m ()), MonadIO m, IsTable a) => O.MethodInfo TableSetRowDescriptionMethodInfo a signature where
        overloadedMethod _ = tableSetRowDescription

    #endif

    -- method Table::set_row_header
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "table", argType = TInterface (Name {namespace = "Atk", name = "Table"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a GObject instance that implements AtkTableIface", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "row", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #gint representing a row in @table", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "header", argType = TInterface (Name {namespace = "Atk", name = "Object"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an #AtkTable", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "atk_table_set_row_header" atk_table_set_row_header ::
        Ptr Table ->                            -- table : TInterface (Name {namespace = "Atk", name = "Table"})
        Int32 ->                                -- row : TBasicType TInt
        Ptr Atk.Object.Object ->                -- header : TInterface (Name {namespace = "Atk", name = "Object"})
        IO ()

    {- |
    Sets the specified row header to /@header@/.
    -}
    tableSetRowHeader ::
        (B.CallStack.HasCallStack, MonadIO m, IsTable a, Atk.Object.IsObject b) =>
        a
        {- ^ /@table@/: a GObject instance that implements AtkTableIface -}
        -> Int32
        {- ^ /@row@/: a @/gint/@ representing a row in /@table@/ -}
        -> b
        {- ^ /@header@/: an 'GI.Atk.Interfaces.Table.Table' -}
        -> m ()
    tableSetRowHeader table row header = liftIO $ do
        table' <- unsafeManagedPtrCastPtr table
        header' <- unsafeManagedPtrCastPtr header
        atk_table_set_row_header table' row header'
        touchManagedPtr table
        touchManagedPtr header
        return ()

    #if ENABLE_OVERLOADING
    data TableSetRowHeaderMethodInfo
    instance (signature ~ (Int32 -> b -> m ()), MonadIO m, IsTable a, Atk.Object.IsObject b) => O.MethodInfo TableSetRowHeaderMethodInfo a signature where
        overloadedMethod _ = tableSetRowHeader

    #endif

    -- method Table::set_summary
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "table", argType = TInterface (Name {namespace = "Atk", name = "Table"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a GObject instance that implements AtkTableIface", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "accessible", argType = TInterface (Name {namespace = "Atk", name = "Object"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an #AtkObject representing the summary description\nto set for @table", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Nothing
    -- throws : False
    -- Skip return : False

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

    {- |
    Sets the summary description of the table.
    -}
    tableSetSummary ::
        (B.CallStack.HasCallStack, MonadIO m, IsTable a, Atk.Object.IsObject b) =>
        a
        {- ^ /@table@/: a GObject instance that implements AtkTableIface -}
        -> b
        {- ^ /@accessible@/: an 'GI.Atk.Objects.Object.Object' representing the summary description
    to set for /@table@/ -}
        -> m ()
    tableSetSummary table accessible = liftIO $ do
        table' <- unsafeManagedPtrCastPtr table
        accessible' <- unsafeManagedPtrCastPtr accessible
        atk_table_set_summary table' accessible'
        touchManagedPtr table
        touchManagedPtr accessible
        return ()

    #if ENABLE_OVERLOADING
    data TableSetSummaryMethodInfo
    instance (signature ~ (b -> m ()), MonadIO m, IsTable a, Atk.Object.IsObject b) => O.MethodInfo TableSetSummaryMethodInfo a signature where
        overloadedMethod _ = tableSetSummary

    #endif