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

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

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

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

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

module GI.Atk.Interfaces.Table
    ( 

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


 -- * Methods
-- ** addColumnSelection #method:addColumnSelection#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    TableAddColumnSelectionMethodInfo       ,
#endif
    tableAddColumnSelection                 ,


-- ** addRowSelection #method:addRowSelection#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    TableAddRowSelectionMethodInfo          ,
#endif
    tableAddRowSelection                    ,


-- ** getCaption #method:getCaption#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    TableGetCaptionMethodInfo               ,
#endif
    tableGetCaption                         ,


-- ** getColumnAtIndex #method:getColumnAtIndex#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    TableGetColumnAtIndexMethodInfo         ,
#endif
    tableGetColumnAtIndex                   ,


-- ** getColumnDescription #method:getColumnDescription#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    TableGetColumnDescriptionMethodInfo     ,
#endif
    tableGetColumnDescription               ,


-- ** getColumnExtentAt #method:getColumnExtentAt#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    TableGetColumnExtentAtMethodInfo        ,
#endif
    tableGetColumnExtentAt                  ,


-- ** getColumnHeader #method:getColumnHeader#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    TableGetColumnHeaderMethodInfo          ,
#endif
    tableGetColumnHeader                    ,


-- ** getIndexAt #method:getIndexAt#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    TableGetIndexAtMethodInfo               ,
#endif
    tableGetIndexAt                         ,


-- ** getNColumns #method:getNColumns#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    TableGetNColumnsMethodInfo              ,
#endif
    tableGetNColumns                        ,


-- ** getNRows #method:getNRows#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    TableGetNRowsMethodInfo                 ,
#endif
    tableGetNRows                           ,


-- ** getRowAtIndex #method:getRowAtIndex#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    TableGetRowAtIndexMethodInfo            ,
#endif
    tableGetRowAtIndex                      ,


-- ** getRowDescription #method:getRowDescription#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    TableGetRowDescriptionMethodInfo        ,
#endif
    tableGetRowDescription                  ,


-- ** getRowExtentAt #method:getRowExtentAt#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    TableGetRowExtentAtMethodInfo           ,
#endif
    tableGetRowExtentAt                     ,


-- ** getRowHeader #method:getRowHeader#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    TableGetRowHeaderMethodInfo             ,
#endif
    tableGetRowHeader                       ,


-- ** getSelectedColumns #method:getSelectedColumns#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    TableGetSelectedColumnsMethodInfo       ,
#endif
    tableGetSelectedColumns                 ,


-- ** getSelectedRows #method:getSelectedRows#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    TableGetSelectedRowsMethodInfo          ,
#endif
    tableGetSelectedRows                    ,


-- ** getSummary #method:getSummary#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    TableGetSummaryMethodInfo               ,
#endif
    tableGetSummary                         ,


-- ** isColumnSelected #method:isColumnSelected#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    TableIsColumnSelectedMethodInfo         ,
#endif
    tableIsColumnSelected                   ,


-- ** isRowSelected #method:isRowSelected#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    TableIsRowSelectedMethodInfo            ,
#endif
    tableIsRowSelected                      ,


-- ** isSelected #method:isSelected#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    TableIsSelectedMethodInfo               ,
#endif
    tableIsSelected                         ,


-- ** refAt #method:refAt#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    TableRefAtMethodInfo                    ,
#endif
    tableRefAt                              ,


-- ** removeColumnSelection #method:removeColumnSelection#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    TableRemoveColumnSelectionMethodInfo    ,
#endif
    tableRemoveColumnSelection              ,


-- ** removeRowSelection #method:removeRowSelection#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    TableRemoveRowSelectionMethodInfo       ,
#endif
    tableRemoveRowSelection                 ,


-- ** setCaption #method:setCaption#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    TableSetCaptionMethodInfo               ,
#endif
    tableSetCaption                         ,


-- ** setColumnDescription #method:setColumnDescription#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    TableSetColumnDescriptionMethodInfo     ,
#endif
    tableSetColumnDescription               ,


-- ** setColumnHeader #method:setColumnHeader#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    TableSetColumnHeaderMethodInfo          ,
#endif
    tableSetColumnHeader                    ,


-- ** setRowDescription #method:setRowDescription#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    TableSetRowDescriptionMethodInfo        ,
#endif
    tableSetRowDescription                  ,


-- ** setRowHeader #method:setRowHeader#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    TableSetRowHeaderMethodInfo             ,
#endif
    tableSetRowHeader                       ,


-- ** setSummary #method:setSummary#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    TableSetSummaryMethodInfo               ,
#endif
    tableSetSummary                         ,




 -- * Signals
-- ** columnDeleted #signal:columnDeleted#
    C_TableColumnDeletedCallback            ,
    TableColumnDeletedCallback              ,
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    TableColumnDeletedSignalInfo            ,
#endif
    afterTableColumnDeleted                 ,
    genClosure_TableColumnDeleted           ,
    mk_TableColumnDeletedCallback           ,
    noTableColumnDeletedCallback            ,
    onTableColumnDeleted                    ,
    wrap_TableColumnDeletedCallback         ,


-- ** columnInserted #signal:columnInserted#
    C_TableColumnInsertedCallback           ,
    TableColumnInsertedCallback             ,
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    TableColumnInsertedSignalInfo           ,
#endif
    afterTableColumnInserted                ,
    genClosure_TableColumnInserted          ,
    mk_TableColumnInsertedCallback          ,
    noTableColumnInsertedCallback           ,
    onTableColumnInserted                   ,
    wrap_TableColumnInsertedCallback        ,


-- ** columnReordered #signal:columnReordered#
    C_TableColumnReorderedCallback          ,
    TableColumnReorderedCallback            ,
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    TableColumnReorderedSignalInfo          ,
#endif
    afterTableColumnReordered               ,
    genClosure_TableColumnReordered         ,
    mk_TableColumnReorderedCallback         ,
    noTableColumnReorderedCallback          ,
    onTableColumnReordered                  ,
    wrap_TableColumnReorderedCallback       ,


-- ** modelChanged #signal:modelChanged#
    C_TableModelChangedCallback             ,
    TableModelChangedCallback               ,
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    TableModelChangedSignalInfo             ,
#endif
    afterTableModelChanged                  ,
    genClosure_TableModelChanged            ,
    mk_TableModelChangedCallback            ,
    noTableModelChangedCallback             ,
    onTableModelChanged                     ,
    wrap_TableModelChangedCallback          ,


-- ** rowDeleted #signal:rowDeleted#
    C_TableRowDeletedCallback               ,
    TableRowDeletedCallback                 ,
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    TableRowDeletedSignalInfo               ,
#endif
    afterTableRowDeleted                    ,
    genClosure_TableRowDeleted              ,
    mk_TableRowDeletedCallback              ,
    noTableRowDeletedCallback               ,
    onTableRowDeleted                       ,
    wrap_TableRowDeletedCallback            ,


-- ** rowInserted #signal:rowInserted#
    C_TableRowInsertedCallback              ,
    TableRowInsertedCallback                ,
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    TableRowInsertedSignalInfo              ,
#endif
    afterTableRowInserted                   ,
    genClosure_TableRowInserted             ,
    mk_TableRowInsertedCallback             ,
    noTableRowInsertedCallback              ,
    onTableRowInserted                      ,
    wrap_TableRowInsertedCallback           ,


-- ** rowReordered #signal:rowReordered#
    C_TableRowReorderedCallback             ,
    TableRowReorderedCallback               ,
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    TableRowReorderedSignalInfo             ,
#endif
    afterTableRowReordered                  ,
    genClosure_TableRowReordered            ,
    mk_TableRowReorderedCallback            ,
    noTableRowReorderedCallback             ,
    onTableRowReordered                     ,
    wrap_TableRowReorderedCallback          ,




    ) where

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

import qualified Data.GI.Base.Attributes as GI.Attributes
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP

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

-- interface Table 
newtype Table = Table (ManagedPtr Table)
noTable :: Maybe Table
noTable = Nothing

-- signal Table::column-deleted
type TableColumnDeletedCallback =
    Int32 ->
    Int32 ->
    IO ()

noTableColumnDeletedCallback :: Maybe TableColumnDeletedCallback
noTableColumnDeletedCallback = Nothing

type C_TableColumnDeletedCallback =
    Ptr () ->                               -- object
    Int32 ->
    Int32 ->
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mk_TableColumnDeletedCallback :: C_TableColumnDeletedCallback -> IO (FunPtr C_TableColumnDeletedCallback)

genClosure_TableColumnDeleted :: TableColumnDeletedCallback -> IO Closure
genClosure_TableColumnDeleted cb = do
    let cb' = wrap_TableColumnDeletedCallback cb
    mk_TableColumnDeletedCallback cb' >>= newCClosure


wrap_TableColumnDeletedCallback ::
    TableColumnDeletedCallback ->
    Ptr () ->
    Int32 ->
    Int32 ->
    Ptr () ->
    IO ()
wrap_TableColumnDeletedCallback _cb _ arg1 arg2 _ = do
    _cb  arg1 arg2


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

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
type TableColumnInsertedCallback =
    Int32 ->
    Int32 ->
    IO ()

noTableColumnInsertedCallback :: Maybe TableColumnInsertedCallback
noTableColumnInsertedCallback = Nothing

type C_TableColumnInsertedCallback =
    Ptr () ->                               -- object
    Int32 ->
    Int32 ->
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mk_TableColumnInsertedCallback :: C_TableColumnInsertedCallback -> IO (FunPtr C_TableColumnInsertedCallback)

genClosure_TableColumnInserted :: TableColumnInsertedCallback -> IO Closure
genClosure_TableColumnInserted cb = do
    let cb' = wrap_TableColumnInsertedCallback cb
    mk_TableColumnInsertedCallback cb' >>= newCClosure


wrap_TableColumnInsertedCallback ::
    TableColumnInsertedCallback ->
    Ptr () ->
    Int32 ->
    Int32 ->
    Ptr () ->
    IO ()
wrap_TableColumnInsertedCallback _cb _ arg1 arg2 _ = do
    _cb  arg1 arg2


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

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
type TableColumnReorderedCallback =
    IO ()

noTableColumnReorderedCallback :: Maybe TableColumnReorderedCallback
noTableColumnReorderedCallback = Nothing

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

foreign import ccall "wrapper"
    mk_TableColumnReorderedCallback :: C_TableColumnReorderedCallback -> IO (FunPtr C_TableColumnReorderedCallback)

genClosure_TableColumnReordered :: TableColumnReorderedCallback -> IO Closure
genClosure_TableColumnReordered cb = do
    let cb' = wrap_TableColumnReorderedCallback cb
    mk_TableColumnReorderedCallback cb' >>= newCClosure


wrap_TableColumnReorderedCallback ::
    TableColumnReorderedCallback ->
    Ptr () ->
    Ptr () ->
    IO ()
wrap_TableColumnReorderedCallback _cb _ _ = do
    _cb 


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

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
type TableModelChangedCallback =
    IO ()

noTableModelChangedCallback :: Maybe TableModelChangedCallback
noTableModelChangedCallback = Nothing

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

foreign import ccall "wrapper"
    mk_TableModelChangedCallback :: C_TableModelChangedCallback -> IO (FunPtr C_TableModelChangedCallback)

genClosure_TableModelChanged :: TableModelChangedCallback -> IO Closure
genClosure_TableModelChanged cb = do
    let cb' = wrap_TableModelChangedCallback cb
    mk_TableModelChangedCallback cb' >>= newCClosure


wrap_TableModelChangedCallback ::
    TableModelChangedCallback ->
    Ptr () ->
    Ptr () ->
    IO ()
wrap_TableModelChangedCallback _cb _ _ = do
    _cb 


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

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
type TableRowDeletedCallback =
    Int32 ->
    Int32 ->
    IO ()

noTableRowDeletedCallback :: Maybe TableRowDeletedCallback
noTableRowDeletedCallback = Nothing

type C_TableRowDeletedCallback =
    Ptr () ->                               -- object
    Int32 ->
    Int32 ->
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mk_TableRowDeletedCallback :: C_TableRowDeletedCallback -> IO (FunPtr C_TableRowDeletedCallback)

genClosure_TableRowDeleted :: TableRowDeletedCallback -> IO Closure
genClosure_TableRowDeleted cb = do
    let cb' = wrap_TableRowDeletedCallback cb
    mk_TableRowDeletedCallback cb' >>= newCClosure


wrap_TableRowDeletedCallback ::
    TableRowDeletedCallback ->
    Ptr () ->
    Int32 ->
    Int32 ->
    Ptr () ->
    IO ()
wrap_TableRowDeletedCallback _cb _ arg1 arg2 _ = do
    _cb  arg1 arg2


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

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
type TableRowInsertedCallback =
    Int32 ->
    Int32 ->
    IO ()

noTableRowInsertedCallback :: Maybe TableRowInsertedCallback
noTableRowInsertedCallback = Nothing

type C_TableRowInsertedCallback =
    Ptr () ->                               -- object
    Int32 ->
    Int32 ->
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mk_TableRowInsertedCallback :: C_TableRowInsertedCallback -> IO (FunPtr C_TableRowInsertedCallback)

genClosure_TableRowInserted :: TableRowInsertedCallback -> IO Closure
genClosure_TableRowInserted cb = do
    let cb' = wrap_TableRowInsertedCallback cb
    mk_TableRowInsertedCallback cb' >>= newCClosure


wrap_TableRowInsertedCallback ::
    TableRowInsertedCallback ->
    Ptr () ->
    Int32 ->
    Int32 ->
    Ptr () ->
    IO ()
wrap_TableRowInsertedCallback _cb _ arg1 arg2 _ = do
    _cb  arg1 arg2


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

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
type TableRowReorderedCallback =
    IO ()

noTableRowReorderedCallback :: Maybe TableRowReorderedCallback
noTableRowReorderedCallback = Nothing

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

foreign import ccall "wrapper"
    mk_TableRowReorderedCallback :: C_TableRowReorderedCallback -> IO (FunPtr C_TableRowReorderedCallback)

genClosure_TableRowReordered :: TableRowReorderedCallback -> IO Closure
genClosure_TableRowReordered cb = do
    let cb' = wrap_TableRowReorderedCallback cb
    mk_TableRowReorderedCallback cb' >>= newCClosure


wrap_TableRowReorderedCallback ::
    TableRowReorderedCallback ->
    Ptr () ->
    Ptr () ->
    IO ()
wrap_TableRowReorderedCallback _cb _ _ = do
    _cb 


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

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 defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
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
    

class GObject o => IsTable o
#if MIN_VERSION_base(4,9,0)
instance {-# OVERLAPPABLE #-} (GObject a, O.UnknownAncestorError Table a) =>
    IsTable a
#endif
instance IsTable Table
instance GObject.Object.IsObject Table

toTable :: (MonadIO m, IsTable o) => o -> m Table
toTable = liftIO . unsafeCastTo Table

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

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
#endif

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
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 "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 "replaceData" o = GObject.Object.ObjectReplaceDataMethodInfo
    ResolveTableMethod "replaceQdata" o = GObject.Object.ObjectReplaceQdataMethodInfo
    ResolveTableMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveTableMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveTableMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveTableMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveTableMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
    ResolveTableMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveTableMethod "getCaption" o = TableGetCaptionMethodInfo
    ResolveTableMethod "getColumnAtIndex" o = TableGetColumnAtIndexMethodInfo
    ResolveTableMethod "getColumnDescription" o = TableGetColumnDescriptionMethodInfo
    ResolveTableMethod "getColumnExtentAt" o = TableGetColumnExtentAtMethodInfo
    ResolveTableMethod "getColumnHeader" o = TableGetColumnHeaderMethodInfo
    ResolveTableMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveTableMethod "getIndexAt" o = TableGetIndexAtMethodInfo
    ResolveTableMethod "getNColumns" o = TableGetNColumnsMethodInfo
    ResolveTableMethod "getNRows" o = TableGetNRowsMethodInfo
    ResolveTableMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveTableMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveTableMethod "getRowAtIndex" o = TableGetRowAtIndexMethodInfo
    ResolveTableMethod "getRowDescription" o = TableGetRowDescriptionMethodInfo
    ResolveTableMethod "getRowExtentAt" o = TableGetRowExtentAtMethodInfo
    ResolveTableMethod "getRowHeader" o = TableGetRowHeaderMethodInfo
    ResolveTableMethod "getSelectedColumns" o = TableGetSelectedColumnsMethodInfo
    ResolveTableMethod "getSelectedRows" o = TableGetSelectedRowsMethodInfo
    ResolveTableMethod "getSummary" o = TableGetSummaryMethodInfo
    ResolveTableMethod "setCaption" o = TableSetCaptionMethodInfo
    ResolveTableMethod "setColumnDescription" o = TableSetColumnDescriptionMethodInfo
    ResolveTableMethod "setColumnHeader" o = TableSetColumnHeaderMethodInfo
    ResolveTableMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveTableMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveTableMethod "setRowDescription" o = TableSetRowDescriptionMethodInfo
    ResolveTableMethod "setRowHeader" o = TableSetRowHeaderMethodInfo
    ResolveTableMethod "setSummary" o = TableSetSummaryMethodInfo
    ResolveTableMethod l o = O.MethodResolutionFailed l o

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

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

#endif

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

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

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

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
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 defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
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 defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
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 defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
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 defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
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 defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
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 defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
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 defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
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 defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
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 defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
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 defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
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 defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
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 defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
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 defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
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 defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
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 defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
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 defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
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 defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
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 defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
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 defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
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 defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
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 defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
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 defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
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 defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
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 defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
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 defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
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 defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
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 defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
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 defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data TableSetSummaryMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsTable a, Atk.Object.IsObject b) => O.MethodInfo TableSetSummaryMethodInfo a signature where
    overloadedMethod _ = tableSetSummary

#endif