forked from enlightenment/efl
670 lines
31 KiB
Plaintext
670 lines
31 KiB
Plaintext
type @extern Evas_Object_Box_Data: __undefined_type; [[Evas object box data type]] /* FIXME: Not implemented because annonymous structs are not supported */
|
|
type @extern Evas_Object_Box_Option: __undefined_type; [[Evas object box option type]] /* FIXME: Not implemented because bitfields are not supported. */
|
|
type @extern Evas_Object_Box_Layout: __undefined_type; [[Evas object box layout type]] /* FIXME: Function pointers are not supported */
|
|
type @extern Eina_Free_Cb: __undefined_type; [[Eina free callback type]] /* FIXME: Function pointers are not supported */
|
|
type @extern va_list: __undefined_type; [[va_list type]] /* FIXME: va_list is not supported */
|
|
|
|
class Evas.Box (Efl.Canvas.Group)
|
|
{
|
|
[[Evas box class]]
|
|
legacy_prefix: evas_object_box;
|
|
eo_prefix: evas_obj_box;
|
|
event_prefix: evas_box;
|
|
data: Evas_Object_Box_Data;
|
|
methods {
|
|
@property align {
|
|
set {
|
|
[[Set the alignment of the whole bounding box of contents, for a
|
|
given box object.
|
|
|
|
This will influence how a box object is to align its bounding box
|
|
of contents within its own area. The values must be in the range
|
|
$0.0 - $1.0, or undefined behavior is expected. For horizontal
|
|
alignment, $0.0 means to the left, with $1.0 meaning to the
|
|
right. For vertical alignment, $0.0 means to the top, with $1.0
|
|
meaning to the bottom.
|
|
|
|
Note: The default values for both alignments is $0.5.
|
|
|
|
See also @.align.get.]]
|
|
}
|
|
get {
|
|
[[Get the alignment of the whole bounding box of contents, for a
|
|
given box object.
|
|
|
|
See also @.align.set for more information.]]
|
|
}
|
|
values {
|
|
horizontal: double; [[The horizontal alignment, in pixels.]]
|
|
vertical: double; [[The vertical alignment, in pixels.]]
|
|
}
|
|
}
|
|
@property padding {
|
|
set {
|
|
[[Set the (space) padding between cells set for a given box object.
|
|
|
|
Note: The default values for both padding components is $0.
|
|
|
|
See also @.padding.get.]]
|
|
}
|
|
get {
|
|
[[Get the (space) padding between cells set for a given box object.
|
|
|
|
See also @.padding.set.]]
|
|
}
|
|
values {
|
|
horizontal: int; [[The horizontal padding, in pixels.]]
|
|
vertical: int; [[The vertical padding, in pixels.]]
|
|
}
|
|
}
|
|
@property layout {
|
|
set {
|
|
[[Set a new layouting function to a given box object
|
|
|
|
A box layout function affects how a box object displays child
|
|
elements within its area. The list of pre-defined box layouts
|
|
available in Evas are @.layout_horizontal, @.layout_vertical,
|
|
@.layout_homogeneous_horizontal, @.layout_homogeneous_vertical,
|
|
@.layout_homogeneous_max_size_horizontal, @.layout_homogeneous_max_size_vertical,
|
|
@.layout_flow_horizontal, @.layout_flow_vertical and @.layout_stack
|
|
|
|
Refer to each of their documentation texts for details on them.
|
|
|
|
Note: A box layouting function will be triggered by the
|
|
$'calculate' smart callback of the box's smart class.]]
|
|
}
|
|
values {
|
|
cb: Evas_Object_Box_Layout @nonull; [[The new layout function to set on $o.]]
|
|
data: const(void_ptr); [[Data pointer to be passed to $cb.]]
|
|
free_data: Eina_Free_Cb; [[Function to free $data, if need be.]]
|
|
}
|
|
}
|
|
layout_horizontal {
|
|
[[Layout function which sets the box o to a (basic) horizontal box
|
|
|
|
In this layout, the box object's overall behavior is controlled by
|
|
its padding/alignment properties, which are set by the
|
|
evas_object_box_{h,v}_{align,padding}_set family of
|
|
functions. The size hints of the elements in the box -- set by the
|
|
evas_object_size_hint_{align,padding,weight}_set functions
|
|
-- also control the way this function works.
|
|
|
|
Box's properties:
|
|
$align_h controls the horizontal alignment of the child objects
|
|
relative to the containing box. When set to $0.0, children are
|
|
aligned to the left. A value of $1.0 makes them aligned to the
|
|
right border. Values in between align them proportionally. Note
|
|
that if the size required by the children, which is given by their
|
|
widths and the $padding_h property of the box, is bigger than the
|
|
their container's width, the children will be displayed out of the
|
|
box's bounds. A negative value of $align_h makes the box to
|
|
justify its children. The padding between them, in this case, is
|
|
corrected so that the leftmost one touches the left border and the
|
|
rightmost one touches the right border (even if they must
|
|
overlap). The $align_v and $padding_v properties of the box
|
|
don't contribute to its behaviour when this layout is chosen.
|
|
|
|
Child element's properties:
|
|
$align_x does not influence the box's behavior. $padding_l
|
|
and $padding_r sum up to the container's horizontal padding
|
|
between elements. The child's $padding_t, $padding_b and
|
|
$align_y properties apply for padding/alignment relative to the
|
|
overall height of the box. Finally, there is the $weight_x
|
|
property, which, if set to a non-zero value, tells the container
|
|
that the child width is not pre-defined. If the container can't
|
|
accommodate all its children, it sets the widths of the ones
|
|
with weights to sizes as small as they can all fit into
|
|
it. If the size required by the children is less than the
|
|
available, the box increases its childrens' (which have weights)
|
|
widths as to fit the remaining space. The $weight_x property,
|
|
besides telling the element is resizable, gives a weight for the
|
|
resizing process. The parent box will try to distribute (or take
|
|
off) widths accordingly to the normalized list of weights: most
|
|
weighted children remain/get larger in this process than the least
|
|
ones. $weight_y does not influence the layout.
|
|
|
|
If one desires that, besides having weights, child elements must be
|
|
resized bounded to a minimum or maximum size, those size hints must
|
|
be set, by the evas_object_size_hint_{min,max}_set
|
|
functions.]]
|
|
params {
|
|
priv: ptr(Evas_Object_Box_Data); [[Private data pointer]]
|
|
data: void_ptr; [[Data pointer]]
|
|
}
|
|
}
|
|
layout_vertical {
|
|
[[Layout function which sets the box o to a (basic) vertical box
|
|
|
|
This function behaves analogously to
|
|
evas_object_box_layout_horizontal. The description of its
|
|
behaviour can be derived from that function's documentation.]]
|
|
params {
|
|
priv: ptr(Evas_Object_Box_Data); [[Private data pointer]]
|
|
data: void_ptr; [[Data pointer]]
|
|
}
|
|
}
|
|
layout_homogeneous_max_size_horizontal {
|
|
[[Layout function which sets the box o to a maximum size,
|
|
homogeneous horizontal box
|
|
|
|
In a maximum size, homogeneous horizontal box, besides having cells
|
|
of equal size reserved for the child objects, this size will
|
|
be defined by the size of the largest child in the box (in
|
|
width). The box's overall behavior is controlled by its properties,
|
|
which are set by the
|
|
evas_object_box_{h,v}_{align,padding}_set family of
|
|
functions. The size hints of the elements in the box -- set by the
|
|
evas_object_size_hint_{align,padding,weight}_set functions
|
|
-- also control the way this function works.
|
|
|
|
Box's properties:
|
|
$padding_h tells the box to draw empty spaces of that size, in
|
|
pixels, between the child objects' cells. $align_h controls the
|
|
horizontal alignment of the child objects, relative to the
|
|
containing box. When set to $0.0, children are aligned to the
|
|
left. A value of $1.0 lets them aligned to the right
|
|
border. Values in between align them proportionally. A negative
|
|
value of $align_h makes the box to justify its children
|
|
cells. The padding between them, in this case, is corrected so that
|
|
the leftmost one touches the left border and the rightmost one
|
|
touches the right border (even if they must overlap). The
|
|
$align_v and $padding_v properties of the box don't contribute to
|
|
its behaviour when this layout is chosen.
|
|
|
|
Child element's properties:
|
|
$padding_l and $padding_r sum up to the required width of the
|
|
child element. The $align_x property tells the relative position
|
|
of this overall child width in its allocated cell ($0.0 to
|
|
extreme left, $1.0 to extreme right). A value of $-1.0 to
|
|
$align_x makes the box try to resize this child element to the exact
|
|
width of its cell (respecting the minimum and maximum size hints on
|
|
the child's width and accounting for its horizontal padding
|
|
hints). The child's $padding_t, $padding_b and $align_y
|
|
properties apply for padding/alignment relative to the overall
|
|
height of the box. A value of $-1.0 to $align_y makes the box
|
|
try to resize this child element to the exact height of its parent
|
|
(respecting the max hint on the child's height).]]
|
|
params {
|
|
priv: ptr(Evas_Object_Box_Data); [[Private data pointer]]
|
|
data: void_ptr; [[Data pointer]]
|
|
}
|
|
|
|
}
|
|
internal_remove {
|
|
[[No description supplied by the EAPI.]]
|
|
return: Efl.Canvas.Object; [[New object with child removed]]
|
|
legacy: null;
|
|
params {
|
|
@in child: Efl.Canvas.Object; [[Child object to be removed]]
|
|
}
|
|
}
|
|
layout_flow_vertical {
|
|
[[Layout function which sets the box o to a flow vertical box.
|
|
|
|
This function behaves analogously to
|
|
evas_object_box_layout_flow_horizontal. The description of its
|
|
behaviour can be derived from that function's documentation.]]
|
|
params {
|
|
priv: ptr(Evas_Object_Box_Data); [[Private data pointer]]
|
|
data: void_ptr; [[Data pointer]]
|
|
}
|
|
}
|
|
internal_option_free {
|
|
[[No description supplied by the EAPI.]]
|
|
legacy: null;
|
|
params {
|
|
@in opt: ptr(Evas_Object_Box_Option); [[Box option to be freed]]
|
|
}
|
|
}
|
|
insert_after {
|
|
[[Insert a new child object after another existing one, in
|
|
a given box object o.
|
|
|
|
On success, the $"child,added" smart event will take place.
|
|
|
|
Note: This function will fail if $reference is not a member of $o.
|
|
|
|
Note: The actual placing of the item relative to $o's area will
|
|
depend on the layout set to it.
|
|
|
|
Note: This call will trigger the box's
|
|
_Evas_Object_Box_Api.insert_after smart function.]]
|
|
|
|
return: ptr(Evas_Object_Box_Option); [[A box option bound to the recently added box item or
|
|
$null, on errors]]
|
|
params {
|
|
@in child: Efl.Canvas.Object @nonull; [[A child Evas object to be made a member of $o.]]
|
|
@in reference: const(Efl.Canvas.Object) @nonull; [[The child object to place this new one after.]]
|
|
}
|
|
}
|
|
remove_all {
|
|
[[Remove all child objects from a box object, unparenting them again.
|
|
|
|
This has the same effect of calling evas_object_box_remove on
|
|
each of $o's child objects, in sequence. If, and only if, all
|
|
those calls succeed, so does this one.]]
|
|
|
|
return: bool; [[$true on success, $false otherwise.]]
|
|
params {
|
|
@in clear: bool; [[If $true, it will delete just removed children.]]
|
|
}
|
|
}
|
|
iterator_new @const {
|
|
[[Get an iterator to walk the list of children of a given box object.
|
|
|
|
Note: Do not remove or delete objects while walking the list.]]
|
|
return: iterator<Efl.Canvas.Object> @owned
|
|
@warn_unused; [[An iterator on $o's child objects, on success, or $null, on errors.]]
|
|
}
|
|
add_to {
|
|
[[Add a new box as a child of a given smart object.
|
|
|
|
This is a helper function that has the same effect of putting a new
|
|
box object into $parent by use of evas_object_smart_member_add.]]
|
|
|
|
return: Efl.Canvas.Object @warn_unused; [[$null on error, a pointer to a new box object on
|
|
success.]]
|
|
}
|
|
append {
|
|
[[Append a new child object to the given box object o.
|
|
|
|
On success, the $"child,added" smart event will take place.
|
|
|
|
Note: The actual placing of the item relative to $o's area will
|
|
depend on the layout set to it. For example, on horizontal layouts
|
|
an item in the end of the box's list of children will appear on its
|
|
right.
|
|
|
|
Note: This call will trigger the box's _Evas_Object_Box_Api.append
|
|
smart function.]]
|
|
|
|
return: ptr(Evas_Object_Box_Option); [[A box option bound to the recently added box item or
|
|
$null, on errors.]]
|
|
params {
|
|
@in child: Efl.Canvas.Object @nonull; [[A child Evas object to be made a member of $o.]]
|
|
}
|
|
}
|
|
option_property_id_get @const {
|
|
[[Get the numerical identifier of the property of the child elements
|
|
of the box o which have name as name string
|
|
|
|
Note: This call won't do anything for a canonical Evas box. Only
|
|
users which have subclassed it, setting custom box items options
|
|
(see #Evas_Object_Box_Option) on it, would benefit from this
|
|
function. They'd have to implement it and set it to be the
|
|
_Evas_Object_Box_Api.property_id_get smart class function of the
|
|
box, which is originally set to $null.]]
|
|
return: int @warn_unused; [[The numerical ID of the given property or $-1, on
|
|
errors.]]
|
|
params {
|
|
@in name: string @nonull; [[The name string of the option being searched, for
|
|
its ID.]]
|
|
}
|
|
}
|
|
prepend {
|
|
[[Prepend a new child object to the given box object o.
|
|
|
|
On success, the $"child,added" smart event will take place.
|
|
|
|
Note: The actual placing of the item relative to $o's area will
|
|
depend on the layout set to it. For example, on horizontal layouts
|
|
an item in the beginning of the box's list of children will appear
|
|
on its left.
|
|
|
|
Note: This call will trigger the box's
|
|
_Evas_Object_Box_Api.prepend smart function.]]
|
|
|
|
return: ptr(Evas_Object_Box_Option); [[A box option bound to the recently added box item or
|
|
$null, on errors.]]
|
|
params {
|
|
@in child: Efl.Canvas.Object @nonull; [[A child Evas object to be made a member of $o.]]
|
|
}
|
|
}
|
|
accessor_new @const {
|
|
[[Get an accessor (a structure providing random items access) to the
|
|
list of children of a given box object.
|
|
|
|
Note: Do not remove or delete objects while walking the list.]]
|
|
return: accessor<Efl.Canvas.Object> @owned
|
|
@warn_unused; [[An accessor on $o's child objects, on success, or $null,
|
|
on errors.]]
|
|
}
|
|
internal_append {
|
|
[[No description supplied by the EAPI.]]
|
|
legacy: null;
|
|
return: ptr(Evas_Object_Box_Option); [[Box option]]
|
|
params {
|
|
@in child: Efl.Canvas.Object; [[Child object to be appended]]
|
|
}
|
|
}
|
|
option_property_vset {
|
|
[[Set a property value (by its given numerical identifier), on a
|
|
given box child element -- by a variable argument list
|
|
|
|
This is a variable argument list variant of the
|
|
evas_object_box_option_property_set. See its documentation for
|
|
more details.]]
|
|
|
|
return: bool; [[$true on success, $false on failure.]]
|
|
params {
|
|
@in opt: ptr(Evas_Object_Box_Option) @nonull; [[The box option structure bound to the child box element
|
|
to set a property on.]]
|
|
@in property: int; [[The numerical ID of the given property.]]
|
|
@in args: ptr(va_list); [[The variable argument list implementing the value to
|
|
be set for this property. It must be of the same type the user has
|
|
defined for it.]]
|
|
}
|
|
legacy: null;
|
|
}
|
|
internal_remove_at {
|
|
[[No description supplied by the EAPI.]]
|
|
legacy: null;
|
|
return: Efl.Canvas.Object; [[Canvas object]]
|
|
params {
|
|
@in pos: uint; [[Position of object to be removed]]
|
|
}
|
|
}
|
|
remove_at {
|
|
[[Remove an object, bound to a given position in a box object,
|
|
unparenting it again.
|
|
|
|
On removal, you'll get an unparented object again, just as it was
|
|
before you inserted it in the box. The $option_free box smart
|
|
callback will be called automatically for you and, also, the
|
|
$"child,removed" smart event will take place.
|
|
|
|
Note: This function will fail if the given position is invalid,
|
|
given $o's internal list of elements.
|
|
|
|
Note: This call will trigger the box's
|
|
_Evas_Object_Box_Api.remove_at smart function.]]
|
|
|
|
return: bool; [[$true on success, $false on failure.]]
|
|
params {
|
|
@in pos: uint; [[The numeric position (starting from $0) of the child
|
|
object to be removed.]]
|
|
}
|
|
}
|
|
option_property_vget @const {
|
|
[[Get a property's value (by its given numerical identifier), on a
|
|
given box child element -- by a variable argument list
|
|
|
|
This is a variable argument list variant of the
|
|
evas_object_box_option_property_get. See its documentation for
|
|
more details.]]
|
|
return: bool; [[$true on success, $false on failure.]]
|
|
params {
|
|
@in opt: ptr(Evas_Object_Box_Option) @nonull; [[The box option structure bound to the child box element
|
|
to get a property from.]]
|
|
@in property: int; [[The numerical ID of the given property.]]
|
|
@in args: ptr(va_list); [[The variable argument list with pointers to where to
|
|
store the values of this property. They must point to variables
|
|
of the same type the user has defined for them.]]
|
|
}
|
|
legacy: null;
|
|
}
|
|
internal_insert_at {
|
|
[[No description supplied by the EAPI.]]
|
|
legacy: null;
|
|
return: ptr(Evas_Object_Box_Option); [[Box option]]
|
|
params {
|
|
@in child: Efl.Canvas.Object; [[Child object to be inserted]]
|
|
@in pos: uint; [[Position where the object will be inserted]]
|
|
}
|
|
}
|
|
insert_before {
|
|
[[Insert a new child object before another existing one, in
|
|
a given box object o.
|
|
|
|
On success, the $"child,added" smart event will take place.
|
|
|
|
Note: This function will fail if $reference is not a member of $o.
|
|
|
|
Note: The actual placing of the item relative to $o's area will
|
|
depend on the layout set to it.
|
|
|
|
Note: This call will trigger the box's
|
|
_Evas_Object_Box_Api.insert_before smart function.]]
|
|
|
|
return: ptr(Evas_Object_Box_Option); [[A box option bound to the recently added box item or
|
|
$null, on errors.]]
|
|
params {
|
|
@in child: Efl.Canvas.Object @nonull; [[A child Evas object to be made a member of $o.]]
|
|
@in reference: const(Efl.Canvas.Object) @nonull; [[The child object to place this new one before.]]
|
|
}
|
|
}
|
|
option_property_name_get @const {
|
|
[[Get the name of the property of the child elements of the box o
|
|
which have id as identifier
|
|
|
|
Note: This call won't do anything for a canonical Evas box. Only
|
|
users which have subclassed it, setting custom box items options
|
|
(see #Evas_Object_Box_Option) on it, would benefit from this
|
|
function. They'd have to implement it and set it to be the
|
|
_Evas_Object_Box_Api.property_name_get smart class function of the
|
|
box, which is originally set to $null.]]
|
|
return: string @warn_unused; [[The name of the given property or $null, on errors.]]
|
|
params {
|
|
@in property: int; [[The numerical identifier of the option being searched,
|
|
for its name.]]
|
|
}
|
|
}
|
|
internal_insert_before {
|
|
[[No description supplied by the EAPI.]]
|
|
legacy: null;
|
|
return: ptr(Evas_Object_Box_Option); [[Box option]]
|
|
params {
|
|
@in child: Efl.Canvas.Object; [[Object to be inserted]]
|
|
@in reference: const(Efl.Canvas.Object); [[Reference where the object will be inserted]]
|
|
}
|
|
}
|
|
layout_homogeneous_horizontal {
|
|
[[Layout function which sets the box o to a homogeneous
|
|
horizontal box
|
|
|
|
In a homogeneous horizontal box, its width is divided equally
|
|
between the contained objects. The box's overall behavior is
|
|
controlled by its padding/alignment properties, which are set by
|
|
the evas_object_box_{h,v}_{align,padding}_set family of
|
|
functions. The size hints the elements in the box -- set by the
|
|
evas_object_size_hint_{align,padding,weight}_set functions
|
|
-- also control the way this function works.
|
|
|
|
Box's properties:
|
|
$align_h has no influence on the box for this layout.
|
|
$padding_h tells the box to draw empty spaces of that size, in
|
|
pixels, between the (equal) child objects' cells. The $align_v
|
|
and $padding_v properties of the box don't contribute to its
|
|
behaviour when this layout is chosen.
|
|
|
|
Child element's properties:
|
|
$padding_l and $padding_r sum up to the required width of the
|
|
child element. The $align_x property tells the relative position
|
|
of this overall child width in its allocated cell ($0.0 to
|
|
extreme left, $1.0 to extreme right). A value of $-1.0 to
|
|
$align_x makes the box try to resize this child element to the exact
|
|
width of its cell (respecting the minimum and maximum size hints on
|
|
the child's width and accounting for its horizontal padding
|
|
hints). The child's $padding_t, $padding_b and $align_y
|
|
properties apply for padding/alignment relative to the overall
|
|
height of the box. A value of $-1.0 to $align_y makes the box
|
|
try to resize this child element to the exact height of its parent
|
|
(respecting the maximum size hint on the child's height).]]
|
|
params {
|
|
@in priv: ptr(Evas_Object_Box_Data); [[Private data pointer]]
|
|
@in data: void_ptr; [[Data pointer]]
|
|
}
|
|
}
|
|
internal_option_new {
|
|
[[No description supplied by the EAPI.]]
|
|
legacy: null;
|
|
return: ptr(Evas_Object_Box_Option); [[Box option]]
|
|
params {
|
|
@in child: Efl.Canvas.Object; [[New box object]]
|
|
}
|
|
}
|
|
layout_homogeneous_max_size_vertical {
|
|
[[Layout function which sets the box o to a maximum size,
|
|
homogeneous vertical box
|
|
|
|
This function behaves analogously to
|
|
evas_object_box_layout_homogeneous_max_size_horizontal. The
|
|
description of its behaviour can be derived from that function's
|
|
documentation.]]
|
|
params {
|
|
@in priv: ptr(Evas_Object_Box_Data); [[Private data pointer]]
|
|
@in data: void_ptr; [[Data pointer]]
|
|
}
|
|
}
|
|
internal_insert_after {
|
|
[[No description supplied by the EAPI.]]
|
|
legacy: null;
|
|
return: ptr(Evas_Object_Box_Option); [[Box option]]
|
|
params {
|
|
@in child: Efl.Canvas.Object; [[Object to be inserted]]
|
|
@in reference: const(Efl.Canvas.Object); [[Reference where the object will be inserted]]
|
|
}
|
|
}
|
|
insert_at {
|
|
[[Insert a new child object at a given position, in a given
|
|
box object $o.
|
|
|
|
On success, the $"child,added" smart event will take place.
|
|
|
|
Note: This function will fail if the given position is invalid,
|
|
given $o's internal list of elements.
|
|
|
|
Note: The actual placing of the item relative to $o's area will
|
|
depend on the layout set to it.
|
|
|
|
Note: This call will trigger the box's
|
|
_Evas_Object_Box_Api.insert_at smart function.]]
|
|
|
|
return: ptr(Evas_Object_Box_Option); [[A box option bound to the recently added box item or
|
|
$null, on errors.]]
|
|
params {
|
|
@in child: Efl.Canvas.Object @nonull; [[A child Evas object to be made a member of $o.]]
|
|
@in pos: uint; [[The numeric position (starting from $0) to place the
|
|
new child object at.]]
|
|
}
|
|
}
|
|
internal_prepend {
|
|
[[No description supplied by the EAPI.]]
|
|
legacy: null;
|
|
return: ptr(Evas_Object_Box_Option); [[Box option]]
|
|
params {
|
|
@in child: Efl.Canvas.Object; [[Object to be prepended]]
|
|
}
|
|
}
|
|
remove {
|
|
[[Remove a given object from a box object, unparenting it again.
|
|
|
|
On removal, you'll get an unparented object again, just as it was
|
|
before you inserted it in the box. The
|
|
_Evas_Object_Box_Api.option_free box smart callback will be called
|
|
automatically for you and, also, the $"child,removed" smart event
|
|
will take place.
|
|
|
|
Note: This call will trigger the box's _Evas_Object_Box_Api.remove
|
|
smart function.]]
|
|
|
|
return: bool; [[$true on success, $false otherwise.]]
|
|
params {
|
|
@in child: Efl.Canvas.Object @nonull; [[The handle to the child object to be removed.]]
|
|
}
|
|
}
|
|
layout_stack {
|
|
[[Layout function which sets the box o to a stacking box
|
|
|
|
In a stacking box, all children will be given the same size -- the
|
|
box's own size -- and they will be stacked one above the other, so
|
|
that the first object in $o's internal list of child elements
|
|
will be the bottommost in the stack.
|
|
|
|
Box's properties:
|
|
No box properties are used.
|
|
|
|
Child element's properties:
|
|
$padding_l and $padding_r sum up to the required width of the
|
|
child element. The $align_x property tells the relative position
|
|
of this overall child width in its allocated cell ($0.0 to
|
|
extreme left, $1.0 to extreme right). A value of $-1.0 to
|
|
$align_x makes the box try to resize this child element to the exact
|
|
width of its cell (respecting the min and max hints on the child's
|
|
width and accounting for its horizontal padding properties). The
|
|
same applies to the vertical axis.]]
|
|
params {
|
|
@in priv: ptr(Evas_Object_Box_Data); [[Private data pointer]]
|
|
@in data: void_ptr; [[Data pointer]]
|
|
}
|
|
}
|
|
layout_homogeneous_vertical {
|
|
[[Layout function which sets the box o to a homogeneous
|
|
vertical box.
|
|
|
|
This function behaves analogously to
|
|
evas_object_box_layout_homogeneous_horizontal. The description
|
|
of its behaviour can be derived from that function's documentation.]]
|
|
params {
|
|
priv: ptr(Evas_Object_Box_Data); [[Private data pointer]]
|
|
data: void_ptr; [[Data pointer]]
|
|
}
|
|
}
|
|
layout_flow_horizontal {
|
|
[[Layout function which sets the box o to a flow horizontal
|
|
box.
|
|
|
|
In a flow horizontal box, the box's child elements are placed in
|
|
rows (think of text as an analogy). A row has as many elements as
|
|
can fit into the box's width. The box's overall behavior is
|
|
controlled by its properties, which are set by the
|
|
evas_object_box_{h,v}_{align,padding}_set family of
|
|
functions. The size hints of the elements in the box -- set by the
|
|
evas_object_size_hint_{align,padding,weight}_set functions
|
|
-- also control the way this function works.
|
|
|
|
Box's properties:
|
|
$padding_h tells the box to draw empty spaces of that size, in
|
|
pixels, between the child objects' cells. $align_h dictates the
|
|
horizontal alignment of the rows ($0.0 to left align them, $1.0
|
|
to right align). A value of $-1.0 to $align_h lets the rows
|
|
justified horizontally. $align_v controls the vertical alignment
|
|
of the entire set of rows ($0.0 to top, $1.0 to bottom). A
|
|
value of $-1.0 to $align_v makes the box to justify the rows
|
|
vertically. The padding between them in this case is corrected so
|
|
that the first row touches the top border and the last one touches
|
|
the bottom border (even if they must overlap). $padding_v has no
|
|
influence on the layout.
|
|
|
|
Child element's properties:
|
|
$padding_l and $padding_r sum up to the required width of the
|
|
child element. The $align_x property has no influence on the
|
|
layout. The child's $padding_t and $padding_b sum up to the
|
|
required height of the child element and is the only means (besides
|
|
row justifying) of setting space between rows. Note, however, that
|
|
$align_y dictates positioning relative to the largest
|
|
height required by a child object in the actual row.]]
|
|
params {
|
|
priv: ptr(Evas_Object_Box_Data); [[Private data pointer]]
|
|
data: void_ptr; [[Data pointer]]
|
|
}
|
|
}
|
|
count {
|
|
[[Returns the number of items in the box.]]
|
|
legacy: null;
|
|
return: int; [[Number of items in the box]]
|
|
}
|
|
}
|
|
implements {
|
|
class.constructor;
|
|
Efl.Object.constructor;
|
|
Efl.Gfx.Entity.size { set; }
|
|
Efl.Gfx.Entity.position { set; }
|
|
Efl.Canvas.Group.group_calculate;
|
|
}
|
|
events {
|
|
child,added: ptr(Evas_Object_Box_Option); [[Called when a child object was added to the box]]
|
|
child,removed: Efl.Canvas.Object; [[Called when a child object was removed from the box]]
|
|
}
|
|
}
|