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