forked from enlightenment/efl
485 lines
18 KiB
Plaintext
485 lines
18 KiB
Plaintext
class Elm.Layout (Elm.Container, Efl.File)
|
|
{
|
|
eo_prefix: elm_obj_layout;
|
|
data: Elm_Layout_Smart_Data;
|
|
methods {
|
|
@property edje_object_can_access {
|
|
set {
|
|
[[Set accessibility to all texblock(text) parts in the layout
|
|
object.
|
|
|
|
@since 1.7
|
|
]]
|
|
return: bool; [[$true on success or $false on failure. If $obj
|
|
is not a proper layout object, $false is returned.]]
|
|
}
|
|
get {
|
|
[[Get accessibility state of texblock(text) parts in the layout
|
|
object
|
|
|
|
@since 1.7
|
|
]]
|
|
}
|
|
values {
|
|
can_access: bool; [[Makes all textblock(text) parts in the layout
|
|
$obj possible to have accessibility. $true
|
|
means textblock(text) parts can be accessible.]]
|
|
}
|
|
}
|
|
@property theme {
|
|
set {
|
|
[[Set the edje group from the elementary theme that will be used
|
|
as layout.
|
|
|
|
Note that $style will be the new style of $obj too, as in an
|
|
\@ref elm_object_style_set call.
|
|
]]
|
|
return: bool;
|
|
}
|
|
values {
|
|
klass: const(char)*; [[The class of the group.]]
|
|
group: const(char)*; [[The group.]]
|
|
style: const(char)*; [[The style to used.]]
|
|
}
|
|
}
|
|
@property text_aliases {
|
|
get {
|
|
legacy: null;
|
|
}
|
|
values {
|
|
aliases: const(Elm.Layout_Part_Alias_Description)*;
|
|
}
|
|
}
|
|
@property content_aliases {
|
|
get {
|
|
legacy: null;
|
|
}
|
|
values {
|
|
aliases: const(Elm.Layout_Part_Alias_Description)*;
|
|
}
|
|
}
|
|
@property edje {
|
|
get {
|
|
[[Get the edje layout
|
|
|
|
This returns the edje object. It is not expected to be used
|
|
to then swallow objects via \@ref edje_object_part_swallow
|
|
for example. Use \@ref elm_layout_content_set instead so
|
|
child object handling and sizing is done properly.
|
|
|
|
Note: This function should only be used if you really need
|
|
to call some low level Edje function on this edje object.
|
|
All the common stuff (setting text, emitting signals,
|
|
hooking callbacks to signals, etc.) can be done with
|
|
proper elementary functions.
|
|
]]
|
|
return: Evas.Object *; [[An Evas_Object with the edje layout
|
|
settings loaded \@ref elm_layout_file_set.]]
|
|
}
|
|
}
|
|
box_remove_all {
|
|
[[Remove all children of the given part box.
|
|
|
|
The objects will be removed from the box part and their lifetime
|
|
will not be handled by the layout anymore. This is equivalent to
|
|
@.box_remove for all box children.
|
|
]]
|
|
return: bool;
|
|
params {
|
|
@in part: const(char)*; [[The box part name to remove child.]]
|
|
@in clear: bool; [[If true, then all objects will be deleted as
|
|
well, otherwise they will just be removed and
|
|
will be dangling on the canvas.]]
|
|
}
|
|
}
|
|
part_cursor_engine_only_set {
|
|
[[Sets if the cursor set should be searched on the theme or should
|
|
use the provided by the engine, only.
|
|
|
|
Note: Before you set if should look on theme you should define a
|
|
cursor with @.part_cursor_set. By default it will only look for
|
|
cursors provided by the engine.
|
|
]]
|
|
return: bool; [[$true on success or $false on failure, that may be
|
|
part not exists or it did not had a cursor set.]]
|
|
params {
|
|
@in part_name: const(char)*; [[A part from loaded edje group.]]
|
|
@in engine_only: bool; [[If cursors should be just provided by
|
|
the engine ($true) or should also search
|
|
on widget's theme as well ($false)]]
|
|
}
|
|
}
|
|
part_cursor_engine_only_get @const {
|
|
[[Get a specific cursor engine_only for an edje part.]]
|
|
return: bool; [[Whenever the cursor is just provided by engine
|
|
or also from theme.]]
|
|
params {
|
|
@in part_name: const(char)*; [[A part from loaded edje group.]]
|
|
}
|
|
}
|
|
table_unpack {
|
|
[[Unpack (remove) a child of the given part table.
|
|
|
|
The object will be unpacked from the table part and its lifetime
|
|
will not be handled by the layout anymore. This is equivalent to
|
|
\@ref elm_layout_content_unset for table.
|
|
]]
|
|
return: Evas.Object *; [[The object that was being used, or $null if not found.]]
|
|
params {
|
|
@in part: const(char)*; [[The table part name to remove child.]]
|
|
@in child: Evas.Object *; [[The object to remove from table.]]
|
|
}
|
|
}
|
|
freeze {
|
|
[[Freezes the Elementary layout object.
|
|
|
|
This function puts all changes on hold. Successive freezes will
|
|
nest, requiring an equal number of thaws.
|
|
|
|
See also @.thaw.
|
|
]]
|
|
return: int; [[The frozen state or 0 on error.]]
|
|
}
|
|
theme_enable {
|
|
legacy: null;
|
|
return: bool;
|
|
}
|
|
sizing_eval {
|
|
[[Eval sizing.
|
|
|
|
Manually forces a sizing re-evaluation. This is useful when the
|
|
minimum size required by the edje theme of this layout has
|
|
changed. The change on the minimum size required by the edje
|
|
theme is not immediately reported to the elementary layout,
|
|
so one needs to call this function in order to tell the widget
|
|
(layout) that it needs to reevaluate its own size.
|
|
|
|
The minimum size of the theme is calculated based on minimum
|
|
size of parts, the size of elements inside containers like box
|
|
and table, etc. All of this can change due to state changes,
|
|
and that's when this function should be called.
|
|
|
|
Also note that a standard signal of "size,eval" "elm" emitted
|
|
from the edje object will cause this to happen too.
|
|
]]
|
|
}
|
|
box_remove {
|
|
[[Remove a child of the given part box.
|
|
|
|
The object will be removed from the box part and its lifetime
|
|
will not be handled by the layout anymore. This is equivalent to
|
|
\@ref elm_layout_content_unset for box.
|
|
]]
|
|
return: Evas.Object *; [[The object that was being used, or $null if not found.]]
|
|
params {
|
|
@in part: const(char)*; [[The box part name to remove child.]]
|
|
@in child: Evas.Object *; [[The object to remove from box.]]
|
|
}
|
|
}
|
|
sizing_restricted_eval {
|
|
[[Request sizing reevaluation, restricted to current width and/or
|
|
height.
|
|
|
|
Useful mostly when there are TEXTBLOCK parts defining the height
|
|
of the object and nothing else restricting it to a minimum width.
|
|
Calling this function will restrict the minimum size in the Edje
|
|
calculation to whatever size it the layout has at the moment.
|
|
|
|
@since 1.8
|
|
]]
|
|
params {
|
|
@in width: bool; [[Restrict minimum size to the current width.]]
|
|
@in height: bool; [[Restrict minimum size ot the current height.]]
|
|
}
|
|
}
|
|
part_cursor_style_set {
|
|
[[Sets a specific cursor style for an edje part.]]
|
|
return: bool; [[True on success or false on failure, that may be
|
|
part not exists or it did not had a cursor set.]]
|
|
params {
|
|
@in part_name: const(char)*; [[A part from loaded edje group.]]
|
|
@in style: const(char)*; [[The theme style to use (default,
|
|
transparent, ...).]]
|
|
}
|
|
}
|
|
part_cursor_style_get @const {
|
|
[[Get a specific cursor style for an edje part.]]
|
|
return: const(char)*; [[The theme style in use, defaults to "default".
|
|
If the object does not have a cursor set,
|
|
then $null is returned.]]
|
|
params {
|
|
@in part_name: const(char)*; [[A part from loaded edje group.]]
|
|
}
|
|
}
|
|
@property text {
|
|
set {
|
|
[[Set the text of the given part.]]
|
|
return: bool;
|
|
}
|
|
get {
|
|
[[Get the text set in the given part.]]
|
|
}
|
|
keys {
|
|
part: const(char)* @nullable; [[The TEXT part where to set the text.]]
|
|
}
|
|
values {
|
|
text: const(char)* @nullable; [[The text to set.]]
|
|
}
|
|
}
|
|
signal_callback_add {
|
|
[[Add a callback for a (Edje) signal emitted by a layout widget's
|
|
underlying Edje object.
|
|
|
|
This function connects a callback function to a signal emitted by
|
|
the underlying Edje object of $obj. Globs are accepted in either
|
|
the emission or source strings.
|
|
]]
|
|
params {
|
|
@in emission: const(char)*; [[The signal's name string.]]
|
|
@in source: const(char)*; [[The signal's source string.]]
|
|
@in func: Edje_Signal_Cb; [[The callback function to be executed
|
|
when the signal is emitted.]]
|
|
@in data: void * @optional; [[A pointer to data to pass in to the
|
|
callback function.]]
|
|
}
|
|
}
|
|
part_cursor_set {
|
|
[[Sets a specific cursor for an edje part.]]
|
|
return: bool; [[$true on success or $false on failure, that may be
|
|
part not exists or it has "mouse_events: 0".]]
|
|
params {
|
|
@in part_name: const(char)*; [[A part from loaded edje group.]]
|
|
@in cursor: const(char)*; [[Cursor name to use, see Elementary_Cursor.h.]]
|
|
}
|
|
}
|
|
part_cursor_get @const {
|
|
[[Get the cursor to be shown when mouse is over an edje part.]]
|
|
return: const(char)*;
|
|
params {
|
|
@in part_name: const(char)*; [[A part from loaded edje group.]]
|
|
}
|
|
}
|
|
box_insert_before {
|
|
[[Insert child to layout box part before a reference object.
|
|
|
|
Once the object is inserted, it will become child of the layout.
|
|
Its lifetime will be bound to the layout, whenever the layout
|
|
dies the child will be deleted automatically. One should use
|
|
@.box_remove to make this layout forget about the object.
|
|
]]
|
|
return: bool;
|
|
params {
|
|
@in part: const(char)*; [[The box part to insert.]]
|
|
@in child: own(Evas.Object *); [[The child object to insert into box.]]
|
|
@in reference: const(Evas.Object)*; [[Another reference object to insert before in box.]]
|
|
}
|
|
}
|
|
box_insert_at {
|
|
[[Insert child to layout box part at a given position.
|
|
|
|
Once the object is inserted, it will become child of the layout.
|
|
Its lifetime will be bound to the layout, whenever the layout
|
|
dies the child will be deleted automatically. One should use
|
|
@.box_remove to make this layout forget about the object.
|
|
]]
|
|
return: bool;
|
|
params {
|
|
@in part: const(char)*; [[The box part to insert.]]
|
|
@in child: own(Evas.Object *); [[The child object to insert into box.]]
|
|
@in pos: uint; [[The numeric position >=0 to insert the child.]]
|
|
}
|
|
}
|
|
sub_object_add_enable {
|
|
legacy: null;
|
|
return: bool;
|
|
}
|
|
data_get @const {
|
|
[[Get the edje data from the given layout.
|
|
|
|
This function fetches data specified inside the edje theme of
|
|
this layout. This function return NULL if data is not found.
|
|
|
|
In EDC this comes from a data block within the group block that
|
|
$obj was loaded from.
|
|
]]
|
|
/* FIXME-doc
|
|
@code
|
|
collections {
|
|
group {
|
|
name: "a_group";
|
|
data {
|
|
item: "key1" "value1";
|
|
item: "key2" "value2";
|
|
}
|
|
}
|
|
}
|
|
@endcode
|
|
*/
|
|
return: const(char)*; [[The edje data string.]]
|
|
params {
|
|
@in key: const(char)*; [[The data key.]]
|
|
}
|
|
}
|
|
box_append {
|
|
[[Append child to layout box part.
|
|
|
|
Once the object is appended, it will become child of the layout.
|
|
Its lifetime will be bound to the layout, whenever the layout
|
|
dies the child will be deleted automatically. One should use
|
|
@.box_remove to make this layout forget about the object.
|
|
]]
|
|
return: bool;
|
|
params {
|
|
@in part: const(char)*; [[The box part to which the object will be appended.]]
|
|
@in child: own(Evas.Object *); [[The child object to append to box.]]
|
|
}
|
|
}
|
|
signal_callback_del {
|
|
[[Remove a signal-triggered callback from a given layout widget.
|
|
|
|
This function removes the last callback attached to a signal
|
|
emitted by the undelying Edje object of $obj, with parameters
|
|
$emission, $source and $func matching exactly those passed to a
|
|
previous call to @.signal_callback_add. The data pointer that
|
|
was passed to this call will be returned.
|
|
]]
|
|
return: void *; [[The data pointer of the signal callback (passed on
|
|
@.signal_callback_add) or $null on errors.]]
|
|
params {
|
|
@in emission: const(char)*; [[The signal's name string.]]
|
|
@in source: const(char)*; [[The signal's source string.]]
|
|
@in func: Edje_Signal_Cb; [[The callback function being executed
|
|
when the signal was emitted.]]
|
|
}
|
|
}
|
|
thaw {
|
|
[[Thaws the Elementary object.
|
|
|
|
This function thaws the given Edje object and the Elementary
|
|
sizing calc.
|
|
|
|
Note: If sucessives freezes were done, an equal number of
|
|
thaws will be required.
|
|
|
|
See also @.freeze.
|
|
]]
|
|
return: int; [[The frozen state or 0 if the object is not frozen or on error.]]
|
|
}
|
|
box_prepend {
|
|
[[Prepend child to layout box part.
|
|
|
|
Once the object is prepended, it will become child of the layout.
|
|
Its lifetime will be bound to the layout, whenever the layout
|
|
dies the child will be deleted automatically. One should use
|
|
@.box_remove to make this layout forget about the object.
|
|
]]
|
|
return: bool;
|
|
params {
|
|
@in part: const(char)*; [[The box part to which the object will be prepended.]]
|
|
@in child: own(Evas.Object *); [[The child object to prepend to box.]]
|
|
}
|
|
}
|
|
signal_emit {
|
|
[[Send a (Edje) signal to a given layout widget's underlying Edje
|
|
object.
|
|
|
|
This function sends a signal to the underlying Edje object of
|
|
$obj. An Edje program on that Edje object's definition can
|
|
respond to a signal by specifying matching 'signal' and
|
|
'source' fields.
|
|
]]
|
|
params {
|
|
@in emission: const(char)*; [[The signal's name string.]]
|
|
@in source: const(char)*; [[The signal's source string.]]
|
|
}
|
|
}
|
|
table_pack {
|
|
[[Insert child to layout table part.
|
|
|
|
Once the object is inserted, it will become child of the table.
|
|
Its lifetime will be bound to the layout, and whenever the layout
|
|
dies the child will be deleted automatically. One should use
|
|
@.table_unpack to make this layout forget about the object.
|
|
|
|
If $colspan or $rowspan are bigger than 1, that object will occupy
|
|
more space than a single cell.
|
|
|
|
See also @.table_unpack, @.table_clear.
|
|
]]
|
|
/* FIXME-doc
|
|
For instance, the following code:
|
|
@code
|
|
elm_layout_table_pack(layout, "table_part", child, 0, 1, 3, 1);
|
|
@endcode
|
|
|
|
Would result in an object being added like the following picture:
|
|
|
|
@image html layout_colspan.png
|
|
@image latex layout_colspan.eps width=\textwidth
|
|
*/
|
|
return: bool;
|
|
params {
|
|
@in part: const(char)*; [[The box part to pack child.]]
|
|
@in child: own(Evas.Object *); [[The child object to pack into table.]]
|
|
@in col: ushort; [[The column to which the child should be added. (>= 0)]]
|
|
@in row: ushort; [[The row to which the child should be added. (>= 0)]]
|
|
@in colspan: ushort; [[How many columns should be used to store this object. (>= 1)]]
|
|
@in rowspan: ushort; [[How many rows should be used to store this object. (>= 1)]]
|
|
}
|
|
}
|
|
part_cursor_unset {
|
|
[[Unsets a cursor previously set with @.part_cursor_set.]]
|
|
return: bool;
|
|
params {
|
|
@in part_name: const(char)*; [[A part from loaded edje group,
|
|
that had a cursor set wit
|
|
@.part_cursor_set.]]
|
|
}
|
|
}
|
|
table_clear {
|
|
[[Remove all the child objects of the given part table.
|
|
|
|
The objects will be removed from the table part and their
|
|
lifetime will not be handled by the layout anymore. This
|
|
is equivalent to @.table_unpack for all table children.
|
|
]]
|
|
return: bool;
|
|
params {
|
|
@in part: const(char)*; [[The table part name to remove child.]]
|
|
@in clear: bool; [[If true, then all objects will be deleted as
|
|
well, otherwise they will just be removed and
|
|
will be dangling on the canvas.]]
|
|
}
|
|
}
|
|
}
|
|
implements {
|
|
class.constructor;
|
|
Eo.Base.constructor;
|
|
Eo.Base.dbg_info_get;
|
|
Efl.File.file.set;
|
|
Efl.File.file.get;
|
|
Evas.Object_Smart.del;
|
|
Evas.Object_Smart.add;
|
|
Evas.Object_Smart.calculate;
|
|
Elm.Widget.focus_direction;
|
|
Elm.Widget.sub_object_add;
|
|
Elm.Widget.theme_apply;
|
|
Elm.Widget.focus_direction_manager_is;
|
|
Elm.Widget.focus_next_manager_is;
|
|
Elm.Widget.focus_next;
|
|
Elm.Widget.disable;
|
|
Elm.Widget.sub_object_del;
|
|
Elm.Widget.on_focus;
|
|
Elm.Container.content_get;
|
|
Elm.Container.content_set;
|
|
Elm.Container.content_unset;
|
|
Elm.Container.content_swallow_list.get;
|
|
}
|
|
events {
|
|
theme,changed;
|
|
language,changed;
|
|
access,changed;
|
|
}
|
|
|
|
}
|