{- | Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte License : LGPL-2.1 Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) 'GI.Atk.Interfaces.Table.Table' should be implemented by components which present elements ordered via rows and columns. It may also be used to present tree-structured information if the nodes of the trees can be said to contain multiple \"columns\". Individual elements of an 'GI.Atk.Interfaces.Table.Table' are typically referred to as \"cells\". Those cells should implement the interface 'GI.Atk.Interfaces.TableCell.TableCell', but @/Atk/@ doesn\'t require them to be direct children of the current 'GI.Atk.Interfaces.Table.Table'. They can be grand-children, grand-grand-children etc. 'GI.Atk.Interfaces.Table.Table' provides the API needed to get a individual cell based on the row and column numbers. Children of 'GI.Atk.Interfaces.Table.Table' are frequently \"lightweight\" objects, that is, they may not have backing widgets in the host UI toolkit. They are therefore often transient. Since tables are often very complex, 'GI.Atk.Interfaces.Table.Table' includes provision for offering simplified summary information, as well as row and column headers and captions. Headers and captions are @/AtkObjects/@ which may implement other interfaces ('GI.Atk.Interfaces.Text.Text', 'GI.Atk.Interfaces.Image.Image', etc.) as appropriate. 'GI.Atk.Interfaces.Table.Table' summaries may themselves be (simplified) @/AtkTables/@, etc. Note for implementors: in the past, 'GI.Atk.Interfaces.Table.Table' required that all the cells should be direct children of 'GI.Atk.Interfaces.Table.Table', and provided some index based methods to request the cells. The practice showed that that forcing made 'GI.Atk.Interfaces.Table.Table' implementation complex, and hard to expose other kind of children, like rows or captions. Right now, index-based methods are deprecated. -} #define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ && !defined(__HADDOCK_VERSION__)) module GI.Atk.Interfaces.Table ( -- * Exported types Table(..) , noTable , IsTable , toTable , -- * Methods -- ** addColumnSelection #method:addColumnSelection# #if ENABLE_OVERLOADING TableAddColumnSelectionMethodInfo , #endif tableAddColumnSelection , -- ** addRowSelection #method:addRowSelection# #if ENABLE_OVERLOADING TableAddRowSelectionMethodInfo , #endif tableAddRowSelection , -- ** getCaption #method:getCaption# #if ENABLE_OVERLOADING TableGetCaptionMethodInfo , #endif tableGetCaption , -- ** getColumnAtIndex #method:getColumnAtIndex# #if ENABLE_OVERLOADING TableGetColumnAtIndexMethodInfo , #endif tableGetColumnAtIndex , -- ** getColumnDescription #method:getColumnDescription# #if ENABLE_OVERLOADING TableGetColumnDescriptionMethodInfo , #endif tableGetColumnDescription , -- ** getColumnExtentAt #method:getColumnExtentAt# #if ENABLE_OVERLOADING TableGetColumnExtentAtMethodInfo , #endif tableGetColumnExtentAt , -- ** getColumnHeader #method:getColumnHeader# #if ENABLE_OVERLOADING TableGetColumnHeaderMethodInfo , #endif tableGetColumnHeader , -- ** getIndexAt #method:getIndexAt# #if ENABLE_OVERLOADING TableGetIndexAtMethodInfo , #endif tableGetIndexAt , -- ** getNColumns #method:getNColumns# #if ENABLE_OVERLOADING TableGetNColumnsMethodInfo , #endif tableGetNColumns , -- ** getNRows #method:getNRows# #if ENABLE_OVERLOADING TableGetNRowsMethodInfo , #endif tableGetNRows , -- ** getRowAtIndex #method:getRowAtIndex# #if ENABLE_OVERLOADING TableGetRowAtIndexMethodInfo , #endif tableGetRowAtIndex , -- ** getRowDescription #method:getRowDescription# #if ENABLE_OVERLOADING TableGetRowDescriptionMethodInfo , #endif tableGetRowDescription , -- ** getRowExtentAt #method:getRowExtentAt# #if ENABLE_OVERLOADING TableGetRowExtentAtMethodInfo , #endif tableGetRowExtentAt , -- ** getRowHeader #method:getRowHeader# #if ENABLE_OVERLOADING TableGetRowHeaderMethodInfo , #endif tableGetRowHeader , -- ** getSelectedColumns #method:getSelectedColumns# #if ENABLE_OVERLOADING TableGetSelectedColumnsMethodInfo , #endif tableGetSelectedColumns , -- ** getSelectedRows #method:getSelectedRows# #if ENABLE_OVERLOADING TableGetSelectedRowsMethodInfo , #endif tableGetSelectedRows , -- ** getSummary #method:getSummary# #if ENABLE_OVERLOADING TableGetSummaryMethodInfo , #endif tableGetSummary , -- ** isColumnSelected #method:isColumnSelected# #if ENABLE_OVERLOADING TableIsColumnSelectedMethodInfo , #endif tableIsColumnSelected , -- ** isRowSelected #method:isRowSelected# #if ENABLE_OVERLOADING TableIsRowSelectedMethodInfo , #endif tableIsRowSelected , -- ** isSelected #method:isSelected# #if ENABLE_OVERLOADING TableIsSelectedMethodInfo , #endif tableIsSelected , -- ** refAt #method:refAt# #if ENABLE_OVERLOADING TableRefAtMethodInfo , #endif tableRefAt , -- ** removeColumnSelection #method:removeColumnSelection# #if ENABLE_OVERLOADING TableRemoveColumnSelectionMethodInfo , #endif tableRemoveColumnSelection , -- ** removeRowSelection #method:removeRowSelection# #if ENABLE_OVERLOADING TableRemoveRowSelectionMethodInfo , #endif tableRemoveRowSelection , -- ** setCaption #method:setCaption# #if ENABLE_OVERLOADING TableSetCaptionMethodInfo , #endif tableSetCaption , -- ** setColumnDescription #method:setColumnDescription# #if ENABLE_OVERLOADING TableSetColumnDescriptionMethodInfo , #endif tableSetColumnDescription , -- ** setColumnHeader #method:setColumnHeader# #if ENABLE_OVERLOADING TableSetColumnHeaderMethodInfo , #endif tableSetColumnHeader , -- ** setRowDescription #method:setRowDescription# #if ENABLE_OVERLOADING TableSetRowDescriptionMethodInfo , #endif tableSetRowDescription , -- ** setRowHeader #method:setRowHeader# #if ENABLE_OVERLOADING TableSetRowHeaderMethodInfo , #endif tableSetRowHeader , -- ** setSummary #method:setSummary# #if ENABLE_OVERLOADING TableSetSummaryMethodInfo , #endif tableSetSummary , -- * Signals -- ** columnDeleted #signal:columnDeleted# C_TableColumnDeletedCallback , TableColumnDeletedCallback , #if ENABLE_OVERLOADING TableColumnDeletedSignalInfo , #endif afterTableColumnDeleted , genClosure_TableColumnDeleted , mk_TableColumnDeletedCallback , noTableColumnDeletedCallback , onTableColumnDeleted , wrap_TableColumnDeletedCallback , -- ** columnInserted #signal:columnInserted# C_TableColumnInsertedCallback , TableColumnInsertedCallback , #if ENABLE_OVERLOADING TableColumnInsertedSignalInfo , #endif afterTableColumnInserted , genClosure_TableColumnInserted , mk_TableColumnInsertedCallback , noTableColumnInsertedCallback , onTableColumnInserted , wrap_TableColumnInsertedCallback , -- ** columnReordered #signal:columnReordered# C_TableColumnReorderedCallback , TableColumnReorderedCallback , #if ENABLE_OVERLOADING TableColumnReorderedSignalInfo , #endif afterTableColumnReordered , genClosure_TableColumnReordered , mk_TableColumnReorderedCallback , noTableColumnReorderedCallback , onTableColumnReordered , wrap_TableColumnReorderedCallback , -- ** modelChanged #signal:modelChanged# C_TableModelChangedCallback , TableModelChangedCallback , #if ENABLE_OVERLOADING TableModelChangedSignalInfo , #endif afterTableModelChanged , genClosure_TableModelChanged , mk_TableModelChangedCallback , noTableModelChangedCallback , onTableModelChanged , wrap_TableModelChangedCallback , -- ** rowDeleted #signal:rowDeleted# C_TableRowDeletedCallback , TableRowDeletedCallback , #if ENABLE_OVERLOADING TableRowDeletedSignalInfo , #endif afterTableRowDeleted , genClosure_TableRowDeleted , mk_TableRowDeletedCallback , noTableRowDeletedCallback , onTableRowDeleted , wrap_TableRowDeletedCallback , -- ** rowInserted #signal:rowInserted# C_TableRowInsertedCallback , TableRowInsertedCallback , #if ENABLE_OVERLOADING TableRowInsertedSignalInfo , #endif afterTableRowInserted , genClosure_TableRowInserted , mk_TableRowInsertedCallback , noTableRowInsertedCallback , onTableRowInserted , wrap_TableRowInsertedCallback , -- ** rowReordered #signal:rowReordered# C_TableRowReorderedCallback , TableRowReorderedCallback , #if ENABLE_OVERLOADING TableRowReorderedSignalInfo , #endif afterTableRowReordered , genClosure_TableRowReordered , mk_TableRowReorderedCallback , noTableRowReorderedCallback , onTableRowReordered , wrap_TableRowReorderedCallback , ) where import Data.GI.Base.ShortPrelude import qualified Data.GI.Base.ShortPrelude as SP import qualified Data.GI.Base.Overloading as O import qualified Prelude as P import qualified Data.GI.Base.Attributes as GI.Attributes import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr import qualified Data.GI.Base.GClosure as B.GClosure import qualified Data.GI.Base.GError as B.GError import qualified Data.GI.Base.GVariant as B.GVariant import qualified Data.GI.Base.GValue as B.GValue import qualified Data.GI.Base.GParamSpec as B.GParamSpec import qualified Data.GI.Base.CallStack as B.CallStack import qualified Data.GI.Base.Properties as B.Properties import qualified Data.Text as T import qualified Data.ByteString.Char8 as B import qualified Data.Map as Map import qualified Foreign.Ptr as FP import qualified GHC.OverloadedLabels as OL import {-# SOURCE #-} qualified GI.Atk.Objects.Object as Atk.Object import qualified GI.GObject.Objects.Object as GObject.Object -- interface Table -- | Memory-managed wrapper type. newtype Table = Table (ManagedPtr Table) -- | A convenience alias for `Nothing` :: `Maybe` `Table`. noTable :: Maybe Table noTable = Nothing -- signal Table::column-deleted {- | The \"column-deleted\" signal is emitted by an object which implements the AtkTable interface when a column is deleted. -} type TableColumnDeletedCallback = Int32 {- ^ /@arg1@/: The index of the first column deleted. -} -> Int32 {- ^ /@arg2@/: The number of columns deleted. -} -> IO () -- | A convenience synonym for @`Nothing` :: `Maybe` `TableColumnDeletedCallback`@. noTableColumnDeletedCallback :: Maybe TableColumnDeletedCallback noTableColumnDeletedCallback = Nothing -- | Type for the callback on the (unwrapped) C side. type C_TableColumnDeletedCallback = Ptr () -> -- object Int32 -> Int32 -> Ptr () -> -- user_data IO () -- | Generate a function pointer callable from C code, from a `C_TableColumnDeletedCallback`. foreign import ccall "wrapper" mk_TableColumnDeletedCallback :: C_TableColumnDeletedCallback -> IO (FunPtr C_TableColumnDeletedCallback) -- | Wrap the callback into a `GClosure`. genClosure_TableColumnDeleted :: MonadIO m => TableColumnDeletedCallback -> m (GClosure C_TableColumnDeletedCallback) genClosure_TableColumnDeleted cb = liftIO $ do let cb' = wrap_TableColumnDeletedCallback cb mk_TableColumnDeletedCallback cb' >>= B.GClosure.newGClosure -- | Wrap a `TableColumnDeletedCallback` into a `C_TableColumnDeletedCallback`. wrap_TableColumnDeletedCallback :: TableColumnDeletedCallback -> C_TableColumnDeletedCallback wrap_TableColumnDeletedCallback _cb _ arg1 arg2 _ = do _cb arg1 arg2 {- | Connect a signal handler for the “@column-deleted@” signal, to be run before the default handler. When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to @ 'Data.GI.Base.Signals.on' table #columnDeleted callback @ -} onTableColumnDeleted :: (IsTable a, MonadIO m) => a -> TableColumnDeletedCallback -> m SignalHandlerId onTableColumnDeleted obj cb = liftIO $ do let cb' = wrap_TableColumnDeletedCallback cb cb'' <- mk_TableColumnDeletedCallback cb' connectSignalFunPtr obj "column-deleted" cb'' SignalConnectBefore {- | Connect a signal handler for the “@column-deleted@” signal, to be run after the default handler. When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to @ 'Data.GI.Base.Signals.after' table #columnDeleted callback @ -} afterTableColumnDeleted :: (IsTable a, MonadIO m) => a -> TableColumnDeletedCallback -> m SignalHandlerId afterTableColumnDeleted obj cb = liftIO $ do let cb' = wrap_TableColumnDeletedCallback cb cb'' <- mk_TableColumnDeletedCallback cb' connectSignalFunPtr obj "column-deleted" cb'' SignalConnectAfter -- signal Table::column-inserted {- | The \"column-inserted\" signal is emitted by an object which implements the AtkTable interface when a column is inserted. -} type TableColumnInsertedCallback = Int32 {- ^ /@arg1@/: The index of the column inserted. -} -> Int32 {- ^ /@arg2@/: The number of colums inserted. -} -> IO () -- | A convenience synonym for @`Nothing` :: `Maybe` `TableColumnInsertedCallback`@. noTableColumnInsertedCallback :: Maybe TableColumnInsertedCallback noTableColumnInsertedCallback = Nothing -- | Type for the callback on the (unwrapped) C side. type C_TableColumnInsertedCallback = Ptr () -> -- object Int32 -> Int32 -> Ptr () -> -- user_data IO () -- | Generate a function pointer callable from C code, from a `C_TableColumnInsertedCallback`. foreign import ccall "wrapper" mk_TableColumnInsertedCallback :: C_TableColumnInsertedCallback -> IO (FunPtr C_TableColumnInsertedCallback) -- | Wrap the callback into a `GClosure`. genClosure_TableColumnInserted :: MonadIO m => TableColumnInsertedCallback -> m (GClosure C_TableColumnInsertedCallback) genClosure_TableColumnInserted cb = liftIO $ do let cb' = wrap_TableColumnInsertedCallback cb mk_TableColumnInsertedCallback cb' >>= B.GClosure.newGClosure -- | Wrap a `TableColumnInsertedCallback` into a `C_TableColumnInsertedCallback`. wrap_TableColumnInsertedCallback :: TableColumnInsertedCallback -> C_TableColumnInsertedCallback wrap_TableColumnInsertedCallback _cb _ arg1 arg2 _ = do _cb arg1 arg2 {- | Connect a signal handler for the “@column-inserted@” signal, to be run before the default handler. When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to @ 'Data.GI.Base.Signals.on' table #columnInserted callback @ -} onTableColumnInserted :: (IsTable a, MonadIO m) => a -> TableColumnInsertedCallback -> m SignalHandlerId onTableColumnInserted obj cb = liftIO $ do let cb' = wrap_TableColumnInsertedCallback cb cb'' <- mk_TableColumnInsertedCallback cb' connectSignalFunPtr obj "column-inserted" cb'' SignalConnectBefore {- | Connect a signal handler for the “@column-inserted@” signal, to be run after the default handler. When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to @ 'Data.GI.Base.Signals.after' table #columnInserted callback @ -} afterTableColumnInserted :: (IsTable a, MonadIO m) => a -> TableColumnInsertedCallback -> m SignalHandlerId afterTableColumnInserted obj cb = liftIO $ do let cb' = wrap_TableColumnInsertedCallback cb cb'' <- mk_TableColumnInsertedCallback cb' connectSignalFunPtr obj "column-inserted" cb'' SignalConnectAfter -- signal Table::column-reordered {- | The \"column-reordered\" signal is emitted by an object which implements the AtkTable interface when the columns are reordered. -} type TableColumnReorderedCallback = IO () -- | A convenience synonym for @`Nothing` :: `Maybe` `TableColumnReorderedCallback`@. noTableColumnReorderedCallback :: Maybe TableColumnReorderedCallback noTableColumnReorderedCallback = Nothing -- | Type for the callback on the (unwrapped) C side. type C_TableColumnReorderedCallback = Ptr () -> -- object Ptr () -> -- user_data IO () -- | Generate a function pointer callable from C code, from a `C_TableColumnReorderedCallback`. foreign import ccall "wrapper" mk_TableColumnReorderedCallback :: C_TableColumnReorderedCallback -> IO (FunPtr C_TableColumnReorderedCallback) -- | Wrap the callback into a `GClosure`. genClosure_TableColumnReordered :: MonadIO m => TableColumnReorderedCallback -> m (GClosure C_TableColumnReorderedCallback) genClosure_TableColumnReordered cb = liftIO $ do let cb' = wrap_TableColumnReorderedCallback cb mk_TableColumnReorderedCallback cb' >>= B.GClosure.newGClosure -- | Wrap a `TableColumnReorderedCallback` into a `C_TableColumnReorderedCallback`. wrap_TableColumnReorderedCallback :: TableColumnReorderedCallback -> C_TableColumnReorderedCallback wrap_TableColumnReorderedCallback _cb _ _ = do _cb {- | Connect a signal handler for the “@column-reordered@” signal, to be run before the default handler. When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to @ 'Data.GI.Base.Signals.on' table #columnReordered callback @ -} onTableColumnReordered :: (IsTable a, MonadIO m) => a -> TableColumnReorderedCallback -> m SignalHandlerId onTableColumnReordered obj cb = liftIO $ do let cb' = wrap_TableColumnReorderedCallback cb cb'' <- mk_TableColumnReorderedCallback cb' connectSignalFunPtr obj "column-reordered" cb'' SignalConnectBefore {- | Connect a signal handler for the “@column-reordered@” signal, to be run after the default handler. When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to @ 'Data.GI.Base.Signals.after' table #columnReordered callback @ -} afterTableColumnReordered :: (IsTable a, MonadIO m) => a -> TableColumnReorderedCallback -> m SignalHandlerId afterTableColumnReordered obj cb = liftIO $ do let cb' = wrap_TableColumnReorderedCallback cb cb'' <- mk_TableColumnReorderedCallback cb' connectSignalFunPtr obj "column-reordered" cb'' SignalConnectAfter -- signal Table::model-changed {- | The \"model-changed\" signal is emitted by an object which implements the AtkTable interface when the model displayed by the table changes. -} type TableModelChangedCallback = IO () -- | A convenience synonym for @`Nothing` :: `Maybe` `TableModelChangedCallback`@. noTableModelChangedCallback :: Maybe TableModelChangedCallback noTableModelChangedCallback = Nothing -- | Type for the callback on the (unwrapped) C side. type C_TableModelChangedCallback = Ptr () -> -- object Ptr () -> -- user_data IO () -- | Generate a function pointer callable from C code, from a `C_TableModelChangedCallback`. foreign import ccall "wrapper" mk_TableModelChangedCallback :: C_TableModelChangedCallback -> IO (FunPtr C_TableModelChangedCallback) -- | Wrap the callback into a `GClosure`. genClosure_TableModelChanged :: MonadIO m => TableModelChangedCallback -> m (GClosure C_TableModelChangedCallback) genClosure_TableModelChanged cb = liftIO $ do let cb' = wrap_TableModelChangedCallback cb mk_TableModelChangedCallback cb' >>= B.GClosure.newGClosure -- | Wrap a `TableModelChangedCallback` into a `C_TableModelChangedCallback`. wrap_TableModelChangedCallback :: TableModelChangedCallback -> C_TableModelChangedCallback wrap_TableModelChangedCallback _cb _ _ = do _cb {- | Connect a signal handler for the “@model-changed@” signal, to be run before the default handler. When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to @ 'Data.GI.Base.Signals.on' table #modelChanged callback @ -} onTableModelChanged :: (IsTable a, MonadIO m) => a -> TableModelChangedCallback -> m SignalHandlerId onTableModelChanged obj cb = liftIO $ do let cb' = wrap_TableModelChangedCallback cb cb'' <- mk_TableModelChangedCallback cb' connectSignalFunPtr obj "model-changed" cb'' SignalConnectBefore {- | Connect a signal handler for the “@model-changed@” signal, to be run after the default handler. When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to @ 'Data.GI.Base.Signals.after' table #modelChanged callback @ -} afterTableModelChanged :: (IsTable a, MonadIO m) => a -> TableModelChangedCallback -> m SignalHandlerId afterTableModelChanged obj cb = liftIO $ do let cb' = wrap_TableModelChangedCallback cb cb'' <- mk_TableModelChangedCallback cb' connectSignalFunPtr obj "model-changed" cb'' SignalConnectAfter -- signal Table::row-deleted {- | The \"row-deleted\" signal is emitted by an object which implements the AtkTable interface when a row is deleted. -} type TableRowDeletedCallback = Int32 {- ^ /@arg1@/: The index of the first row deleted. -} -> Int32 {- ^ /@arg2@/: The number of rows deleted. -} -> IO () -- | A convenience synonym for @`Nothing` :: `Maybe` `TableRowDeletedCallback`@. noTableRowDeletedCallback :: Maybe TableRowDeletedCallback noTableRowDeletedCallback = Nothing -- | Type for the callback on the (unwrapped) C side. type C_TableRowDeletedCallback = Ptr () -> -- object Int32 -> Int32 -> Ptr () -> -- user_data IO () -- | Generate a function pointer callable from C code, from a `C_TableRowDeletedCallback`. foreign import ccall "wrapper" mk_TableRowDeletedCallback :: C_TableRowDeletedCallback -> IO (FunPtr C_TableRowDeletedCallback) -- | Wrap the callback into a `GClosure`. genClosure_TableRowDeleted :: MonadIO m => TableRowDeletedCallback -> m (GClosure C_TableRowDeletedCallback) genClosure_TableRowDeleted cb = liftIO $ do let cb' = wrap_TableRowDeletedCallback cb mk_TableRowDeletedCallback cb' >>= B.GClosure.newGClosure -- | Wrap a `TableRowDeletedCallback` into a `C_TableRowDeletedCallback`. wrap_TableRowDeletedCallback :: TableRowDeletedCallback -> C_TableRowDeletedCallback wrap_TableRowDeletedCallback _cb _ arg1 arg2 _ = do _cb arg1 arg2 {- | Connect a signal handler for the “@row-deleted@” signal, to be run before the default handler. When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to @ 'Data.GI.Base.Signals.on' table #rowDeleted callback @ -} onTableRowDeleted :: (IsTable a, MonadIO m) => a -> TableRowDeletedCallback -> m SignalHandlerId onTableRowDeleted obj cb = liftIO $ do let cb' = wrap_TableRowDeletedCallback cb cb'' <- mk_TableRowDeletedCallback cb' connectSignalFunPtr obj "row-deleted" cb'' SignalConnectBefore {- | Connect a signal handler for the “@row-deleted@” signal, to be run after the default handler. When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to @ 'Data.GI.Base.Signals.after' table #rowDeleted callback @ -} afterTableRowDeleted :: (IsTable a, MonadIO m) => a -> TableRowDeletedCallback -> m SignalHandlerId afterTableRowDeleted obj cb = liftIO $ do let cb' = wrap_TableRowDeletedCallback cb cb'' <- mk_TableRowDeletedCallback cb' connectSignalFunPtr obj "row-deleted" cb'' SignalConnectAfter -- signal Table::row-inserted {- | The \"row-inserted\" signal is emitted by an object which implements the AtkTable interface when a row is inserted. -} type TableRowInsertedCallback = Int32 {- ^ /@arg1@/: The index of the first row inserted. -} -> Int32 {- ^ /@arg2@/: The number of rows inserted. -} -> IO () -- | A convenience synonym for @`Nothing` :: `Maybe` `TableRowInsertedCallback`@. noTableRowInsertedCallback :: Maybe TableRowInsertedCallback noTableRowInsertedCallback = Nothing -- | Type for the callback on the (unwrapped) C side. type C_TableRowInsertedCallback = Ptr () -> -- object Int32 -> Int32 -> Ptr () -> -- user_data IO () -- | Generate a function pointer callable from C code, from a `C_TableRowInsertedCallback`. foreign import ccall "wrapper" mk_TableRowInsertedCallback :: C_TableRowInsertedCallback -> IO (FunPtr C_TableRowInsertedCallback) -- | Wrap the callback into a `GClosure`. genClosure_TableRowInserted :: MonadIO m => TableRowInsertedCallback -> m (GClosure C_TableRowInsertedCallback) genClosure_TableRowInserted cb = liftIO $ do let cb' = wrap_TableRowInsertedCallback cb mk_TableRowInsertedCallback cb' >>= B.GClosure.newGClosure -- | Wrap a `TableRowInsertedCallback` into a `C_TableRowInsertedCallback`. wrap_TableRowInsertedCallback :: TableRowInsertedCallback -> C_TableRowInsertedCallback wrap_TableRowInsertedCallback _cb _ arg1 arg2 _ = do _cb arg1 arg2 {- | Connect a signal handler for the “@row-inserted@” signal, to be run before the default handler. When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to @ 'Data.GI.Base.Signals.on' table #rowInserted callback @ -} onTableRowInserted :: (IsTable a, MonadIO m) => a -> TableRowInsertedCallback -> m SignalHandlerId onTableRowInserted obj cb = liftIO $ do let cb' = wrap_TableRowInsertedCallback cb cb'' <- mk_TableRowInsertedCallback cb' connectSignalFunPtr obj "row-inserted" cb'' SignalConnectBefore {- | Connect a signal handler for the “@row-inserted@” signal, to be run after the default handler. When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to @ 'Data.GI.Base.Signals.after' table #rowInserted callback @ -} afterTableRowInserted :: (IsTable a, MonadIO m) => a -> TableRowInsertedCallback -> m SignalHandlerId afterTableRowInserted obj cb = liftIO $ do let cb' = wrap_TableRowInsertedCallback cb cb'' <- mk_TableRowInsertedCallback cb' connectSignalFunPtr obj "row-inserted" cb'' SignalConnectAfter -- signal Table::row-reordered {- | The \"row-reordered\" signal is emitted by an object which implements the AtkTable interface when the rows are reordered. -} type TableRowReorderedCallback = IO () -- | A convenience synonym for @`Nothing` :: `Maybe` `TableRowReorderedCallback`@. noTableRowReorderedCallback :: Maybe TableRowReorderedCallback noTableRowReorderedCallback = Nothing -- | Type for the callback on the (unwrapped) C side. type C_TableRowReorderedCallback = Ptr () -> -- object Ptr () -> -- user_data IO () -- | Generate a function pointer callable from C code, from a `C_TableRowReorderedCallback`. foreign import ccall "wrapper" mk_TableRowReorderedCallback :: C_TableRowReorderedCallback -> IO (FunPtr C_TableRowReorderedCallback) -- | Wrap the callback into a `GClosure`. genClosure_TableRowReordered :: MonadIO m => TableRowReorderedCallback -> m (GClosure C_TableRowReorderedCallback) genClosure_TableRowReordered cb = liftIO $ do let cb' = wrap_TableRowReorderedCallback cb mk_TableRowReorderedCallback cb' >>= B.GClosure.newGClosure -- | Wrap a `TableRowReorderedCallback` into a `C_TableRowReorderedCallback`. wrap_TableRowReorderedCallback :: TableRowReorderedCallback -> C_TableRowReorderedCallback wrap_TableRowReorderedCallback _cb _ _ = do _cb {- | Connect a signal handler for the “@row-reordered@” signal, to be run before the default handler. When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to @ 'Data.GI.Base.Signals.on' table #rowReordered callback @ -} onTableRowReordered :: (IsTable a, MonadIO m) => a -> TableRowReorderedCallback -> m SignalHandlerId onTableRowReordered obj cb = liftIO $ do let cb' = wrap_TableRowReorderedCallback cb cb'' <- mk_TableRowReorderedCallback cb' connectSignalFunPtr obj "row-reordered" cb'' SignalConnectBefore {- | Connect a signal handler for the “@row-reordered@” signal, to be run after the default handler. When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to @ 'Data.GI.Base.Signals.after' table #rowReordered callback @ -} afterTableRowReordered :: (IsTable a, MonadIO m) => a -> TableRowReorderedCallback -> m SignalHandlerId afterTableRowReordered obj cb = liftIO $ do let cb' = wrap_TableRowReorderedCallback cb cb'' <- mk_TableRowReorderedCallback cb' connectSignalFunPtr obj "row-reordered" cb'' SignalConnectAfter #if ENABLE_OVERLOADING data TableColumnDeletedSignalInfo instance SignalInfo TableColumnDeletedSignalInfo where type HaskellCallbackType TableColumnDeletedSignalInfo = TableColumnDeletedCallback connectSignal _ obj cb connectMode = do let cb' = wrap_TableColumnDeletedCallback cb cb'' <- mk_TableColumnDeletedCallback cb' connectSignalFunPtr obj "column-deleted" cb'' connectMode data TableColumnInsertedSignalInfo instance SignalInfo TableColumnInsertedSignalInfo where type HaskellCallbackType TableColumnInsertedSignalInfo = TableColumnInsertedCallback connectSignal _ obj cb connectMode = do let cb' = wrap_TableColumnInsertedCallback cb cb'' <- mk_TableColumnInsertedCallback cb' connectSignalFunPtr obj "column-inserted" cb'' connectMode data TableColumnReorderedSignalInfo instance SignalInfo TableColumnReorderedSignalInfo where type HaskellCallbackType TableColumnReorderedSignalInfo = TableColumnReorderedCallback connectSignal _ obj cb connectMode = do let cb' = wrap_TableColumnReorderedCallback cb cb'' <- mk_TableColumnReorderedCallback cb' connectSignalFunPtr obj "column-reordered" cb'' connectMode data TableModelChangedSignalInfo instance SignalInfo TableModelChangedSignalInfo where type HaskellCallbackType TableModelChangedSignalInfo = TableModelChangedCallback connectSignal _ obj cb connectMode = do let cb' = wrap_TableModelChangedCallback cb cb'' <- mk_TableModelChangedCallback cb' connectSignalFunPtr obj "model-changed" cb'' connectMode data TableRowDeletedSignalInfo instance SignalInfo TableRowDeletedSignalInfo where type HaskellCallbackType TableRowDeletedSignalInfo = TableRowDeletedCallback connectSignal _ obj cb connectMode = do let cb' = wrap_TableRowDeletedCallback cb cb'' <- mk_TableRowDeletedCallback cb' connectSignalFunPtr obj "row-deleted" cb'' connectMode data TableRowInsertedSignalInfo instance SignalInfo TableRowInsertedSignalInfo where type HaskellCallbackType TableRowInsertedSignalInfo = TableRowInsertedCallback connectSignal _ obj cb connectMode = do let cb' = wrap_TableRowInsertedCallback cb cb'' <- mk_TableRowInsertedCallback cb' connectSignalFunPtr obj "row-inserted" cb'' connectMode data TableRowReorderedSignalInfo instance SignalInfo TableRowReorderedSignalInfo where type HaskellCallbackType TableRowReorderedSignalInfo = TableRowReorderedCallback connectSignal _ obj cb connectMode = do let cb' = wrap_TableRowReorderedCallback cb cb'' <- mk_TableRowReorderedCallback cb' connectSignalFunPtr obj "row-reordered" cb'' connectMode type instance O.SignalList Table = TableSignalList type TableSignalList = ('[ '("columnDeleted", TableColumnDeletedSignalInfo), '("columnInserted", TableColumnInsertedSignalInfo), '("columnReordered", TableColumnReorderedSignalInfo), '("modelChanged", TableModelChangedSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("rowDeleted", TableRowDeletedSignalInfo), '("rowInserted", TableRowInsertedSignalInfo), '("rowReordered", TableRowReorderedSignalInfo)] :: [(Symbol, *)]) #endif foreign import ccall "atk_table_get_type" c_atk_table_get_type :: IO GType instance GObject Table where gobjectType = c_atk_table_get_type -- | Type class for types which can be safely cast to `Table`, for instance with `toTable`. class (GObject o, O.IsDescendantOf Table o) => IsTable o instance (GObject o, O.IsDescendantOf Table o) => IsTable o instance O.HasParentTypes Table type instance O.ParentTypes Table = '[GObject.Object.Object] -- | Cast to `Table`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. toTable :: (MonadIO m, IsTable o) => o -> m Table toTable = liftIO . unsafeCastTo Table #if ENABLE_OVERLOADING instance O.HasAttributeList Table type instance O.AttributeList Table = TableAttributeList type TableAttributeList = ('[ ] :: [(Symbol, *)]) #endif #if ENABLE_OVERLOADING #endif #if ENABLE_OVERLOADING type family ResolveTableMethod (t :: Symbol) (o :: *) :: * where ResolveTableMethod "addColumnSelection" o = TableAddColumnSelectionMethodInfo ResolveTableMethod "addRowSelection" o = TableAddRowSelectionMethodInfo ResolveTableMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo ResolveTableMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo ResolveTableMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo ResolveTableMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo ResolveTableMethod "getv" o = GObject.Object.ObjectGetvMethodInfo ResolveTableMethod "isColumnSelected" o = TableIsColumnSelectedMethodInfo ResolveTableMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo ResolveTableMethod "isRowSelected" o = TableIsRowSelectedMethodInfo ResolveTableMethod "isSelected" o = TableIsSelectedMethodInfo ResolveTableMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo ResolveTableMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo ResolveTableMethod "ref" o = GObject.Object.ObjectRefMethodInfo ResolveTableMethod "refAt" o = TableRefAtMethodInfo ResolveTableMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo ResolveTableMethod "removeColumnSelection" o = TableRemoveColumnSelectionMethodInfo ResolveTableMethod "removeRowSelection" o = TableRemoveRowSelectionMethodInfo ResolveTableMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo ResolveTableMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo ResolveTableMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo ResolveTableMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo ResolveTableMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo ResolveTableMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo ResolveTableMethod "getCaption" o = TableGetCaptionMethodInfo ResolveTableMethod "getColumnAtIndex" o = TableGetColumnAtIndexMethodInfo ResolveTableMethod "getColumnDescription" o = TableGetColumnDescriptionMethodInfo ResolveTableMethod "getColumnExtentAt" o = TableGetColumnExtentAtMethodInfo ResolveTableMethod "getColumnHeader" o = TableGetColumnHeaderMethodInfo ResolveTableMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo ResolveTableMethod "getIndexAt" o = TableGetIndexAtMethodInfo ResolveTableMethod "getNColumns" o = TableGetNColumnsMethodInfo ResolveTableMethod "getNRows" o = TableGetNRowsMethodInfo ResolveTableMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo ResolveTableMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo ResolveTableMethod "getRowAtIndex" o = TableGetRowAtIndexMethodInfo ResolveTableMethod "getRowDescription" o = TableGetRowDescriptionMethodInfo ResolveTableMethod "getRowExtentAt" o = TableGetRowExtentAtMethodInfo ResolveTableMethod "getRowHeader" o = TableGetRowHeaderMethodInfo ResolveTableMethod "getSelectedColumns" o = TableGetSelectedColumnsMethodInfo ResolveTableMethod "getSelectedRows" o = TableGetSelectedRowsMethodInfo ResolveTableMethod "getSummary" o = TableGetSummaryMethodInfo ResolveTableMethod "setCaption" o = TableSetCaptionMethodInfo ResolveTableMethod "setColumnDescription" o = TableSetColumnDescriptionMethodInfo ResolveTableMethod "setColumnHeader" o = TableSetColumnHeaderMethodInfo ResolveTableMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo ResolveTableMethod "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 (O.MethodProxy :: O.MethodProxy info) #else fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) #endif #endif -- method Table::add_column_selection -- method type : OrdinaryMethod -- Args : [Arg {argCName = "table", argType = TInterface (Name {namespace = "Atk", name = "Table"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a GObject instance that implements AtkTableIface", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "column", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #gint representing a column in @table", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TBasicType TBoolean) -- throws : False -- Skip return : False foreign import ccall "atk_table_add_column_selection" atk_table_add_column_selection :: Ptr Table -> -- table : TInterface (Name {namespace = "Atk", name = "Table"}) Int32 -> -- column : TBasicType TInt IO CInt {- | Adds the specified /@column@/ to the selection. -} tableAddColumnSelection :: (B.CallStack.HasCallStack, MonadIO m, IsTable a) => a {- ^ /@table@/: a GObject instance that implements AtkTableIface -} -> Int32 {- ^ /@column@/: a @/gint/@ representing a column in /@table@/ -} -> m Bool {- ^ __Returns:__ a gboolean representing if the column was successfully added to the selection, or 0 if value does not implement this interface. -} tableAddColumnSelection table column = liftIO $ do table' <- unsafeManagedPtrCastPtr table result <- atk_table_add_column_selection table' column let result' = (/= 0) result touchManagedPtr table return result' #if ENABLE_OVERLOADING data TableAddColumnSelectionMethodInfo instance (signature ~ (Int32 -> m Bool), MonadIO m, IsTable a) => O.MethodInfo TableAddColumnSelectionMethodInfo a signature where overloadedMethod _ = tableAddColumnSelection #endif -- method Table::add_row_selection -- method type : OrdinaryMethod -- Args : [Arg {argCName = "table", argType = TInterface (Name {namespace = "Atk", name = "Table"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a GObject instance that implements AtkTableIface", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "row", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #gint representing a row in @table", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TBasicType TBoolean) -- throws : False -- Skip return : False foreign import ccall "atk_table_add_row_selection" atk_table_add_row_selection :: Ptr Table -> -- table : TInterface (Name {namespace = "Atk", name = "Table"}) Int32 -> -- row : TBasicType TInt IO CInt {- | Adds the specified /@row@/ to the selection. -} tableAddRowSelection :: (B.CallStack.HasCallStack, MonadIO m, IsTable a) => a {- ^ /@table@/: a GObject instance that implements AtkTableIface -} -> Int32 {- ^ /@row@/: a @/gint/@ representing a row in /@table@/ -} -> m Bool {- ^ __Returns:__ a gboolean representing if row was successfully added to selection, or 0 if value does not implement this interface. -} tableAddRowSelection table row = liftIO $ do table' <- unsafeManagedPtrCastPtr table result <- atk_table_add_row_selection table' row let result' = (/= 0) result touchManagedPtr table return result' #if ENABLE_OVERLOADING data TableAddRowSelectionMethodInfo instance (signature ~ (Int32 -> m Bool), MonadIO m, IsTable a) => O.MethodInfo TableAddRowSelectionMethodInfo a signature where overloadedMethod _ = tableAddRowSelection #endif -- method Table::get_caption -- method type : OrdinaryMethod -- Args : [Arg {argCName = "table", argType = TInterface (Name {namespace = "Atk", name = "Table"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a GObject instance that implements AtkTableInterface", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TInterface (Name {namespace = "Atk", name = "Object"})) -- throws : False -- Skip return : False foreign import ccall "atk_table_get_caption" atk_table_get_caption :: Ptr Table -> -- table : TInterface (Name {namespace = "Atk", name = "Table"}) IO (Ptr Atk.Object.Object) {- | Gets the caption for the /@table@/. -} tableGetCaption :: (B.CallStack.HasCallStack, MonadIO m, IsTable a) => a {- ^ /@table@/: a GObject instance that implements AtkTableInterface -} -> m (Maybe Atk.Object.Object) {- ^ __Returns:__ a AtkObject* representing the table caption, or 'Nothing' if value does not implement this interface. -} tableGetCaption table = liftIO $ do table' <- unsafeManagedPtrCastPtr table result <- atk_table_get_caption table' maybeResult <- convertIfNonNull result $ \result' -> do result'' <- (newObject Atk.Object.Object) result' return result'' touchManagedPtr table return maybeResult #if ENABLE_OVERLOADING data TableGetCaptionMethodInfo instance (signature ~ (m (Maybe Atk.Object.Object)), MonadIO m, IsTable a) => O.MethodInfo TableGetCaptionMethodInfo a signature where overloadedMethod _ = tableGetCaption #endif -- method Table::get_column_at_index -- method type : OrdinaryMethod -- Args : [Arg {argCName = "table", argType = TInterface (Name {namespace = "Atk", name = "Table"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a GObject instance that implements AtkTableInterface", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "index_", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #gint representing an index in @table", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TBasicType TInt) -- throws : False -- Skip return : False foreign import ccall "atk_table_get_column_at_index" atk_table_get_column_at_index :: Ptr Table -> -- table : TInterface (Name {namespace = "Atk", name = "Table"}) Int32 -> -- index_ : TBasicType TInt IO Int32 {-# DEPRECATED tableGetColumnAtIndex ["Since 2.12."] #-} {- | Gets a @/gint/@ representing the column at the specified /@index_@/. -} tableGetColumnAtIndex :: (B.CallStack.HasCallStack, MonadIO m, IsTable a) => a {- ^ /@table@/: a GObject instance that implements AtkTableInterface -} -> Int32 {- ^ /@index_@/: a @/gint/@ representing an index in /@table@/ -} -> m Int32 {- ^ __Returns:__ a gint representing the column at the specified index, or -1 if the table does not implement this method. -} tableGetColumnAtIndex table index_ = liftIO $ do table' <- unsafeManagedPtrCastPtr table result <- atk_table_get_column_at_index table' index_ touchManagedPtr table return result #if ENABLE_OVERLOADING data TableGetColumnAtIndexMethodInfo instance (signature ~ (Int32 -> m Int32), MonadIO m, IsTable a) => O.MethodInfo TableGetColumnAtIndexMethodInfo a signature where overloadedMethod _ = tableGetColumnAtIndex #endif -- method Table::get_column_description -- method type : OrdinaryMethod -- Args : [Arg {argCName = "table", argType = TInterface (Name {namespace = "Atk", name = "Table"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a GObject instance that implements AtkTableIface", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "column", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #gint representing a column in @table", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TBasicType TUTF8) -- throws : False -- Skip return : False foreign import ccall "atk_table_get_column_description" atk_table_get_column_description :: Ptr Table -> -- table : TInterface (Name {namespace = "Atk", name = "Table"}) Int32 -> -- column : TBasicType TInt IO CString {- | Gets the description text of the specified /@column@/ in the table -} tableGetColumnDescription :: (B.CallStack.HasCallStack, MonadIO m, IsTable a) => a {- ^ /@table@/: a GObject instance that implements AtkTableIface -} -> Int32 {- ^ /@column@/: a @/gint/@ representing a column in /@table@/ -} -> m T.Text {- ^ __Returns:__ a gchar* representing the column description, or 'Nothing' if value does not implement this interface. -} tableGetColumnDescription table column = liftIO $ do table' <- unsafeManagedPtrCastPtr table result <- atk_table_get_column_description table' column checkUnexpectedReturnNULL "tableGetColumnDescription" result result' <- cstringToText result touchManagedPtr table return result' #if ENABLE_OVERLOADING data TableGetColumnDescriptionMethodInfo instance (signature ~ (Int32 -> m T.Text), MonadIO m, IsTable a) => O.MethodInfo TableGetColumnDescriptionMethodInfo a signature where overloadedMethod _ = tableGetColumnDescription #endif -- method Table::get_column_extent_at -- method type : OrdinaryMethod -- Args : [Arg {argCName = "table", argType = TInterface (Name {namespace = "Atk", name = "Table"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a GObject instance that implements AtkTableIface", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "row", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #gint representing a row in @table", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "column", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #gint representing a column in @table", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TBasicType TInt) -- throws : False -- Skip return : False foreign import ccall "atk_table_get_column_extent_at" atk_table_get_column_extent_at :: Ptr Table -> -- table : TInterface (Name {namespace = "Atk", name = "Table"}) Int32 -> -- row : TBasicType TInt Int32 -> -- column : TBasicType TInt IO Int32 {- | Gets the number of columns occupied by the accessible object at the specified /@row@/ and /@column@/ in the /@table@/. -} tableGetColumnExtentAt :: (B.CallStack.HasCallStack, MonadIO m, IsTable a) => a {- ^ /@table@/: a GObject instance that implements AtkTableIface -} -> Int32 {- ^ /@row@/: a @/gint/@ representing a row in /@table@/ -} -> Int32 {- ^ /@column@/: a @/gint/@ representing a column in /@table@/ -} -> m Int32 {- ^ __Returns:__ a gint representing the column extent at specified position, or 0 if value does not implement this interface. -} tableGetColumnExtentAt table row column = liftIO $ do table' <- unsafeManagedPtrCastPtr table result <- atk_table_get_column_extent_at table' row column touchManagedPtr table return result #if ENABLE_OVERLOADING data TableGetColumnExtentAtMethodInfo instance (signature ~ (Int32 -> Int32 -> m Int32), MonadIO m, IsTable a) => O.MethodInfo TableGetColumnExtentAtMethodInfo a signature where overloadedMethod _ = tableGetColumnExtentAt #endif -- method Table::get_column_header -- method type : OrdinaryMethod -- Args : [Arg {argCName = "table", argType = TInterface (Name {namespace = "Atk", name = "Table"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a GObject instance that implements AtkTableIface", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "column", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #gint representing a column in the table", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TInterface (Name {namespace = "Atk", name = "Object"})) -- throws : False -- Skip return : False foreign import ccall "atk_table_get_column_header" atk_table_get_column_header :: Ptr Table -> -- table : TInterface (Name {namespace = "Atk", name = "Table"}) Int32 -> -- column : TBasicType TInt IO (Ptr Atk.Object.Object) {- | Gets the column header of a specified column in an accessible table. -} tableGetColumnHeader :: (B.CallStack.HasCallStack, MonadIO m, IsTable a) => a {- ^ /@table@/: a GObject instance that implements AtkTableIface -} -> Int32 {- ^ /@column@/: a @/gint/@ representing a column in the table -} -> m (Maybe Atk.Object.Object) {- ^ __Returns:__ a AtkObject* representing the specified column header, or 'Nothing' if value does not implement this interface. -} tableGetColumnHeader table column = liftIO $ do table' <- unsafeManagedPtrCastPtr table result <- atk_table_get_column_header table' column maybeResult <- convertIfNonNull result $ \result' -> do result'' <- (newObject Atk.Object.Object) result' return result'' touchManagedPtr table return maybeResult #if ENABLE_OVERLOADING data TableGetColumnHeaderMethodInfo instance (signature ~ (Int32 -> m (Maybe Atk.Object.Object)), MonadIO m, IsTable a) => O.MethodInfo TableGetColumnHeaderMethodInfo a signature where overloadedMethod _ = tableGetColumnHeader #endif -- method Table::get_index_at -- method type : OrdinaryMethod -- Args : [Arg {argCName = "table", argType = TInterface (Name {namespace = "Atk", name = "Table"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a GObject instance that implements AtkTableIface", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "row", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #gint representing a row in @table", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "column", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #gint representing a column in @table", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TBasicType TInt) -- throws : False -- Skip return : False foreign import ccall "atk_table_get_index_at" atk_table_get_index_at :: Ptr Table -> -- table : TInterface (Name {namespace = "Atk", name = "Table"}) Int32 -> -- row : TBasicType TInt Int32 -> -- column : TBasicType TInt IO Int32 {-# DEPRECATED tableGetIndexAt ["Since 2.12. Use 'GI.Atk.Interfaces.Table.tableRefAt' in order to get the","accessible that represents the cell at (/@row@/, /@column@/)"] #-} {- | Gets a @/gint/@ representing the index at the specified /@row@/ and /@column@/. -} tableGetIndexAt :: (B.CallStack.HasCallStack, MonadIO m, IsTable a) => a {- ^ /@table@/: a GObject instance that implements AtkTableIface -} -> Int32 {- ^ /@row@/: a @/gint/@ representing a row in /@table@/ -} -> Int32 {- ^ /@column@/: a @/gint/@ representing a column in /@table@/ -} -> m Int32 {- ^ __Returns:__ a @/gint/@ representing the index at specified position. The value -1 is returned if the object at row,column is not a child of table or table does not implement this interface. -} tableGetIndexAt table row column = liftIO $ do table' <- unsafeManagedPtrCastPtr table result <- atk_table_get_index_at table' row column touchManagedPtr table return result #if ENABLE_OVERLOADING data TableGetIndexAtMethodInfo instance (signature ~ (Int32 -> Int32 -> m Int32), MonadIO m, IsTable a) => O.MethodInfo TableGetIndexAtMethodInfo a signature where overloadedMethod _ = tableGetIndexAt #endif -- method Table::get_n_columns -- method type : OrdinaryMethod -- Args : [Arg {argCName = "table", argType = TInterface (Name {namespace = "Atk", name = "Table"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a GObject instance that implements AtkTableIface", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TBasicType TInt) -- throws : False -- Skip return : False foreign import ccall "atk_table_get_n_columns" atk_table_get_n_columns :: Ptr Table -> -- table : TInterface (Name {namespace = "Atk", name = "Table"}) IO Int32 {- | Gets the number of columns in the table. -} tableGetNColumns :: (B.CallStack.HasCallStack, MonadIO m, IsTable a) => a {- ^ /@table@/: a GObject instance that implements AtkTableIface -} -> m Int32 {- ^ __Returns:__ a gint representing the number of columns, or 0 if value does not implement this interface. -} tableGetNColumns table = liftIO $ do table' <- unsafeManagedPtrCastPtr table result <- atk_table_get_n_columns table' touchManagedPtr table return result #if ENABLE_OVERLOADING data TableGetNColumnsMethodInfo instance (signature ~ (m Int32), MonadIO m, IsTable a) => O.MethodInfo TableGetNColumnsMethodInfo a signature where overloadedMethod _ = tableGetNColumns #endif -- method Table::get_n_rows -- method type : OrdinaryMethod -- Args : [Arg {argCName = "table", argType = TInterface (Name {namespace = "Atk", name = "Table"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a GObject instance that implements AtkTableIface", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TBasicType TInt) -- throws : False -- Skip return : False foreign import ccall "atk_table_get_n_rows" atk_table_get_n_rows :: Ptr Table -> -- table : TInterface (Name {namespace = "Atk", name = "Table"}) IO Int32 {- | Gets the number of rows in the table. -} tableGetNRows :: (B.CallStack.HasCallStack, MonadIO m, IsTable a) => a {- ^ /@table@/: a GObject instance that implements AtkTableIface -} -> m Int32 {- ^ __Returns:__ a gint representing the number of rows, or 0 if value does not implement this interface. -} tableGetNRows table = liftIO $ do table' <- unsafeManagedPtrCastPtr table result <- atk_table_get_n_rows table' touchManagedPtr table return result #if ENABLE_OVERLOADING data TableGetNRowsMethodInfo instance (signature ~ (m Int32), MonadIO m, IsTable a) => O.MethodInfo TableGetNRowsMethodInfo a signature where overloadedMethod _ = tableGetNRows #endif -- method Table::get_row_at_index -- method type : OrdinaryMethod -- Args : [Arg {argCName = "table", argType = TInterface (Name {namespace = "Atk", name = "Table"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a GObject instance that implements AtkTableInterface", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "index_", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #gint representing an index in @table", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TBasicType TInt) -- throws : False -- Skip return : False foreign import ccall "atk_table_get_row_at_index" atk_table_get_row_at_index :: Ptr Table -> -- table : TInterface (Name {namespace = "Atk", name = "Table"}) Int32 -> -- index_ : TBasicType TInt IO Int32 {-# DEPRECATED tableGetRowAtIndex ["since 2.12."] #-} {- | Gets a @/gint/@ representing the row at the specified /@index_@/. -} tableGetRowAtIndex :: (B.CallStack.HasCallStack, MonadIO m, IsTable a) => a {- ^ /@table@/: a GObject instance that implements AtkTableInterface -} -> Int32 {- ^ /@index_@/: a @/gint/@ representing an index in /@table@/ -} -> m Int32 {- ^ __Returns:__ a gint representing the row at the specified index, or -1 if the table does not implement this method. -} tableGetRowAtIndex table index_ = liftIO $ do table' <- unsafeManagedPtrCastPtr table result <- atk_table_get_row_at_index table' index_ touchManagedPtr table return result #if ENABLE_OVERLOADING data TableGetRowAtIndexMethodInfo instance (signature ~ (Int32 -> m Int32), MonadIO m, IsTable a) => O.MethodInfo TableGetRowAtIndexMethodInfo a signature where overloadedMethod _ = tableGetRowAtIndex #endif -- method Table::get_row_description -- method type : OrdinaryMethod -- Args : [Arg {argCName = "table", argType = TInterface (Name {namespace = "Atk", name = "Table"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a GObject instance that implements AtkTableIface", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "row", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #gint representing a row in @table", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TBasicType TUTF8) -- throws : False -- Skip return : False foreign import ccall "atk_table_get_row_description" atk_table_get_row_description :: Ptr Table -> -- table : TInterface (Name {namespace = "Atk", name = "Table"}) Int32 -> -- row : TBasicType TInt IO CString {- | Gets the description text of the specified row in the table -} tableGetRowDescription :: (B.CallStack.HasCallStack, MonadIO m, IsTable a) => a {- ^ /@table@/: a GObject instance that implements AtkTableIface -} -> Int32 {- ^ /@row@/: a @/gint/@ representing a row in /@table@/ -} -> m (Maybe T.Text) {- ^ __Returns:__ a gchar* representing the row description, or 'Nothing' if value does not implement this interface. -} tableGetRowDescription table row = liftIO $ do table' <- unsafeManagedPtrCastPtr table result <- atk_table_get_row_description table' row maybeResult <- convertIfNonNull result $ \result' -> do result'' <- cstringToText result' return result'' touchManagedPtr table return maybeResult #if ENABLE_OVERLOADING data TableGetRowDescriptionMethodInfo instance (signature ~ (Int32 -> m (Maybe T.Text)), MonadIO m, IsTable a) => O.MethodInfo TableGetRowDescriptionMethodInfo a signature where overloadedMethod _ = tableGetRowDescription #endif -- method Table::get_row_extent_at -- method type : OrdinaryMethod -- Args : [Arg {argCName = "table", argType = TInterface (Name {namespace = "Atk", name = "Table"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a GObject instance that implements AtkTableIface", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "row", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #gint representing a row in @table", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "column", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #gint representing a column in @table", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TBasicType TInt) -- throws : False -- Skip return : False foreign import ccall "atk_table_get_row_extent_at" atk_table_get_row_extent_at :: Ptr Table -> -- table : TInterface (Name {namespace = "Atk", name = "Table"}) Int32 -> -- row : TBasicType TInt Int32 -> -- column : TBasicType TInt IO Int32 {- | Gets the number of rows occupied by the accessible object at a specified /@row@/ and /@column@/ in the /@table@/. -} tableGetRowExtentAt :: (B.CallStack.HasCallStack, MonadIO m, IsTable a) => a {- ^ /@table@/: a GObject instance that implements AtkTableIface -} -> Int32 {- ^ /@row@/: a @/gint/@ representing a row in /@table@/ -} -> Int32 {- ^ /@column@/: a @/gint/@ representing a column in /@table@/ -} -> m Int32 {- ^ __Returns:__ a gint representing the row extent at specified position, or 0 if value does not implement this interface. -} tableGetRowExtentAt table row column = liftIO $ do table' <- unsafeManagedPtrCastPtr table result <- atk_table_get_row_extent_at table' row column touchManagedPtr table return result #if ENABLE_OVERLOADING data TableGetRowExtentAtMethodInfo instance (signature ~ (Int32 -> Int32 -> m Int32), MonadIO m, IsTable a) => O.MethodInfo TableGetRowExtentAtMethodInfo a signature where overloadedMethod _ = tableGetRowExtentAt #endif -- method Table::get_row_header -- method type : OrdinaryMethod -- Args : [Arg {argCName = "table", argType = TInterface (Name {namespace = "Atk", name = "Table"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a GObject instance that implements AtkTableIface", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "row", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #gint representing a row in the table", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TInterface (Name {namespace = "Atk", name = "Object"})) -- throws : False -- Skip return : False foreign import ccall "atk_table_get_row_header" atk_table_get_row_header :: Ptr Table -> -- table : TInterface (Name {namespace = "Atk", name = "Table"}) Int32 -> -- row : TBasicType TInt IO (Ptr Atk.Object.Object) {- | Gets the row header of a specified row in an accessible table. -} tableGetRowHeader :: (B.CallStack.HasCallStack, MonadIO m, IsTable a) => a {- ^ /@table@/: a GObject instance that implements AtkTableIface -} -> Int32 {- ^ /@row@/: a @/gint/@ representing a row in the table -} -> m (Maybe Atk.Object.Object) {- ^ __Returns:__ a AtkObject* representing the specified row header, or 'Nothing' if value does not implement this interface. -} tableGetRowHeader table row = liftIO $ do table' <- unsafeManagedPtrCastPtr table result <- atk_table_get_row_header table' row maybeResult <- convertIfNonNull result $ \result' -> do result'' <- (newObject Atk.Object.Object) result' return result'' touchManagedPtr table return maybeResult #if ENABLE_OVERLOADING data TableGetRowHeaderMethodInfo instance (signature ~ (Int32 -> m (Maybe Atk.Object.Object)), MonadIO m, IsTable a) => O.MethodInfo TableGetRowHeaderMethodInfo a signature where overloadedMethod _ = tableGetRowHeader #endif -- method Table::get_selected_columns -- method type : OrdinaryMethod -- Args : [Arg {argCName = "table", argType = TInterface (Name {namespace = "Atk", name = "Table"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a GObject instance that implements AtkTableIface", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "selected", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #gint** that is to contain the selected columns numbers", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TBasicType TInt) -- throws : False -- Skip return : False foreign import ccall "atk_table_get_selected_columns" atk_table_get_selected_columns :: Ptr Table -> -- table : TInterface (Name {namespace = "Atk", name = "Table"}) Int32 -> -- selected : TBasicType TInt IO Int32 {- | Gets the selected columns of the table by initializing **selected with the selected column numbers. This array should be freed by the caller. -} tableGetSelectedColumns :: (B.CallStack.HasCallStack, MonadIO m, IsTable a) => a {- ^ /@table@/: a GObject instance that implements AtkTableIface -} -> Int32 {- ^ /@selected@/: a @/gint/@** that is to contain the selected columns numbers -} -> m Int32 {- ^ __Returns:__ a gint representing the number of selected columns, or @/0/@ if value does not implement this interface. -} tableGetSelectedColumns table selected = liftIO $ do table' <- unsafeManagedPtrCastPtr table result <- atk_table_get_selected_columns table' selected touchManagedPtr table return result #if ENABLE_OVERLOADING data TableGetSelectedColumnsMethodInfo instance (signature ~ (Int32 -> m Int32), MonadIO m, IsTable a) => O.MethodInfo TableGetSelectedColumnsMethodInfo a signature where overloadedMethod _ = tableGetSelectedColumns #endif -- method Table::get_selected_rows -- method type : OrdinaryMethod -- Args : [Arg {argCName = "table", argType = TInterface (Name {namespace = "Atk", name = "Table"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a GObject instance that implements AtkTableIface", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "selected", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #gint** that is to contain the selected row numbers", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TBasicType TInt) -- throws : False -- Skip return : False foreign import ccall "atk_table_get_selected_rows" atk_table_get_selected_rows :: Ptr Table -> -- table : TInterface (Name {namespace = "Atk", name = "Table"}) Int32 -> -- selected : TBasicType TInt IO Int32 {- | Gets the selected rows of the table by initializing **selected with the selected row numbers. This array should be freed by the caller. -} tableGetSelectedRows :: (B.CallStack.HasCallStack, MonadIO m, IsTable a) => a {- ^ /@table@/: a GObject instance that implements AtkTableIface -} -> Int32 {- ^ /@selected@/: a @/gint/@** that is to contain the selected row numbers -} -> m Int32 {- ^ __Returns:__ a gint representing the number of selected rows, or zero if value does not implement this interface. -} tableGetSelectedRows table selected = liftIO $ do table' <- unsafeManagedPtrCastPtr table result <- atk_table_get_selected_rows table' selected touchManagedPtr table return result #if ENABLE_OVERLOADING data TableGetSelectedRowsMethodInfo instance (signature ~ (Int32 -> m Int32), MonadIO m, IsTable a) => O.MethodInfo TableGetSelectedRowsMethodInfo a signature where overloadedMethod _ = tableGetSelectedRows #endif -- method Table::get_summary -- method type : OrdinaryMethod -- Args : [Arg {argCName = "table", argType = TInterface (Name {namespace = "Atk", name = "Table"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a GObject instance that implements AtkTableIface", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TInterface (Name {namespace = "Atk", name = "Object"})) -- throws : False -- Skip return : False foreign import ccall "atk_table_get_summary" atk_table_get_summary :: Ptr Table -> -- table : TInterface (Name {namespace = "Atk", name = "Table"}) IO (Ptr Atk.Object.Object) {- | Gets the summary description of the table. -} tableGetSummary :: (B.CallStack.HasCallStack, MonadIO m, IsTable a) => a {- ^ /@table@/: a GObject instance that implements AtkTableIface -} -> m Atk.Object.Object {- ^ __Returns:__ a AtkObject* representing a summary description of the table, or zero if value does not implement this interface. -} tableGetSummary table = liftIO $ do table' <- unsafeManagedPtrCastPtr table result <- atk_table_get_summary table' checkUnexpectedReturnNULL "tableGetSummary" result result' <- (wrapObject Atk.Object.Object) result touchManagedPtr table return result' #if ENABLE_OVERLOADING data TableGetSummaryMethodInfo instance (signature ~ (m Atk.Object.Object), MonadIO m, IsTable a) => O.MethodInfo TableGetSummaryMethodInfo a signature where overloadedMethod _ = tableGetSummary #endif -- method Table::is_column_selected -- method type : OrdinaryMethod -- Args : [Arg {argCName = "table", argType = TInterface (Name {namespace = "Atk", name = "Table"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a GObject instance that implements AtkTableIface", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "column", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #gint representing a column in @table", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TBasicType TBoolean) -- throws : False -- Skip return : False foreign import ccall "atk_table_is_column_selected" atk_table_is_column_selected :: Ptr Table -> -- table : TInterface (Name {namespace = "Atk", name = "Table"}) Int32 -> -- column : TBasicType TInt IO CInt {- | Gets a boolean value indicating whether the specified /@column@/ is selected -} tableIsColumnSelected :: (B.CallStack.HasCallStack, MonadIO m, IsTable a) => a {- ^ /@table@/: a GObject instance that implements AtkTableIface -} -> Int32 {- ^ /@column@/: a @/gint/@ representing a column in /@table@/ -} -> m Bool {- ^ __Returns:__ a gboolean representing if the column is selected, or 0 if value does not implement this interface. -} tableIsColumnSelected table column = liftIO $ do table' <- unsafeManagedPtrCastPtr table result <- atk_table_is_column_selected table' column let result' = (/= 0) result touchManagedPtr table return result' #if ENABLE_OVERLOADING data TableIsColumnSelectedMethodInfo instance (signature ~ (Int32 -> m Bool), MonadIO m, IsTable a) => O.MethodInfo TableIsColumnSelectedMethodInfo a signature where overloadedMethod _ = tableIsColumnSelected #endif -- method Table::is_row_selected -- method type : OrdinaryMethod -- Args : [Arg {argCName = "table", argType = TInterface (Name {namespace = "Atk", name = "Table"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a GObject instance that implements AtkTableIface", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "row", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #gint representing a row in @table", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TBasicType TBoolean) -- throws : False -- Skip return : False foreign import ccall "atk_table_is_row_selected" atk_table_is_row_selected :: Ptr Table -> -- table : TInterface (Name {namespace = "Atk", name = "Table"}) Int32 -> -- row : TBasicType TInt IO CInt {- | Gets a boolean value indicating whether the specified /@row@/ is selected -} tableIsRowSelected :: (B.CallStack.HasCallStack, MonadIO m, IsTable a) => a {- ^ /@table@/: a GObject instance that implements AtkTableIface -} -> Int32 {- ^ /@row@/: a @/gint/@ representing a row in /@table@/ -} -> m Bool {- ^ __Returns:__ a gboolean representing if the row is selected, or 0 if value does not implement this interface. -} tableIsRowSelected table row = liftIO $ do table' <- unsafeManagedPtrCastPtr table result <- atk_table_is_row_selected table' row let result' = (/= 0) result touchManagedPtr table return result' #if ENABLE_OVERLOADING data TableIsRowSelectedMethodInfo instance (signature ~ (Int32 -> m Bool), MonadIO m, IsTable a) => O.MethodInfo TableIsRowSelectedMethodInfo a signature where overloadedMethod _ = tableIsRowSelected #endif -- method Table::is_selected -- method type : OrdinaryMethod -- Args : [Arg {argCName = "table", argType = TInterface (Name {namespace = "Atk", name = "Table"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a GObject instance that implements AtkTableIface", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "row", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #gint representing a row in @table", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "column", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #gint representing a column in @table", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TBasicType TBoolean) -- throws : False -- Skip return : False foreign import ccall "atk_table_is_selected" atk_table_is_selected :: Ptr Table -> -- table : TInterface (Name {namespace = "Atk", name = "Table"}) Int32 -> -- row : TBasicType TInt Int32 -> -- column : TBasicType TInt IO CInt {- | Gets a boolean value indicating whether the accessible object at the specified /@row@/ and /@column@/ is selected -} tableIsSelected :: (B.CallStack.HasCallStack, MonadIO m, IsTable a) => a {- ^ /@table@/: a GObject instance that implements AtkTableIface -} -> Int32 {- ^ /@row@/: a @/gint/@ representing a row in /@table@/ -} -> Int32 {- ^ /@column@/: a @/gint/@ representing a column in /@table@/ -} -> m Bool {- ^ __Returns:__ a gboolean representing if the cell is selected, or 0 if value does not implement this interface. -} tableIsSelected table row column = liftIO $ do table' <- unsafeManagedPtrCastPtr table result <- atk_table_is_selected table' row column let result' = (/= 0) result touchManagedPtr table return result' #if ENABLE_OVERLOADING data TableIsSelectedMethodInfo instance (signature ~ (Int32 -> Int32 -> m Bool), MonadIO m, IsTable a) => O.MethodInfo TableIsSelectedMethodInfo a signature where overloadedMethod _ = tableIsSelected #endif -- method Table::ref_at -- method type : OrdinaryMethod -- Args : [Arg {argCName = "table", argType = TInterface (Name {namespace = "Atk", name = "Table"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a GObject instance that implements AtkTableIface", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "row", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #gint representing a row in @table", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "column", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #gint representing a column in @table", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TInterface (Name {namespace = "Atk", name = "Object"})) -- throws : False -- Skip return : False foreign import ccall "atk_table_ref_at" atk_table_ref_at :: Ptr Table -> -- table : TInterface (Name {namespace = "Atk", name = "Table"}) Int32 -> -- row : TBasicType TInt Int32 -> -- column : TBasicType TInt IO (Ptr Atk.Object.Object) {- | Get a reference to the table cell at /@row@/, /@column@/. This cell should implement the interface 'GI.Atk.Interfaces.TableCell.TableCell' -} tableRefAt :: (B.CallStack.HasCallStack, MonadIO m, IsTable a) => a {- ^ /@table@/: a GObject instance that implements AtkTableIface -} -> Int32 {- ^ /@row@/: a @/gint/@ representing a row in /@table@/ -} -> Int32 {- ^ /@column@/: a @/gint/@ representing a column in /@table@/ -} -> m Atk.Object.Object {- ^ __Returns:__ an 'GI.Atk.Objects.Object.Object' representing the referred to accessible -} tableRefAt table row column = liftIO $ do table' <- unsafeManagedPtrCastPtr table result <- atk_table_ref_at table' row column checkUnexpectedReturnNULL "tableRefAt" result result' <- (wrapObject Atk.Object.Object) result touchManagedPtr table return result' #if ENABLE_OVERLOADING data TableRefAtMethodInfo instance (signature ~ (Int32 -> Int32 -> m Atk.Object.Object), MonadIO m, IsTable a) => O.MethodInfo TableRefAtMethodInfo a signature where overloadedMethod _ = tableRefAt #endif -- method Table::remove_column_selection -- method type : OrdinaryMethod -- Args : [Arg {argCName = "table", argType = TInterface (Name {namespace = "Atk", name = "Table"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a GObject instance that implements AtkTableIface", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "column", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #gint representing a column in @table", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TBasicType TBoolean) -- throws : False -- Skip return : False foreign import ccall "atk_table_remove_column_selection" atk_table_remove_column_selection :: Ptr Table -> -- table : TInterface (Name {namespace = "Atk", name = "Table"}) Int32 -> -- column : TBasicType TInt IO CInt {- | Adds the specified /@column@/ to the selection. -} tableRemoveColumnSelection :: (B.CallStack.HasCallStack, MonadIO m, IsTable a) => a {- ^ /@table@/: a GObject instance that implements AtkTableIface -} -> Int32 {- ^ /@column@/: a @/gint/@ representing a column in /@table@/ -} -> m Bool {- ^ __Returns:__ a gboolean representing if the column was successfully removed from the selection, or 0 if value does not implement this interface. -} tableRemoveColumnSelection table column = liftIO $ do table' <- unsafeManagedPtrCastPtr table result <- atk_table_remove_column_selection table' column let result' = (/= 0) result touchManagedPtr table return result' #if ENABLE_OVERLOADING data TableRemoveColumnSelectionMethodInfo instance (signature ~ (Int32 -> m Bool), MonadIO m, IsTable a) => O.MethodInfo TableRemoveColumnSelectionMethodInfo a signature where overloadedMethod _ = tableRemoveColumnSelection #endif -- method Table::remove_row_selection -- method type : OrdinaryMethod -- Args : [Arg {argCName = "table", argType = TInterface (Name {namespace = "Atk", name = "Table"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a GObject instance that implements AtkTableIface", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "row", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #gint representing a row in @table", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TBasicType TBoolean) -- throws : False -- Skip return : False foreign import ccall "atk_table_remove_row_selection" atk_table_remove_row_selection :: Ptr Table -> -- table : TInterface (Name {namespace = "Atk", name = "Table"}) Int32 -> -- row : TBasicType TInt IO CInt {- | Removes the specified /@row@/ from the selection. -} tableRemoveRowSelection :: (B.CallStack.HasCallStack, MonadIO m, IsTable a) => a {- ^ /@table@/: a GObject instance that implements AtkTableIface -} -> Int32 {- ^ /@row@/: a @/gint/@ representing a row in /@table@/ -} -> m Bool {- ^ __Returns:__ a gboolean representing if the row was successfully removed from the selection, or 0 if value does not implement this interface. -} tableRemoveRowSelection table row = liftIO $ do table' <- unsafeManagedPtrCastPtr table result <- atk_table_remove_row_selection table' row let result' = (/= 0) result touchManagedPtr table return result' #if ENABLE_OVERLOADING data TableRemoveRowSelectionMethodInfo instance (signature ~ (Int32 -> m Bool), MonadIO m, IsTable a) => O.MethodInfo TableRemoveRowSelectionMethodInfo a signature where overloadedMethod _ = tableRemoveRowSelection #endif -- method Table::set_caption -- method type : OrdinaryMethod -- Args : [Arg {argCName = "table", argType = TInterface (Name {namespace = "Atk", name = "Table"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a GObject instance that implements AtkTableIface", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "caption", argType = TInterface (Name {namespace = "Atk", name = "Object"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #AtkObject representing the caption to set for @table", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Nothing -- throws : False -- Skip return : False foreign import ccall "atk_table_set_caption" atk_table_set_caption :: Ptr Table -> -- table : TInterface (Name {namespace = "Atk", name = "Table"}) Ptr Atk.Object.Object -> -- caption : TInterface (Name {namespace = "Atk", name = "Object"}) IO () {- | Sets the caption for the table. -} tableSetCaption :: (B.CallStack.HasCallStack, MonadIO m, IsTable a, Atk.Object.IsObject b) => a {- ^ /@table@/: a GObject instance that implements AtkTableIface -} -> b {- ^ /@caption@/: a 'GI.Atk.Objects.Object.Object' representing the caption to set for /@table@/ -} -> m () tableSetCaption table caption = liftIO $ do table' <- unsafeManagedPtrCastPtr table caption' <- unsafeManagedPtrCastPtr caption atk_table_set_caption table' caption' touchManagedPtr table touchManagedPtr caption return () #if ENABLE_OVERLOADING data TableSetCaptionMethodInfo instance (signature ~ (b -> m ()), MonadIO m, IsTable a, Atk.Object.IsObject b) => O.MethodInfo TableSetCaptionMethodInfo a signature where overloadedMethod _ = tableSetCaption #endif -- method Table::set_column_description -- method type : OrdinaryMethod -- Args : [Arg {argCName = "table", argType = TInterface (Name {namespace = "Atk", name = "Table"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a GObject instance that implements AtkTableIface", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "column", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #gint representing a column in @table", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "description", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #gchar representing the description text\nto set for the specified @column of the @table", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Nothing -- throws : False -- Skip return : False foreign import ccall "atk_table_set_column_description" atk_table_set_column_description :: Ptr Table -> -- table : TInterface (Name {namespace = "Atk", name = "Table"}) Int32 -> -- column : TBasicType TInt CString -> -- description : TBasicType TUTF8 IO () {- | Sets the description text for the specified /@column@/ of the /@table@/. -} tableSetColumnDescription :: (B.CallStack.HasCallStack, MonadIO m, IsTable a) => a {- ^ /@table@/: a GObject instance that implements AtkTableIface -} -> Int32 {- ^ /@column@/: a @/gint/@ representing a column in /@table@/ -} -> T.Text {- ^ /@description@/: a @/gchar/@ representing the description text to set for the specified /@column@/ of the /@table@/ -} -> m () tableSetColumnDescription table column description = liftIO $ do table' <- unsafeManagedPtrCastPtr table description' <- textToCString description atk_table_set_column_description table' column description' touchManagedPtr table freeMem description' return () #if ENABLE_OVERLOADING data TableSetColumnDescriptionMethodInfo instance (signature ~ (Int32 -> T.Text -> m ()), MonadIO m, IsTable a) => O.MethodInfo TableSetColumnDescriptionMethodInfo a signature where overloadedMethod _ = tableSetColumnDescription #endif -- method Table::set_column_header -- method type : OrdinaryMethod -- Args : [Arg {argCName = "table", argType = TInterface (Name {namespace = "Atk", name = "Table"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a GObject instance that implements AtkTableIface", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "column", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #gint representing a column in @table", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "header", argType = TInterface (Name {namespace = "Atk", name = "Object"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an #AtkTable", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Nothing -- throws : False -- Skip return : False foreign import ccall "atk_table_set_column_header" atk_table_set_column_header :: Ptr Table -> -- table : TInterface (Name {namespace = "Atk", name = "Table"}) Int32 -> -- column : TBasicType TInt Ptr Atk.Object.Object -> -- header : TInterface (Name {namespace = "Atk", name = "Object"}) IO () {- | Sets the specified column header to /@header@/. -} tableSetColumnHeader :: (B.CallStack.HasCallStack, MonadIO m, IsTable a, Atk.Object.IsObject b) => a {- ^ /@table@/: a GObject instance that implements AtkTableIface -} -> Int32 {- ^ /@column@/: a @/gint/@ representing a column in /@table@/ -} -> b {- ^ /@header@/: an 'GI.Atk.Interfaces.Table.Table' -} -> m () tableSetColumnHeader table column header = liftIO $ do table' <- unsafeManagedPtrCastPtr table header' <- unsafeManagedPtrCastPtr header atk_table_set_column_header table' column header' touchManagedPtr table touchManagedPtr header return () #if ENABLE_OVERLOADING data TableSetColumnHeaderMethodInfo instance (signature ~ (Int32 -> b -> m ()), MonadIO m, IsTable a, Atk.Object.IsObject b) => O.MethodInfo TableSetColumnHeaderMethodInfo a signature where overloadedMethod _ = tableSetColumnHeader #endif -- method Table::set_row_description -- method type : OrdinaryMethod -- Args : [Arg {argCName = "table", argType = TInterface (Name {namespace = "Atk", name = "Table"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a GObject instance that implements AtkTableIface", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "row", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #gint representing a row in @table", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "description", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #gchar representing the description text\nto set for the specified @row of @table", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Nothing -- throws : False -- Skip return : False foreign import ccall "atk_table_set_row_description" atk_table_set_row_description :: Ptr Table -> -- table : TInterface (Name {namespace = "Atk", name = "Table"}) Int32 -> -- row : TBasicType TInt CString -> -- description : TBasicType TUTF8 IO () {- | Sets the description text for the specified /@row@/ of /@table@/. -} tableSetRowDescription :: (B.CallStack.HasCallStack, MonadIO m, IsTable a) => a {- ^ /@table@/: a GObject instance that implements AtkTableIface -} -> Int32 {- ^ /@row@/: a @/gint/@ representing a row in /@table@/ -} -> T.Text {- ^ /@description@/: a @/gchar/@ representing the description text to set for the specified /@row@/ of /@table@/ -} -> m () tableSetRowDescription table row description = liftIO $ do table' <- unsafeManagedPtrCastPtr table description' <- textToCString description atk_table_set_row_description table' row description' touchManagedPtr table freeMem description' return () #if ENABLE_OVERLOADING data TableSetRowDescriptionMethodInfo instance (signature ~ (Int32 -> T.Text -> m ()), MonadIO m, IsTable a) => O.MethodInfo TableSetRowDescriptionMethodInfo a signature where overloadedMethod _ = tableSetRowDescription #endif -- method Table::set_row_header -- method type : OrdinaryMethod -- Args : [Arg {argCName = "table", argType = TInterface (Name {namespace = "Atk", name = "Table"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a GObject instance that implements AtkTableIface", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "row", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #gint representing a row in @table", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "header", argType = TInterface (Name {namespace = "Atk", name = "Object"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an #AtkTable", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Nothing -- throws : False -- Skip return : False foreign import ccall "atk_table_set_row_header" atk_table_set_row_header :: Ptr Table -> -- table : TInterface (Name {namespace = "Atk", name = "Table"}) Int32 -> -- row : TBasicType TInt Ptr Atk.Object.Object -> -- header : TInterface (Name {namespace = "Atk", name = "Object"}) IO () {- | Sets the specified row header to /@header@/. -} tableSetRowHeader :: (B.CallStack.HasCallStack, MonadIO m, IsTable a, Atk.Object.IsObject b) => a {- ^ /@table@/: a GObject instance that implements AtkTableIface -} -> Int32 {- ^ /@row@/: a @/gint/@ representing a row in /@table@/ -} -> b {- ^ /@header@/: an 'GI.Atk.Interfaces.Table.Table' -} -> m () tableSetRowHeader table row header = liftIO $ do table' <- unsafeManagedPtrCastPtr table header' <- unsafeManagedPtrCastPtr header atk_table_set_row_header table' row header' touchManagedPtr table touchManagedPtr header return () #if ENABLE_OVERLOADING data TableSetRowHeaderMethodInfo instance (signature ~ (Int32 -> b -> m ()), MonadIO m, IsTable a, Atk.Object.IsObject b) => O.MethodInfo TableSetRowHeaderMethodInfo a signature where overloadedMethod _ = tableSetRowHeader #endif -- method Table::set_summary -- method type : OrdinaryMethod -- Args : [Arg {argCName = "table", argType = TInterface (Name {namespace = "Atk", name = "Table"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a GObject instance that implements AtkTableIface", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "accessible", argType = TInterface (Name {namespace = "Atk", name = "Object"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an #AtkObject representing the summary description\nto set for @table", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Nothing -- throws : False -- Skip return : False foreign import ccall "atk_table_set_summary" atk_table_set_summary :: Ptr Table -> -- table : TInterface (Name {namespace = "Atk", name = "Table"}) Ptr Atk.Object.Object -> -- accessible : TInterface (Name {namespace = "Atk", name = "Object"}) IO () {- | Sets the summary description of the table. -} tableSetSummary :: (B.CallStack.HasCallStack, MonadIO m, IsTable a, Atk.Object.IsObject b) => a {- ^ /@table@/: a GObject instance that implements AtkTableIface -} -> b {- ^ /@accessible@/: an 'GI.Atk.Objects.Object.Object' representing the summary description to set for /@table@/ -} -> m () tableSetSummary table accessible = liftIO $ do table' <- unsafeManagedPtrCastPtr table accessible' <- unsafeManagedPtrCastPtr accessible atk_table_set_summary table' accessible' touchManagedPtr table touchManagedPtr accessible return () #if ENABLE_OVERLOADING data TableSetSummaryMethodInfo instance (signature ~ (b -> m ()), MonadIO m, IsTable a, Atk.Object.IsObject b) => O.MethodInfo TableSetSummaryMethodInfo a signature where overloadedMethod _ = tableSetSummary #endif