gi-atk-2.0.17: GI/Atk/Interfaces/Table.hs

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

'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 (MIN_VERSION_haskell_gi_overloading(1,0,0) \
       && !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.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL

import {-# SOURCE #-} qualified GI.Atk.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 `GClosure`.
genClosure_TableColumnDeleted :: MonadIO m => TableColumnDeletedCallback -> m (GClosure C_TableColumnDeletedCallback)
genClosure_TableColumnDeleted cb = liftIO $ do
    let cb' = wrap_TableColumnDeletedCallback cb
    mk_TableColumnDeletedCallback cb' >>= B.GClosure.newGClosure


-- | 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 `GClosure`.
genClosure_TableColumnInserted :: MonadIO m => TableColumnInsertedCallback -> m (GClosure C_TableColumnInsertedCallback)
genClosure_TableColumnInserted cb = liftIO $ do
    let cb' = wrap_TableColumnInsertedCallback cb
    mk_TableColumnInsertedCallback cb' >>= B.GClosure.newGClosure


-- | 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 `GClosure`.
genClosure_TableColumnReordered :: MonadIO m => TableColumnReorderedCallback -> m (GClosure C_TableColumnReorderedCallback)
genClosure_TableColumnReordered cb = liftIO $ do
    let cb' = wrap_TableColumnReorderedCallback cb
    mk_TableColumnReorderedCallback cb' >>= B.GClosure.newGClosure


-- | 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 `GClosure`.
genClosure_TableModelChanged :: MonadIO m => TableModelChangedCallback -> m (GClosure C_TableModelChangedCallback)
genClosure_TableModelChanged cb = liftIO $ do
    let cb' = wrap_TableModelChangedCallback cb
    mk_TableModelChangedCallback cb' >>= B.GClosure.newGClosure


-- | 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 `GClosure`.
genClosure_TableRowDeleted :: MonadIO m => TableRowDeletedCallback -> m (GClosure C_TableRowDeletedCallback)
genClosure_TableRowDeleted cb = liftIO $ do
    let cb' = wrap_TableRowDeletedCallback cb
    mk_TableRowDeletedCallback cb' >>= B.GClosure.newGClosure


-- | 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 `GClosure`.
genClosure_TableRowInserted :: MonadIO m => TableRowInsertedCallback -> m (GClosure C_TableRowInsertedCallback)
genClosure_TableRowInserted cb = liftIO $ do
    let cb' = wrap_TableRowInsertedCallback cb
    mk_TableRowInsertedCallback cb' >>= B.GClosure.newGClosure


-- | 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 `GClosure`.
genClosure_TableRowReordered :: MonadIO m => TableRowReorderedCallback -> m (GClosure C_TableRowReorderedCallback)
genClosure_TableRowReordered cb = liftIO $ do
    let cb' = wrap_TableRowReorderedCallback cb
    mk_TableRowReorderedCallback cb' >>= B.GClosure.newGClosure


-- | 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, O.IsDescendantOf Table o) => IsTable o
instance (GObject o, O.IsDescendantOf Table o) => IsTable o

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

-- | 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) => OL.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

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