forked from enlightenment/efl
878 lines
23 KiB
Plaintext
878 lines
23 KiB
Plaintext
import edje_types;
|
|
import elm_general;
|
|
|
|
/* FIXME: This shouldn't be here. */
|
|
type list_data_get_func_type: __undefined_type;
|
|
type region_hook_func_type: __undefined_type;
|
|
|
|
enum Elm.Activate
|
|
{
|
|
[[ Used in 'Virtual' function @Elm.Widget.activate. ]]
|
|
default = 0,
|
|
up,
|
|
down,
|
|
right,
|
|
left,
|
|
back,
|
|
}
|
|
|
|
struct Elm.Tooltip;
|
|
struct Elm.Cursor;
|
|
struct @extern Elm.Theme;
|
|
|
|
abstract Elm.Widget (Evas.Object.Smart, Elm.Interface.Atspi_Accessible, Elm.Interface.Atspi_Component)
|
|
{
|
|
eo_prefix: elm_obj_widget;
|
|
data: Elm_Widget_Smart_Data;
|
|
methods {
|
|
@property focus {
|
|
[[Whether an Elementary object has the focus or not.
|
|
|
|
Note that when you set focus to this object, if it can handle focus,
|
|
it will take the focus away from the one who had it previously and will,
|
|
for now on, be the one receiving input events. Unsetting focus will remove
|
|
the focus from this object, passing it back to the previous element in the
|
|
focus chain list.
|
|
|
|
Warning: Only visible object can get a focus. Call @Evas.Object.Smart.show
|
|
before calling this API, if you want to give a focus to the evas object.]]
|
|
set {
|
|
[[$true set the focus to the object,
|
|
$false unset the focus to the object.]]
|
|
}
|
|
get {
|
|
[[Return $true if the object is focused,
|
|
and $false if not (and on errors).]]
|
|
}
|
|
values {
|
|
focus: bool;
|
|
}
|
|
}
|
|
@property drag_lock_y {
|
|
set {
|
|
}
|
|
get {
|
|
}
|
|
values {
|
|
lock: bool;
|
|
}
|
|
}
|
|
@property focus_highlight_style {
|
|
[[Control the widget focus highlight style.]]
|
|
set {
|
|
return: bool; [[$true on success, $false otherwise.]]
|
|
}
|
|
get {
|
|
}
|
|
values {
|
|
style: const(char)*; [[The name of the focus highlight style.]]
|
|
}
|
|
}
|
|
@property tree_unfocusable {
|
|
[[Make the elementary object and its children to be unfocusable (or focusable).
|
|
If the tree is set as unfocusable, newest focused object which is not in
|
|
this tree will get focus.
|
|
This API can be helpful for an object to be deleted.
|
|
When an object will be deleted soon, it and its children may not want to
|
|
get focus (by focus reverting or by other focus controls).
|
|
Then, just use this API before deleting.]]
|
|
set {
|
|
}
|
|
get {
|
|
[[Return $true, if the tree is unfocusable,
|
|
$false otherwise (and on errors).]]
|
|
}
|
|
values {
|
|
tree_unfocusable: bool; [[$true for unfocusable, $false for focusable.]]
|
|
}
|
|
}
|
|
@property mirrored {
|
|
[[Control the widget's mirrored mode.]]
|
|
set {
|
|
}
|
|
get {
|
|
}
|
|
values {
|
|
mirrored: bool;
|
|
}
|
|
}
|
|
@property theme {
|
|
set {
|
|
}
|
|
get {
|
|
}
|
|
values {
|
|
th: Elm.Theme * @nullable;
|
|
}
|
|
}
|
|
@property disabled {
|
|
set {
|
|
}
|
|
get {
|
|
}
|
|
values {
|
|
disabled: bool;
|
|
}
|
|
}
|
|
@property highlight_ignore {
|
|
set {
|
|
}
|
|
get {
|
|
}
|
|
values {
|
|
ignore: bool;
|
|
}
|
|
}
|
|
@property mirrored_automatic {
|
|
[[Control the widget's mirrored mode setting.]]
|
|
set {
|
|
}
|
|
get {
|
|
}
|
|
values {
|
|
automatic: bool;
|
|
}
|
|
}
|
|
@property orientation_mode_disabled {
|
|
set {
|
|
}
|
|
get {
|
|
}
|
|
values {
|
|
disabled: bool;
|
|
}
|
|
}
|
|
@property style {
|
|
set {
|
|
return: bool;
|
|
}
|
|
get {
|
|
}
|
|
values {
|
|
style: const(char)*;
|
|
}
|
|
}
|
|
@property scale {
|
|
set {
|
|
}
|
|
get {
|
|
}
|
|
values {
|
|
scale: double;
|
|
}
|
|
}
|
|
@property focus_custom_chain {
|
|
[[A custom chain of objects to pass focus.
|
|
|
|
Note: On focus cycle, only will be evaluated children of this container.]]
|
|
set {
|
|
[[This function overwrites any previous custom focus chain within
|
|
the list of objects. The previous list will be deleted and this list
|
|
will be managed by elementary. After it is set, don't modify it.]]
|
|
values {
|
|
objs: list<Evas.Object*>*; [[Chain of objects to pass focus]]
|
|
}
|
|
}
|
|
get {
|
|
values {
|
|
objs: const(list<Evas.Object*>)*; [[Chain of objects]]
|
|
}
|
|
}
|
|
}
|
|
@property can_focus {
|
|
[[The ability for an Elementary object to be focused.
|
|
|
|
Unfocusable objects do nothing when programmatically
|
|
focused, being the nearest focusable parent object the one
|
|
really getting focus. Also, when they receive mouse input, they
|
|
will get the event, but not take away the focus from where it
|
|
was previously.
|
|
|
|
Note: Objects which are meant to be interacted with by input
|
|
events are created able to be focused, by default. All the
|
|
others are not.]]
|
|
set {
|
|
}
|
|
get {
|
|
[[Return $true if the object is allowed to be focused,
|
|
$false if not (and on errors).]]
|
|
}
|
|
values {
|
|
can_focus: bool; [[$true if the object can be focused,
|
|
$false if not.]]
|
|
}
|
|
}
|
|
@property highlight_in_theme {
|
|
set {
|
|
}
|
|
get {
|
|
}
|
|
values {
|
|
highlight: bool;
|
|
}
|
|
}
|
|
@property widget_parent @protected {
|
|
[[The internal widget parent]]
|
|
set {
|
|
legacy: elm_widget_parent_set; /* Needed because we don't do duplication removal for legacy names. */
|
|
}
|
|
get {
|
|
legacy: elm_widget_parent_get; /* Needed because we don't do duplication removal for legacy names. */
|
|
}
|
|
values {
|
|
parent: Evas.Object * @nullable;
|
|
}
|
|
}
|
|
@property access_info {
|
|
set {
|
|
}
|
|
get {
|
|
}
|
|
values {
|
|
txt: const(char)* @nullable;
|
|
}
|
|
}
|
|
@property drag_lock_x {
|
|
set {
|
|
}
|
|
get {
|
|
}
|
|
values {
|
|
lock: bool;
|
|
}
|
|
}
|
|
@property access_highlight_in_theme {
|
|
set {
|
|
}
|
|
get {
|
|
}
|
|
values {
|
|
highlight: bool; [[highlight]]
|
|
}
|
|
}
|
|
@property focus_region_show_mode {
|
|
[[Control the focus_region_show mode.]]
|
|
set {
|
|
}
|
|
get {
|
|
}
|
|
values {
|
|
mode: Elm.Focus.Region.Show_Mode;
|
|
}
|
|
}
|
|
@property parent_highlight {
|
|
set {
|
|
}
|
|
values {
|
|
highlighted: bool;
|
|
}
|
|
}
|
|
@property theme_object {
|
|
set {
|
|
return: bool;
|
|
}
|
|
values {
|
|
edj: Evas.Object *;
|
|
wname: const(char)*;
|
|
welement: const(char)*;
|
|
wstyle: const(char)*;
|
|
}
|
|
}
|
|
@property hover_object {
|
|
set {
|
|
}
|
|
values {
|
|
sobj: Evas.Object * @nullable;
|
|
}
|
|
}
|
|
@property display_mode {
|
|
set {
|
|
}
|
|
values {
|
|
dispmode: Evas.Display_Mode;
|
|
}
|
|
}
|
|
@property on_show_region_hook {
|
|
set {
|
|
}
|
|
values {
|
|
func: region_hook_func_type @nullable;
|
|
data: void * @optional;
|
|
}
|
|
}
|
|
@property domain_part_text_translatable {
|
|
set {
|
|
}
|
|
values {
|
|
part: const(char)*;
|
|
domain: const(char)*;
|
|
translatable: bool;
|
|
}
|
|
}
|
|
@property orientation {
|
|
set {
|
|
}
|
|
values {
|
|
rotation: int;
|
|
}
|
|
}
|
|
@property resize_object {
|
|
set {
|
|
}
|
|
values {
|
|
sobj: Evas.Object * @nullable;
|
|
sub_obj: bool;
|
|
}
|
|
}
|
|
@property domain_translatable_part_text {
|
|
set {
|
|
}
|
|
values {
|
|
part: const(char)*;
|
|
domain: const(char)*;
|
|
label: const(char)*;
|
|
}
|
|
}
|
|
@property scrollable_children {
|
|
get {
|
|
[[Function to operate on a given widget's scrollabe children when necessary.
|
|
|
|
Warning: free the returned list with eina_list_free().]]
|
|
return: free(own(list<Evas.Object *> *), eina_list_free) @warn_unused;
|
|
}
|
|
}
|
|
@property scroll_hold {
|
|
get {
|
|
return: int;
|
|
}
|
|
}
|
|
@property drag_child_locked_y {
|
|
get {
|
|
return: int;
|
|
}
|
|
}
|
|
@property item_loop_enabled {
|
|
[[Control item loop feature.]]
|
|
set {
|
|
}
|
|
get {
|
|
}
|
|
values {
|
|
enable: bool;
|
|
}
|
|
}
|
|
@property child_can_focus {
|
|
get {
|
|
return: bool;
|
|
}
|
|
}
|
|
@property scroll_freeze {
|
|
get {
|
|
return: int;
|
|
}
|
|
}
|
|
@property focus_region {
|
|
get {
|
|
return: bool;
|
|
}
|
|
values {
|
|
x: Evas.Coord;
|
|
y: Evas.Coord;
|
|
w: Evas.Coord;
|
|
h: Evas.Coord;
|
|
}
|
|
}
|
|
@property top {
|
|
get {
|
|
return: Evas.Object *;
|
|
}
|
|
}
|
|
@property focus_order {
|
|
get {
|
|
return: uint;
|
|
}
|
|
}
|
|
@property drag_child_locked_x {
|
|
get {
|
|
return: int;
|
|
}
|
|
}
|
|
@property can_focus_child_list {
|
|
get {
|
|
return: free(own(list<Evas.Object *> *), eina_list_free) @warn_unused;
|
|
}
|
|
}
|
|
@property focused_item {
|
|
get {
|
|
[[Get the focused widget item.]]
|
|
return: Elm.Widget.Item *;
|
|
}
|
|
}
|
|
@property parents_bounce {
|
|
get {
|
|
}
|
|
values {
|
|
horiz: bool;
|
|
vert: bool;
|
|
}
|
|
}
|
|
@property parent_widget {
|
|
get @virtual_pure {
|
|
return: Evas.Object *;
|
|
legacy: null;
|
|
}
|
|
}
|
|
@property highlight {
|
|
get {
|
|
return: bool;
|
|
}
|
|
}
|
|
@property focused_object {
|
|
[[Current focused object in object tree.]]
|
|
get {
|
|
return: Evas.Object *; [[Current focused or $null, if there is no focused object.]]
|
|
}
|
|
}
|
|
@property parent2 {
|
|
set {
|
|
}
|
|
get {
|
|
}
|
|
values {
|
|
parent: Evas.Object * @nullable;
|
|
}
|
|
}
|
|
@property part_text {
|
|
set {
|
|
}
|
|
get {
|
|
}
|
|
keys {
|
|
part: const(char)*;
|
|
}
|
|
values {
|
|
label: const(char)*;
|
|
}
|
|
}
|
|
newest_focus_order_get @const {
|
|
return: Evas.Object *;
|
|
params {
|
|
@out newest_focus_order: uint;
|
|
@in can_focus_only: bool;
|
|
}
|
|
}
|
|
scroll_hold_push {
|
|
}
|
|
cursor_add {
|
|
params {
|
|
@in cur: Elm.Cursor *;
|
|
}
|
|
}
|
|
focus_next_object_set {
|
|
[[Set the next object with specific focus direction.
|
|
|
|
@since 1.8]]
|
|
params {
|
|
@in next: Evas.Object * @nullable; [[Focus next object]]
|
|
@in dir: Elm.Focus_Direction; [[Focus direction]]
|
|
}
|
|
}
|
|
focus_next_object_get @const {
|
|
[[Get the next object with specific focus direction.
|
|
|
|
@since 1.8]]
|
|
return: Evas.Object *; [[Focus next object]]
|
|
params {
|
|
@in dir: Elm.Focus_Direction; [[Focus direction]]
|
|
}
|
|
}
|
|
focus_next_item_set {
|
|
[[Set the next object item with specific focus direction.
|
|
|
|
@since 1.16]]
|
|
params {
|
|
@in next_item: Elm.Widget.Item * @nullable; [[Focus next object item]]
|
|
@in dir: Elm.Focus_Direction; [[Focus direction]]
|
|
}
|
|
}
|
|
focus_next_item_get @const {
|
|
[[Get the next object item with specific focus direction.
|
|
|
|
@since 1.16]]
|
|
return: Elm.Widget.Item *; [[Focus next object item]]
|
|
params {
|
|
@in dir: Elm.Focus_Direction; [[Focus direction]]
|
|
}
|
|
}
|
|
focus_tree_unfocusable_handle {
|
|
}
|
|
focus_custom_chain_prepend {
|
|
[[Prepend object to custom focus chain.
|
|
|
|
Note: If @"relative_child" equal to $null or not in custom chain,
|
|
the object will be added in begin.
|
|
|
|
Note: On focus cycle, only will be evaluated children of this container.]]
|
|
params {
|
|
@in child: Evas.Object *; [[The child to be added in custom chain.]]
|
|
@in relative_child: Evas.Object * @optional; [[The relative object to position the child.]]
|
|
}
|
|
}
|
|
part_text_translate {
|
|
return: const(char)*;
|
|
params {
|
|
@in part: const(char)*;
|
|
@in text: const(char)*;
|
|
}
|
|
}
|
|
focus_highlight_geometry_get @const {
|
|
[[Get the focus highlight geometry of widget.]]
|
|
params {
|
|
@out x: Evas.Coord;
|
|
@out y: Evas.Coord;
|
|
@out w: Evas.Coord;
|
|
@out h: Evas.Coord;
|
|
}
|
|
}
|
|
activate {
|
|
[['Virtual' function to activate widget.]]
|
|
params {
|
|
@in act: Elm.Activate;
|
|
}
|
|
return: bool;
|
|
legacy: null; /* the legacy API has not the same number of parameter to we don't generate it. */
|
|
}
|
|
sub_object_add {
|
|
[['Virtual' function handling sub objects being added.]]
|
|
return: bool;
|
|
params {
|
|
@in sobj: Evas.Object *;
|
|
}
|
|
}
|
|
focus_direction_manager_is {
|
|
[['Virtual' function which checks if handling of passing focus to sub-objects in given direction is supported by widget.]]
|
|
return: bool;
|
|
legacy: null;
|
|
}
|
|
event {
|
|
[['Virtual' function handling input events on the widget.]]
|
|
params {
|
|
@in source: Evas.Object *;
|
|
@in type: Evas.Callback_Type;
|
|
@in event_info: void *;
|
|
}
|
|
return: bool;
|
|
}
|
|
event_callback_add {
|
|
params {
|
|
@in func: Elm_Event_Cb;
|
|
@in data: const(void)* @optional;
|
|
}
|
|
}
|
|
access {
|
|
[['Virtual' function on the widget being set access.]]
|
|
params {
|
|
@in acs: bool;
|
|
}
|
|
legacy: null;
|
|
}
|
|
cursor_del {
|
|
params {
|
|
@in cur: Elm.Cursor *;
|
|
}
|
|
}
|
|
event_callback_del {
|
|
return: void *;
|
|
params {
|
|
@in func: Elm_Event_Cb;
|
|
@in data: const(void)* @nullable;
|
|
}
|
|
}
|
|
on_focus {
|
|
[['Virtual' function handling focus in/out events on the widget. return true if this widget can handle focus, false otherwise]]
|
|
params {
|
|
@in item: Elm.Widget.Item * @nullable;
|
|
}
|
|
return: bool;
|
|
}
|
|
on_focus_region {
|
|
[['Virtual' function returning an inner area of a widget that should be brought into the visible area of a broader viewport, may this context arise.]]
|
|
params {
|
|
@out x: Evas.Coord;
|
|
@out y: Evas.Coord;
|
|
@out w: Evas.Coord;
|
|
@out h: Evas.Coord;
|
|
}
|
|
return: bool;
|
|
}
|
|
focus_cycle {
|
|
[[Give focus to next object with specific focus direction in
|
|
object tree.]]
|
|
params {
|
|
@in dir: Elm.Focus_Direction; [[Direction to move the focus.]]
|
|
}
|
|
}
|
|
focus_direction @virtual_pure {
|
|
[['Virtual' function handling passing focus to sub-objects given a direction, in degrees.]]
|
|
params {
|
|
@in base: const(Evas.Object)*;
|
|
@in degree: double;
|
|
@out direction: Evas.Object *;
|
|
@out direction_item: Elm.Widget.Item *;
|
|
@out weight: double;
|
|
}
|
|
return: bool;
|
|
}
|
|
event_propagate {
|
|
return: bool;
|
|
params {
|
|
@in type: Evas.Callback_Type;
|
|
@in event_info: void *;
|
|
@in event_flags: Evas.Event_Flags *;
|
|
}
|
|
}
|
|
signal_callback_add {
|
|
params {
|
|
@in emission: const(char)*;
|
|
@in source: const(char)*;
|
|
@in func: Edje.Signal_Cb;
|
|
@in data: void *;
|
|
}
|
|
}
|
|
focus_next_manager_is {
|
|
[['Virtual' function which checks if handling of passing focus to sub-objects is supported by widget.]]
|
|
return: bool;
|
|
}
|
|
name_find @const {
|
|
return: Evas.Object *;
|
|
params {
|
|
@in name: const(char)*;
|
|
@in recurse: int;
|
|
}
|
|
}
|
|
focus_list_direction_get @const {
|
|
return: bool;
|
|
params {
|
|
@in base: const(Evas.Object)*;
|
|
@in items: const(list<Eo.Base*>)*;
|
|
@in list_data_get: list_data_get_func_type;
|
|
@in degree: double;
|
|
@out direction: Evas.Object *;
|
|
@out direction_item: Elm.Widget.Item *;
|
|
@out weight: double;
|
|
}
|
|
}
|
|
focused_object_clear {
|
|
}
|
|
focus_direction_go {
|
|
return: bool;
|
|
params {
|
|
@in degree: double;
|
|
}
|
|
}
|
|
show_region_set {
|
|
params {
|
|
@in x: Evas.Coord;
|
|
@in y: Evas.Coord;
|
|
@in w: Evas.Coord;
|
|
@in h: Evas.Coord;
|
|
@in forceshow: bool;
|
|
}
|
|
}
|
|
show_region_get @const {
|
|
params {
|
|
@out x: Evas.Coord @optional;
|
|
@out y: Evas.Coord @optional;
|
|
@out w: Evas.Coord @optional;
|
|
@out h: Evas.Coord @optional;
|
|
}
|
|
}
|
|
scroll_freeze_pop {
|
|
}
|
|
tooltip_del {
|
|
params {
|
|
@in tt: Elm.Tooltip *;
|
|
}
|
|
}
|
|
focus_next_get @const {
|
|
return: bool;
|
|
params {
|
|
@in dir: Elm.Focus_Direction;
|
|
@out next: Evas.Object *;
|
|
@out next_item: Elm.Widget.Item *;
|
|
}
|
|
}
|
|
translatable_part_text_get @const {
|
|
return: const(char)*;
|
|
params {
|
|
@in part: const(char)*;
|
|
}
|
|
}
|
|
focus_restore {
|
|
[[Restore the focus state of the sub-tree.
|
|
|
|
This API will restore the focus state of the sub-tree to the latest
|
|
state. If a sub-tree is unfocused and wants to get back to the latest
|
|
focus state, this API will be helpful.]]
|
|
}
|
|
scroll_hold_pop {
|
|
}
|
|
translate {
|
|
[['Virtual' function handling language changes on Elementary.]]
|
|
return: bool;
|
|
legacy: null;
|
|
}
|
|
scroll_freeze_push {
|
|
}
|
|
focus_custom_chain_unset {
|
|
[[Unset a custom focus chain on a given Elementary widget.
|
|
|
|
Any focus chain previously set is removed entirely after this call.]]
|
|
}
|
|
focus_steal {
|
|
params {
|
|
@in item: Elm.Widget.Item * @nullable;
|
|
}
|
|
}
|
|
focus_hide_handle {
|
|
}
|
|
focus_next @virtual_pure {
|
|
[['Virtual' function handling passing focus to sub-objects.]]
|
|
params {
|
|
@in dir: Elm.Focus_Direction;
|
|
@out next: Evas.Object *;
|
|
@out next_item: Elm.Widget.Item *;
|
|
}
|
|
return: bool;
|
|
}
|
|
focus_list_next_get @const {
|
|
return: bool;
|
|
params {
|
|
@in items: const(list<Eo.Base*>)*;
|
|
@in list_data_get: list_data_get_func_type;
|
|
@in dir: Elm.Focus_Direction;
|
|
@out next: Evas.Object *;
|
|
@out next_item: Elm.Widget.Item *;
|
|
}
|
|
}
|
|
focus_mouse_up_handle {
|
|
legacy: null;
|
|
}
|
|
theme_apply {
|
|
[['Virtual' function on the widget being re-themed.]]
|
|
return: bool;
|
|
}
|
|
focus_direction_get @const {
|
|
return: bool;
|
|
params {
|
|
@in base: const(Evas.Object)*;
|
|
@in degree: double;
|
|
@out direction: Evas.Object *;
|
|
@out direction_item: Elm.Widget.Item *;
|
|
@out weight: double;
|
|
}
|
|
}
|
|
signal_callback_del {
|
|
return: void *;
|
|
params {
|
|
@in emission: const(char)*;
|
|
@in source: const(char)*;
|
|
@in func: Edje.Signal_Cb;
|
|
}
|
|
}
|
|
signal_emit {
|
|
params {
|
|
@in emission: const(char)*;
|
|
@in source: const(char)*;
|
|
}
|
|
}
|
|
disable {
|
|
[['Virtual' function on the widget being disabled.]]
|
|
return: bool;
|
|
}
|
|
sub_object_del {
|
|
[['Virtual' function handling sub objects being removed.]]
|
|
return: bool;
|
|
params {
|
|
@in sobj: Evas.Object *;
|
|
}
|
|
}
|
|
tooltip_add {
|
|
params {
|
|
@in tt: Elm.Tooltip *;
|
|
}
|
|
}
|
|
focus_region_show @const {
|
|
}
|
|
focus_disabled_handle {
|
|
}
|
|
focus_custom_chain_append {
|
|
[[Append object to custom focus chain.
|
|
|
|
Note: If @"relative_child" equal to $null or not in custom chain,
|
|
the object will be added in end.
|
|
|
|
Note: On focus cycle, only will be evaluated children of this container.]]
|
|
params {
|
|
@in child: Evas.Object *; [[The child to be added in custom chain.]]
|
|
@in relative_child: Evas.Object * @optional; [[The relative object to position the child.]]
|
|
}
|
|
}
|
|
@property focus_move_policy {
|
|
set {
|
|
[[Sets the widget's focus move policy.]]
|
|
}
|
|
get {
|
|
[[Returns the widget's focus move policy.]]
|
|
}
|
|
values {
|
|
policy: Elm.Focus.Move_Policy; [[Object's focus move policy.]]
|
|
}
|
|
}
|
|
@property focus_move_policy_automatic {
|
|
[[Control the widget's focus_move_policy mode setting.]]
|
|
set {
|
|
}
|
|
get {
|
|
}
|
|
values {
|
|
automatic: bool; [[$true to follow system focus move policy change, $false otherwise]]
|
|
}
|
|
}
|
|
focus_reconfigure {
|
|
}
|
|
}
|
|
implements {
|
|
class.constructor;
|
|
Eo.Base.constructor;
|
|
Eo.Base.destructor;
|
|
Eo.Base.dbg_info_get;
|
|
Evas.Object.Smart.hide;
|
|
Evas.Object.Smart.calculate;
|
|
Evas.Object.Smart.clip_unset;
|
|
Evas.Object.Smart.show;
|
|
Evas.Object.Smart.color.set;
|
|
Evas.Object.Smart.move;
|
|
Evas.Object.Smart.member_del;
|
|
Evas.Object.Smart.add;
|
|
Evas.Object.Smart.del;
|
|
Evas.Object.Smart.clip.set;
|
|
Evas.Object.Smart.member_add;
|
|
Evas.Object.Smart.resize;
|
|
Evas.Object.Smart.smart_no_render.set;
|
|
Elm.Interface.Atspi_Accessible.name.get;
|
|
Elm.Interface.Atspi_Accessible.state_set.get;
|
|
Elm.Interface.Atspi_Accessible.children.get;
|
|
Elm.Interface.Atspi_Accessible.parent.get;
|
|
Elm.Interface.Atspi_Accessible.attributes.get;
|
|
Elm.Interface.Atspi_Component.focus_grab;
|
|
}
|
|
events {
|
|
moved;
|
|
focused;
|
|
unfocused;
|
|
language,changed;
|
|
access,changed;
|
|
}
|
|
}
|