Copyright	Will Thompson Iñaki García Etxebarria and Jonas Platte
License	LGPL-2.1
Maintainer	Iñaki García Etxebarria
Safe Haskell	None
Language	Haskell2010

GI.Atk.Interfaces.Table

Contents

Exported types
Methods
Signals

Description

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 Table are typically referred to as "cells". Those cells should implement the interface TableCell, but Atk doesn't require them to be direct children of the current Table. They can be grand-children, grand-grand-children etc. Table provides the API needed to get a individual cell based on the row and column numbers.

Children of 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, 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 (tText, Image, etc.) as appropriate. Table summaries may themselves be (simplified) AtkTables, etc.

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

Synopsis

newtype Table = Table (ManagedPtr Table)
class (GObject o, IsDescendantOf Table o) => IsTable o
toTable :: (MonadIO m, IsTable o) => o -> m Table
tableAddColumnSelection :: (HasCallStack, MonadIO m, IsTable a) => a -> Int32 -> m Bool
tableAddRowSelection :: (HasCallStack, MonadIO m, IsTable a) => a -> Int32 -> m Bool
tableGetCaption :: (HasCallStack, MonadIO m, IsTable a) => a -> m (Maybe Object)
tableGetColumnAtIndex :: (HasCallStack, MonadIO m, IsTable a) => a -> Int32 -> m Int32
tableGetColumnDescription :: (HasCallStack, MonadIO m, IsTable a) => a -> Int32 -> m Text
tableGetColumnExtentAt :: (HasCallStack, MonadIO m, IsTable a) => a -> Int32 -> Int32 -> m Int32
tableGetColumnHeader :: (HasCallStack, MonadIO m, IsTable a) => a -> Int32 -> m (Maybe Object)
tableGetIndexAt :: (HasCallStack, MonadIO m, IsTable a) => a -> Int32 -> Int32 -> m Int32
tableGetNColumns :: (HasCallStack, MonadIO m, IsTable a) => a -> m Int32
tableGetNRows :: (HasCallStack, MonadIO m, IsTable a) => a -> m Int32
tableGetRowAtIndex :: (HasCallStack, MonadIO m, IsTable a) => a -> Int32 -> m Int32
tableGetRowDescription :: (HasCallStack, MonadIO m, IsTable a) => a -> Int32 -> m (Maybe Text)
tableGetRowExtentAt :: (HasCallStack, MonadIO m, IsTable a) => a -> Int32 -> Int32 -> m Int32
tableGetRowHeader :: (HasCallStack, MonadIO m, IsTable a) => a -> Int32 -> m (Maybe Object)
tableGetSelectedColumns :: (HasCallStack, MonadIO m, IsTable a) => a -> Int32 -> m Int32
tableGetSelectedRows :: (HasCallStack, MonadIO m, IsTable a) => a -> Int32 -> m Int32
tableGetSummary :: (HasCallStack, MonadIO m, IsTable a) => a -> m Object
tableIsColumnSelected :: (HasCallStack, MonadIO m, IsTable a) => a -> Int32 -> m Bool
tableIsRowSelected :: (HasCallStack, MonadIO m, IsTable a) => a -> Int32 -> m Bool
tableIsSelected :: (HasCallStack, MonadIO m, IsTable a) => a -> Int32 -> Int32 -> m Bool
tableRefAt :: (HasCallStack, MonadIO m, IsTable a) => a -> Int32 -> Int32 -> m Object
tableRemoveColumnSelection :: (HasCallStack, MonadIO m, IsTable a) => a -> Int32 -> m Bool
tableRemoveRowSelection :: (HasCallStack, MonadIO m, IsTable a) => a -> Int32 -> m Bool
tableSetCaption :: (HasCallStack, MonadIO m, IsTable a, IsObject b) => a -> b -> m ()
tableSetColumnDescription :: (HasCallStack, MonadIO m, IsTable a) => a -> Int32 -> Text -> m ()
tableSetColumnHeader :: (HasCallStack, MonadIO m, IsTable a, IsObject b) => a -> Int32 -> b -> m ()
tableSetRowDescription :: (HasCallStack, MonadIO m, IsTable a) => a -> Int32 -> Text -> m ()
tableSetRowHeader :: (HasCallStack, MonadIO m, IsTable a, IsObject b) => a -> Int32 -> b -> m ()
tableSetSummary :: (HasCallStack, MonadIO m, IsTable a, IsObject b) => a -> b -> m ()
type C_TableColumnDeletedCallback = Ptr () -> Int32 -> Int32 -> Ptr () -> IO ()
type TableColumnDeletedCallback = Int32 -> Int32 -> IO ()
afterTableColumnDeleted :: (IsTable a, MonadIO m) => a -> TableColumnDeletedCallback -> m SignalHandlerId
genClosure_TableColumnDeleted :: MonadIO m => TableColumnDeletedCallback -> m (GClosure C_TableColumnDeletedCallback)
mk_TableColumnDeletedCallback :: C_TableColumnDeletedCallback -> IO (FunPtr C_TableColumnDeletedCallback)
noTableColumnDeletedCallback :: Maybe TableColumnDeletedCallback
onTableColumnDeleted :: (IsTable a, MonadIO m) => a -> TableColumnDeletedCallback -> m SignalHandlerId
wrap_TableColumnDeletedCallback :: TableColumnDeletedCallback -> C_TableColumnDeletedCallback
type C_TableColumnInsertedCallback = Ptr () -> Int32 -> Int32 -> Ptr () -> IO ()
type TableColumnInsertedCallback = Int32 -> Int32 -> IO ()
afterTableColumnInserted :: (IsTable a, MonadIO m) => a -> TableColumnInsertedCallback -> m SignalHandlerId
genClosure_TableColumnInserted :: MonadIO m => TableColumnInsertedCallback -> m (GClosure C_TableColumnInsertedCallback)
mk_TableColumnInsertedCallback :: C_TableColumnInsertedCallback -> IO (FunPtr C_TableColumnInsertedCallback)
noTableColumnInsertedCallback :: Maybe TableColumnInsertedCallback
onTableColumnInserted :: (IsTable a, MonadIO m) => a -> TableColumnInsertedCallback -> m SignalHandlerId
wrap_TableColumnInsertedCallback :: TableColumnInsertedCallback -> C_TableColumnInsertedCallback
type C_TableColumnReorderedCallback = Ptr () -> Ptr () -> IO ()
type TableColumnReorderedCallback = IO ()
afterTableColumnReordered :: (IsTable a, MonadIO m) => a -> TableColumnReorderedCallback -> m SignalHandlerId
genClosure_TableColumnReordered :: MonadIO m => TableColumnReorderedCallback -> m (GClosure C_TableColumnReorderedCallback)
mk_TableColumnReorderedCallback :: C_TableColumnReorderedCallback -> IO (FunPtr C_TableColumnReorderedCallback)
noTableColumnReorderedCallback :: Maybe TableColumnReorderedCallback
onTableColumnReordered :: (IsTable a, MonadIO m) => a -> TableColumnReorderedCallback -> m SignalHandlerId
wrap_TableColumnReorderedCallback :: TableColumnReorderedCallback -> C_TableColumnReorderedCallback
type C_TableModelChangedCallback = Ptr () -> Ptr () -> IO ()
type TableModelChangedCallback = IO ()
afterTableModelChanged :: (IsTable a, MonadIO m) => a -> TableModelChangedCallback -> m SignalHandlerId
genClosure_TableModelChanged :: MonadIO m => TableModelChangedCallback -> m (GClosure C_TableModelChangedCallback)
mk_TableModelChangedCallback :: C_TableModelChangedCallback -> IO (FunPtr C_TableModelChangedCallback)
noTableModelChangedCallback :: Maybe TableModelChangedCallback
onTableModelChanged :: (IsTable a, MonadIO m) => a -> TableModelChangedCallback -> m SignalHandlerId
wrap_TableModelChangedCallback :: TableModelChangedCallback -> C_TableModelChangedCallback
type C_TableRowDeletedCallback = Ptr () -> Int32 -> Int32 -> Ptr () -> IO ()
type TableRowDeletedCallback = Int32 -> Int32 -> IO ()
afterTableRowDeleted :: (IsTable a, MonadIO m) => a -> TableRowDeletedCallback -> m SignalHandlerId
genClosure_TableRowDeleted :: MonadIO m => TableRowDeletedCallback -> m (GClosure C_TableRowDeletedCallback)
mk_TableRowDeletedCallback :: C_TableRowDeletedCallback -> IO (FunPtr C_TableRowDeletedCallback)
noTableRowDeletedCallback :: Maybe TableRowDeletedCallback
onTableRowDeleted :: (IsTable a, MonadIO m) => a -> TableRowDeletedCallback -> m SignalHandlerId
wrap_TableRowDeletedCallback :: TableRowDeletedCallback -> C_TableRowDeletedCallback
type C_TableRowInsertedCallback = Ptr () -> Int32 -> Int32 -> Ptr () -> IO ()
type TableRowInsertedCallback = Int32 -> Int32 -> IO ()
afterTableRowInserted :: (IsTable a, MonadIO m) => a -> TableRowInsertedCallback -> m SignalHandlerId
genClosure_TableRowInserted :: MonadIO m => TableRowInsertedCallback -> m (GClosure C_TableRowInsertedCallback)
mk_TableRowInsertedCallback :: C_TableRowInsertedCallback -> IO (FunPtr C_TableRowInsertedCallback)
noTableRowInsertedCallback :: Maybe TableRowInsertedCallback
onTableRowInserted :: (IsTable a, MonadIO m) => a -> TableRowInsertedCallback -> m SignalHandlerId
wrap_TableRowInsertedCallback :: TableRowInsertedCallback -> C_TableRowInsertedCallback
type C_TableRowReorderedCallback = Ptr () -> Ptr () -> IO ()
type TableRowReorderedCallback = IO ()
afterTableRowReordered :: (IsTable a, MonadIO m) => a -> TableRowReorderedCallback -> m SignalHandlerId
genClosure_TableRowReordered :: MonadIO m => TableRowReorderedCallback -> m (GClosure C_TableRowReorderedCallback)
mk_TableRowReorderedCallback :: C_TableRowReorderedCallback -> IO (FunPtr C_TableRowReorderedCallback)
noTableRowReorderedCallback :: Maybe TableRowReorderedCallback
onTableRowReordered :: (IsTable a, MonadIO m) => a -> TableRowReorderedCallback -> m SignalHandlerId
wrap_TableRowReorderedCallback :: TableRowReorderedCallback -> C_TableRowReorderedCallback

Exported types

newtype Table Source #

Memory-managed wrapper type.

Constructors

Table (ManagedPtr Table)

Instances

Instances details

Eq Table Source #
Instance details Defined in GI.Atk.Interfaces.Table Methods (==) :: Table -> Table -> Bool # (/=) :: Table -> Table -> Bool #
IsGValue Table Source #	Convert `Table` to and from `GValue` with `toGValue` and `fromGValue`.
Instance details Defined in GI.Atk.Interfaces.Table Methods toGValue :: Table -> IO GValue # fromGValue :: GValue -> IO Table #
ManagedPtrNewtype Table Source #
Instance details Defined in GI.Atk.Interfaces.Table Methods toManagedPtr :: Table -> ManagedPtr Table #
TypedObject Table Source #
Instance details Defined in GI.Atk.Interfaces.Table Methods glibType :: IO GType #
GObject Table Source #
Instance details Defined in GI.Atk.Interfaces.Table
HasParentTypes Table Source #
Instance details Defined in GI.Atk.Interfaces.Table
type ParentTypes Table Source #
Instance details Defined in GI.Atk.Interfaces.Table type ParentTypes Table = '[Object]

class (GObject o, IsDescendantOf Table o) => IsTable o Source #

Type class for types which can be safely cast to Table, for instance with toTable.

Instances

Instances details

(GObject o, IsDescendantOf Table o) => IsTable o Source #
Instance details Defined in GI.Atk.Interfaces.Table

toTable :: (MonadIO m, IsTable o) => o -> m Table Source #

Cast to Table, for types for which this is known to be safe. For general casts, use castTo.

Methods

Overloaded methods

addColumnSelection

tableAddColumnSelection Source #

Arguments

:: (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.

Adds the specified column to the selection.

addRowSelection

tableAddRowSelection Source #

Arguments

:: (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.

Adds the specified row to the selection.

getCaption

tableGetCaption Source #

Arguments

:: (HasCallStack, MonadIO m, IsTable a)
=> a	`table`: a GObject instance that implements AtkTableInterface
-> m (Maybe Object)	Returns: a AtkObject* representing the table caption, or `Nothing` if value does not implement this interface.

Gets the caption for the table.

getColumnAtIndex

tableGetColumnAtIndex Source #

Arguments

:: (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.

Deprecated: Since 2.12.

Gets a gint representing the column at the specified index_.

getColumnDescription

tableGetColumnDescription Source #

Arguments

:: (HasCallStack, MonadIO m, IsTable a)
=> a	`table`: a GObject instance that implements AtkTableIface
-> Int32	`column`: a `gint` representing a column in `table`
-> m Text	Returns: a gchar* representing the column description, or `Nothing` if value does not implement this interface.

Gets the description text of the specified column in the table

getColumnExtentAt

tableGetColumnExtentAt Source #

Arguments

:: (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.

Gets the number of columns occupied by the accessible object at the specified row and column in the table.

getColumnHeader

tableGetColumnHeader Source #

Arguments

:: (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 Object)	Returns: a AtkObject* representing the specified column header, or `Nothing` if value does not implement this interface.

Gets the column header of a specified column in an accessible table.

getIndexAt

tableGetIndexAt Source #

Arguments

:: (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.

Deprecated: Since 2.12. Use tableRefAt in order to get theaccessible that represents the cell at (row, column)

Gets a gint representing the index at the specified row and column.

getNColumns

tableGetNColumns Source #

Arguments

:: (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.

Gets the number of columns in the table.

getNRows

tableGetNRows Source #

Arguments

:: (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.

Gets the number of rows in the table.

getRowAtIndex

tableGetRowAtIndex Source #

Arguments

:: (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.

Deprecated: since 2.12.

Gets a gint representing the row at the specified index_.

getRowDescription

tableGetRowDescription Source #

Arguments

:: (HasCallStack, MonadIO m, IsTable a)
=> a	`table`: a GObject instance that implements AtkTableIface
-> Int32	`row`: a `gint` representing a row in `table`
-> m (Maybe Text)	Returns: a gchar* representing the row description, or `Nothing` if value does not implement this interface.

Gets the description text of the specified row in the table

getRowExtentAt

tableGetRowExtentAt Source #

Arguments

:: (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.

Gets the number of rows occupied by the accessible object at a specified row and column in the table.

getRowHeader

tableGetRowHeader Source #

Arguments

:: (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 Object)	Returns: a AtkObject* representing the specified row header, or `Nothing` if value does not implement this interface.

Gets the row header of a specified row in an accessible table.

getSelectedColumns

tableGetSelectedColumns Source #

Arguments

:: (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.

Gets the selected columns of the table by initializing **selected with the selected column numbers. This array should be freed by the caller.

getSelectedRows

tableGetSelectedRows Source #

Arguments

:: (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.

Gets the selected rows of the table by initializing **selected with the selected row numbers. This array should be freed by the caller.

getSummary

tableGetSummary Source #

Arguments

:: (HasCallStack, MonadIO m, IsTable a)
=> a	`table`: a GObject instance that implements AtkTableIface
-> m Object	Returns: a AtkObject* representing a summary description of the table, or zero if value does not implement this interface.

Gets the summary description of the table.

isColumnSelected

tableIsColumnSelected Source #

Arguments

:: (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.

Gets a boolean value indicating whether the specified column is selected

isRowSelected

tableIsRowSelected Source #

Arguments

:: (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.

Gets a boolean value indicating whether the specified row is selected

isSelected

tableIsSelected Source #

Arguments

:: (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.

Gets a boolean value indicating whether the accessible object at the specified row and column is selected

refAt

tableRefAt Source #

Arguments

:: (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 Object	Returns: an `Object` representing the referred to accessible

Get a reference to the table cell at row, column. This cell should implement the interface TableCell

removeColumnSelection

tableRemoveColumnSelection Source #

Arguments

:: (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.

Adds the specified column to the selection.

removeRowSelection

tableRemoveRowSelection Source #

Arguments

:: (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.

Removes the specified row from the selection.

setCaption

tableSetCaption Source #

Arguments

:: (HasCallStack, MonadIO m, IsTable a, IsObject b)
=> a	`table`: a GObject instance that implements AtkTableIface
-> b	`caption`: a `Object` representing the caption to set for `table`
-> m ()

Sets the caption for the table.

setColumnDescription

tableSetColumnDescription Source #

Arguments

:: (HasCallStack, MonadIO m, IsTable a)
=> a	`table`: a GObject instance that implements AtkTableIface
-> Int32	`column`: a `gint` representing a column in `table`
-> Text	`description`: a `gchar` representing the description text to set for the specified `column` of the `table`
-> m ()

Sets the description text for the specified column of the table.

setColumnHeader

tableSetColumnHeader Source #

Arguments

:: (HasCallStack, MonadIO m, IsTable a, IsObject b)
=> a	`table`: a GObject instance that implements AtkTableIface
-> Int32	`column`: a `gint` representing a column in `table`
-> b	`header`: an `Table`
-> m ()

Sets the specified column header to header.

setRowDescription

tableSetRowDescription Source #

Arguments

:: (HasCallStack, MonadIO m, IsTable a)
=> a	`table`: a GObject instance that implements AtkTableIface
-> Int32	`row`: a `gint` representing a row in `table`
-> Text	`description`: a `gchar` representing the description text to set for the specified `row` of `table`
-> m ()

Sets the description text for the specified row of table.

setRowHeader

tableSetRowHeader Source #

Arguments

:: (HasCallStack, MonadIO m, IsTable a, IsObject b)
=> a	`table`: a GObject instance that implements AtkTableIface
-> Int32	`row`: a `gint` representing a row in `table`
-> b	`header`: an `Table`
-> m ()

Sets the specified row header to header.

setSummary

tableSetSummary Source #

Arguments

:: (HasCallStack, MonadIO m, IsTable a, IsObject b)
=> a	`table`: a GObject instance that implements AtkTableIface
-> b	`accessible`: an `Object` representing the summary description to set for `table`
-> m ()

Sets the summary description of the table.

Signals

columnDeleted

type C_TableColumnDeletedCallback = Ptr () -> Int32 -> Int32 -> Ptr () -> IO () Source #

Type for the callback on the (unwrapped) C side.

type TableColumnDeletedCallback Source #

Arguments

= Int32	`arg1`: The index of the first column deleted.
-> Int32	`arg2`: The number of columns deleted.
-> IO ()

The "column-deleted" signal is emitted by an object which implements the AtkTable interface when a column is deleted.

afterTableColumnDeleted :: (IsTable a, MonadIO m) => a -> TableColumnDeletedCallback -> m SignalHandlerId Source #

Connect a signal handler for the columnDeleted signal, to be run after the default handler. When overloading is enabled, this is equivalent to

after table #columnDeleted callback

genClosure_TableColumnDeleted :: MonadIO m => TableColumnDeletedCallback -> m (GClosure C_TableColumnDeletedCallback) Source #

Wrap the callback into a GClosure.

mk_TableColumnDeletedCallback :: C_TableColumnDeletedCallback -> IO (FunPtr C_TableColumnDeletedCallback) Source #

Generate a function pointer callable from C code, from a C_TableColumnDeletedCallback.

noTableColumnDeletedCallback :: Maybe TableColumnDeletedCallback Source #

A convenience synonym for Nothing :: Maybe TableColumnDeletedCallback.

onTableColumnDeleted :: (IsTable a, MonadIO m) => a -> TableColumnDeletedCallback -> m SignalHandlerId Source #

Connect a signal handler for the columnDeleted signal, to be run before the default handler. When overloading is enabled, this is equivalent to

on table #columnDeleted callback

wrap_TableColumnDeletedCallback :: TableColumnDeletedCallback -> C_TableColumnDeletedCallback Source #

Wrap a TableColumnDeletedCallback into a C_TableColumnDeletedCallback.

columnInserted

type C_TableColumnInsertedCallback = Ptr () -> Int32 -> Int32 -> Ptr () -> IO () Source #

Type for the callback on the (unwrapped) C side.

type TableColumnInsertedCallback Source #

Arguments

= Int32	`arg1`: The index of the column inserted.
-> Int32	`arg2`: The number of colums inserted.
-> IO ()

The "column-inserted" signal is emitted by an object which implements the AtkTable interface when a column is inserted.

afterTableColumnInserted :: (IsTable a, MonadIO m) => a -> TableColumnInsertedCallback -> m SignalHandlerId Source #

Connect a signal handler for the columnInserted signal, to be run after the default handler. When overloading is enabled, this is equivalent to

after table #columnInserted callback

genClosure_TableColumnInserted :: MonadIO m => TableColumnInsertedCallback -> m (GClosure C_TableColumnInsertedCallback) Source #

Wrap the callback into a GClosure.

mk_TableColumnInsertedCallback :: C_TableColumnInsertedCallback -> IO (FunPtr C_TableColumnInsertedCallback) Source #

Generate a function pointer callable from C code, from a C_TableColumnInsertedCallback.

noTableColumnInsertedCallback :: Maybe TableColumnInsertedCallback Source #

A convenience synonym for Nothing :: Maybe TableColumnInsertedCallback.

onTableColumnInserted :: (IsTable a, MonadIO m) => a -> TableColumnInsertedCallback -> m SignalHandlerId Source #

Connect a signal handler for the columnInserted signal, to be run before the default handler. When overloading is enabled, this is equivalent to

on table #columnInserted callback

wrap_TableColumnInsertedCallback :: TableColumnInsertedCallback -> C_TableColumnInsertedCallback Source #

Wrap a TableColumnInsertedCallback into a C_TableColumnInsertedCallback.

columnReordered

type C_TableColumnReorderedCallback = Ptr () -> Ptr () -> IO () Source #

Type for the callback on the (unwrapped) C side.

type TableColumnReorderedCallback = IO () Source #

The "column-reordered" signal is emitted by an object which implements the AtkTable interface when the columns are reordered.

afterTableColumnReordered :: (IsTable a, MonadIO m) => a -> TableColumnReorderedCallback -> m SignalHandlerId Source #

Connect a signal handler for the columnReordered signal, to be run after the default handler. When overloading is enabled, this is equivalent to

after table #columnReordered callback

genClosure_TableColumnReordered :: MonadIO m => TableColumnReorderedCallback -> m (GClosure C_TableColumnReorderedCallback) Source #

Wrap the callback into a GClosure.

mk_TableColumnReorderedCallback :: C_TableColumnReorderedCallback -> IO (FunPtr C_TableColumnReorderedCallback) Source #

Generate a function pointer callable from C code, from a C_TableColumnReorderedCallback.

noTableColumnReorderedCallback :: Maybe TableColumnReorderedCallback Source #

A convenience synonym for Nothing :: Maybe TableColumnReorderedCallback.

onTableColumnReordered :: (IsTable a, MonadIO m) => a -> TableColumnReorderedCallback -> m SignalHandlerId Source #

Connect a signal handler for the columnReordered signal, to be run before the default handler. When overloading is enabled, this is equivalent to

on table #columnReordered callback

wrap_TableColumnReorderedCallback :: TableColumnReorderedCallback -> C_TableColumnReorderedCallback Source #

Wrap a TableColumnReorderedCallback into a C_TableColumnReorderedCallback.

modelChanged

type C_TableModelChangedCallback = Ptr () -> Ptr () -> IO () Source #

Type for the callback on the (unwrapped) C side.

type TableModelChangedCallback = IO () Source #

The "model-changed" signal is emitted by an object which implements the AtkTable interface when the model displayed by the table changes.

afterTableModelChanged :: (IsTable a, MonadIO m) => a -> TableModelChangedCallback -> m SignalHandlerId Source #

Connect a signal handler for the modelChanged signal, to be run after the default handler. When overloading is enabled, this is equivalent to

after table #modelChanged callback

genClosure_TableModelChanged :: MonadIO m => TableModelChangedCallback -> m (GClosure C_TableModelChangedCallback) Source #

Wrap the callback into a GClosure.

mk_TableModelChangedCallback :: C_TableModelChangedCallback -> IO (FunPtr C_TableModelChangedCallback) Source #

Generate a function pointer callable from C code, from a C_TableModelChangedCallback.

noTableModelChangedCallback :: Maybe TableModelChangedCallback Source #

A convenience synonym for Nothing :: Maybe TableModelChangedCallback.

onTableModelChanged :: (IsTable a, MonadIO m) => a -> TableModelChangedCallback -> m SignalHandlerId Source #

Connect a signal handler for the modelChanged signal, to be run before the default handler. When overloading is enabled, this is equivalent to

on table #modelChanged callback

wrap_TableModelChangedCallback :: TableModelChangedCallback -> C_TableModelChangedCallback Source #

Wrap a TableModelChangedCallback into a C_TableModelChangedCallback.

rowDeleted

type C_TableRowDeletedCallback = Ptr () -> Int32 -> Int32 -> Ptr () -> IO () Source #

Type for the callback on the (unwrapped) C side.

type TableRowDeletedCallback Source #

Arguments

= Int32	`arg1`: The index of the first row deleted.
-> Int32	`arg2`: The number of rows deleted.
-> IO ()

The "row-deleted" signal is emitted by an object which implements the AtkTable interface when a row is deleted.

afterTableRowDeleted :: (IsTable a, MonadIO m) => a -> TableRowDeletedCallback -> m SignalHandlerId Source #

Connect a signal handler for the rowDeleted signal, to be run after the default handler. When overloading is enabled, this is equivalent to

after table #rowDeleted callback

genClosure_TableRowDeleted :: MonadIO m => TableRowDeletedCallback -> m (GClosure C_TableRowDeletedCallback) Source #

Wrap the callback into a GClosure.

mk_TableRowDeletedCallback :: C_TableRowDeletedCallback -> IO (FunPtr C_TableRowDeletedCallback) Source #

Generate a function pointer callable from C code, from a C_TableRowDeletedCallback.

noTableRowDeletedCallback :: Maybe TableRowDeletedCallback Source #

A convenience synonym for Nothing :: Maybe TableRowDeletedCallback.

onTableRowDeleted :: (IsTable a, MonadIO m) => a -> TableRowDeletedCallback -> m SignalHandlerId Source #

Connect a signal handler for the rowDeleted signal, to be run before the default handler. When overloading is enabled, this is equivalent to

on table #rowDeleted callback

wrap_TableRowDeletedCallback :: TableRowDeletedCallback -> C_TableRowDeletedCallback Source #

Wrap a TableRowDeletedCallback into a C_TableRowDeletedCallback.

rowInserted

type C_TableRowInsertedCallback = Ptr () -> Int32 -> Int32 -> Ptr () -> IO () Source #

Type for the callback on the (unwrapped) C side.

type TableRowInsertedCallback Source #

Arguments

= Int32	`arg1`: The index of the first row inserted.
-> Int32	`arg2`: The number of rows inserted.
-> IO ()

The "row-inserted" signal is emitted by an object which implements the AtkTable interface when a row is inserted.

afterTableRowInserted :: (IsTable a, MonadIO m) => a -> TableRowInsertedCallback -> m SignalHandlerId Source #

Connect a signal handler for the rowInserted signal, to be run after the default handler. When overloading is enabled, this is equivalent to

after table #rowInserted callback

genClosure_TableRowInserted :: MonadIO m => TableRowInsertedCallback -> m (GClosure C_TableRowInsertedCallback) Source #

Wrap the callback into a GClosure.

mk_TableRowInsertedCallback :: C_TableRowInsertedCallback -> IO (FunPtr C_TableRowInsertedCallback) Source #

Generate a function pointer callable from C code, from a C_TableRowInsertedCallback.

noTableRowInsertedCallback :: Maybe TableRowInsertedCallback Source #

A convenience synonym for Nothing :: Maybe TableRowInsertedCallback.

onTableRowInserted :: (IsTable a, MonadIO m) => a -> TableRowInsertedCallback -> m SignalHandlerId Source #

Connect a signal handler for the rowInserted signal, to be run before the default handler. When overloading is enabled, this is equivalent to

on table #rowInserted callback

wrap_TableRowInsertedCallback :: TableRowInsertedCallback -> C_TableRowInsertedCallback Source #

Wrap a TableRowInsertedCallback into a C_TableRowInsertedCallback.

rowReordered

type C_TableRowReorderedCallback = Ptr () -> Ptr () -> IO () Source #

Type for the callback on the (unwrapped) C side.

type TableRowReorderedCallback = IO () Source #

The "row-reordered" signal is emitted by an object which implements the AtkTable interface when the rows are reordered.

afterTableRowReordered :: (IsTable a, MonadIO m) => a -> TableRowReorderedCallback -> m SignalHandlerId Source #

Connect a signal handler for the rowReordered signal, to be run after the default handler. When overloading is enabled, this is equivalent to

after table #rowReordered callback

genClosure_TableRowReordered :: MonadIO m => TableRowReorderedCallback -> m (GClosure C_TableRowReorderedCallback) Source #

Wrap the callback into a GClosure.

mk_TableRowReorderedCallback :: C_TableRowReorderedCallback -> IO (FunPtr C_TableRowReorderedCallback) Source #

Generate a function pointer callable from C code, from a C_TableRowReorderedCallback.

noTableRowReorderedCallback :: Maybe TableRowReorderedCallback Source #

A convenience synonym for Nothing :: Maybe TableRowReorderedCallback.

onTableRowReordered :: (IsTable a, MonadIO m) => a -> TableRowReorderedCallback -> m SignalHandlerId Source #

Connect a signal handler for the rowReordered signal, to be run before the default handler. When overloading is enabled, this is equivalent to

on table #rowReordered callback

wrap_TableRowReorderedCallback :: TableRowReorderedCallback -> C_TableRowReorderedCallback Source #

Wrap a TableRowReorderedCallback into a C_TableRowReorderedCallback.