{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- t'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
-- t'GI.Atk.Interfaces.Table.Table' are typically referred to as \"cells\". Those cells should
-- implement the interface t'GI.Atk.Interfaces.TableCell.TableCell', but @/Atk/@ doesn\'t require
-- them to be direct children of the current t'GI.Atk.Interfaces.Table.Table'. They can be
-- grand-children, grand-grand-children etc. t'GI.Atk.Interfaces.Table.Table' provides the
-- API needed to get a individual cell based on the row and column
-- numbers.
-- 
-- Children of t'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, t'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 (t'GI.Atk.Interfaces.Text.Text', t'GI.Atk.Interfaces.Image.Image', etc.) as
-- appropriate.  t'GI.Atk.Interfaces.Table.Table' summaries may themselves be (simplified)
-- @/AtkTables/@, etc.
-- 
-- Note for implementors: in the past, t'GI.Atk.Interfaces.Table.Table' required that all the
-- cells should be direct children of t'GI.Atk.Interfaces.Table.Table', and provided some
-- index based methods to request the cells. The practice showed that
-- that forcing made t'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.

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

module GI.Atk.Interfaces.Table
    ( 

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


 -- * Methods
-- ** Overloaded methods #method:Overloaded methods#

#if defined(ENABLE_OVERLOADING)
    ResolveTableMethod                      ,
#endif


-- ** addColumnSelection #method:addColumnSelection#

#if defined(ENABLE_OVERLOADING)
    TableAddColumnSelectionMethodInfo       ,
#endif
    tableAddColumnSelection                 ,


-- ** addRowSelection #method:addRowSelection#

#if defined(ENABLE_OVERLOADING)
    TableAddRowSelectionMethodInfo          ,
#endif
    tableAddRowSelection                    ,


-- ** getCaption #method:getCaption#

#if defined(ENABLE_OVERLOADING)
    TableGetCaptionMethodInfo               ,
#endif
    tableGetCaption                         ,


-- ** getColumnAtIndex #method:getColumnAtIndex#

#if defined(ENABLE_OVERLOADING)
    TableGetColumnAtIndexMethodInfo         ,
#endif
    tableGetColumnAtIndex                   ,


-- ** getColumnDescription #method:getColumnDescription#

#if defined(ENABLE_OVERLOADING)
    TableGetColumnDescriptionMethodInfo     ,
#endif
    tableGetColumnDescription               ,


-- ** getColumnExtentAt #method:getColumnExtentAt#

#if defined(ENABLE_OVERLOADING)
    TableGetColumnExtentAtMethodInfo        ,
#endif
    tableGetColumnExtentAt                  ,


-- ** getColumnHeader #method:getColumnHeader#

#if defined(ENABLE_OVERLOADING)
    TableGetColumnHeaderMethodInfo          ,
#endif
    tableGetColumnHeader                    ,


-- ** getIndexAt #method:getIndexAt#

#if defined(ENABLE_OVERLOADING)
    TableGetIndexAtMethodInfo               ,
#endif
    tableGetIndexAt                         ,


-- ** getNColumns #method:getNColumns#

#if defined(ENABLE_OVERLOADING)
    TableGetNColumnsMethodInfo              ,
#endif
    tableGetNColumns                        ,


-- ** getNRows #method:getNRows#

#if defined(ENABLE_OVERLOADING)
    TableGetNRowsMethodInfo                 ,
#endif
    tableGetNRows                           ,


-- ** getRowAtIndex #method:getRowAtIndex#

#if defined(ENABLE_OVERLOADING)
    TableGetRowAtIndexMethodInfo            ,
#endif
    tableGetRowAtIndex                      ,


-- ** getRowDescription #method:getRowDescription#

#if defined(ENABLE_OVERLOADING)
    TableGetRowDescriptionMethodInfo        ,
#endif
    tableGetRowDescription                  ,


-- ** getRowExtentAt #method:getRowExtentAt#

#if defined(ENABLE_OVERLOADING)
    TableGetRowExtentAtMethodInfo           ,
#endif
    tableGetRowExtentAt                     ,


-- ** getRowHeader #method:getRowHeader#

#if defined(ENABLE_OVERLOADING)
    TableGetRowHeaderMethodInfo             ,
#endif
    tableGetRowHeader                       ,


-- ** getSelectedColumns #method:getSelectedColumns#

#if defined(ENABLE_OVERLOADING)
    TableGetSelectedColumnsMethodInfo       ,
#endif
    tableGetSelectedColumns                 ,


-- ** getSelectedRows #method:getSelectedRows#

#if defined(ENABLE_OVERLOADING)
    TableGetSelectedRowsMethodInfo          ,
#endif
    tableGetSelectedRows                    ,


-- ** getSummary #method:getSummary#

#if defined(ENABLE_OVERLOADING)
    TableGetSummaryMethodInfo               ,
#endif
    tableGetSummary                         ,


-- ** isColumnSelected #method:isColumnSelected#

#if defined(ENABLE_OVERLOADING)
    TableIsColumnSelectedMethodInfo         ,
#endif
    tableIsColumnSelected                   ,


-- ** isRowSelected #method:isRowSelected#

#if defined(ENABLE_OVERLOADING)
    TableIsRowSelectedMethodInfo            ,
#endif
    tableIsRowSelected                      ,


-- ** isSelected #method:isSelected#

#if defined(ENABLE_OVERLOADING)
    TableIsSelectedMethodInfo               ,
#endif
    tableIsSelected                         ,


-- ** refAt #method:refAt#

#if defined(ENABLE_OVERLOADING)
    TableRefAtMethodInfo                    ,
#endif
    tableRefAt                              ,


-- ** removeColumnSelection #method:removeColumnSelection#

#if defined(ENABLE_OVERLOADING)
    TableRemoveColumnSelectionMethodInfo    ,
#endif
    tableRemoveColumnSelection              ,


-- ** removeRowSelection #method:removeRowSelection#

#if defined(ENABLE_OVERLOADING)
    TableRemoveRowSelectionMethodInfo       ,
#endif
    tableRemoveRowSelection                 ,


-- ** setCaption #method:setCaption#

#if defined(ENABLE_OVERLOADING)
    TableSetCaptionMethodInfo               ,
#endif
    tableSetCaption                         ,


-- ** setColumnDescription #method:setColumnDescription#

#if defined(ENABLE_OVERLOADING)
    TableSetColumnDescriptionMethodInfo     ,
#endif
    tableSetColumnDescription               ,


-- ** setColumnHeader #method:setColumnHeader#

#if defined(ENABLE_OVERLOADING)
    TableSetColumnHeaderMethodInfo          ,
#endif
    tableSetColumnHeader                    ,


-- ** setRowDescription #method:setRowDescription#

#if defined(ENABLE_OVERLOADING)
    TableSetRowDescriptionMethodInfo        ,
#endif
    tableSetRowDescription                  ,


-- ** setRowHeader #method:setRowHeader#

#if defined(ENABLE_OVERLOADING)
    TableSetRowHeaderMethodInfo             ,
#endif
    tableSetRowHeader                       ,


-- ** setSummary #method:setSummary#

#if defined(ENABLE_OVERLOADING)
    TableSetSummaryMethodInfo               ,
#endif
    tableSetSummary                         ,




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

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


-- ** columnInserted #signal:columnInserted#

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


-- ** columnReordered #signal:columnReordered#

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


-- ** modelChanged #signal:modelChanged#

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


-- ** rowDeleted #signal:rowDeleted#

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


-- ** rowInserted #signal:rowInserted#

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


-- ** rowReordered #signal:rowReordered#

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




    ) where

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

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

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

-- interface Table 
-- | Memory-managed wrapper type.
newtype Table = Table (ManagedPtr Table)
    deriving (Table -> Table -> Bool
(Table -> Table -> Bool) -> (Table -> Table -> Bool) -> Eq Table
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Table -> Table -> Bool
$c/= :: Table -> Table -> Bool
== :: Table -> Table -> Bool
$c== :: Table -> Table -> Bool
Eq)
-- | A convenience alias for `Nothing` :: `Maybe` `Table`.
noTable :: Maybe Table
noTable :: Maybe Table
noTable = Maybe Table
forall a. Maybe a
Nothing

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

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

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

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

-- | Wrap the callback into a `GClosure`.
genClosure_TableColumnDeleted :: MonadIO m => TableColumnDeletedCallback -> m (GClosure C_TableColumnDeletedCallback)
genClosure_TableColumnDeleted :: TableColumnDeletedCallback
-> m (GClosure C_TableColumnDeletedCallback)
genClosure_TableColumnDeleted cb :: TableColumnDeletedCallback
cb = IO (GClosure C_TableColumnDeletedCallback)
-> m (GClosure C_TableColumnDeletedCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_TableColumnDeletedCallback)
 -> m (GClosure C_TableColumnDeletedCallback))
-> IO (GClosure C_TableColumnDeletedCallback)
-> m (GClosure C_TableColumnDeletedCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_TableColumnDeletedCallback
cb' = TableColumnDeletedCallback -> C_TableColumnDeletedCallback
wrap_TableColumnDeletedCallback TableColumnDeletedCallback
cb
    C_TableColumnDeletedCallback
-> IO (FunPtr C_TableColumnDeletedCallback)
mk_TableColumnDeletedCallback C_TableColumnDeletedCallback
cb' IO (FunPtr C_TableColumnDeletedCallback)
-> (FunPtr C_TableColumnDeletedCallback
    -> IO (GClosure C_TableColumnDeletedCallback))
-> IO (GClosure C_TableColumnDeletedCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_TableColumnDeletedCallback
-> IO (GClosure C_TableColumnDeletedCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


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


-- | Connect a signal handler for the [columnDeleted](#signal:columnDeleted) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' table #columnDeleted callback
-- @
-- 
-- 
onTableColumnDeleted :: (IsTable a, MonadIO m) => a -> TableColumnDeletedCallback -> m SignalHandlerId
onTableColumnDeleted :: a -> TableColumnDeletedCallback -> m SignalHandlerId
onTableColumnDeleted obj :: a
obj cb :: TableColumnDeletedCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_TableColumnDeletedCallback
cb' = TableColumnDeletedCallback -> C_TableColumnDeletedCallback
wrap_TableColumnDeletedCallback TableColumnDeletedCallback
cb
    FunPtr C_TableColumnDeletedCallback
cb'' <- C_TableColumnDeletedCallback
-> IO (FunPtr C_TableColumnDeletedCallback)
mk_TableColumnDeletedCallback C_TableColumnDeletedCallback
cb'
    a
-> Text
-> FunPtr C_TableColumnDeletedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj "column-deleted" FunPtr C_TableColumnDeletedCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [columnDeleted](#signal:columnDeleted) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' table #columnDeleted callback
-- @
-- 
-- 
afterTableColumnDeleted :: (IsTable a, MonadIO m) => a -> TableColumnDeletedCallback -> m SignalHandlerId
afterTableColumnDeleted :: a -> TableColumnDeletedCallback -> m SignalHandlerId
afterTableColumnDeleted obj :: a
obj cb :: TableColumnDeletedCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_TableColumnDeletedCallback
cb' = TableColumnDeletedCallback -> C_TableColumnDeletedCallback
wrap_TableColumnDeletedCallback TableColumnDeletedCallback
cb
    FunPtr C_TableColumnDeletedCallback
cb'' <- C_TableColumnDeletedCallback
-> IO (FunPtr C_TableColumnDeletedCallback)
mk_TableColumnDeletedCallback C_TableColumnDeletedCallback
cb'
    a
-> Text
-> FunPtr C_TableColumnDeletedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj "column-deleted" FunPtr C_TableColumnDeletedCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


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

#endif

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

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

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

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

-- | Wrap the callback into a `GClosure`.
genClosure_TableColumnInserted :: MonadIO m => TableColumnInsertedCallback -> m (GClosure C_TableColumnInsertedCallback)
genClosure_TableColumnInserted :: TableColumnDeletedCallback
-> m (GClosure C_TableColumnDeletedCallback)
genClosure_TableColumnInserted cb :: TableColumnDeletedCallback
cb = IO (GClosure C_TableColumnDeletedCallback)
-> m (GClosure C_TableColumnDeletedCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_TableColumnDeletedCallback)
 -> m (GClosure C_TableColumnDeletedCallback))
-> IO (GClosure C_TableColumnDeletedCallback)
-> m (GClosure C_TableColumnDeletedCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_TableColumnDeletedCallback
cb' = TableColumnDeletedCallback -> C_TableColumnDeletedCallback
wrap_TableColumnInsertedCallback TableColumnDeletedCallback
cb
    C_TableColumnDeletedCallback
-> IO (FunPtr C_TableColumnDeletedCallback)
mk_TableColumnInsertedCallback C_TableColumnDeletedCallback
cb' IO (FunPtr C_TableColumnDeletedCallback)
-> (FunPtr C_TableColumnDeletedCallback
    -> IO (GClosure C_TableColumnDeletedCallback))
-> IO (GClosure C_TableColumnDeletedCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_TableColumnDeletedCallback
-> IO (GClosure C_TableColumnDeletedCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


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


-- | Connect a signal handler for the [columnInserted](#signal:columnInserted) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' table #columnInserted callback
-- @
-- 
-- 
onTableColumnInserted :: (IsTable a, MonadIO m) => a -> TableColumnInsertedCallback -> m SignalHandlerId
onTableColumnInserted :: a -> TableColumnDeletedCallback -> m SignalHandlerId
onTableColumnInserted obj :: a
obj cb :: TableColumnDeletedCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_TableColumnDeletedCallback
cb' = TableColumnDeletedCallback -> C_TableColumnDeletedCallback
wrap_TableColumnInsertedCallback TableColumnDeletedCallback
cb
    FunPtr C_TableColumnDeletedCallback
cb'' <- C_TableColumnDeletedCallback
-> IO (FunPtr C_TableColumnDeletedCallback)
mk_TableColumnInsertedCallback C_TableColumnDeletedCallback
cb'
    a
-> Text
-> FunPtr C_TableColumnDeletedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj "column-inserted" FunPtr C_TableColumnDeletedCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [columnInserted](#signal:columnInserted) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' table #columnInserted callback
-- @
-- 
-- 
afterTableColumnInserted :: (IsTable a, MonadIO m) => a -> TableColumnInsertedCallback -> m SignalHandlerId
afterTableColumnInserted :: a -> TableColumnDeletedCallback -> m SignalHandlerId
afterTableColumnInserted obj :: a
obj cb :: TableColumnDeletedCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_TableColumnDeletedCallback
cb' = TableColumnDeletedCallback -> C_TableColumnDeletedCallback
wrap_TableColumnInsertedCallback TableColumnDeletedCallback
cb
    FunPtr C_TableColumnDeletedCallback
cb'' <- C_TableColumnDeletedCallback
-> IO (FunPtr C_TableColumnDeletedCallback)
mk_TableColumnInsertedCallback C_TableColumnDeletedCallback
cb'
    a
-> Text
-> FunPtr C_TableColumnDeletedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj "column-inserted" FunPtr C_TableColumnDeletedCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data TableColumnInsertedSignalInfo
instance SignalInfo TableColumnInsertedSignalInfo where
    type HaskellCallbackType TableColumnInsertedSignalInfo = TableColumnInsertedCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_TableColumnInsertedCallback cb
        cb'' <- mk_TableColumnInsertedCallback cb'
        connectSignalFunPtr obj "column-inserted" cb'' connectMode detail

#endif

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

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

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

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

-- | Wrap the callback into a `GClosure`.
genClosure_TableColumnReordered :: MonadIO m => TableColumnReorderedCallback -> m (GClosure C_TableColumnReorderedCallback)
genClosure_TableColumnReordered :: TableColumnReorderedCallback
-> m (GClosure C_TableColumnReorderedCallback)
genClosure_TableColumnReordered cb :: TableColumnReorderedCallback
cb = IO (GClosure C_TableColumnReorderedCallback)
-> m (GClosure C_TableColumnReorderedCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_TableColumnReorderedCallback)
 -> m (GClosure C_TableColumnReorderedCallback))
-> IO (GClosure C_TableColumnReorderedCallback)
-> m (GClosure C_TableColumnReorderedCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_TableColumnReorderedCallback
cb' = TableColumnReorderedCallback -> C_TableColumnReorderedCallback
wrap_TableColumnReorderedCallback TableColumnReorderedCallback
cb
    C_TableColumnReorderedCallback
-> IO (FunPtr C_TableColumnReorderedCallback)
mk_TableColumnReorderedCallback C_TableColumnReorderedCallback
cb' IO (FunPtr C_TableColumnReorderedCallback)
-> (FunPtr C_TableColumnReorderedCallback
    -> IO (GClosure C_TableColumnReorderedCallback))
-> IO (GClosure C_TableColumnReorderedCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_TableColumnReorderedCallback
-> IO (GClosure C_TableColumnReorderedCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


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


-- | Connect a signal handler for the [columnReordered](#signal:columnReordered) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' table #columnReordered callback
-- @
-- 
-- 
onTableColumnReordered :: (IsTable a, MonadIO m) => a -> TableColumnReorderedCallback -> m SignalHandlerId
onTableColumnReordered :: a -> TableColumnReorderedCallback -> m SignalHandlerId
onTableColumnReordered obj :: a
obj cb :: TableColumnReorderedCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_TableColumnReorderedCallback
cb' = TableColumnReorderedCallback -> C_TableColumnReorderedCallback
wrap_TableColumnReorderedCallback TableColumnReorderedCallback
cb
    FunPtr C_TableColumnReorderedCallback
cb'' <- C_TableColumnReorderedCallback
-> IO (FunPtr C_TableColumnReorderedCallback)
mk_TableColumnReorderedCallback C_TableColumnReorderedCallback
cb'
    a
-> Text
-> FunPtr C_TableColumnReorderedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj "column-reordered" FunPtr C_TableColumnReorderedCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [columnReordered](#signal:columnReordered) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' table #columnReordered callback
-- @
-- 
-- 
afterTableColumnReordered :: (IsTable a, MonadIO m) => a -> TableColumnReorderedCallback -> m SignalHandlerId
afterTableColumnReordered :: a -> TableColumnReorderedCallback -> m SignalHandlerId
afterTableColumnReordered obj :: a
obj cb :: TableColumnReorderedCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_TableColumnReorderedCallback
cb' = TableColumnReorderedCallback -> C_TableColumnReorderedCallback
wrap_TableColumnReorderedCallback TableColumnReorderedCallback
cb
    FunPtr C_TableColumnReorderedCallback
cb'' <- C_TableColumnReorderedCallback
-> IO (FunPtr C_TableColumnReorderedCallback)
mk_TableColumnReorderedCallback C_TableColumnReorderedCallback
cb'
    a
-> Text
-> FunPtr C_TableColumnReorderedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj "column-reordered" FunPtr C_TableColumnReorderedCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data TableColumnReorderedSignalInfo
instance SignalInfo TableColumnReorderedSignalInfo where
    type HaskellCallbackType TableColumnReorderedSignalInfo = TableColumnReorderedCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_TableColumnReorderedCallback cb
        cb'' <- mk_TableColumnReorderedCallback cb'
        connectSignalFunPtr obj "column-reordered" cb'' connectMode detail

#endif

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

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

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

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

-- | Wrap the callback into a `GClosure`.
genClosure_TableModelChanged :: MonadIO m => TableModelChangedCallback -> m (GClosure C_TableModelChangedCallback)
genClosure_TableModelChanged :: TableColumnReorderedCallback
-> m (GClosure C_TableColumnReorderedCallback)
genClosure_TableModelChanged cb :: TableColumnReorderedCallback
cb = IO (GClosure C_TableColumnReorderedCallback)
-> m (GClosure C_TableColumnReorderedCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_TableColumnReorderedCallback)
 -> m (GClosure C_TableColumnReorderedCallback))
-> IO (GClosure C_TableColumnReorderedCallback)
-> m (GClosure C_TableColumnReorderedCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_TableColumnReorderedCallback
cb' = TableColumnReorderedCallback -> C_TableColumnReorderedCallback
wrap_TableModelChangedCallback TableColumnReorderedCallback
cb
    C_TableColumnReorderedCallback
-> IO (FunPtr C_TableColumnReorderedCallback)
mk_TableModelChangedCallback C_TableColumnReorderedCallback
cb' IO (FunPtr C_TableColumnReorderedCallback)
-> (FunPtr C_TableColumnReorderedCallback
    -> IO (GClosure C_TableColumnReorderedCallback))
-> IO (GClosure C_TableColumnReorderedCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_TableColumnReorderedCallback
-> IO (GClosure C_TableColumnReorderedCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


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


-- | Connect a signal handler for the [modelChanged](#signal:modelChanged) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' table #modelChanged callback
-- @
-- 
-- 
onTableModelChanged :: (IsTable a, MonadIO m) => a -> TableModelChangedCallback -> m SignalHandlerId
onTableModelChanged :: a -> TableColumnReorderedCallback -> m SignalHandlerId
onTableModelChanged obj :: a
obj cb :: TableColumnReorderedCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_TableColumnReorderedCallback
cb' = TableColumnReorderedCallback -> C_TableColumnReorderedCallback
wrap_TableModelChangedCallback TableColumnReorderedCallback
cb
    FunPtr C_TableColumnReorderedCallback
cb'' <- C_TableColumnReorderedCallback
-> IO (FunPtr C_TableColumnReorderedCallback)
mk_TableModelChangedCallback C_TableColumnReorderedCallback
cb'
    a
-> Text
-> FunPtr C_TableColumnReorderedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj "model-changed" FunPtr C_TableColumnReorderedCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [modelChanged](#signal:modelChanged) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' table #modelChanged callback
-- @
-- 
-- 
afterTableModelChanged :: (IsTable a, MonadIO m) => a -> TableModelChangedCallback -> m SignalHandlerId
afterTableModelChanged :: a -> TableColumnReorderedCallback -> m SignalHandlerId
afterTableModelChanged obj :: a
obj cb :: TableColumnReorderedCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_TableColumnReorderedCallback
cb' = TableColumnReorderedCallback -> C_TableColumnReorderedCallback
wrap_TableModelChangedCallback TableColumnReorderedCallback
cb
    FunPtr C_TableColumnReorderedCallback
cb'' <- C_TableColumnReorderedCallback
-> IO (FunPtr C_TableColumnReorderedCallback)
mk_TableModelChangedCallback C_TableColumnReorderedCallback
cb'
    a
-> Text
-> FunPtr C_TableColumnReorderedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj "model-changed" FunPtr C_TableColumnReorderedCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data TableModelChangedSignalInfo
instance SignalInfo TableModelChangedSignalInfo where
    type HaskellCallbackType TableModelChangedSignalInfo = TableModelChangedCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_TableModelChangedCallback cb
        cb'' <- mk_TableModelChangedCallback cb'
        connectSignalFunPtr obj "model-changed" cb'' connectMode detail

#endif

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

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

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

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

-- | Wrap the callback into a `GClosure`.
genClosure_TableRowDeleted :: MonadIO m => TableRowDeletedCallback -> m (GClosure C_TableRowDeletedCallback)
genClosure_TableRowDeleted :: TableColumnDeletedCallback
-> m (GClosure C_TableColumnDeletedCallback)
genClosure_TableRowDeleted cb :: TableColumnDeletedCallback
cb = IO (GClosure C_TableColumnDeletedCallback)
-> m (GClosure C_TableColumnDeletedCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_TableColumnDeletedCallback)
 -> m (GClosure C_TableColumnDeletedCallback))
-> IO (GClosure C_TableColumnDeletedCallback)
-> m (GClosure C_TableColumnDeletedCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_TableColumnDeletedCallback
cb' = TableColumnDeletedCallback -> C_TableColumnDeletedCallback
wrap_TableRowDeletedCallback TableColumnDeletedCallback
cb
    C_TableColumnDeletedCallback
-> IO (FunPtr C_TableColumnDeletedCallback)
mk_TableRowDeletedCallback C_TableColumnDeletedCallback
cb' IO (FunPtr C_TableColumnDeletedCallback)
-> (FunPtr C_TableColumnDeletedCallback
    -> IO (GClosure C_TableColumnDeletedCallback))
-> IO (GClosure C_TableColumnDeletedCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_TableColumnDeletedCallback
-> IO (GClosure C_TableColumnDeletedCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


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


-- | Connect a signal handler for the [rowDeleted](#signal:rowDeleted) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' table #rowDeleted callback
-- @
-- 
-- 
onTableRowDeleted :: (IsTable a, MonadIO m) => a -> TableRowDeletedCallback -> m SignalHandlerId
onTableRowDeleted :: a -> TableColumnDeletedCallback -> m SignalHandlerId
onTableRowDeleted obj :: a
obj cb :: TableColumnDeletedCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_TableColumnDeletedCallback
cb' = TableColumnDeletedCallback -> C_TableColumnDeletedCallback
wrap_TableRowDeletedCallback TableColumnDeletedCallback
cb
    FunPtr C_TableColumnDeletedCallback
cb'' <- C_TableColumnDeletedCallback
-> IO (FunPtr C_TableColumnDeletedCallback)
mk_TableRowDeletedCallback C_TableColumnDeletedCallback
cb'
    a
-> Text
-> FunPtr C_TableColumnDeletedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj "row-deleted" FunPtr C_TableColumnDeletedCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [rowDeleted](#signal:rowDeleted) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' table #rowDeleted callback
-- @
-- 
-- 
afterTableRowDeleted :: (IsTable a, MonadIO m) => a -> TableRowDeletedCallback -> m SignalHandlerId
afterTableRowDeleted :: a -> TableColumnDeletedCallback -> m SignalHandlerId
afterTableRowDeleted obj :: a
obj cb :: TableColumnDeletedCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_TableColumnDeletedCallback
cb' = TableColumnDeletedCallback -> C_TableColumnDeletedCallback
wrap_TableRowDeletedCallback TableColumnDeletedCallback
cb
    FunPtr C_TableColumnDeletedCallback
cb'' <- C_TableColumnDeletedCallback
-> IO (FunPtr C_TableColumnDeletedCallback)
mk_TableRowDeletedCallback C_TableColumnDeletedCallback
cb'
    a
-> Text
-> FunPtr C_TableColumnDeletedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj "row-deleted" FunPtr C_TableColumnDeletedCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data TableRowDeletedSignalInfo
instance SignalInfo TableRowDeletedSignalInfo where
    type HaskellCallbackType TableRowDeletedSignalInfo = TableRowDeletedCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_TableRowDeletedCallback cb
        cb'' <- mk_TableRowDeletedCallback cb'
        connectSignalFunPtr obj "row-deleted" cb'' connectMode detail

#endif

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

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

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

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

-- | Wrap the callback into a `GClosure`.
genClosure_TableRowInserted :: MonadIO m => TableRowInsertedCallback -> m (GClosure C_TableRowInsertedCallback)
genClosure_TableRowInserted :: TableColumnDeletedCallback
-> m (GClosure C_TableColumnDeletedCallback)
genClosure_TableRowInserted cb :: TableColumnDeletedCallback
cb = IO (GClosure C_TableColumnDeletedCallback)
-> m (GClosure C_TableColumnDeletedCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_TableColumnDeletedCallback)
 -> m (GClosure C_TableColumnDeletedCallback))
-> IO (GClosure C_TableColumnDeletedCallback)
-> m (GClosure C_TableColumnDeletedCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_TableColumnDeletedCallback
cb' = TableColumnDeletedCallback -> C_TableColumnDeletedCallback
wrap_TableRowInsertedCallback TableColumnDeletedCallback
cb
    C_TableColumnDeletedCallback
-> IO (FunPtr C_TableColumnDeletedCallback)
mk_TableRowInsertedCallback C_TableColumnDeletedCallback
cb' IO (FunPtr C_TableColumnDeletedCallback)
-> (FunPtr C_TableColumnDeletedCallback
    -> IO (GClosure C_TableColumnDeletedCallback))
-> IO (GClosure C_TableColumnDeletedCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_TableColumnDeletedCallback
-> IO (GClosure C_TableColumnDeletedCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


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


-- | Connect a signal handler for the [rowInserted](#signal:rowInserted) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' table #rowInserted callback
-- @
-- 
-- 
onTableRowInserted :: (IsTable a, MonadIO m) => a -> TableRowInsertedCallback -> m SignalHandlerId
onTableRowInserted :: a -> TableColumnDeletedCallback -> m SignalHandlerId
onTableRowInserted obj :: a
obj cb :: TableColumnDeletedCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_TableColumnDeletedCallback
cb' = TableColumnDeletedCallback -> C_TableColumnDeletedCallback
wrap_TableRowInsertedCallback TableColumnDeletedCallback
cb
    FunPtr C_TableColumnDeletedCallback
cb'' <- C_TableColumnDeletedCallback
-> IO (FunPtr C_TableColumnDeletedCallback)
mk_TableRowInsertedCallback C_TableColumnDeletedCallback
cb'
    a
-> Text
-> FunPtr C_TableColumnDeletedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj "row-inserted" FunPtr C_TableColumnDeletedCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [rowInserted](#signal:rowInserted) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' table #rowInserted callback
-- @
-- 
-- 
afterTableRowInserted :: (IsTable a, MonadIO m) => a -> TableRowInsertedCallback -> m SignalHandlerId
afterTableRowInserted :: a -> TableColumnDeletedCallback -> m SignalHandlerId
afterTableRowInserted obj :: a
obj cb :: TableColumnDeletedCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_TableColumnDeletedCallback
cb' = TableColumnDeletedCallback -> C_TableColumnDeletedCallback
wrap_TableRowInsertedCallback TableColumnDeletedCallback
cb
    FunPtr C_TableColumnDeletedCallback
cb'' <- C_TableColumnDeletedCallback
-> IO (FunPtr C_TableColumnDeletedCallback)
mk_TableRowInsertedCallback C_TableColumnDeletedCallback
cb'
    a
-> Text
-> FunPtr C_TableColumnDeletedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj "row-inserted" FunPtr C_TableColumnDeletedCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data TableRowInsertedSignalInfo
instance SignalInfo TableRowInsertedSignalInfo where
    type HaskellCallbackType TableRowInsertedSignalInfo = TableRowInsertedCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_TableRowInsertedCallback cb
        cb'' <- mk_TableRowInsertedCallback cb'
        connectSignalFunPtr obj "row-inserted" cb'' connectMode detail

#endif

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

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

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

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

-- | Wrap the callback into a `GClosure`.
genClosure_TableRowReordered :: MonadIO m => TableRowReorderedCallback -> m (GClosure C_TableRowReorderedCallback)
genClosure_TableRowReordered :: TableColumnReorderedCallback
-> m (GClosure C_TableColumnReorderedCallback)
genClosure_TableRowReordered cb :: TableColumnReorderedCallback
cb = IO (GClosure C_TableColumnReorderedCallback)
-> m (GClosure C_TableColumnReorderedCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_TableColumnReorderedCallback)
 -> m (GClosure C_TableColumnReorderedCallback))
-> IO (GClosure C_TableColumnReorderedCallback)
-> m (GClosure C_TableColumnReorderedCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_TableColumnReorderedCallback
cb' = TableColumnReorderedCallback -> C_TableColumnReorderedCallback
wrap_TableRowReorderedCallback TableColumnReorderedCallback
cb
    C_TableColumnReorderedCallback
-> IO (FunPtr C_TableColumnReorderedCallback)
mk_TableRowReorderedCallback C_TableColumnReorderedCallback
cb' IO (FunPtr C_TableColumnReorderedCallback)
-> (FunPtr C_TableColumnReorderedCallback
    -> IO (GClosure C_TableColumnReorderedCallback))
-> IO (GClosure C_TableColumnReorderedCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_TableColumnReorderedCallback
-> IO (GClosure C_TableColumnReorderedCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


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


-- | Connect a signal handler for the [rowReordered](#signal:rowReordered) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' table #rowReordered callback
-- @
-- 
-- 
onTableRowReordered :: (IsTable a, MonadIO m) => a -> TableRowReorderedCallback -> m SignalHandlerId
onTableRowReordered :: a -> TableColumnReorderedCallback -> m SignalHandlerId
onTableRowReordered obj :: a
obj cb :: TableColumnReorderedCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_TableColumnReorderedCallback
cb' = TableColumnReorderedCallback -> C_TableColumnReorderedCallback
wrap_TableRowReorderedCallback TableColumnReorderedCallback
cb
    FunPtr C_TableColumnReorderedCallback
cb'' <- C_TableColumnReorderedCallback
-> IO (FunPtr C_TableColumnReorderedCallback)
mk_TableRowReorderedCallback C_TableColumnReorderedCallback
cb'
    a
-> Text
-> FunPtr C_TableColumnReorderedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj "row-reordered" FunPtr C_TableColumnReorderedCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [rowReordered](#signal:rowReordered) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' table #rowReordered callback
-- @
-- 
-- 
afterTableRowReordered :: (IsTable a, MonadIO m) => a -> TableRowReorderedCallback -> m SignalHandlerId
afterTableRowReordered :: a -> TableColumnReorderedCallback -> m SignalHandlerId
afterTableRowReordered obj :: a
obj cb :: TableColumnReorderedCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_TableColumnReorderedCallback
cb' = TableColumnReorderedCallback -> C_TableColumnReorderedCallback
wrap_TableRowReorderedCallback TableColumnReorderedCallback
cb
    FunPtr C_TableColumnReorderedCallback
cb'' <- C_TableColumnReorderedCallback
-> IO (FunPtr C_TableColumnReorderedCallback)
mk_TableRowReorderedCallback C_TableColumnReorderedCallback
cb'
    a
-> Text
-> FunPtr C_TableColumnReorderedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj "row-reordered" FunPtr C_TableColumnReorderedCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data TableRowReorderedSignalInfo
instance SignalInfo TableRowReorderedSignalInfo where
    type HaskellCallbackType TableRowReorderedSignalInfo = TableRowReorderedCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_TableRowReorderedCallback cb
        cb'' <- mk_TableRowReorderedCallback cb'
        connectSignalFunPtr obj "row-reordered" cb'' connectMode detail

#endif

#if defined(ENABLE_OVERLOADING)
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 :: IO GType
gobjectType = IO GType
c_atk_table_get_type
    

-- | Convert 'Table' to and from 'Data.GI.Base.GValue.GValue' with 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'.
instance B.GValue.IsGValue Table where
    toGValue :: Table -> IO GValue
toGValue o :: Table
o = do
        GType
gtype <- IO GType
c_atk_table_get_type
        Table -> (Ptr Table -> IO GValue) -> IO GValue
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr Table
o (GType
-> (GValue -> Ptr Table -> TableColumnReorderedCallback)
-> Ptr Table
-> IO GValue
forall a.
GType
-> (GValue -> a -> TableColumnReorderedCallback) -> a -> IO GValue
B.GValue.buildGValue GType
gtype GValue -> Ptr Table -> TableColumnReorderedCallback
forall a.
GObject a =>
GValue -> Ptr a -> TableColumnReorderedCallback
B.GValue.set_object)
        
    fromGValue :: GValue -> IO Table
fromGValue gv :: GValue
gv = do
        Ptr Table
ptr <- GValue -> IO (Ptr Table)
forall b. GObject b => GValue -> IO (Ptr b)
B.GValue.get_object GValue
gv :: IO (Ptr Table)
        (ManagedPtr Table -> Table) -> Ptr Table -> IO Table
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr Table -> Table
Table Ptr Table
ptr
        
    

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

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

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

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

#if defined(ENABLE_OVERLOADING)
#endif

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

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

#endif

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

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

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

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

#endif

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

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

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

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

#endif

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

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

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

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

#endif

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

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

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

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

#endif

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

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

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

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

#endif

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

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

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

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

#endif

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

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

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

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

#endif

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

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

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

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

#endif

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

foreign import ccall "atk_table_get_n_columns" atk_table_get_n_columns :: 
    Ptr Table ->                            -- table : TInterface (Name {namespace = "Atk", name = "Table"})
    IO Int32

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

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

#endif

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

foreign import ccall "atk_table_get_n_rows" atk_table_get_n_rows :: 
    Ptr Table ->                            -- table : TInterface (Name {namespace = "Atk", name = "Table"})
    IO Int32

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

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

#endif

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

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

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

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

#endif

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

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

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

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

#endif

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

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

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

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

#endif

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

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

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

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

#endif

-- method Table::get_selected_columns
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "table"
--           , argType = TInterface Name { namespace = "Atk" , name = "Table" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "a GObject instance that implements AtkTableIface"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "selected"
--           , argType = TBasicType TInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "a #gint** that is to contain the selected columns numbers"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TInt)
-- throws : False
-- Skip return : False

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

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

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

#endif

-- method Table::get_selected_rows
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "table"
--           , argType = TInterface Name { namespace = "Atk" , name = "Table" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "a GObject instance that implements AtkTableIface"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "selected"
--           , argType = TBasicType TInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "a #gint** that is to contain the selected row numbers"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TInt)
-- throws : False
-- Skip return : False

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

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

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

#endif

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

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

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

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

#endif

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

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

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

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

#endif

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

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

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

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

#endif

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

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

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

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

#endif

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

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

-- | Get a reference to the table cell at /@row@/, /@column@/. This cell
-- should implement the interface t'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 t'GI.Atk.Objects.Object.Object' representing the referred
    -- to accessible
tableRefAt :: a -> Int32 -> Int32 -> m Object
tableRefAt table :: a
table row :: Int32
row column :: Int32
column = IO Object -> m Object
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Object -> m Object) -> IO Object -> m Object
forall a b. (a -> b) -> a -> b
$ do
    Ptr Table
table' <- a -> IO (Ptr Table)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
table
    Ptr Object
result <- Ptr Table -> Int32 -> Int32 -> IO (Ptr Object)
atk_table_ref_at Ptr Table
table' Int32
row Int32
column
    Text -> Ptr Object -> TableColumnReorderedCallback
forall a.
HasCallStack =>
Text -> Ptr a -> TableColumnReorderedCallback
checkUnexpectedReturnNULL "tableRefAt" Ptr Object
result
    Object
result' <- ((ManagedPtr Object -> Object) -> Ptr Object -> IO Object
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr Object -> Object
Atk.Object.Object) Ptr Object
result
    a -> TableColumnReorderedCallback
forall a. ManagedPtrNewtype a => a -> TableColumnReorderedCallback
touchManagedPtr a
table
    Object -> IO Object
forall (m :: * -> *) a. Monad m => a -> m a
return Object
result'

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

#endif

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

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

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

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

#endif

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

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

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

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

#endif

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

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

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

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

#endif

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

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

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

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

#endif

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

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

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

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

#endif

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

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

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

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

#endif

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

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

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

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

#endif

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

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

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

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

#endif