554 lines
22 KiB
Plaintext
554 lines
22 KiB
Plaintext
import elm_general;
|
|
|
|
type @extern Ecore_Pos_Map: __undefined_type; [[External ecore position map]]
|
|
|
|
enum Elm.Gengrid.Reorder_Type
|
|
{
|
|
[[Gengrid reorder modes]]
|
|
normal, [[Normal reorder type]]
|
|
swap [[Swap reorder type]]
|
|
}
|
|
|
|
class Elm.Gengrid extends Efl.Ui.Layout implements Efl.Ui.Focus.Composition, Elm.Interface_Scrollable,
|
|
Efl.Ui.Clickable, Efl.Access.Widget.Action,
|
|
Efl.Access.Selection, Efl.Ui.Legacy, Elm.Widget_Item_Container
|
|
{
|
|
[[Elementary gengrid class]]
|
|
legacy_prefix: elm_gengrid;
|
|
eo_prefix: elm_obj_gengrid;
|
|
event_prefix: elm_gengrid;
|
|
methods {
|
|
@property align {
|
|
set {
|
|
[[Set the items grid's alignment within a given gengrid widget.
|
|
|
|
This sets the alignment of the whole grid of items of a gengrid
|
|
within its given viewport. By default, those values are both
|
|
0.5, meaning that the gengrid will have its items grid placed
|
|
exactly in the middle of its viewport.
|
|
|
|
Note: If given alignment values are out of the cited ranges,
|
|
they'll be changed to the nearest boundary values on the valid
|
|
ranges.
|
|
]]
|
|
}
|
|
get {
|
|
[[Get the items grid's alignment values within a given gengrid
|
|
widget.
|
|
|
|
Note: Use $null pointers on the alignment values you're not
|
|
interested in: they'll be ignored by the function.
|
|
]]
|
|
}
|
|
values {
|
|
align_x: double; [[Alignment in the horizontal axis (0 <= align_x <= 1).]]
|
|
align_y: double; [[Alignment in the vertical axis (0 <= align_y <= 1).]]
|
|
}
|
|
}
|
|
@property filled {
|
|
set {
|
|
[[Set how the items grid's filled within a given gengrid widget
|
|
|
|
This sets the fill state of the whole grid of items of a
|
|
gengrid within its given viewport. By default, this value
|
|
is false, meaning that if the first line of items grid's
|
|
isn't filled, the items are centered with the alignment.
|
|
]]
|
|
}
|
|
get {
|
|
[[Get how the items grid's filled within a given gengrid widget
|
|
|
|
Note: Use $null pointers on the alignment values you're not
|
|
interested in: they'll be ignored by the function.
|
|
]]
|
|
}
|
|
values {
|
|
fill: bool; [[$true if the grid is filled, $false otherwise]]
|
|
}
|
|
}
|
|
@property multi_select {
|
|
set {
|
|
[[Enable or disable multi-selection in a given gengrid widget.
|
|
|
|
Multi-selection is the ability to have more than one item
|
|
selected, on a given gengrid, simultaneously. When it is
|
|
enabled, a sequence of clicks on different items will make
|
|
them all selected, progressively. A click on an already
|
|
selected item will unselect it. If interacting via the
|
|
keyboard, multi-selection is enabled while holding the
|
|
"Shift" key.
|
|
|
|
Note: By default, multi-selection is disabled on gengrids.
|
|
]]
|
|
}
|
|
get {
|
|
[[Get whether multi-selection is enabled or disabled for a given
|
|
gengrid widget.
|
|
]]
|
|
}
|
|
values {
|
|
multi: bool; [[$true if multislect is enabled, $false otherwise]]
|
|
}
|
|
}
|
|
@property group_item_size {
|
|
set {
|
|
[[Set the size for the group items of a given gengrid widget.
|
|
|
|
A gengrid, after creation, has still no information on the size
|
|
to give to each of its cells. So, you most probably will end up
|
|
with squares one \@ref Fingers "finger" wide, the default
|
|
size. Use this function to force a custom size for you group
|
|
items, making them as big as you wish.
|
|
]]
|
|
}
|
|
get {
|
|
[[Get the size set for the group items of a given gengrid widget.
|
|
|
|
Note: Use $null pointers on the size values you're not
|
|
interested in: they'll be ignored by the function.
|
|
]]
|
|
}
|
|
values {
|
|
w: int; [[The group items' width.]]
|
|
h: int; [[The group items' height.]]
|
|
}
|
|
}
|
|
@property select_mode {
|
|
set {
|
|
[[Set the gengrid select mode.
|
|
|
|
This changes item select mode in the gengrid widget.
|
|
#ELM_OBJECT_SELECT_MODE_DEFAULT means that items will only
|
|
call their selection func and callback 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 gengrid select mode.]]
|
|
}
|
|
values {
|
|
mode: Elm.Object.Select_Mode(Elm.Object.Select_Mode.max); [[The select mode.]]
|
|
}
|
|
}
|
|
@property reorder_mode {
|
|
set {
|
|
[[Set whether a given gengrid widget is or not able have items
|
|
reordered.
|
|
|
|
If a gengrid is set to allow reordering, a click held for more
|
|
than 0.5 over a given item will highlight it specially,
|
|
signaling the gengrid has entered the reordering state. From
|
|
that time on, the user will be able to, while still holding the
|
|
mouse button down, move the item freely in the gengrid's
|
|
viewport, replacing to said item to the locations it goes to.
|
|
The replacements will be animated and, whenever the user
|
|
releases the mouse button, the item being replaced gets a new
|
|
definitive place in the grid.
|
|
]]
|
|
}
|
|
get {
|
|
[[Get whether a given gengrid widget is or not able have items
|
|
reordered.
|
|
]]
|
|
}
|
|
values {
|
|
reorder_mode: bool; [[Use $true to turn reordering on,
|
|
$false to turn it off.]]
|
|
}
|
|
}
|
|
@property highlight_mode {
|
|
[[Control whether the gengrid items' should be highlighted when
|
|
item selected.
|
|
]]
|
|
set {}
|
|
get {}
|
|
values {
|
|
highlight: bool; [[$true if item will be highlighted, $false otherwise]]
|
|
}
|
|
}
|
|
@property reorder_type {
|
|
set {
|
|
[[ Set the Gengrid reorder type
|
|
@since 1.11
|
|
]]
|
|
}
|
|
values {
|
|
type: Elm.Gengrid.Reorder_Type; [[ Reorder type value ]]
|
|
}
|
|
}
|
|
@property item_size {
|
|
set {
|
|
[[Set the size for the items of a given gengrid widget.
|
|
|
|
A gengrid, after creation, has still no information on the size
|
|
to give to each of its cells. So, you most probably will end up
|
|
with squares one \@ref Fingers "finger" wide, the default
|
|
size. Use this function to force a custom size for you items,
|
|
making them as big as you wish.
|
|
]]
|
|
}
|
|
get {
|
|
[[Get the size set for the items of a given gengrid widget.
|
|
|
|
Note: Use $null pointers on the size values you're not
|
|
interested in: they'll be ignored by the function.
|
|
]]
|
|
}
|
|
values {
|
|
w: int; [[The items' width.]]
|
|
h: int; [[The items' height.]]
|
|
}
|
|
}
|
|
@property multi_select_mode {
|
|
set {
|
|
[[Set the gengrid 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 gengrid multi select mode.
|
|
|
|
If getting mode fails, it returns
|
|
#ELM_OBJECT_MULTI_SELECT_MODE_MAX.
|
|
|
|
@since 1.8
|
|
]]
|
|
}
|
|
values {
|
|
mode: Elm.Object.Multi_Select_Mode(Elm.Object.Multi_Select_Mode.max); [[The multi select mode.]]
|
|
}
|
|
}
|
|
@property horizontal {
|
|
set {
|
|
[[Set the direction in which a given gengrid widget will
|
|
expand while placing its items.
|
|
|
|
When in "horizontal mode" ($true), items will be placed in
|
|
columns, from top to bottom and, when the space for a column
|
|
is filled, another one is started on the right, thus expanding
|
|
the grid horizontally. When in "vertical mode" ($false),
|
|
though, items will be placed in rows, from left to right
|
|
and, when the space for a row is filled, another one is
|
|
started below, thus expanding the grid vertically.
|
|
|
|
Note: By default, gengrid is in vertical mode, $false.
|
|
]]
|
|
}
|
|
get {
|
|
[[Get for what direction a given gengrid widget will expand while
|
|
placing its items.
|
|
]]
|
|
}
|
|
values {
|
|
horizontal: bool; [[$true to make the gengrid expand horizontally,
|
|
$false to expand vertically.]]
|
|
}
|
|
}
|
|
@property selected_item {
|
|
get {
|
|
[[Get the selected item in a given gengrid widget.
|
|
|
|
This returns the selected item in $obj. If multi selection is
|
|
enabled on $obj (See @.multi_select.set), only the first item
|
|
in the list is selected, which might not be very useful. For
|
|
that case, see @.selected_items.get.
|
|
]]
|
|
return: Elm.Widget.Item; [[The selected item's handle or $null
|
|
if none is selected at the moment
|
|
(and on errors).]]
|
|
}
|
|
}
|
|
@property realized_items {
|
|
get {
|
|
[[Get a list of realized items in gengrid.
|
|
|
|
This returns a list of the realized items in the gengrid. The
|
|
list contains gengrid item pointers. The list must be freed by
|
|
the caller when done with eina_list_free(). The item pointers
|
|
in the list are only valid so long as those items are not
|
|
deleted or the gengrid is not deleted.
|
|
]]
|
|
return: list<ptr(Elm_Gen_Item)> @owned @warn_unused; [[
|
|
The list of realized items or $null if none are realized.
|
|
]]
|
|
}
|
|
}
|
|
@property first_item {
|
|
get {
|
|
[[Get the first item in a given gengrid widget.
|
|
|
|
This returns the first item in the $obj's internal list of
|
|
items.
|
|
]]
|
|
return: Elm.Widget.Item; [[
|
|
The first item's handle or $null, if there are no
|
|
items in $obj (and on errors)
|
|
]]
|
|
}
|
|
}
|
|
@property selected_items {
|
|
get {
|
|
[[Get a list of selected items in a given gengrid.
|
|
|
|
This returns a list of the selected items, in the order that
|
|
they appear in the grid. This list is only valid as long as no
|
|
more items are selected or unselected (or unselected implicitly
|
|
by deletion). The list contains Gengrid item pointers as
|
|
data, naturally.
|
|
]]
|
|
return: const(list<Elm.Widget.Item>); [[
|
|
The list of selected items or $null, if none is
|
|
selected at the moment (and on errors).
|
|
]]
|
|
}
|
|
}
|
|
@property last_item {
|
|
get {
|
|
[[Get the last item in a given gengrid widget.
|
|
|
|
This returns the last item in the $obj's internal list of
|
|
items.
|
|
]]
|
|
return: Elm.Widget.Item; [[The last item's handle or $null
|
|
if there are no items in $obj
|
|
(and on errors).]]
|
|
}
|
|
}
|
|
item_insert_before {
|
|
[[Insert an item before another in a gengrid widget.
|
|
|
|
This inserts an item before another in the gengrid.
|
|
]]
|
|
return: Elm.Widget.Item; [[A handle to the item added or $null on errors.]]
|
|
params {
|
|
@cref itc: Elm.Gengrid.Item.Class; [[The item class for the item.]]
|
|
@in data: const(void_ptr); [[The item data.]]
|
|
@in relative: Elm.Widget.Item; [[The item to place this new one before.]]
|
|
@in func: Evas_Smart_Cb @optional; [[Convenience function called
|
|
when the item is selected.]]
|
|
@in func_data: const(void_ptr) @optional; [[Data to be passed to $func.]]
|
|
}
|
|
}
|
|
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_gengrid_item_update.
|
|
]]
|
|
}
|
|
item_insert_after {
|
|
[[Insert an item after another in a gengrid widget.
|
|
|
|
This inserts an item after another in the gengrid.
|
|
]]
|
|
return: Elm.Widget.Item; [[A handle to the item added or $null on error.]]
|
|
params {
|
|
@cref itc: Elm.Gengrid.Item.Class; [[The item class for the item.]]
|
|
@in data: const(void_ptr); [[The item data.]]
|
|
@in relative: Elm.Widget.Item; [[The item to place this new one after.]]
|
|
@in func: Evas_Smart_Cb @optional; [[Convenience function called
|
|
when the item is selected.]]
|
|
@in func_data: const(void_ptr) @optional; [[Data to be passed to $func.]]
|
|
}
|
|
}
|
|
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; [[Items in list]]
|
|
}
|
|
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 $xposret is not $null, the
|
|
integer pointed to is set to a value of -1, 0 or 1, depending if
|
|
the coordinate is on the left portion of that item (-1), on the
|
|
middle section (0) or on the right part (1).
|
|
|
|
If $yposret 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 gengrid.
|
|
]]
|
|
return: Elm.Widget.Item; [[The item at the coordinates or $null if none.]]
|
|
params {
|
|
@in x: int; [[The input x coordinate.]]
|
|
@in y: int; [[The input y coordinate.]]
|
|
@out xposret: int; [[The position relative to the item returned here.]]
|
|
@out yposret: int; [[The position relative to the item returned here.]]
|
|
}
|
|
}
|
|
item_append {
|
|
[[Append a new item in a given gengrid widget.
|
|
|
|
This adds an item to the beginning of the gengrid.
|
|
]]
|
|
return: Elm.Widget.Item; [[A handle to the item added or $null on errors.]]
|
|
params {
|
|
@cref itc: Elm.Gengrid.Item.Class; [[The item class for the item.]]
|
|
@in data: const(void_ptr); [[The item data.]]
|
|
@in func: Evas_Smart_Cb @optional; [[Convenience function called
|
|
when the item is selected.]]
|
|
@in func_data: const(void_ptr) @optional; [[Data to be passed to $func.]]
|
|
}
|
|
}
|
|
item_prepend {
|
|
[[Prepend a new item in a given gengrid widget.
|
|
|
|
This adds an item to the end of the gengrid.
|
|
]]
|
|
return: Elm.Widget.Item; [[A handle to the item added or $null on errors.]]
|
|
params {
|
|
@cref itc: Elm.Gengrid.Item.Class; [[The item class for the item.]]
|
|
@in data: const(void_ptr); [[The item data.]]
|
|
@in func: Evas_Smart_Cb @optional; [[Convenience function called
|
|
when the item is selected.]]
|
|
@in func_data: const(void_ptr) @optional; [[Data to be passed to $func.]]
|
|
}
|
|
}
|
|
clear {
|
|
[[Remove all items from a given gengrid widget.
|
|
|
|
This removes (and deletes) all items in $obj, leaving it empty.
|
|
|
|
See \@ref elm_gengrid_item_del to remove just one item.
|
|
]]
|
|
}
|
|
item_sorted_insert {
|
|
[[Insert an item in a gengrid widget using a user-defined sort
|
|
function.
|
|
|
|
This inserts an item in the gengrid based on user defined
|
|
comparison function. The two arguments passed to the function
|
|
$func are gengrid item handles to compare.
|
|
]]
|
|
return: Elm.Widget.Item; [[A handle to the item added or $null on errors.]]
|
|
params {
|
|
@cref itc: Elm.Gengrid.Item.Class; [[The item class for the item.]]
|
|
@in data: const(void_ptr); [[The item data.]]
|
|
@in comp: Eina_Compare_Cb; [[User defined comparison function
|
|
that defines the sort order based
|
|
on gengrid item and its data.
|
|
]]
|
|
@in func: Evas_Smart_Cb @optional; [[Convenience function called when the item is selected.]]
|
|
@in func_data: const(void_ptr) @optional; [[Data to be passed to $func.]]
|
|
}
|
|
}
|
|
search_by_text_item_get {
|
|
[[Get gengrid item by given string.
|
|
|
|
It takes pointer to the gengrid 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; [[Pointer to the gengrid item which matches
|
|
search_string in case of success,
|
|
otherwise $null.]]
|
|
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 gengrid.
|
|
]]
|
|
@in part_name: string; [[Name of the TEXT part of gengrid item to search string in. If $null, search by "elm.text" parts.]]
|
|
@in pattern: string; [[The search pattern.]]
|
|
@in flags: Elm.Glob.Match_Flags; [[Search flags.]]
|
|
}
|
|
}
|
|
reorder_mode_start {
|
|
[[
|
|
Starts the reorder mode of Gengrid
|
|
@since 1.10
|
|
]]
|
|
params {
|
|
@in tween_mode: Ecore_Pos_Map; [[ Position mappings for animation ]]
|
|
}
|
|
}
|
|
reorder_mode_stop {
|
|
[[
|
|
Stops the reorder mode of Gengrid
|
|
@since 1.10
|
|
]]
|
|
}
|
|
}
|
|
implements {
|
|
class.constructor;
|
|
Efl.Object.constructor;
|
|
Efl.Object.provider_find;
|
|
Efl.Gfx.Entity.position { set; }
|
|
Efl.Gfx.Entity.size { set; }
|
|
Efl.Canvas.Group.group_member_add;
|
|
Efl.Ui.Widget.theme_apply;
|
|
Efl.Ui.Widget.on_access_update;
|
|
Efl.Ui.Widget.interest_region { get; }
|
|
Efl.Ui.Widget.widget_event;
|
|
Efl.Ui.Widget.focus_highlight_geometry { get; }
|
|
Elm.Widget_Item_Container.focused_item { get; }
|
|
Elm.Interface_Scrollable.item_loop_enabled { get; set; }
|
|
Elm.Interface_Scrollable.bounce_allow { set; }
|
|
Elm.Interface_Scrollable.policy { get; set; }
|
|
Efl.Access.Object.access_children { get; }
|
|
Efl.Access.Object.state_set { get; }
|
|
Efl.Access.Widget.Action.elm_actions { get; }
|
|
Efl.Access.Selection.selected_children_count { get; }
|
|
Efl.Access.Selection.selected_child { get; }
|
|
Efl.Access.Selection.selected_child_deselect;
|
|
Efl.Access.Selection.child_select;
|
|
Efl.Access.Selection.child_deselect;
|
|
Efl.Access.Selection.is_child_selected;
|
|
Efl.Access.Selection.all_children_select;
|
|
Efl.Access.Selection.access_selection_clear;
|
|
Efl.Ui.Focus.Composition.prepare;
|
|
Efl.Ui.Widget.focus_state_apply;
|
|
Efl.Ui.Focus.Manager.setup_on_first_touch;
|
|
Efl.Ui.Focus.Manager.manager_focus { get; }
|
|
Efl.Ui.Focus.Manager.move;
|
|
}
|
|
events {
|
|
realized: Efl.Object; [[Called when gengrid realized]]
|
|
unrealized: Efl.Object; [[Called when gengrid unrealized]]
|
|
index,update: Efl.Object; [[Called on gengrid index update]]
|
|
scroll,page,changed: void; [[Called when scroll page changed]]
|
|
edge,bottom: void; [[Called when bottom edge is reached]]
|
|
edge,top: void; [[Called when top edge is reached]]
|
|
edge,right: void; [[Called when right edge is reached]]
|
|
edge,left: void; [[Called when left edge is reached]]
|
|
item,focused: Efl.Object; [[Called when item got focus]]
|
|
item,unfocused: Efl.Object; [[Called when item no longer has focus]]
|
|
item,reorder,anim,start: Efl.Object; [[Called when item reorder animation started]]
|
|
item,reorder,anim,stop: Efl.Object; [[Called when item reorder animation stopped]]
|
|
activated: Efl.Object; [[Called when gengrid got activated]]
|
|
highlighted: Efl.Object; [[Called when gengrid is highlighted]]
|
|
unhighlighted: Efl.Object; [[Called when gengrid is no longer highlighted]]
|
|
released: Efl.Object; [[Called when gengrid is released]]
|
|
moved: Efl.Object; [[Called when gengrid item moved]]
|
|
}
|
|
}
|