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.
Synopsis
- 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 -> C_ListBoxActivateCursorRowCallback
- 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 -> C_ListBoxMoveCursorCallback
- 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 -> C_ListBoxRowActivatedCallback
- 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 -> C_ListBoxRowSelectedCallback
- 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 -> C_ListBoxSelectAllCallback
- 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 -> C_ListBoxSelectedRowsChangedCallback
- 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 -> C_ListBoxToggleCursorRowCallback
- 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 -> C_ListBoxUnselectAllCallback
Exported types
Memory-managed wrapper type.
Instances
GObject ListBox Source # | |
Defined in GI.Gtk.Objects.ListBox gobjectType :: ListBox -> IO GType # | |
IsImplementorIface ListBox Source # | |
Defined in GI.Gtk.Objects.ListBox | |
IsObject ListBox Source # | |
Defined in GI.Gtk.Objects.ListBox | |
IsBuildable ListBox Source # | |
Defined in GI.Gtk.Objects.ListBox | |
IsContainer ListBox Source # | |
Defined in GI.Gtk.Objects.ListBox | |
IsListBox ListBox Source # | |
Defined in GI.Gtk.Objects.ListBox | |
IsWidget ListBox Source # | |
Defined in GI.Gtk.Objects.ListBox |
class GObject o => IsListBox o Source #
Instances
(GObject a, (UnknownAncestorError ListBox a :: Constraint)) => IsListBox a Source # | |
Defined in GI.Gtk.Objects.ListBox | |
IsListBox ListBox Source # | |
Defined in GI.Gtk.Objects.ListBox |
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
No description available in the introspection data.
constructListBoxActivateOnSingleClick :: IsListBox o => Bool -> IO (GValueConstruct o) Source #
Construct a GValueConstruct
with valid value for the “activate-on-single-click
” property. This is rarely needed directly, but it is used by new
.
getListBoxActivateOnSingleClick :: (MonadIO m, IsListBox o) => o -> m Bool Source #
Get the value of the “activate-on-single-click
” property.
When overloading is enabled, this is equivalent to
get
listBox #activateOnSingleClick
setListBoxActivateOnSingleClick :: (MonadIO m, IsListBox o) => o -> Bool -> m () Source #
Set the value of the “activate-on-single-click
” property.
When overloading is enabled, this is equivalent to
set
listBox [ #activateOnSingleClick:=
value ]
selectionMode
No description available in the introspection data.
constructListBoxSelectionMode :: IsListBox o => SelectionMode -> IO (GValueConstruct o) Source #
Construct a GValueConstruct
with valid value for the “selection-mode
” property. This is rarely needed directly, but it is used by new
.
getListBoxSelectionMode :: (MonadIO m, IsListBox o) => o -> m SelectionMode Source #
Get the value of the “selection-mode
” property.
When overloading is enabled, this is equivalent to
get
listBox #selectionMode
setListBoxSelectionMode :: (MonadIO m, IsListBox o) => o -> SelectionMode -> m () Source #
Set the value of the “selection-mode
” property.
When overloading is enabled, this is equivalent to
set
listBox [ #selectionMode:=
value ]
Signals
activateCursorRow
type C_ListBoxActivateCursorRowCallback = Ptr () -> Ptr () -> IO () Source #
Type for the callback on the (unwrapped) C side.
type ListBoxActivateCursorRowCallback = IO () Source #
No description available in the introspection data.
afterListBoxActivateCursorRow :: (IsListBox a, MonadIO m) => a -> ListBoxActivateCursorRowCallback -> m SignalHandlerId Source #
Connect a signal handler for the “activate-cursor-row
” signal, to be run after the default handler.
When overloading is enabled, this is equivalent to
after
listBox #activateCursorRow callback
genClosure_ListBoxActivateCursorRow :: ListBoxActivateCursorRowCallback -> IO Closure Source #
Wrap the callback into a Closure
.
mk_ListBoxActivateCursorRowCallback :: C_ListBoxActivateCursorRowCallback -> IO (FunPtr C_ListBoxActivateCursorRowCallback) Source #
Generate a function pointer callable from C code, from a C_ListBoxActivateCursorRowCallback
.
noListBoxActivateCursorRowCallback :: Maybe ListBoxActivateCursorRowCallback Source #
A convenience synonym for
.Nothing
:: Maybe
ListBoxActivateCursorRowCallback
onListBoxActivateCursorRow :: (IsListBox a, MonadIO m) => a -> ListBoxActivateCursorRowCallback -> m SignalHandlerId Source #
Connect a signal handler for the “activate-cursor-row
” signal, to be run before the default handler.
When overloading is enabled, this is equivalent to
on
listBox #activateCursorRow callback
wrap_ListBoxActivateCursorRowCallback :: ListBoxActivateCursorRowCallback -> C_ListBoxActivateCursorRowCallback Source #
moveCursor
type C_ListBoxMoveCursorCallback = Ptr () -> CUInt -> Int32 -> Ptr () -> IO () Source #
Type for the callback on the (unwrapped) C side.
type ListBoxMoveCursorCallback = MovementStep -> Int32 -> IO () Source #
No description available in the introspection data.
afterListBoxMoveCursor :: (IsListBox a, MonadIO m) => a -> ListBoxMoveCursorCallback -> m SignalHandlerId Source #
Connect a signal handler for the “move-cursor
” signal, to be run after the default handler.
When overloading is enabled, this is equivalent to
after
listBox #moveCursor callback
genClosure_ListBoxMoveCursor :: ListBoxMoveCursorCallback -> IO Closure Source #
Wrap the callback into a Closure
.
mk_ListBoxMoveCursorCallback :: C_ListBoxMoveCursorCallback -> IO (FunPtr C_ListBoxMoveCursorCallback) Source #
Generate a function pointer callable from C code, from a C_ListBoxMoveCursorCallback
.
noListBoxMoveCursorCallback :: Maybe ListBoxMoveCursorCallback Source #
A convenience synonym for
.Nothing
:: Maybe
ListBoxMoveCursorCallback
onListBoxMoveCursor :: (IsListBox a, MonadIO m) => a -> ListBoxMoveCursorCallback -> m SignalHandlerId Source #
Connect a signal handler for the “move-cursor
” signal, to be run before the default handler.
When overloading is enabled, this is equivalent to
on
listBox #moveCursor callback
wrap_ListBoxMoveCursorCallback :: ListBoxMoveCursorCallback -> C_ListBoxMoveCursorCallback Source #
Wrap a ListBoxMoveCursorCallback
into a C_ListBoxMoveCursorCallback
.
rowActivated
type C_ListBoxRowActivatedCallback = Ptr () -> Ptr ListBoxRow -> Ptr () -> IO () Source #
Type for the callback on the (unwrapped) C side.
type ListBoxRowActivatedCallback Source #
= ListBoxRow |
|
-> IO () |
The ::row-activated signal is emitted when a row has been activated by the user.
Since: 3.10
afterListBoxRowActivated :: (IsListBox a, MonadIO m) => a -> ListBoxRowActivatedCallback -> m SignalHandlerId Source #
Connect a signal handler for the “row-activated
” signal, to be run after the default handler.
When overloading is enabled, this is equivalent to
after
listBox #rowActivated callback
genClosure_ListBoxRowActivated :: ListBoxRowActivatedCallback -> IO Closure Source #
Wrap the callback into a Closure
.
mk_ListBoxRowActivatedCallback :: C_ListBoxRowActivatedCallback -> IO (FunPtr C_ListBoxRowActivatedCallback) Source #
Generate a function pointer callable from C code, from a C_ListBoxRowActivatedCallback
.
noListBoxRowActivatedCallback :: Maybe ListBoxRowActivatedCallback Source #
A convenience synonym for
.Nothing
:: Maybe
ListBoxRowActivatedCallback
onListBoxRowActivated :: (IsListBox a, MonadIO m) => a -> ListBoxRowActivatedCallback -> m SignalHandlerId Source #
Connect a signal handler for the “row-activated
” signal, to be run before the default handler.
When overloading is enabled, this is equivalent to
on
listBox #rowActivated callback
wrap_ListBoxRowActivatedCallback :: ListBoxRowActivatedCallback -> C_ListBoxRowActivatedCallback Source #
Wrap a ListBoxRowActivatedCallback
into a C_ListBoxRowActivatedCallback
.
rowSelected
type C_ListBoxRowSelectedCallback = Ptr () -> Ptr ListBoxRow -> Ptr () -> IO () Source #
Type for the callback on the (unwrapped) C side.
type ListBoxRowSelectedCallback Source #
= Maybe ListBoxRow |
|
-> IO () |
The ::row-selected signal is emitted when a new row is selected, or
(with a Nothing
row
) when the selection is cleared.
When the box
is using GTK_SELECTION_MULTIPLE
, this signal will not
give you the full picture of selection changes, and you should use
the ListBox
::selected-rows-changed
signal instead.
Since: 3.10
afterListBoxRowSelected :: (IsListBox a, MonadIO m) => a -> ListBoxRowSelectedCallback -> m SignalHandlerId Source #
Connect a signal handler for the “row-selected
” signal, to be run after the default handler.
When overloading is enabled, this is equivalent to
after
listBox #rowSelected callback
genClosure_ListBoxRowSelected :: ListBoxRowSelectedCallback -> IO Closure Source #
Wrap the callback into a Closure
.
mk_ListBoxRowSelectedCallback :: C_ListBoxRowSelectedCallback -> IO (FunPtr C_ListBoxRowSelectedCallback) Source #
Generate a function pointer callable from C code, from a C_ListBoxRowSelectedCallback
.
noListBoxRowSelectedCallback :: Maybe ListBoxRowSelectedCallback Source #
A convenience synonym for
.Nothing
:: Maybe
ListBoxRowSelectedCallback
onListBoxRowSelected :: (IsListBox a, MonadIO m) => a -> ListBoxRowSelectedCallback -> m SignalHandlerId Source #
Connect a signal handler for the “row-selected
” signal, to be run before the default handler.
When overloading is enabled, this is equivalent to
on
listBox #rowSelected callback
wrap_ListBoxRowSelectedCallback :: ListBoxRowSelectedCallback -> C_ListBoxRowSelectedCallback Source #
Wrap a ListBoxRowSelectedCallback
into a C_ListBoxRowSelectedCallback
.
selectAll
type C_ListBoxSelectAllCallback = Ptr () -> Ptr () -> IO () Source #
Type for the callback on the (unwrapped) C side.
type ListBoxSelectAllCallback = IO () Source #
The ::select-all signal is a [keybinding signal][GtkBindingSignal] which gets emitted to select all children of the box, if the selection mode permits it.
The default bindings for this signal is Ctrl-a.
Since: 3.14
afterListBoxSelectAll :: (IsListBox a, MonadIO m) => a -> ListBoxSelectAllCallback -> m SignalHandlerId Source #
Connect a signal handler for the “select-all
” signal, to be run after the default handler.
When overloading is enabled, this is equivalent to
after
listBox #selectAll callback
genClosure_ListBoxSelectAll :: ListBoxSelectAllCallback -> IO Closure Source #
Wrap the callback into a Closure
.
mk_ListBoxSelectAllCallback :: C_ListBoxSelectAllCallback -> IO (FunPtr C_ListBoxSelectAllCallback) Source #
Generate a function pointer callable from C code, from a C_ListBoxSelectAllCallback
.
noListBoxSelectAllCallback :: Maybe ListBoxSelectAllCallback Source #
A convenience synonym for
.Nothing
:: Maybe
ListBoxSelectAllCallback
onListBoxSelectAll :: (IsListBox a, MonadIO m) => a -> ListBoxSelectAllCallback -> m SignalHandlerId Source #
Connect a signal handler for the “select-all
” signal, to be run before the default handler.
When overloading is enabled, this is equivalent to
on
listBox #selectAll callback
wrap_ListBoxSelectAllCallback :: ListBoxSelectAllCallback -> C_ListBoxSelectAllCallback Source #
Wrap a ListBoxSelectAllCallback
into a C_ListBoxSelectAllCallback
.
selectedRowsChanged
type C_ListBoxSelectedRowsChangedCallback = Ptr () -> Ptr () -> IO () Source #
Type for the callback on the (unwrapped) C side.
type ListBoxSelectedRowsChangedCallback = IO () Source #
The ::selected-rows-changed signal is emitted when the set of selected rows changes.
Since: 3.14
afterListBoxSelectedRowsChanged :: (IsListBox a, MonadIO m) => a -> ListBoxSelectedRowsChangedCallback -> m SignalHandlerId Source #
Connect a signal handler for the “selected-rows-changed
” signal, to be run after the default handler.
When overloading is enabled, this is equivalent to
after
listBox #selectedRowsChanged callback
genClosure_ListBoxSelectedRowsChanged :: ListBoxSelectedRowsChangedCallback -> IO Closure Source #
Wrap the callback into a Closure
.
mk_ListBoxSelectedRowsChangedCallback :: C_ListBoxSelectedRowsChangedCallback -> IO (FunPtr C_ListBoxSelectedRowsChangedCallback) Source #
Generate a function pointer callable from C code, from a C_ListBoxSelectedRowsChangedCallback
.
noListBoxSelectedRowsChangedCallback :: Maybe ListBoxSelectedRowsChangedCallback Source #
A convenience synonym for
.Nothing
:: Maybe
ListBoxSelectedRowsChangedCallback
onListBoxSelectedRowsChanged :: (IsListBox a, MonadIO m) => a -> ListBoxSelectedRowsChangedCallback -> m SignalHandlerId Source #
Connect a signal handler for the “selected-rows-changed
” signal, to be run before the default handler.
When overloading is enabled, this is equivalent to
on
listBox #selectedRowsChanged callback
wrap_ListBoxSelectedRowsChangedCallback :: ListBoxSelectedRowsChangedCallback -> C_ListBoxSelectedRowsChangedCallback Source #
toggleCursorRow
type C_ListBoxToggleCursorRowCallback = Ptr () -> Ptr () -> IO () Source #
Type for the callback on the (unwrapped) C side.
type ListBoxToggleCursorRowCallback = IO () Source #
No description available in the introspection data.
afterListBoxToggleCursorRow :: (IsListBox a, MonadIO m) => a -> ListBoxToggleCursorRowCallback -> m SignalHandlerId Source #
Connect a signal handler for the “toggle-cursor-row
” signal, to be run after the default handler.
When overloading is enabled, this is equivalent to
after
listBox #toggleCursorRow callback
genClosure_ListBoxToggleCursorRow :: ListBoxToggleCursorRowCallback -> IO Closure Source #
Wrap the callback into a Closure
.
mk_ListBoxToggleCursorRowCallback :: C_ListBoxToggleCursorRowCallback -> IO (FunPtr C_ListBoxToggleCursorRowCallback) Source #
Generate a function pointer callable from C code, from a C_ListBoxToggleCursorRowCallback
.
noListBoxToggleCursorRowCallback :: Maybe ListBoxToggleCursorRowCallback Source #
A convenience synonym for
.Nothing
:: Maybe
ListBoxToggleCursorRowCallback
onListBoxToggleCursorRow :: (IsListBox a, MonadIO m) => a -> ListBoxToggleCursorRowCallback -> m SignalHandlerId Source #
Connect a signal handler for the “toggle-cursor-row
” signal, to be run before the default handler.
When overloading is enabled, this is equivalent to
on
listBox #toggleCursorRow callback
wrap_ListBoxToggleCursorRowCallback :: ListBoxToggleCursorRowCallback -> C_ListBoxToggleCursorRowCallback Source #
Wrap a ListBoxToggleCursorRowCallback
into a C_ListBoxToggleCursorRowCallback
.
unselectAll
type C_ListBoxUnselectAllCallback = Ptr () -> Ptr () -> IO () Source #
Type for the callback on the (unwrapped) C side.
type ListBoxUnselectAllCallback = IO () Source #
The ::unselect-all signal is a [keybinding signal][GtkBindingSignal] which gets emitted to unselect all children of the box, if the selection mode permits it.
The default bindings for this signal is Ctrl-Shift-a.
Since: 3.14
afterListBoxUnselectAll :: (IsListBox a, MonadIO m) => a -> ListBoxUnselectAllCallback -> m SignalHandlerId Source #
Connect a signal handler for the “unselect-all
” signal, to be run after the default handler.
When overloading is enabled, this is equivalent to
after
listBox #unselectAll callback
genClosure_ListBoxUnselectAll :: ListBoxUnselectAllCallback -> IO Closure Source #
Wrap the callback into a Closure
.
mk_ListBoxUnselectAllCallback :: C_ListBoxUnselectAllCallback -> IO (FunPtr C_ListBoxUnselectAllCallback) Source #
Generate a function pointer callable from C code, from a C_ListBoxUnselectAllCallback
.
noListBoxUnselectAllCallback :: Maybe ListBoxUnselectAllCallback Source #
A convenience synonym for
.Nothing
:: Maybe
ListBoxUnselectAllCallback
onListBoxUnselectAll :: (IsListBox a, MonadIO m) => a -> ListBoxUnselectAllCallback -> m SignalHandlerId Source #
Connect a signal handler for the “unselect-all
” signal, to be run before the default handler.
When overloading is enabled, this is equivalent to
on
listBox #unselectAll callback