forked from enlightenment/efl
225 lines
8.8 KiB
Plaintext
225 lines
8.8 KiB
Plaintext
/* XXX: Remove the Object_ part once the relevant Eolian bugs are fixed. */
|
|
enum Evas.Object_Table.Homogeneous_Mode {
|
|
[[How to pack items into cells in a table.
|
|
|
|
See @Evas.Table.homogeneous for an explanation of the function of each one.]]
|
|
legacy: Evas_Object_Table_Homogeneous;
|
|
none = 0, [[No mode specified]]
|
|
table = 1, [[Table mode]]
|
|
item = 2 [[Item mode]]
|
|
}
|
|
|
|
class Evas.Table (Efl.Canvas.Group)
|
|
{
|
|
[[Evas table class]]
|
|
legacy_prefix: evas_object_table;
|
|
eo_prefix: evas_obj_table;
|
|
methods {
|
|
@property homogeneous {
|
|
[[Set how this table should layout children.
|
|
|
|
Todo: consider aspect hint and respect it.
|
|
|
|
@Evas.Object_Table.Homogeneous_Mode.none
|
|
If table does not use homogeneous mode then columns and rows will
|
|
be calculated based on hints of individual cells. This operation
|
|
mode is more flexible, but more complex and heavy to calculate as
|
|
well. Weight properties are handled as a boolean expand. Negative
|
|
alignment will be considered as 0.5. This is the default.
|
|
|
|
Todo: @Evas.Object_Table.Homogeneous_Mode.none should balance weight.
|
|
|
|
@Evas.Object_Table.Homogeneous_Mode.table
|
|
When homogeneous is relative to table the own table size is divided
|
|
equally among children, filling the whole table area. That is, if
|
|
table has $WIDTH and $COLUMNS, each cell will get _WIDTH /
|
|
COLUMNS_ pixels. If children have minimum size that is larger
|
|
than this amount (including padding), then it will overflow and be
|
|
aligned respecting the alignment hint, possible overlapping sibling
|
|
cells. Weight hint is used as a boolean, if greater than zero it
|
|
will make the child expand in that axis, taking as much space as
|
|
possible (bounded to maximum size hint). Negative alignment will be
|
|
considered as 0.5.
|
|
|
|
@Evas.Object_Table.Homogeneous_Mode.item
|
|
When homogeneous is relative to item it means the greatest minimum
|
|
cell size will be used. That is, if no element is set to expand,
|
|
the table will have its contents to a minimum size, the bounding
|
|
box of all these children will be aligned relatively to the table
|
|
object using evas_object_table_align_get(). If the table area is
|
|
too small to hold this minimum bounding box, then the objects will
|
|
keep their size and the bounding box will overflow the box area,
|
|
still respecting the alignment. Weight hint is used as a
|
|
boolean, if greater than zero it will make that cell expand in that
|
|
axis, toggling the *expand mode*, which makes the table behave
|
|
much like @Evas.Object_Table.Homogeneous_Mode.table, except that the
|
|
bounding box will overflow and items will not overlap siblings. If
|
|
no minimum size is provided at all then the table will fallback to
|
|
expand mode as well.]]
|
|
set {
|
|
}
|
|
get {
|
|
}
|
|
values {
|
|
homogeneous: Evas.Object_Table.Homogeneous_Mode; [[Table homogeneous mode]]
|
|
}
|
|
}
|
|
@property align {
|
|
[[Control the alignment of the whole bounding box of contents.]]
|
|
set {
|
|
}
|
|
get {
|
|
}
|
|
values {
|
|
horizontal: double; [[Horizontal alignment]]
|
|
vertical: double; [[Vertical alignment]]
|
|
}
|
|
}
|
|
@property padding {
|
|
[[Control the padding between cells.]]
|
|
set {
|
|
}
|
|
get {
|
|
}
|
|
values {
|
|
horizontal: int; [[Horizontal padding]]
|
|
vertical: int; [[Vertical padding]]
|
|
}
|
|
}
|
|
@property mirrored {
|
|
[[Control the mirrored mode of the table. In mirrored mode, the table items go
|
|
from right to left instead of left to right. That is, 1,1 is top right, not
|
|
top left.
|
|
|
|
@since 1.1]]
|
|
set {
|
|
}
|
|
get {
|
|
}
|
|
values {
|
|
mirrored: bool; [[$true if mirrored, $false otherwise]]
|
|
}
|
|
}
|
|
@property col_row_size {
|
|
get {
|
|
[[Get the number of columns and rows this table takes.
|
|
|
|
Note: columns and rows are virtual entities, one can specify a table
|
|
with a single object that takes 4 columns and 5 rows. The only
|
|
difference for a single cell table is that paddings will be
|
|
accounted proportionally.]]
|
|
}
|
|
values {
|
|
cols: int; [[Columns in table]]
|
|
rows: int; [[Rows in table]]
|
|
}
|
|
}
|
|
@property children {
|
|
get {
|
|
[[Get the list of children for the table.
|
|
|
|
Note: This is a duplicate of the list kept by the table internally.
|
|
It's up to the user to destroy it when it no longer needs it.
|
|
It's possible to remove objects from the table when walking this
|
|
list, but these removals won't be reflected on it.]]
|
|
return: list<Efl.Canvas.Object> @owned @warn_unused; [[Children list]]
|
|
}
|
|
}
|
|
@property child {
|
|
get {
|
|
[[Get the child of the table at the given coordinates
|
|
|
|
Note: This does not take into account col/row spanning]]
|
|
}
|
|
keys {
|
|
col: ushort; [[Child column]]
|
|
row: ushort; [[Child row]]
|
|
}
|
|
values {
|
|
child: Efl.Canvas.Object; [[Child object]]
|
|
}
|
|
}
|
|
clear {
|
|
[[Faster way to remove all child objects from a table object.]]
|
|
|
|
params {
|
|
@in clear: bool; [[If $true, it will delete just removed children.]]
|
|
}
|
|
}
|
|
accessor_new @const {
|
|
[[Get an accessor to get random access to the list of children for the table.
|
|
|
|
Note: Do not remove or delete objects while walking the list.]]
|
|
return: accessor<Efl.Canvas.Object> @owned
|
|
@warn_unused; [[Accessor to children list]]
|
|
}
|
|
iterator_new @const {
|
|
[[Get an iterator to walk the list of children for the table.
|
|
|
|
Note: Do not remove or delete objects while walking the list.]]
|
|
return: iterator<Efl.Canvas.Object> @owned
|
|
@warn_unused; [[Iterator to children]]
|
|
}
|
|
add_to {
|
|
[[Create a table that is child of a given element $parent.]]
|
|
|
|
return: Efl.Canvas.Object @warn_unused; [[Children table]]
|
|
}
|
|
pack_get @const {
|
|
[[Get packing location of a child of table
|
|
|
|
@since 1.1]]
|
|
return: bool; [[$true on success, $false on failure.]]
|
|
params {
|
|
@in child: Efl.Canvas.Object; [[The child object to add.]]
|
|
@out col: ushort; [[Pointer to store relative-horizontal position to place child.]]
|
|
@out row: ushort; [[Pointer to store relative-vertical position to place child.]]
|
|
@out colspan: ushort; [[Pointer to store how many relative-horizontal positions to use for this child.]]
|
|
@out rowspan: ushort; [[Pointer to store how many relative-vertical positions to use for this child.]]
|
|
}
|
|
}
|
|
pack {
|
|
[[Add a new child to a table object or set its current packing.
|
|
|
|
Note that columns and rows only guarantee 16bit unsigned values at best.
|
|
That means that col + colspan AND row + rowspan must fit inside 16bit
|
|
unsigned values cleanly. You will be warned once values exceed 15bit
|
|
storage, and attempting to use values not able to fit in 16bits will
|
|
result in failure.]]
|
|
|
|
return: bool; [[$true on success, $false on failure.]]
|
|
params {
|
|
@in child: Efl.Canvas.Object @nonull; [[The child object to add.]]
|
|
@in col: ushort; [[Relative-horizontal position to place child.]]
|
|
@in row: ushort; [[Relative-vertical position to place child.]]
|
|
@in colspan: ushort; [[How many relative-horizontal positions to use for this child.]]
|
|
@in rowspan: ushort; [[How many relative-vertical positions to use for this child.]]
|
|
}
|
|
}
|
|
unpack {
|
|
[[Remove child from table.
|
|
|
|
Note: removing a child will immediately call a walk over children in order
|
|
to recalculate numbers of columns and rows. If you plan to remove
|
|
all children, use @Evas.Table.clear instead.]]
|
|
|
|
return: bool; [[$true on success, $false on failure.]]
|
|
params {
|
|
@in child: Efl.Canvas.Object @nonull; [[Child to be removed]]
|
|
}
|
|
}
|
|
count {
|
|
[[Returns the number of items in the table]]
|
|
legacy: null;
|
|
return: int; [[Number of items in table]]
|
|
}
|
|
}
|
|
implements {
|
|
class.constructor;
|
|
Efl.Object.constructor;
|
|
Efl.Gfx.size { set; }
|
|
Efl.Gfx.position { set; }
|
|
Efl.Canvas.Group.group_calculate;
|
|
}
|
|
}
|