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 :: IsListBox o => o -> IO ListBox
- noListBox :: Maybe ListBox
- data ListBoxBindModelMethodInfo
- listBoxBindModel :: (HasCallStack, MonadIO m, IsListBox a, IsListModel b) => a -> Maybe b -> Maybe ListBoxCreateWidgetFunc -> m ()
- data ListBoxDragHighlightRowMethodInfo
- listBoxDragHighlightRow :: (HasCallStack, MonadIO m, IsListBox a, IsListBoxRow b) => a -> b -> m ()
- data ListBoxDragUnhighlightRowMethodInfo
- listBoxDragUnhighlightRow :: (HasCallStack, MonadIO m, IsListBox a) => a -> m ()
- data ListBoxGetActivateOnSingleClickMethodInfo
- listBoxGetActivateOnSingleClick :: (HasCallStack, MonadIO m, IsListBox a) => a -> m Bool
- data ListBoxGetAdjustmentMethodInfo
- listBoxGetAdjustment :: (HasCallStack, MonadIO m, IsListBox a) => a -> m Adjustment
- data ListBoxGetRowAtIndexMethodInfo
- listBoxGetRowAtIndex :: (HasCallStack, MonadIO m, IsListBox a) => a -> Int32 -> m (Maybe ListBoxRow)
- data ListBoxGetRowAtYMethodInfo
- listBoxGetRowAtY :: (HasCallStack, MonadIO m, IsListBox a) => a -> Int32 -> m (Maybe ListBoxRow)
- data ListBoxGetSelectedRowMethodInfo
- listBoxGetSelectedRow :: (HasCallStack, MonadIO m, IsListBox a) => a -> m ListBoxRow
- data ListBoxGetSelectedRowsMethodInfo
- listBoxGetSelectedRows :: (HasCallStack, MonadIO m, IsListBox a) => a -> m [ListBoxRow]
- data ListBoxGetSelectionModeMethodInfo
- listBoxGetSelectionMode :: (HasCallStack, MonadIO m, IsListBox a) => a -> m SelectionMode
- data ListBoxInsertMethodInfo
- listBoxInsert :: (HasCallStack, MonadIO m, IsListBox a, IsWidget b) => a -> b -> Int32 -> m ()
- data ListBoxInvalidateFilterMethodInfo
- listBoxInvalidateFilter :: (HasCallStack, MonadIO m, IsListBox a) => a -> m ()
- data ListBoxInvalidateHeadersMethodInfo
- listBoxInvalidateHeaders :: (HasCallStack, MonadIO m, IsListBox a) => a -> m ()
- data ListBoxInvalidateSortMethodInfo
- listBoxInvalidateSort :: (HasCallStack, MonadIO m, IsListBox a) => a -> m ()
- listBoxNew :: (HasCallStack, MonadIO m) => m ListBox
- data ListBoxPrependMethodInfo
- listBoxPrepend :: (HasCallStack, MonadIO m, IsListBox a, IsWidget b) => a -> b -> m ()
- data ListBoxSelectAllMethodInfo
- listBoxSelectAll :: (HasCallStack, MonadIO m, IsListBox a) => a -> m ()
- data ListBoxSelectRowMethodInfo
- listBoxSelectRow :: (HasCallStack, MonadIO m, IsListBox a, IsListBoxRow b) => a -> Maybe b -> m ()
- data ListBoxSelectedForeachMethodInfo
- listBoxSelectedForeach :: (HasCallStack, MonadIO m, IsListBox a) => a -> ListBoxForeachFunc -> m ()
- data ListBoxSetActivateOnSingleClickMethodInfo
- listBoxSetActivateOnSingleClick :: (HasCallStack, MonadIO m, IsListBox a) => a -> Bool -> m ()
- data ListBoxSetAdjustmentMethodInfo
- listBoxSetAdjustment :: (HasCallStack, MonadIO m, IsListBox a, IsAdjustment b) => a -> Maybe b -> m ()
- data ListBoxSetFilterFuncMethodInfo
- listBoxSetFilterFunc :: (HasCallStack, MonadIO m, IsListBox a) => a -> Maybe ListBoxFilterFunc -> m ()
- data ListBoxSetHeaderFuncMethodInfo
- listBoxSetHeaderFunc :: (HasCallStack, MonadIO m, IsListBox a) => a -> Maybe ListBoxUpdateHeaderFunc -> m ()
- data ListBoxSetPlaceholderMethodInfo
- listBoxSetPlaceholder :: (HasCallStack, MonadIO m, IsListBox a, IsWidget b) => a -> Maybe b -> m ()
- data ListBoxSetSelectionModeMethodInfo
- listBoxSetSelectionMode :: (HasCallStack, MonadIO m, IsListBox a) => a -> SelectionMode -> m ()
- data ListBoxSetSortFuncMethodInfo
- listBoxSetSortFunc :: (HasCallStack, MonadIO m, IsListBox a) => a -> Maybe ListBoxSortFunc -> m ()
- data ListBoxUnselectAllMethodInfo
- listBoxUnselectAll :: (HasCallStack, MonadIO m, IsListBox a) => a -> m ()
- data ListBoxUnselectRowMethodInfo
- listBoxUnselectRow :: (HasCallStack, MonadIO m, IsListBox a, IsListBoxRow b) => a -> b -> m ()
- data ListBoxActivateOnSingleClickPropertyInfo
- constructListBoxActivateOnSingleClick :: IsListBox o => Bool -> IO (GValueConstruct o)
- getListBoxActivateOnSingleClick :: (MonadIO m, IsListBox o) => o -> m Bool
- listBoxActivateOnSingleClick :: AttrLabelProxy "activateOnSingleClick"
- setListBoxActivateOnSingleClick :: (MonadIO m, IsListBox o) => o -> Bool -> m ()
- data ListBoxSelectionModePropertyInfo
- constructListBoxSelectionMode :: IsListBox o => SelectionMode -> IO (GValueConstruct o)
- getListBoxSelectionMode :: (MonadIO m, IsListBox o) => o -> m SelectionMode
- listBoxSelectionMode :: AttrLabelProxy "selectionMode"
- setListBoxSelectionMode :: (MonadIO m, IsListBox o) => o -> SelectionMode -> m ()
- type C_ListBoxActivateCursorRowCallback = Ptr () -> Ptr () -> IO ()
- type ListBoxActivateCursorRowCallback = IO ()
- data ListBoxActivateCursorRowSignalInfo
- afterListBoxActivateCursorRow :: (GObject a, MonadIO m) => a -> ListBoxActivateCursorRowCallback -> m SignalHandlerId
- genClosure_ListBoxActivateCursorRow :: ListBoxActivateCursorRowCallback -> IO Closure
- mk_ListBoxActivateCursorRowCallback :: C_ListBoxActivateCursorRowCallback -> IO (FunPtr C_ListBoxActivateCursorRowCallback)
- noListBoxActivateCursorRowCallback :: Maybe ListBoxActivateCursorRowCallback
- onListBoxActivateCursorRow :: (GObject 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 ()
- data ListBoxMoveCursorSignalInfo
- afterListBoxMoveCursor :: (GObject a, MonadIO m) => a -> ListBoxMoveCursorCallback -> m SignalHandlerId
- genClosure_ListBoxMoveCursor :: ListBoxMoveCursorCallback -> IO Closure
- mk_ListBoxMoveCursorCallback :: C_ListBoxMoveCursorCallback -> IO (FunPtr C_ListBoxMoveCursorCallback)
- noListBoxMoveCursorCallback :: Maybe ListBoxMoveCursorCallback
- onListBoxMoveCursor :: (GObject 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 ()
- data ListBoxRowActivatedSignalInfo
- afterListBoxRowActivated :: (GObject a, MonadIO m) => a -> ListBoxRowActivatedCallback -> m SignalHandlerId
- genClosure_ListBoxRowActivated :: ListBoxRowActivatedCallback -> IO Closure
- mk_ListBoxRowActivatedCallback :: C_ListBoxRowActivatedCallback -> IO (FunPtr C_ListBoxRowActivatedCallback)
- noListBoxRowActivatedCallback :: Maybe ListBoxRowActivatedCallback
- onListBoxRowActivated :: (GObject 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 ()
- data ListBoxRowSelectedSignalInfo
- afterListBoxRowSelected :: (GObject a, MonadIO m) => a -> ListBoxRowSelectedCallback -> m SignalHandlerId
- genClosure_ListBoxRowSelected :: ListBoxRowSelectedCallback -> IO Closure
- mk_ListBoxRowSelectedCallback :: C_ListBoxRowSelectedCallback -> IO (FunPtr C_ListBoxRowSelectedCallback)
- noListBoxRowSelectedCallback :: Maybe ListBoxRowSelectedCallback
- onListBoxRowSelected :: (GObject a, MonadIO m) => a -> ListBoxRowSelectedCallback -> m SignalHandlerId
- wrap_ListBoxRowSelectedCallback :: ListBoxRowSelectedCallback -> Ptr () -> Ptr ListBoxRow -> Ptr () -> IO ()
- type C_ListBoxSelectAllCallback = Ptr () -> Ptr () -> IO ()
- type ListBoxSelectAllCallback = IO ()
- data ListBoxSelectAllSignalInfo
- afterListBoxSelectAll :: (GObject a, MonadIO m) => a -> ListBoxSelectAllCallback -> m SignalHandlerId
- genClosure_ListBoxSelectAll :: ListBoxSelectAllCallback -> IO Closure
- mk_ListBoxSelectAllCallback :: C_ListBoxSelectAllCallback -> IO (FunPtr C_ListBoxSelectAllCallback)
- noListBoxSelectAllCallback :: Maybe ListBoxSelectAllCallback
- onListBoxSelectAll :: (GObject a, MonadIO m) => a -> ListBoxSelectAllCallback -> m SignalHandlerId
- wrap_ListBoxSelectAllCallback :: ListBoxSelectAllCallback -> Ptr () -> Ptr () -> IO ()
- type C_ListBoxSelectedRowsChangedCallback = Ptr () -> Ptr () -> IO ()
- type ListBoxSelectedRowsChangedCallback = IO ()
- data ListBoxSelectedRowsChangedSignalInfo
- afterListBoxSelectedRowsChanged :: (GObject a, MonadIO m) => a -> ListBoxSelectedRowsChangedCallback -> m SignalHandlerId
- genClosure_ListBoxSelectedRowsChanged :: ListBoxSelectedRowsChangedCallback -> IO Closure
- mk_ListBoxSelectedRowsChangedCallback :: C_ListBoxSelectedRowsChangedCallback -> IO (FunPtr C_ListBoxSelectedRowsChangedCallback)
- noListBoxSelectedRowsChangedCallback :: Maybe ListBoxSelectedRowsChangedCallback
- onListBoxSelectedRowsChanged :: (GObject a, MonadIO m) => a -> ListBoxSelectedRowsChangedCallback -> m SignalHandlerId
- wrap_ListBoxSelectedRowsChangedCallback :: ListBoxSelectedRowsChangedCallback -> Ptr () -> Ptr () -> IO ()
- type C_ListBoxToggleCursorRowCallback = Ptr () -> Ptr () -> IO ()
- type ListBoxToggleCursorRowCallback = IO ()
- data ListBoxToggleCursorRowSignalInfo
- afterListBoxToggleCursorRow :: (GObject a, MonadIO m) => a -> ListBoxToggleCursorRowCallback -> m SignalHandlerId
- genClosure_ListBoxToggleCursorRow :: ListBoxToggleCursorRowCallback -> IO Closure
- mk_ListBoxToggleCursorRowCallback :: C_ListBoxToggleCursorRowCallback -> IO (FunPtr C_ListBoxToggleCursorRowCallback)
- noListBoxToggleCursorRowCallback :: Maybe ListBoxToggleCursorRowCallback
- onListBoxToggleCursorRow :: (GObject a, MonadIO m) => a -> ListBoxToggleCursorRowCallback -> m SignalHandlerId
- wrap_ListBoxToggleCursorRowCallback :: ListBoxToggleCursorRowCallback -> Ptr () -> Ptr () -> IO ()
- type C_ListBoxUnselectAllCallback = Ptr () -> Ptr () -> IO ()
- type ListBoxUnselectAllCallback = IO ()
- data ListBoxUnselectAllSignalInfo
- afterListBoxUnselectAll :: (GObject a, MonadIO m) => a -> ListBoxUnselectAllCallback -> m SignalHandlerId
- genClosure_ListBoxUnselectAll :: ListBoxUnselectAllCallback -> IO Closure
- mk_ListBoxUnselectAllCallback :: C_ListBoxUnselectAllCallback -> IO (FunPtr C_ListBoxUnselectAllCallback)
- noListBoxUnselectAllCallback :: Maybe ListBoxUnselectAllCallback
- onListBoxUnselectAll :: (GObject a, MonadIO m) => a -> ListBoxUnselectAllCallback -> m SignalHandlerId
- wrap_ListBoxUnselectAllCallback :: ListBoxUnselectAllCallback -> Ptr () -> Ptr () -> IO ()
Exported types
GObject ListBox Source # | |
IsImplementorIface ListBox Source # | |
IsObject ListBox Source # | |
IsWidget ListBox Source # | |
IsListBox ListBox Source # | |
IsContainer ListBox Source # | |
IsBuildable ListBox Source # | |
((~) * info (ResolveListBoxMethod t ListBox), MethodInfo * info ListBox p) => IsLabel t (ListBox -> p) Source # | |
((~) * info (ResolveListBoxMethod t ListBox), MethodInfo * info ListBox p) => IsLabelProxy t (ListBox -> p) Source # | |
HasAttributeList * ListBox Source # | |
type AttributeList ListBox Source # | |
type SignalList ListBox Source # | |
Methods
bindModel
data ListBoxBindModelMethodInfo Source #
((~) * signature (Maybe b -> Maybe ListBoxCreateWidgetFunc -> m ()), MonadIO m, IsListBox a, IsListModel b) => MethodInfo * ListBoxBindModelMethodInfo a signature Source # | |
:: (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
data ListBoxDragHighlightRowMethodInfo Source #
((~) * signature (b -> m ()), MonadIO m, IsListBox a, IsListBoxRow b) => MethodInfo * ListBoxDragHighlightRowMethodInfo a signature Source # | |
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
data ListBoxDragUnhighlightRowMethodInfo Source #
((~) * signature (m ()), MonadIO m, IsListBox a) => MethodInfo * ListBoxDragUnhighlightRowMethodInfo a signature Source # | |
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
data ListBoxGetActivateOnSingleClickMethodInfo Source #
((~) * signature (m Bool), MonadIO m, IsListBox a) => MethodInfo * ListBoxGetActivateOnSingleClickMethodInfo a signature Source # | |
listBoxGetActivateOnSingleClick Source #
:: (HasCallStack, MonadIO m, IsListBox a) | |
=> a |
|
-> m Bool | Returns: |
Returns whether rows activate on single clicks.
Since: 3.10
getAdjustment
data ListBoxGetAdjustmentMethodInfo Source #
((~) * signature (m Adjustment), MonadIO m, IsListBox a) => MethodInfo * ListBoxGetAdjustmentMethodInfo a signature Source # | |
:: (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
data ListBoxGetRowAtIndexMethodInfo Source #
((~) * signature (Int32 -> m (Maybe ListBoxRow)), MonadIO m, IsListBox a) => MethodInfo * ListBoxGetRowAtIndexMethodInfo a signature Source # | |
:: (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
data ListBoxGetRowAtYMethodInfo Source #
((~) * signature (Int32 -> m (Maybe ListBoxRow)), MonadIO m, IsListBox a) => MethodInfo * ListBoxGetRowAtYMethodInfo a signature Source # | |
:: (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
data ListBoxGetSelectedRowMethodInfo Source #
((~) * signature (m ListBoxRow), MonadIO m, IsListBox a) => MethodInfo * ListBoxGetSelectedRowMethodInfo a signature Source # | |
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
data ListBoxGetSelectedRowsMethodInfo Source #
((~) * signature (m [ListBoxRow]), MonadIO m, IsListBox a) => MethodInfo * ListBoxGetSelectedRowsMethodInfo a signature Source # | |
listBoxGetSelectedRows Source #
:: (HasCallStack, MonadIO m, IsListBox a) | |
=> a |
|
-> m [ListBoxRow] | Returns:
A |
Creates a list of all selected children.
Since: 3.14
getSelectionMode
data ListBoxGetSelectionModeMethodInfo Source #
((~) * signature (m SelectionMode), MonadIO m, IsListBox a) => MethodInfo * ListBoxGetSelectionModeMethodInfo a signature Source # | |
listBoxGetSelectionMode Source #
:: (HasCallStack, MonadIO m, IsListBox a) | |
=> a |
|
-> m SelectionMode | Returns: a |
Gets the selection mode of the listbox.
Since: 3.10
insert
data ListBoxInsertMethodInfo Source #
((~) * signature (b -> Int32 -> m ()), MonadIO m, IsListBox a, IsWidget b) => MethodInfo * ListBoxInsertMethodInfo a signature Source # | |
:: (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
data ListBoxInvalidateFilterMethodInfo Source #
((~) * signature (m ()), MonadIO m, IsListBox a) => MethodInfo * ListBoxInvalidateFilterMethodInfo a signature Source # | |
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
data ListBoxInvalidateHeadersMethodInfo Source #
((~) * signature (m ()), MonadIO m, IsListBox a) => MethodInfo * ListBoxInvalidateHeadersMethodInfo a signature Source # | |
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
data ListBoxInvalidateSortMethodInfo Source #
((~) * signature (m ()), MonadIO m, IsListBox a) => MethodInfo * ListBoxInvalidateSortMethodInfo a signature Source # | |
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
data ListBoxPrependMethodInfo Source #
((~) * signature (b -> m ()), MonadIO m, IsListBox a, IsWidget b) => MethodInfo * ListBoxPrependMethodInfo a signature Source # | |
:: (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
data ListBoxSelectAllMethodInfo Source #
((~) * signature (m ()), MonadIO m, IsListBox a) => MethodInfo * ListBoxSelectAllMethodInfo a signature Source # | |
:: (HasCallStack, MonadIO m, IsListBox a) | |
=> a |
|
-> m () |
Select all children of box
, if the selection mode allows it.
Since: 3.14
selectRow
data ListBoxSelectRowMethodInfo Source #
((~) * signature (Maybe b -> m ()), MonadIO m, IsListBox a, IsListBoxRow b) => MethodInfo * ListBoxSelectRowMethodInfo a signature Source # | |
:: (HasCallStack, MonadIO m, IsListBox a, IsListBoxRow b) | |
=> a |
|
-> Maybe b |
|
-> m () |
Make row
the currently selected row.
Since: 3.10
selectedForeach
data ListBoxSelectedForeachMethodInfo Source #
((~) * signature (ListBoxForeachFunc -> m ()), MonadIO m, IsListBox a) => MethodInfo * ListBoxSelectedForeachMethodInfo a signature Source # | |
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
data ListBoxSetActivateOnSingleClickMethodInfo Source #
((~) * signature (Bool -> m ()), MonadIO m, IsListBox a) => MethodInfo * ListBoxSetActivateOnSingleClickMethodInfo a signature Source # | |
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
data ListBoxSetAdjustmentMethodInfo Source #
((~) * signature (Maybe b -> m ()), MonadIO m, IsListBox a, IsAdjustment b) => MethodInfo * ListBoxSetAdjustmentMethodInfo a signature Source # | |
:: (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
data ListBoxSetFilterFuncMethodInfo Source #
((~) * signature (Maybe ListBoxFilterFunc -> m ()), MonadIO m, IsListBox a) => MethodInfo * ListBoxSetFilterFuncMethodInfo a signature Source # | |
:: (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
data ListBoxSetHeaderFuncMethodInfo Source #
((~) * signature (Maybe ListBoxUpdateHeaderFunc -> m ()), MonadIO m, IsListBox a) => MethodInfo * ListBoxSetHeaderFuncMethodInfo a signature Source # | |
:: (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
data ListBoxSetPlaceholderMethodInfo Source #
((~) * signature (Maybe b -> m ()), MonadIO m, IsListBox a, IsWidget b) => MethodInfo * ListBoxSetPlaceholderMethodInfo a signature Source # | |
listBoxSetPlaceholder Source #
Sets the placeholder widget that is shown in the list when it doesn't display any visible children.
Since: 3.10
setSelectionMode
data ListBoxSetSelectionModeMethodInfo Source #
((~) * signature (SelectionMode -> m ()), MonadIO m, IsListBox a) => MethodInfo * ListBoxSetSelectionModeMethodInfo a signature Source # | |
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
data ListBoxSetSortFuncMethodInfo Source #
((~) * signature (Maybe ListBoxSortFunc -> m ()), MonadIO m, IsListBox a) => MethodInfo * ListBoxSetSortFuncMethodInfo a signature Source # | |
:: (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
data ListBoxUnselectAllMethodInfo Source #
((~) * signature (m ()), MonadIO m, IsListBox a) => MethodInfo * ListBoxUnselectAllMethodInfo a signature Source # | |
:: (HasCallStack, MonadIO m, IsListBox a) | |
=> a |
|
-> m () |
Unselect all children of box
, if the selection mode allows it.
Since: 3.14
unselectRow
data ListBoxUnselectRowMethodInfo Source #
((~) * signature (b -> m ()), MonadIO m, IsListBox a, IsListBoxRow b) => MethodInfo * ListBoxUnselectRowMethodInfo a signature Source # | |
:: (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
data ListBoxActivateOnSingleClickPropertyInfo Source #
constructListBoxActivateOnSingleClick :: IsListBox o => Bool -> IO (GValueConstruct o) Source #
listBoxActivateOnSingleClick :: AttrLabelProxy "activateOnSingleClick" Source #
selectionMode
data ListBoxSelectionModePropertyInfo Source #
constructListBoxSelectionMode :: IsListBox o => SelectionMode -> IO (GValueConstruct o) Source #
getListBoxSelectionMode :: (MonadIO m, IsListBox o) => o -> m SelectionMode Source #
listBoxSelectionMode :: AttrLabelProxy "selectionMode" Source #
setListBoxSelectionMode :: (MonadIO m, IsListBox o) => o -> SelectionMode -> m () Source #
Signals
activateCursorRow
type ListBoxActivateCursorRowCallback = IO () Source #
afterListBoxActivateCursorRow :: (GObject a, MonadIO m) => a -> ListBoxActivateCursorRowCallback -> m SignalHandlerId Source #
mk_ListBoxActivateCursorRowCallback :: C_ListBoxActivateCursorRowCallback -> IO (FunPtr C_ListBoxActivateCursorRowCallback) Source #
onListBoxActivateCursorRow :: (GObject a, MonadIO m) => a -> ListBoxActivateCursorRowCallback -> m SignalHandlerId Source #
wrap_ListBoxActivateCursorRowCallback :: ListBoxActivateCursorRowCallback -> Ptr () -> Ptr () -> IO () Source #
moveCursor
type ListBoxMoveCursorCallback = MovementStep -> Int32 -> IO () Source #
afterListBoxMoveCursor :: (GObject a, MonadIO m) => a -> ListBoxMoveCursorCallback -> m SignalHandlerId Source #
mk_ListBoxMoveCursorCallback :: C_ListBoxMoveCursorCallback -> IO (FunPtr C_ListBoxMoveCursorCallback) Source #
onListBoxMoveCursor :: (GObject 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 :: (GObject a, MonadIO m) => a -> ListBoxRowActivatedCallback -> m SignalHandlerId Source #
mk_ListBoxRowActivatedCallback :: C_ListBoxRowActivatedCallback -> IO (FunPtr C_ListBoxRowActivatedCallback) Source #
onListBoxRowActivated :: (GObject 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 :: (GObject a, MonadIO m) => a -> ListBoxRowSelectedCallback -> m SignalHandlerId Source #
mk_ListBoxRowSelectedCallback :: C_ListBoxRowSelectedCallback -> IO (FunPtr C_ListBoxRowSelectedCallback) Source #
onListBoxRowSelected :: (GObject a, MonadIO m) => a -> ListBoxRowSelectedCallback -> m SignalHandlerId Source #
wrap_ListBoxRowSelectedCallback :: ListBoxRowSelectedCallback -> Ptr () -> Ptr ListBoxRow -> Ptr () -> IO () Source #
selectAll
type ListBoxSelectAllCallback = IO () Source #
afterListBoxSelectAll :: (GObject a, MonadIO m) => a -> ListBoxSelectAllCallback -> m SignalHandlerId Source #
mk_ListBoxSelectAllCallback :: C_ListBoxSelectAllCallback -> IO (FunPtr C_ListBoxSelectAllCallback) Source #
onListBoxSelectAll :: (GObject a, MonadIO m) => a -> ListBoxSelectAllCallback -> m SignalHandlerId Source #
wrap_ListBoxSelectAllCallback :: ListBoxSelectAllCallback -> Ptr () -> Ptr () -> IO () Source #
selectedRowsChanged
type ListBoxSelectedRowsChangedCallback = IO () Source #
afterListBoxSelectedRowsChanged :: (GObject a, MonadIO m) => a -> ListBoxSelectedRowsChangedCallback -> m SignalHandlerId Source #
mk_ListBoxSelectedRowsChangedCallback :: C_ListBoxSelectedRowsChangedCallback -> IO (FunPtr C_ListBoxSelectedRowsChangedCallback) Source #
onListBoxSelectedRowsChanged :: (GObject a, MonadIO m) => a -> ListBoxSelectedRowsChangedCallback -> m SignalHandlerId Source #
wrap_ListBoxSelectedRowsChangedCallback :: ListBoxSelectedRowsChangedCallback -> Ptr () -> Ptr () -> IO () Source #
toggleCursorRow
type ListBoxToggleCursorRowCallback = IO () Source #
afterListBoxToggleCursorRow :: (GObject a, MonadIO m) => a -> ListBoxToggleCursorRowCallback -> m SignalHandlerId Source #
mk_ListBoxToggleCursorRowCallback :: C_ListBoxToggleCursorRowCallback -> IO (FunPtr C_ListBoxToggleCursorRowCallback) Source #
onListBoxToggleCursorRow :: (GObject a, MonadIO m) => a -> ListBoxToggleCursorRowCallback -> m SignalHandlerId Source #
wrap_ListBoxToggleCursorRowCallback :: ListBoxToggleCursorRowCallback -> Ptr () -> Ptr () -> IO () Source #
unselectAll
type ListBoxUnselectAllCallback = IO () Source #
afterListBoxUnselectAll :: (GObject a, MonadIO m) => a -> ListBoxUnselectAllCallback -> m SignalHandlerId Source #
mk_ListBoxUnselectAllCallback :: C_ListBoxUnselectAllCallback -> IO (FunPtr C_ListBoxUnselectAllCallback) Source #
onListBoxUnselectAll :: (GObject a, MonadIO m) => a -> ListBoxUnselectAllCallback -> m SignalHandlerId Source #
wrap_ListBoxUnselectAllCallback :: ListBoxUnselectAllCallback -> Ptr () -> Ptr () -> IO () Source #