600 lines
23 KiB
Plaintext
600 lines
23 KiB
Plaintext
import elm_general;
|
|
import elm_list;
|
|
import elm_genlist_item;
|
|
|
|
class Elm.Genlist (Elm.Layout, Elm.Interface_Scrollable, Evas.Clickable_Interface,
|
|
Elm.Interface_Atspi_Widget_Action, Elm.Interface_Atspi_Selection,
|
|
Evas.Selectable_Interface)
|
|
{
|
|
eo_prefix: elm_obj_genlist;
|
|
methods {
|
|
@property homogeneous {
|
|
set {
|
|
[[Enable/disable homogeneous mode.
|
|
|
|
This will enable the homogeneous mode where items are of the
|
|
same height and width so that genlist may do the lazy-loading
|
|
at its maximum (which increases the performance for scrolling
|
|
the list). In the normal mode, genlist will pre-calculate all
|
|
the items' sizes even though they are not in use. So items'
|
|
callbacks are called many times than expected. But homogeneous
|
|
mode will skip the item size pre-calculation process so
|
|
items' callbacks are called only when the item is needed.
|
|
|
|
Note: This also works well with group index.
|
|
]]
|
|
}
|
|
get {
|
|
[[Get whether the homogeneous mode is enabled.]]
|
|
}
|
|
values {
|
|
homogeneous: bool; [[Assume the items within the genlist are of
|
|
the same height and width. Default is $false.]]
|
|
}
|
|
}
|
|
@property select_mode {
|
|
set {
|
|
[[Set the genlist select mode.
|
|
|
|
#ELM_OBJECT_SELECT_MODE_DEFAULT means that items will call
|
|
their selection func and callback once when first becoming
|
|
selected. Any further clicks will do nothing, unless you set
|
|
always select mode. ELM_OBJECT_SELECT_MODE_ALWAYS means that
|
|
even if selected, every click will make the selected callbacks
|
|
be called. #ELM_OBJECT_SELECT_MODE_NONE will turn off the
|
|
ability to select items entirely and they will neither appear
|
|
selected nor call selected callback functions.
|
|
]]
|
|
}
|
|
get {
|
|
[[Get the genlist select mode.]]
|
|
}
|
|
values {
|
|
mode: Elm.Object.Select_Mode(Elm.Object.Select_Mode.max); [[The select mode.]]
|
|
}
|
|
}
|
|
@property focus_on_selection {
|
|
set {
|
|
[[Set focus upon items selection mode
|
|
|
|
When enabled, every selection of an item inside the genlist
|
|
will automatically set focus to its first focusable widget
|
|
from the left. This is true of course if the selection was
|
|
made by clicking an unfocusable area in an item or selecting
|
|
it with a key movement. Clicking on a focusable widget inside
|
|
an item will couse this particular item to get focus as usual.
|
|
]]
|
|
}
|
|
get {
|
|
[[Get whether focus upon item's selection mode is enabled.]]
|
|
}
|
|
values {
|
|
enabled: bool; [[The tree effect status.]]
|
|
}
|
|
}
|
|
@property longpress_timeout {
|
|
set {
|
|
[[Set the timeout in seconds for the longpress event.
|
|
|
|
This option will change how long it takes to send an event
|
|
"longpressed" after the mouse down signal is sent to the list.
|
|
If this event occurs, no "clicked" event will be sent.
|
|
|
|
Warning: If you set the longpress timeout value with this API,
|
|
your genlist will not be affected by the longpress value of
|
|
elementary config value later.
|
|
]]
|
|
}
|
|
get {
|
|
[[Get the timeout in seconds for the longpress event.]]
|
|
}
|
|
values {
|
|
timeout: double; [[Timeout in seconds. Default is elm config value (1.0).]]
|
|
}
|
|
}
|
|
@property multi_select {
|
|
set {
|
|
[[Enable or disable multi-selection in the genlist.
|
|
|
|
This enables ($true) or disables ($false) multi-selection in
|
|
the list. This allows more than 1 item to be selected. To
|
|
retrieve the list of selected items, use @.selected_items.get.
|
|
]]
|
|
}
|
|
get {
|
|
[[Get if multi-selection in genlist is enabled or disabled.]]
|
|
}
|
|
values {
|
|
multi: bool; [[Multi-select enable/disable. Default is disabled.]]
|
|
}
|
|
}
|
|
@property reorder_mode {
|
|
set {
|
|
[[Set reorder mode.
|
|
|
|
After turning on the reorder mode, longpress on normal item
|
|
will trigger reordering of the item. You can move the item
|
|
up and down. However, reorder does not work with group item.
|
|
]]
|
|
}
|
|
get {
|
|
[[Get the reorder mode.]]
|
|
}
|
|
values {
|
|
reorder_mode: bool; [[The reorder mode.]]
|
|
}
|
|
}
|
|
@property decorate_mode {
|
|
set {
|
|
[[Set Genlist decorate mode.
|
|
|
|
This sets Genlist decorate mode to all items.
|
|
]]
|
|
}
|
|
get {
|
|
[[Get Genlist decorate mode.]]
|
|
}
|
|
values {
|
|
decorated: bool; [[The decorate mode status.]]
|
|
}
|
|
}
|
|
@property multi_select_mode {
|
|
set {
|
|
[[Set the genlist multi select mode.
|
|
|
|
#ELM_OBJECT_MULTI_SELECT_MODE_DEFAULT means that
|
|
select/unselect items whenever each item is clicked.
|
|
#ELM_OBJECT_MULTI_SELECT_MODE_WITH_CONTROL means that only
|
|
one item will be selected although multi-selection is enabled,
|
|
if clicked without pressing control key. This mode is only
|
|
available with multi-selection.
|
|
|
|
@since 1.8
|
|
]]
|
|
}
|
|
get {
|
|
[[Get the genlist multi select mode.
|
|
|
|
@since 1.8
|
|
]]
|
|
}
|
|
values {
|
|
mode: Elm.Object.Multi_Select_Mode(Elm.Object.Multi_Select_Mode.max); [[The multi select mode]]
|
|
}
|
|
}
|
|
@property block_count {
|
|
set {
|
|
[[Set the maximum number of items within an item block.
|
|
|
|
This will configure the block count to tune to the target
|
|
with particular performance matrix.
|
|
|
|
A block of objects will be used to reduce the number of
|
|
operations due to many objects in the screen. It can
|
|
determine the visibility, or if the object has changed,
|
|
it theme needs to be updated, etc. doing this kind of
|
|
calculation to the entire block, instead of per object.
|
|
|
|
The default value for the block count is enough for most
|
|
lists, so unless you know you will have a lot of objects
|
|
visible in the screen at the same time, don't try to
|
|
change this.
|
|
]]
|
|
}
|
|
get {
|
|
[[Get the maximum number of items within an item block.]]
|
|
}
|
|
values {
|
|
count: int; [[Maximum number of items within an item block. Default is 32.]]
|
|
}
|
|
}
|
|
@property tree_effect_enabled {
|
|
[[Control genlist tree effect.]]
|
|
set {}
|
|
get {}
|
|
values {
|
|
enabled: bool; [[The tree effect status.]]
|
|
}
|
|
}
|
|
@property highlight_mode {
|
|
set {
|
|
[[Set whether the genlist items should be highlighted on item
|
|
selection.
|
|
|
|
This will turn on/off the highlight effect on item selection.
|
|
The selected and clicked callback functions will still be
|
|
called.
|
|
|
|
Highlight is enabled by default.
|
|
]]
|
|
}
|
|
get {
|
|
[[Get whether the genlist items' should be highlighted when
|
|
item selected.
|
|
]]
|
|
}
|
|
values {
|
|
highlight: bool; [[$true to enable highlighting or $false to
|
|
disable it.]]
|
|
}
|
|
}
|
|
@property mode {
|
|
set {
|
|
[[This sets the horizontal stretching mode.
|
|
|
|
This sets the mode used for sizing items horizontally. Valid
|
|
modes are @Elm.List.Mode.limit, @Elm.List.Mode.scroll, and
|
|
@Elm.List.Mode.compress. The default is @Elm.List.Mode.scroll. This mode
|
|
means that if items are too wide to fit, the scroller will
|
|
scroll horizontally. Otherwise items are expanded to fill
|
|
the width of the viewport of the scroller. If it is
|
|
@Elm.List.Mode.limit, items will be expanded to the viewport width
|
|
and limited to that size. If it is @Elm.List.Mode.compress, the
|
|
item width will be fixed (restricted to a minimum of) to the
|
|
list width when calculating its size in order to allow the
|
|
height to be calculated based on it. This allows, for
|
|
instance, text block to wrap lines if the Edje part is
|
|
configured with "text.min: 0 1".
|
|
|
|
Note: @Elm.List.Mode.compress will make list resize slower as it
|
|
will have to recalculate every item height again whenever
|
|
the list width changes!
|
|
|
|
Note: Homogeneous mode is for that all items in the genlist
|
|
same width/height. With @Elm.List.Mode.compress, it makes genlist
|
|
items to fast initializing. However there's no sub-objects
|
|
in genlist which can be on the flying resizable (such as
|
|
TEXTBLOCK). If then, some dynamic esizable objects in
|
|
genlist would not diplayed properly.
|
|
]]
|
|
}
|
|
get {
|
|
[[Get the horizontal stretching mode.]]
|
|
}
|
|
values {
|
|
mode: Elm.List.Mode(Elm.List.Mode.last); [[The mode to use (one of @Elm.List.Mode.scroll or @Elm.List.Mode.limit).]]
|
|
}
|
|
}
|
|
@property decorated_item {
|
|
get {
|
|
[[Get active genlist mode item.
|
|
|
|
This function returns the item that was activated with a mode,
|
|
by the function @.decorate_mode.set.
|
|
]]
|
|
return: Elm.Widget_Item *; [[The active item for that current mode.
|
|
Or $null if no item is activated with any mode.]]
|
|
}
|
|
}
|
|
@property selected_item {
|
|
get {
|
|
[[Get the selected item in the genlist.
|
|
|
|
This gets the selected item in the list (if multi-selection
|
|
is enabled, only the item that was first selected in the list
|
|
is returned - which is not very useful, so see
|
|
@.selected_items.get for when multi-selection is used).
|
|
|
|
If no item is selected, $null is returned.
|
|
]]
|
|
return: Elm.Widget_Item *; [[The selected item, or $null if none is selected.]]
|
|
}
|
|
}
|
|
@property first_item {
|
|
get {
|
|
[[Get the first item in the genlist.
|
|
|
|
This returns the first item in the list.
|
|
|
|
If filter is set on genlist, it returns
|
|
the first filtered item in the list.
|
|
]]
|
|
return: Elm.Widget_Item *; [[The first item or $null.]]
|
|
}
|
|
}
|
|
@property realized_items {
|
|
get {
|
|
[[Get a list of realized items in genlist.
|
|
|
|
This returns a list of the realized items in the genlist.
|
|
The list contains genlist item pointers. The list must be
|
|
freed by the caller when done with \@ref eina_list_free. The
|
|
item pointers in the list are only valid so long as those
|
|
items are not deleted or the genlist is not deleted.
|
|
]]
|
|
return: free(own(list<Elm_Gen_Item *> *), eina_list_free) @warn_unused;
|
|
}
|
|
}
|
|
@property selected_items {
|
|
get {
|
|
[[Get a list of selected items in the genlist.
|
|
|
|
It returns a list of the selected items. This list pointer
|
|
is only valid so long as the selection doesn't change (no
|
|
items are selected or unselected, or unselected implicitl
|
|
by deletion). The list contains genlist items pointers. The
|
|
order of the items in this list is the order which they were
|
|
selected, i.e. the first item in this list is the first item
|
|
that was selected, and so on.
|
|
|
|
Note: If not in multi-select mode, consider using function
|
|
@.selected_item.get instead.
|
|
]]
|
|
return: const(list<Elm.Widget_Item *>)*;
|
|
}
|
|
}
|
|
@property last_item {
|
|
get {
|
|
[[Get the last item in the genlist
|
|
|
|
This returns the last item in the list.
|
|
|
|
If filter is set to genlist, it returns
|
|
last filtered item in the list.
|
|
]]
|
|
return: Elm.Widget_Item *;
|
|
}
|
|
}
|
|
item_insert_before {
|
|
[[Insert an item before another in a genlist widget
|
|
|
|
This inserts an item before another in the list. It will be in
|
|
the same tree level or group as the item it is inserted before.
|
|
]]
|
|
return: Elm.Widget_Item *;
|
|
params {
|
|
@in itc: const(Elm.Genlist.Item.Class)*; [[The item class for the item.]]
|
|
@in data: const(void)*; [[The item data.]]
|
|
@in parent: Elm.Widget_Item * @nullable; [[The parent item, or $null if none.]]
|
|
@in before_it: Elm.Widget_Item *; [[The item to place this new one before.]]
|
|
@in type: Elm.Genlist.Item.Type; [[Item type.]]
|
|
@in func: Evas_Smart_Cb @optional; [[Convenience function called when the item is selected.]]
|
|
@in func_data: const(void)* @optional; [[Data passed to $func above.]]
|
|
}
|
|
}
|
|
realized_items_update {
|
|
[[Update the contents of all realized items.
|
|
|
|
This updates all realized items by calling all the item class
|
|
functions again to get the contents, texts and states. Use this
|
|
when the original item data has changed and the changes are
|
|
desired to be reflected.
|
|
|
|
To update just one item, use \@ref elm_genlist_item_update.
|
|
]]
|
|
}
|
|
item_insert_after {
|
|
[[Insert an item after another in a genlist widget
|
|
|
|
This inserts an item after another in the list. It will be in the
|
|
same tree level or group as the item it is inserted after.
|
|
]]
|
|
return: Elm.Widget_Item *;
|
|
params {
|
|
@in itc: const(Elm.Genlist.Item.Class)*; [[The item class for the item.]]
|
|
@in data: const(void)*; [[The item data.]]
|
|
@in parent: Elm.Widget_Item * @nullable; [[The parent item, or $null if none.]]
|
|
@in after_it: Elm.Widget_Item *; [[The item to place this new one after.]]
|
|
@in type: Elm.Genlist.Item.Type; [[Item type.]]
|
|
@in func: Evas_Smart_Cb @optional; [[Convenience function called when the item is selected.]]
|
|
@in func_data: const(void)* @optional; [[Data passed to $func above.]]
|
|
}
|
|
}
|
|
at_xy_item_get @const {
|
|
[[Get the item that is at the x, y canvas coords.
|
|
|
|
This returns the item at the given coordinates (which are canvas
|
|
relative, not object-relative). If an item is at that coordinate,
|
|
that item handle is returned, and if $posret is not NULL, the
|
|
integer pointed to is set to a value of -1, 0 or 1, depending if
|
|
the coordinate is on the upper portion of that item (-1), on the
|
|
middle section (0) or on the lower part (1). If NULL is returned
|
|
as an item (no item found there), then posret may indicate -1 or
|
|
1 based if the coordinate is above or below all items
|
|
respectively in the genlist.
|
|
]]
|
|
return: Elm.Widget_Item *;
|
|
params {
|
|
@in x: Evas.Coord; [[The input x coordinate.]]
|
|
@in y: Evas.Coord; [[The input y coordinate.]]
|
|
@out posret: int; [[The position relative to the item returned here.]]
|
|
}
|
|
}
|
|
@property filter {
|
|
set {
|
|
[[Set filter mode with key.
|
|
|
|
This initiates the filter mode of genlist with user/application
|
|
provided key. If key is NULL, the filter mode is turned off.
|
|
|
|
The filter data passed has to be managed by application itself and
|
|
should not be deleted before genlist is deleted(or while filtering
|
|
is not done.
|
|
]]
|
|
}
|
|
values {
|
|
key: void *; [[Filter key]]
|
|
}
|
|
}
|
|
filter_iterator_new {
|
|
[[Returns an iterator over the list of filtered items.
|
|
|
|
Return NULL if filter is not set. Application must take care
|
|
of the case while calling the API. Must be freed after use.
|
|
]]
|
|
return: free(own(iterator<Elm_Gen_Item *> *), eina_iterator_free); [[Iterator on genlist]]
|
|
}
|
|
filtered_items_count @const {
|
|
[[Return how many items have passed the filter currently.
|
|
|
|
This behaviour is O(1) and returns the count of items which
|
|
are currently passed by the filter. After "filter,done", the
|
|
call returns total count of the filtered items.
|
|
]]
|
|
return: uint;
|
|
}
|
|
items_count @const {
|
|
[[Return how many items are currently in a list.
|
|
|
|
This behavior is O(1) and includes items which may or may not
|
|
be realized.
|
|
]]
|
|
return: uint;
|
|
}
|
|
item_prepend {
|
|
[[Prepend a new item in a given genlist widget.
|
|
|
|
This adds an item to the beginning of the list or beginning of
|
|
the children of the parent if given.
|
|
]]
|
|
return: Elm.Widget_Item *;
|
|
params {
|
|
@in itc: const(Elm.Genlist.Item.Class)*; [[The item class for the item.]]
|
|
@in data: const(void)*; [[The item data.]]
|
|
@in parent: Elm.Widget_Item * @nullable; [[The parent item, or $null if none.]]
|
|
@in type: Elm.Genlist.Item.Type; [[Item type.]]
|
|
@in func: Evas_Smart_Cb @optional; [[Convenience function called when the item is selected.]]
|
|
@in func_data: const(void)* @optional; [[Data passed to $func above.]]
|
|
}
|
|
}
|
|
clear {
|
|
[[Remove all items from a given genlist widget.
|
|
|
|
This removes (and deletes) all items in $obj, leaving it empty.
|
|
]]
|
|
}
|
|
item_append {
|
|
[[Append a new item in a given genlist widget.
|
|
|
|
This adds the given item to the end of the list or the end of
|
|
the children list if the $parent is given.
|
|
]]
|
|
return: Elm.Widget_Item *;
|
|
params {
|
|
@in itc: const(Elm.Genlist.Item.Class)*; [[The item class for the item.]]
|
|
@in data: const(void)*; [[The item data.]]
|
|
@in parent: Elm.Widget_Item * @nullable; [[The parent item, or $null if none.]]
|
|
@in type: Elm.Genlist.Item.Type; [[Item type.]]
|
|
@in func: Evas_Smart_Cb @optional; [[Convenience function called when the item is selected.]]
|
|
@in func_data: const(void)* @optional; [[Data passed to $func above.]]
|
|
}
|
|
}
|
|
item_sorted_insert {
|
|
[[Insert a new item into the sorted genlist object
|
|
|
|
This inserts an item in the genlist based on user defined
|
|
comparison function. The two arguments passed to the function
|
|
$func are genlist item handles to compare.
|
|
]]
|
|
return: Elm.Widget_Item *;
|
|
params {
|
|
@in itc: const(Elm.Genlist.Item.Class)*; [[The item class for the item.]]
|
|
@in data: const(void)*; [[The item data.]]
|
|
@in parent: Elm.Widget_Item * @nullable; [[The parent item, or $null if none.]]
|
|
@in type: Elm.Genlist.Item.Type; [[Item type.]]
|
|
@in comp: Eina_Compare_Cb; [[The function called for the sort.]]
|
|
@in func: Evas_Smart_Cb @optional; [[Convenience function called when the item is selected.]]
|
|
@in func_data: const(void)* @optional; [[Data passed to $func above.]]
|
|
}
|
|
}
|
|
search_by_text_item_get {
|
|
[[Get genlist item by given string.
|
|
|
|
It takes pointer to the genlist item that will be used to start
|
|
search from it.
|
|
|
|
This function uses globs (like "*.jpg") for searching and takes
|
|
search flags as last parameter That is a bitfield with values
|
|
to be ored together or 0 for no flags.
|
|
|
|
@since 1.11
|
|
]]
|
|
return: Elm.Widget_Item *;
|
|
params {
|
|
@in item_to_search_from: Elm.Widget_Item * @optional; [[
|
|
Pointer to item to start search from. If $null, search
|
|
will be started from the first item of the genlist.
|
|
]]
|
|
@in part_name: const(char)*; [[Name of the TEXT part of genlist item to search string in.]]
|
|
@in pattern: const(char)*; [[The search pattern.]]
|
|
@in flags: Elm.Glob.Match_Flags; [[Search flags.]]
|
|
}
|
|
}
|
|
}
|
|
implements {
|
|
class.constructor;
|
|
Eo.Base.constructor;
|
|
Evas.Object_Smart.member_add;
|
|
Evas.Object_Smart.move;
|
|
Evas.Object_Smart.add;
|
|
Evas.Object_Smart.del;
|
|
Evas.Object_Smart.resize;
|
|
Elm.Widget.theme_apply;
|
|
Elm.Widget.focus_next_manager_is;
|
|
Elm.Widget.sub_object_add;
|
|
Elm.Widget.access;
|
|
Elm.Widget.focus_highlight_geometry_get;
|
|
Elm.Widget.focus_next;
|
|
Elm.Widget.on_focus;
|
|
Elm.Widget.focus_direction_manager_is;
|
|
Elm.Widget.sub_object_del;
|
|
Elm.Widget.event;
|
|
Elm.Widget.focused_item.get;
|
|
Elm.Widget.item_loop_enabled.set;
|
|
Elm.Widget.item_loop_enabled.get;
|
|
Elm.Layout.sub_object_add_enable;
|
|
Elm.Layout.sizing_eval;
|
|
Elm.Interface_Scrollable.bounce_allow;
|
|
Elm.Interface_Scrollable.policy;
|
|
Elm.Interface_Atspi_Accessible.children.get;
|
|
Elm.Interface_Atspi_Accessible.state_set.get;
|
|
Elm.Interface_Atspi_Widget_Action.elm_actions.get;
|
|
Elm.Interface_Atspi_Selection.selected_children_count.get;
|
|
Elm.Interface_Atspi_Selection.selected_child.get;
|
|
Elm.Interface_Atspi_Selection.selected_child_deselect;
|
|
Elm.Interface_Atspi_Selection.child_select;
|
|
Elm.Interface_Atspi_Selection.child_deselect;
|
|
Elm.Interface_Atspi_Selection.is_child_selected;
|
|
Elm.Interface_Atspi_Selection.all_children_select;
|
|
Elm.Interface_Atspi_Selection.clear;
|
|
}
|
|
events {
|
|
item,focused;
|
|
item,unfocused;
|
|
vbar,drag;
|
|
vbar,press;
|
|
vbar,unpress;
|
|
hbar,drag;
|
|
hbar,press;
|
|
hbar,unpress;
|
|
edge,top;
|
|
edge,bottom;
|
|
edge,left;
|
|
edge,right;
|
|
moved;
|
|
moved,before;
|
|
moved,after;
|
|
swipe;
|
|
multi,pinch,in;
|
|
multi,pinch,out;
|
|
multi,swipe,down;
|
|
multi,swipe,up;
|
|
multi,swipe,right;
|
|
multi,swipe,left;
|
|
released;
|
|
activated;
|
|
highlighted;
|
|
unhighlighted;
|
|
realized;
|
|
unrealized;
|
|
contract,request;
|
|
expand,request;
|
|
contracted;
|
|
expanded;
|
|
index,update;
|
|
tree,effect,finished;
|
|
filter,done;
|
|
}
|
|
|
|
}
|