Copyright | Will Thompson Iñaki García Etxebarria and Jonas Platte |
---|---|
License | LGPL-2.1 |
Maintainer | Iñaki García Etxebarria (garetxe@gmail.com) |
Safe Haskell | None |
Language | Haskell2010 |
- Exported types
- Methods
- bindModel
- dragHighlightRow
- dragUnhighlightRow
- getActivateOnSingleClick
- getAdjustment
- getRowAtIndex
- getRowAtY
- getSelectedRow
- getSelectedRows
- getSelectionMode
- insert
- invalidateFilter
- invalidateHeaders
- invalidateSort
- new
- prepend
- selectAll
- selectRow
- selectedForeach
- setActivateOnSingleClick
- setAdjustment
- setFilterFunc
- setHeaderFunc
- setPlaceholder
- setSelectionMode
- setSortFunc
- unselectAll
- unselectRow
- Properties
- Signals
A GtkListBox is a vertical container that contains GtkListBoxRow children. These rows can by dynamically sorted and filtered, and headers can be added dynamically depending on the row content. It also allows keyboard and mouse navigation and selection like a typical list.
Using GtkListBox is often an alternative to TreeView
, especially
when the list contents has a more complicated layout than what is allowed
by a CellRenderer
, or when the contents is interactive (i.e. has a
button in it).
Although a ListBox
must have only ListBoxRow
children you can
add any kind of widget to it via containerAdd
, and a ListBoxRow
widget will automatically be inserted between the list and the widget.
GtkListBoxRows
can be marked as activatable or selectable. If a row
is activatable, ListBox
::row-activated
will be emitted for it when
the user tries to activate it. If it is selectable, the row will be marked
as selected when the user tries to select it.
The GtkListBox widget was added in GTK+ 3.10.
CSS nodes
plain code
list ╰── row[.activatable]
GtkListBox uses a single CSS node named list. Each GtkListBoxRow uses a single CSS node named row. The row nodes get the .activatable style class added when appropriate.
- newtype ListBox = ListBox (ManagedPtr ListBox)
- class GObject o => IsListBox o
- toListBox :: (MonadIO m, IsListBox o) => o -> m ListBox
- noListBox :: Maybe ListBox
- listBoxBindModel :: (HasCallStack, MonadIO m, IsListBox a, IsListModel b) => a -> Maybe b -> Maybe ListBoxCreateWidgetFunc -> m ()
- listBoxDragHighlightRow :: (HasCallStack, MonadIO m, IsListBox a, IsListBoxRow b) => a -> b -> m ()
- listBoxDragUnhighlightRow :: (HasCallStack, MonadIO m, IsListBox a) => a -> m ()
- listBoxGetActivateOnSingleClick :: (HasCallStack, MonadIO m, IsListBox a) => a -> m Bool
- listBoxGetAdjustment :: (HasCallStack, MonadIO m, IsListBox a) => a -> m Adjustment
- listBoxGetRowAtIndex :: (HasCallStack, MonadIO m, IsListBox a) => a -> Int32 -> m (Maybe ListBoxRow)
- listBoxGetRowAtY :: (HasCallStack, MonadIO m, IsListBox a) => a -> Int32 -> m (Maybe ListBoxRow)
- listBoxGetSelectedRow :: (HasCallStack, MonadIO m, IsListBox a) => a -> m ListBoxRow
- listBoxGetSelectedRows :: (HasCallStack, MonadIO m, IsListBox a) => a -> m [ListBoxRow]
- listBoxGetSelectionMode :: (HasCallStack, MonadIO m, IsListBox a) => a -> m SelectionMode
- listBoxInsert :: (HasCallStack, MonadIO m, IsListBox a, IsWidget b) => a -> b -> Int32 -> m ()
- listBoxInvalidateFilter :: (HasCallStack, MonadIO m, IsListBox a) => a -> m ()
- listBoxInvalidateHeaders :: (HasCallStack, MonadIO m, IsListBox a) => a -> m ()
- listBoxInvalidateSort :: (HasCallStack, MonadIO m, IsListBox a) => a -> m ()
- listBoxNew :: (HasCallStack, MonadIO m) => m ListBox
- listBoxPrepend :: (HasCallStack, MonadIO m, IsListBox a, IsWidget b) => a -> b -> m ()
- listBoxSelectAll :: (HasCallStack, MonadIO m, IsListBox a) => a -> m ()
- listBoxSelectRow :: (HasCallStack, MonadIO m, IsListBox a, IsListBoxRow b) => a -> Maybe b -> m ()
- listBoxSelectedForeach :: (HasCallStack, MonadIO m, IsListBox a) => a -> ListBoxForeachFunc -> m ()
- listBoxSetActivateOnSingleClick :: (HasCallStack, MonadIO m, IsListBox a) => a -> Bool -> m ()
- listBoxSetAdjustment :: (HasCallStack, MonadIO m, IsListBox a, IsAdjustment b) => a -> Maybe b -> m ()
- listBoxSetFilterFunc :: (HasCallStack, MonadIO m, IsListBox a) => a -> Maybe ListBoxFilterFunc -> m ()
- listBoxSetHeaderFunc :: (HasCallStack, MonadIO m, IsListBox a) => a -> Maybe ListBoxUpdateHeaderFunc -> m ()
- listBoxSetPlaceholder :: (HasCallStack, MonadIO m, IsListBox a, IsWidget b) => a -> Maybe b -> m ()
- listBoxSetSelectionMode :: (HasCallStack, MonadIO m, IsListBox a) => a -> SelectionMode -> m ()
- listBoxSetSortFunc :: (HasCallStack, MonadIO m, IsListBox a) => a -> Maybe ListBoxSortFunc -> m ()
- listBoxUnselectAll :: (HasCallStack, MonadIO m, IsListBox a) => a -> m ()
- listBoxUnselectRow :: (HasCallStack, MonadIO m, IsListBox a, IsListBoxRow b) => a -> b -> m ()
- constructListBoxActivateOnSingleClick :: IsListBox o => Bool -> IO (GValueConstruct o)
- getListBoxActivateOnSingleClick :: (MonadIO m, IsListBox o) => o -> m Bool
- setListBoxActivateOnSingleClick :: (MonadIO m, IsListBox o) => o -> Bool -> m ()
- constructListBoxSelectionMode :: IsListBox o => SelectionMode -> IO (GValueConstruct o)
- getListBoxSelectionMode :: (MonadIO m, IsListBox o) => o -> m SelectionMode
- setListBoxSelectionMode :: (MonadIO m, IsListBox o) => o -> SelectionMode -> m ()
- type C_ListBoxActivateCursorRowCallback = Ptr () -> Ptr () -> IO ()
- type ListBoxActivateCursorRowCallback = IO ()
- afterListBoxActivateCursorRow :: (IsListBox a, MonadIO m) => a -> ListBoxActivateCursorRowCallback -> m SignalHandlerId
- genClosure_ListBoxActivateCursorRow :: ListBoxActivateCursorRowCallback -> IO Closure
- mk_ListBoxActivateCursorRowCallback :: C_ListBoxActivateCursorRowCallback -> IO (FunPtr C_ListBoxActivateCursorRowCallback)
- noListBoxActivateCursorRowCallback :: Maybe ListBoxActivateCursorRowCallback
- onListBoxActivateCursorRow :: (IsListBox a, MonadIO m) => a -> ListBoxActivateCursorRowCallback -> m SignalHandlerId
- wrap_ListBoxActivateCursorRowCallback :: ListBoxActivateCursorRowCallback -> Ptr () -> Ptr () -> IO ()
- type C_ListBoxMoveCursorCallback = Ptr () -> CUInt -> Int32 -> Ptr () -> IO ()
- type ListBoxMoveCursorCallback = MovementStep -> Int32 -> IO ()
- afterListBoxMoveCursor :: (IsListBox a, MonadIO m) => a -> ListBoxMoveCursorCallback -> m SignalHandlerId
- genClosure_ListBoxMoveCursor :: ListBoxMoveCursorCallback -> IO Closure
- mk_ListBoxMoveCursorCallback :: C_ListBoxMoveCursorCallback -> IO (FunPtr C_ListBoxMoveCursorCallback)
- noListBoxMoveCursorCallback :: Maybe ListBoxMoveCursorCallback
- onListBoxMoveCursor :: (IsListBox a, MonadIO m) => a -> ListBoxMoveCursorCallback -> m SignalHandlerId
- wrap_ListBoxMoveCursorCallback :: ListBoxMoveCursorCallback -> Ptr () -> CUInt -> Int32 -> Ptr () -> IO ()
- type C_ListBoxRowActivatedCallback = Ptr () -> Ptr ListBoxRow -> Ptr () -> IO ()
- type ListBoxRowActivatedCallback = ListBoxRow -> IO ()
- afterListBoxRowActivated :: (IsListBox a, MonadIO m) => a -> ListBoxRowActivatedCallback -> m SignalHandlerId
- genClosure_ListBoxRowActivated :: ListBoxRowActivatedCallback -> IO Closure
- mk_ListBoxRowActivatedCallback :: C_ListBoxRowActivatedCallback -> IO (FunPtr C_ListBoxRowActivatedCallback)
- noListBoxRowActivatedCallback :: Maybe ListBoxRowActivatedCallback
- onListBoxRowActivated :: (IsListBox a, MonadIO m) => a -> ListBoxRowActivatedCallback -> m SignalHandlerId
- wrap_ListBoxRowActivatedCallback :: ListBoxRowActivatedCallback -> Ptr () -> Ptr ListBoxRow -> Ptr () -> IO ()
- type C_ListBoxRowSelectedCallback = Ptr () -> Ptr ListBoxRow -> Ptr () -> IO ()
- type ListBoxRowSelectedCallback = Maybe ListBoxRow -> IO ()
- afterListBoxRowSelected :: (IsListBox a, MonadIO m) => a -> ListBoxRowSelectedCallback -> m SignalHandlerId
- genClosure_ListBoxRowSelected :: ListBoxRowSelectedCallback -> IO Closure
- mk_ListBoxRowSelectedCallback :: C_ListBoxRowSelectedCallback -> IO (FunPtr C_ListBoxRowSelectedCallback)
- noListBoxRowSelectedCallback :: Maybe ListBoxRowSelectedCallback
- onListBoxRowSelected :: (IsListBox a, MonadIO m) => a -> ListBoxRowSelectedCallback -> m SignalHandlerId
- wrap_ListBoxRowSelectedCallback :: ListBoxRowSelectedCallback -> Ptr () -> Ptr ListBoxRow -> Ptr () -> IO ()
- type C_ListBoxSelectAllCallback = Ptr () -> Ptr () -> IO ()
- type ListBoxSelectAllCallback = IO ()
- afterListBoxSelectAll :: (IsListBox a, MonadIO m) => a -> ListBoxSelectAllCallback -> m SignalHandlerId
- genClosure_ListBoxSelectAll :: ListBoxSelectAllCallback -> IO Closure
- mk_ListBoxSelectAllCallback :: C_ListBoxSelectAllCallback -> IO (FunPtr C_ListBoxSelectAllCallback)
- noListBoxSelectAllCallback :: Maybe ListBoxSelectAllCallback
- onListBoxSelectAll :: (IsListBox a, MonadIO m) => a -> ListBoxSelectAllCallback -> m SignalHandlerId
- wrap_ListBoxSelectAllCallback :: ListBoxSelectAllCallback -> Ptr () -> Ptr () -> IO ()
- type C_ListBoxSelectedRowsChangedCallback = Ptr () -> Ptr () -> IO ()
- type ListBoxSelectedRowsChangedCallback = IO ()
- afterListBoxSelectedRowsChanged :: (IsListBox a, MonadIO m) => a -> ListBoxSelectedRowsChangedCallback -> m SignalHandlerId
- genClosure_ListBoxSelectedRowsChanged :: ListBoxSelectedRowsChangedCallback -> IO Closure
- mk_ListBoxSelectedRowsChangedCallback :: C_ListBoxSelectedRowsChangedCallback -> IO (FunPtr C_ListBoxSelectedRowsChangedCallback)
- noListBoxSelectedRowsChangedCallback :: Maybe ListBoxSelectedRowsChangedCallback
- onListBoxSelectedRowsChanged :: (IsListBox a, MonadIO m) => a -> ListBoxSelectedRowsChangedCallback -> m SignalHandlerId
- wrap_ListBoxSelectedRowsChangedCallback :: ListBoxSelectedRowsChangedCallback -> Ptr () -> Ptr () -> IO ()
- type C_ListBoxToggleCursorRowCallback = Ptr () -> Ptr () -> IO ()
- type ListBoxToggleCursorRowCallback = IO ()
- afterListBoxToggleCursorRow :: (IsListBox a, MonadIO m) => a -> ListBoxToggleCursorRowCallback -> m SignalHandlerId
- genClosure_ListBoxToggleCursorRow :: ListBoxToggleCursorRowCallback -> IO Closure
- mk_ListBoxToggleCursorRowCallback :: C_ListBoxToggleCursorRowCallback -> IO (FunPtr C_ListBoxToggleCursorRowCallback)
- noListBoxToggleCursorRowCallback :: Maybe ListBoxToggleCursorRowCallback
- onListBoxToggleCursorRow :: (IsListBox a, MonadIO m) => a -> ListBoxToggleCursorRowCallback -> m SignalHandlerId
- wrap_ListBoxToggleCursorRowCallback :: ListBoxToggleCursorRowCallback -> Ptr () -> Ptr () -> IO ()
- type C_ListBoxUnselectAllCallback = Ptr () -> Ptr () -> IO ()
- type ListBoxUnselectAllCallback = IO ()
- afterListBoxUnselectAll :: (IsListBox a, MonadIO m) => a -> ListBoxUnselectAllCallback -> m SignalHandlerId
- genClosure_ListBoxUnselectAll :: ListBoxUnselectAllCallback -> IO Closure
- mk_ListBoxUnselectAllCallback :: C_ListBoxUnselectAllCallback -> IO (FunPtr C_ListBoxUnselectAllCallback)
- noListBoxUnselectAllCallback :: Maybe ListBoxUnselectAllCallback
- onListBoxUnselectAll :: (IsListBox a, MonadIO m) => a -> ListBoxUnselectAllCallback -> m SignalHandlerId
- wrap_ListBoxUnselectAllCallback :: ListBoxUnselectAllCallback -> Ptr () -> Ptr () -> IO ()
Exported types
Methods
bindModel
:: (HasCallStack, MonadIO m, IsListBox a, IsListModel b) | |
=> a |
|
-> Maybe b |
|
-> Maybe ListBoxCreateWidgetFunc |
|
-> m () |
Binds model
to box
.
If box
was already bound to a model, that previous binding is
destroyed.
The contents of box
are cleared and then filled with widgets that
represent items from model
. box
is updated whenever model
changes.
If model
is Nothing
, box
is left empty.
It is undefined to add or remove widgets directly (for example, with
listBoxInsert
or containerAdd
) while box
is bound to a
model.
Note that using a model is incompatible with the filtering and sorting functionality in GtkListBox. When using a model, filtering and sorting should be implemented by the model.
Since: 3.16
dragHighlightRow
listBoxDragHighlightRow Source #
:: (HasCallStack, MonadIO m, IsListBox a, IsListBoxRow b) | |
=> a |
|
-> b |
|
-> m () |
This is a helper function for implementing DnD onto a ListBox
.
The passed in row
will be highlighted via widgetDragHighlight
,
and any previously highlighted row will be unhighlighted.
The row will also be unhighlighted when the widget gets a drag leave event.
Since: 3.10
dragUnhighlightRow
listBoxDragUnhighlightRow Source #
:: (HasCallStack, MonadIO m, IsListBox a) | |
=> a |
|
-> m () |
If a row has previously been highlighted via listBoxDragHighlightRow
it will have the highlight removed.
Since: 3.10
getActivateOnSingleClick
listBoxGetActivateOnSingleClick Source #
:: (HasCallStack, MonadIO m, IsListBox a) | |
=> a |
|
-> m Bool | Returns: |
Returns whether rows activate on single clicks.
Since: 3.10
getAdjustment
:: (HasCallStack, MonadIO m, IsListBox a) | |
=> a |
|
-> m Adjustment | Returns: the adjustment |
Gets the adjustment (if any) that the widget uses to for vertical scrolling.
Since: 3.10
getRowAtIndex
:: (HasCallStack, MonadIO m, IsListBox a) | |
=> a |
|
-> Int32 |
|
-> m (Maybe ListBoxRow) |
Gets the n-th child in the list (not counting headers).
If index_
is negative or larger than the number of items in the
list, Nothing
is returned.
Since: 3.10
getRowAtY
:: (HasCallStack, MonadIO m, IsListBox a) | |
=> a |
|
-> Int32 |
|
-> m (Maybe ListBoxRow) | Returns: the row or |
Gets the row at the y
position.
Since: 3.10
getSelectedRow
listBoxGetSelectedRow Source #
:: (HasCallStack, MonadIO m, IsListBox a) | |
=> a |
|
-> m ListBoxRow | Returns: the selected row |
Gets the selected row.
Note that the box may allow multiple selection, in which
case you should use listBoxSelectedForeach
to
find all selected rows.
Since: 3.10
getSelectedRows
listBoxGetSelectedRows Source #
:: (HasCallStack, MonadIO m, IsListBox a) | |
=> a |
|
-> m [ListBoxRow] | Returns:
A |
Creates a list of all selected children.
Since: 3.14
getSelectionMode
listBoxGetSelectionMode Source #
:: (HasCallStack, MonadIO m, IsListBox a) | |
=> a |
|
-> m SelectionMode | Returns: a |
Gets the selection mode of the listbox.
Since: 3.10
insert
:: (HasCallStack, MonadIO m, IsListBox a, IsWidget b) | |
=> a |
|
-> b |
|
-> Int32 |
|
-> m () |
Insert the child
into the box
at position
. If a sort function is
set, the widget will actually be inserted at the calculated position and
this function has the same effect of containerAdd
.
If position
is -1, or larger than the total number of items in the
box
, then the child
will be appended to the end.
Since: 3.10
invalidateFilter
listBoxInvalidateFilter Source #
:: (HasCallStack, MonadIO m, IsListBox a) | |
=> a |
|
-> m () |
Update the filtering for all rows. Call this when result
of the filter function on the box
is changed due
to an external factor. For instance, this would be used
if the filter function just looked for a specific search
string and the entry with the search string has changed.
Since: 3.10
invalidateHeaders
listBoxInvalidateHeaders Source #
:: (HasCallStack, MonadIO m, IsListBox a) | |
=> a |
|
-> m () |
Update the separators for all rows. Call this when result
of the header function on the box
is changed due
to an external factor.
Since: 3.10
invalidateSort
listBoxInvalidateSort Source #
:: (HasCallStack, MonadIO m, IsListBox a) | |
=> a |
|
-> m () |
Update the sorting for all rows. Call this when result
of the sort function on the box
is changed due
to an external factor.
Since: 3.10
new
:: (HasCallStack, MonadIO m) | |
=> m ListBox | Returns: a new |
Creates a new ListBox
container.
Since: 3.10
prepend
:: (HasCallStack, MonadIO m, IsListBox a, IsWidget b) | |
=> a |
|
-> b |
|
-> m () |
Prepend a widget to the list. If a sort function is set, the widget will
actually be inserted at the calculated position and this function has the
same effect of containerAdd
.
Since: 3.10
selectAll
:: (HasCallStack, MonadIO m, IsListBox a) | |
=> a |
|
-> m () |
Select all children of box
, if the selection mode allows it.
Since: 3.14
selectRow
:: (HasCallStack, MonadIO m, IsListBox a, IsListBoxRow b) | |
=> a |
|
-> Maybe b |
|
-> m () |
Make row
the currently selected row.
Since: 3.10
selectedForeach
listBoxSelectedForeach Source #
:: (HasCallStack, MonadIO m, IsListBox a) | |
=> a |
|
-> ListBoxForeachFunc |
|
-> m () |
Calls a function for each selected child.
Note that the selection cannot be modified from within this function.
Since: 3.14
setActivateOnSingleClick
listBoxSetActivateOnSingleClick Source #
:: (HasCallStack, MonadIO m, IsListBox a) | |
=> a |
|
-> Bool |
|
-> m () |
If single
is True
, rows will be activated when you click on them,
otherwise you need to double-click.
Since: 3.10
setAdjustment
:: (HasCallStack, MonadIO m, IsListBox a, IsAdjustment b) | |
=> a |
|
-> Maybe b |
|
-> m () |
Sets the adjustment (if any) that the widget uses to for vertical scrolling. For instance, this is used to get the page size for PageUp/Down key handling.
In the normal case when the box
is packed inside
a ScrolledWindow
the adjustment from that will
be picked up automatically, so there is no need
to manually do that.
Since: 3.10
setFilterFunc
:: (HasCallStack, MonadIO m, IsListBox a) | |
=> a |
|
-> Maybe ListBoxFilterFunc |
|
-> m () |
By setting a filter function on the box
one can decide dynamically which
of the rows to show. For instance, to implement a search function on a list that
filters the original list to only show the matching rows.
The filterFunc
will be called for each row after the call, and it will
continue to be called each time a row changes (via listBoxRowChanged
) or
when listBoxInvalidateFilter
is called.
Note that using a filter function is incompatible with using a model
(see listBoxBindModel
).
Since: 3.10
setHeaderFunc
:: (HasCallStack, MonadIO m, IsListBox a) | |
=> a |
|
-> Maybe ListBoxUpdateHeaderFunc |
|
-> m () |
By setting a header function on the box
one can dynamically add headers
in front of rows, depending on the contents of the row and its position in the list.
For instance, one could use it to add headers in front of the first item of a
new kind, in a list sorted by the kind.
The updateHeader
can look at the current header widget using listBoxRowGetHeader
and either update the state of the widget as needed, or set a new one using
listBoxRowSetHeader
. If no header is needed, set the header to Nothing
.
Note that you may get many calls updateHeader
to this for a particular row when e.g.
changing things that don’t affect the header. In this case it is important for performance
to not blindly replace an existing header with an identical one.
The updateHeader
function will be called for each row after the call, and it will
continue to be called each time a row changes (via listBoxRowChanged
) and when
the row before changes (either by listBoxRowChanged
on the previous row, or when
the previous row becomes a different row). It is also called for all rows when
listBoxInvalidateHeaders
is called.
Since: 3.10
setPlaceholder
listBoxSetPlaceholder Source #
Sets the placeholder widget that is shown in the list when it doesn't display any visible children.
Since: 3.10
setSelectionMode
listBoxSetSelectionMode Source #
:: (HasCallStack, MonadIO m, IsListBox a) | |
=> a |
|
-> SelectionMode |
|
-> m () |
Sets how selection works in the listbox.
See SelectionMode
for details.
Since: 3.10
setSortFunc
:: (HasCallStack, MonadIO m, IsListBox a) | |
=> a |
|
-> Maybe ListBoxSortFunc |
|
-> m () |
By setting a sort function on the box
one can dynamically reorder the rows
of the list, based on the contents of the rows.
The sortFunc
will be called for each row after the call, and will continue to
be called each time a row changes (via listBoxRowChanged
) and when
listBoxInvalidateSort
is called.
Note that using a sort function is incompatible with using a model
(see listBoxBindModel
).
Since: 3.10
unselectAll
:: (HasCallStack, MonadIO m, IsListBox a) | |
=> a |
|
-> m () |
Unselect all children of box
, if the selection mode allows it.
Since: 3.14
unselectRow
:: (HasCallStack, MonadIO m, IsListBox a, IsListBoxRow b) | |
=> a |
|
-> b |
|
-> m () |
Unselects a single row of box
, if the selection mode allows it.
Since: 3.14
Properties
activateOnSingleClick
constructListBoxActivateOnSingleClick :: IsListBox o => Bool -> IO (GValueConstruct o) Source #
selectionMode
constructListBoxSelectionMode :: IsListBox o => SelectionMode -> IO (GValueConstruct o) Source #
getListBoxSelectionMode :: (MonadIO m, IsListBox o) => o -> m SelectionMode Source #
setListBoxSelectionMode :: (MonadIO m, IsListBox o) => o -> SelectionMode -> m () Source #
Signals
activateCursorRow
type ListBoxActivateCursorRowCallback = IO () Source #
afterListBoxActivateCursorRow :: (IsListBox a, MonadIO m) => a -> ListBoxActivateCursorRowCallback -> m SignalHandlerId Source #
mk_ListBoxActivateCursorRowCallback :: C_ListBoxActivateCursorRowCallback -> IO (FunPtr C_ListBoxActivateCursorRowCallback) Source #
onListBoxActivateCursorRow :: (IsListBox a, MonadIO m) => a -> ListBoxActivateCursorRowCallback -> m SignalHandlerId Source #
wrap_ListBoxActivateCursorRowCallback :: ListBoxActivateCursorRowCallback -> Ptr () -> Ptr () -> IO () Source #
moveCursor
type ListBoxMoveCursorCallback = MovementStep -> Int32 -> IO () Source #
afterListBoxMoveCursor :: (IsListBox a, MonadIO m) => a -> ListBoxMoveCursorCallback -> m SignalHandlerId Source #
mk_ListBoxMoveCursorCallback :: C_ListBoxMoveCursorCallback -> IO (FunPtr C_ListBoxMoveCursorCallback) Source #
onListBoxMoveCursor :: (IsListBox a, MonadIO m) => a -> ListBoxMoveCursorCallback -> m SignalHandlerId Source #
wrap_ListBoxMoveCursorCallback :: ListBoxMoveCursorCallback -> Ptr () -> CUInt -> Int32 -> Ptr () -> IO () Source #
rowActivated
type C_ListBoxRowActivatedCallback = Ptr () -> Ptr ListBoxRow -> Ptr () -> IO () Source #
type ListBoxRowActivatedCallback = ListBoxRow -> IO () Source #
afterListBoxRowActivated :: (IsListBox a, MonadIO m) => a -> ListBoxRowActivatedCallback -> m SignalHandlerId Source #
mk_ListBoxRowActivatedCallback :: C_ListBoxRowActivatedCallback -> IO (FunPtr C_ListBoxRowActivatedCallback) Source #
onListBoxRowActivated :: (IsListBox a, MonadIO m) => a -> ListBoxRowActivatedCallback -> m SignalHandlerId Source #
wrap_ListBoxRowActivatedCallback :: ListBoxRowActivatedCallback -> Ptr () -> Ptr ListBoxRow -> Ptr () -> IO () Source #
rowSelected
type C_ListBoxRowSelectedCallback = Ptr () -> Ptr ListBoxRow -> Ptr () -> IO () Source #
type ListBoxRowSelectedCallback = Maybe ListBoxRow -> IO () Source #
afterListBoxRowSelected :: (IsListBox a, MonadIO m) => a -> ListBoxRowSelectedCallback -> m SignalHandlerId Source #
mk_ListBoxRowSelectedCallback :: C_ListBoxRowSelectedCallback -> IO (FunPtr C_ListBoxRowSelectedCallback) Source #
onListBoxRowSelected :: (IsListBox a, MonadIO m) => a -> ListBoxRowSelectedCallback -> m SignalHandlerId Source #
wrap_ListBoxRowSelectedCallback :: ListBoxRowSelectedCallback -> Ptr () -> Ptr ListBoxRow -> Ptr () -> IO () Source #
selectAll
type ListBoxSelectAllCallback = IO () Source #
afterListBoxSelectAll :: (IsListBox a, MonadIO m) => a -> ListBoxSelectAllCallback -> m SignalHandlerId Source #
mk_ListBoxSelectAllCallback :: C_ListBoxSelectAllCallback -> IO (FunPtr C_ListBoxSelectAllCallback) Source #
onListBoxSelectAll :: (IsListBox a, MonadIO m) => a -> ListBoxSelectAllCallback -> m SignalHandlerId Source #
wrap_ListBoxSelectAllCallback :: ListBoxSelectAllCallback -> Ptr () -> Ptr () -> IO () Source #
selectedRowsChanged
type ListBoxSelectedRowsChangedCallback = IO () Source #
afterListBoxSelectedRowsChanged :: (IsListBox a, MonadIO m) => a -> ListBoxSelectedRowsChangedCallback -> m SignalHandlerId Source #
mk_ListBoxSelectedRowsChangedCallback :: C_ListBoxSelectedRowsChangedCallback -> IO (FunPtr C_ListBoxSelectedRowsChangedCallback) Source #
onListBoxSelectedRowsChanged :: (IsListBox a, MonadIO m) => a -> ListBoxSelectedRowsChangedCallback -> m SignalHandlerId Source #
wrap_ListBoxSelectedRowsChangedCallback :: ListBoxSelectedRowsChangedCallback -> Ptr () -> Ptr () -> IO () Source #
toggleCursorRow
type ListBoxToggleCursorRowCallback = IO () Source #
afterListBoxToggleCursorRow :: (IsListBox a, MonadIO m) => a -> ListBoxToggleCursorRowCallback -> m SignalHandlerId Source #
mk_ListBoxToggleCursorRowCallback :: C_ListBoxToggleCursorRowCallback -> IO (FunPtr C_ListBoxToggleCursorRowCallback) Source #
onListBoxToggleCursorRow :: (IsListBox a, MonadIO m) => a -> ListBoxToggleCursorRowCallback -> m SignalHandlerId Source #
wrap_ListBoxToggleCursorRowCallback :: ListBoxToggleCursorRowCallback -> Ptr () -> Ptr () -> IO () Source #
unselectAll
type ListBoxUnselectAllCallback = IO () Source #
afterListBoxUnselectAll :: (IsListBox a, MonadIO m) => a -> ListBoxUnselectAllCallback -> m SignalHandlerId Source #
mk_ListBoxUnselectAllCallback :: C_ListBoxUnselectAllCallback -> IO (FunPtr C_ListBoxUnselectAllCallback) Source #
onListBoxUnselectAll :: (IsListBox a, MonadIO m) => a -> ListBoxUnselectAllCallback -> m SignalHandlerId Source #
wrap_ListBoxUnselectAllCallback :: ListBoxUnselectAllCallback -> Ptr () -> Ptr () -> IO () Source #