forked from enlightenment/efl
601 lines
22 KiB
Plaintext
601 lines
22 KiB
Plaintext
function Efl.Ui.Scrollable_On_Show_Region {
|
|
[[Function pointer for on show region hook]]
|
|
params {
|
|
@in obj: Efl.Canvas.Object; [[Canvas object]]
|
|
@in region: Eina.Rect; [[Showed region]]
|
|
}
|
|
};
|
|
|
|
struct Efl.Ui.Widget_Focus_State {
|
|
[[All relevant fields needed for the current state of focus registeration]]
|
|
manager : Efl.Ui.Focus.Manager; [[The manager where the widget is registered in]]
|
|
parent : Efl.Ui.Focus.Object; [[The parent the widget is using as logical parent]]
|
|
logical : bool; [[$true if this is registered as logical currently]]
|
|
}
|
|
|
|
abstract Efl.Ui.Widget (Efl.Canvas.Group, Efl.Access.Object,
|
|
Efl.Access.Component, Efl.Part, Efl.Ui.Focus.Object,
|
|
Efl.Ui.Cursor, Efl.Ui.Translatable,
|
|
Efl.Ui.Selection, Efl.Ui.Dnd)
|
|
{
|
|
[[Efl UI widget abstract class]]
|
|
legacy_prefix: elm_widget;
|
|
//eo_prefix: efl_ui_widget;
|
|
event_prefix: efl_ui_widget;
|
|
data: Efl_Ui_Widget_Data;
|
|
methods {
|
|
@property resize_object @protected {
|
|
[[This is the internal canvas object managed by a widget.
|
|
|
|
This property is protected as it is meant for widget implementations
|
|
only, to set and access the internal canvas object. Do use this
|
|
function unless you're implementing a widget.
|
|
]]
|
|
set {
|
|
[[Sets the new resize object for this widget.]]
|
|
}
|
|
values {
|
|
sobj: Efl.Canvas.Object @nullable;
|
|
[[A canvas object (often a @Efl.Canvas.Layout object).]]
|
|
}
|
|
}
|
|
@property disabled {
|
|
[[Whether the widget is enabled (accepts and reacts to user inputs).
|
|
|
|
Each widget may handle the disabled state differently, but overall
|
|
disabled widgets shall not respond to any input events. This is
|
|
$false by default, meaning the widget is enabled.
|
|
]]
|
|
set {
|
|
[[Enables or disables this widget.
|
|
|
|
Disabling a widget will disable all its children recursively,
|
|
but only this widget will be marked as disabled internally.
|
|
]]
|
|
}
|
|
get {
|
|
[[Returns whether the widget is disabled.
|
|
|
|
This will return $true if any widget in the parent hierarchy
|
|
is disabled. Re-enabling that parent may in turn change the
|
|
disabled state of this widget.
|
|
]]
|
|
}
|
|
values {
|
|
disabled: bool(false); [[$true if the widget is disabled.]]
|
|
}
|
|
}
|
|
@property style {
|
|
[[The widget style to use.
|
|
|
|
Styles define different look and feel for widgets, and may provide
|
|
different parts for layout-based widgets. Styles vary from widget
|
|
to widget and may be defined by other themes by means of extensions
|
|
and overlays.
|
|
|
|
The style can only be set before @Efl.Object.finalize, which means
|
|
at construction time of the object (inside $efl_add in C).
|
|
]]
|
|
set @protected {
|
|
[[Can only be called during construction, before finalize.]]
|
|
return: Efl.Ui.Theme_Apply_Result(0);
|
|
[[Whether the style was successfully applied or not, see
|
|
the values of @Efl.Ui.Theme_Apply_Result for more information.]]
|
|
}
|
|
get {
|
|
[[Returns the current style of a widget.]]
|
|
}
|
|
values {
|
|
style: string;
|
|
[[Name of the style to use. Refer to each widget's documentation
|
|
for the available style names, or to the themes in use.]]
|
|
}
|
|
}
|
|
widget_event @protected {
|
|
[[Virtual function handling input events on the widget.
|
|
|
|
This method should return $true if the event has been processed.
|
|
Only key down, key up and pointer wheel events will be propagated
|
|
through this function.
|
|
|
|
It is common for the event to be also marked as processed as in
|
|
@Efl.Input.Event.processed, if this operation was successful. This
|
|
makes sure other widgets will not also process this input event.
|
|
]]
|
|
params {
|
|
@cref eo_event: Efl.Event;
|
|
[[EO event struct with an Efl.Input.Event as info.]]
|
|
@in source: Efl.Canvas.Object;
|
|
[[Source object where the event originated. Often same as this.]]
|
|
}
|
|
return: bool; [[$true on success, $false otherwise]]
|
|
legacy: null;
|
|
}
|
|
// FIXME: focus_allow? can_focus? focusable?
|
|
@property focus_allow {
|
|
[[The ability for a widget to be focused.
|
|
|
|
Unfocusable objects do nothing when programmatically focused. 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.
|
|
|
|
This property's default value depends on the widget (eg. a box is
|
|
not focusable, but a button is).
|
|
]]
|
|
set {
|
|
legacy: elm_widget_can_focus_set;
|
|
}
|
|
get {
|
|
legacy: elm_widget_can_focus_get;
|
|
}
|
|
values {
|
|
can_focus: bool; [[Whether the object is focusable.]]
|
|
}
|
|
}
|
|
@property widget_parent @protected {
|
|
[[The internal parent of this widget.
|
|
|
|
@Efl.Ui.Widget objects have a parent hierarchy that may differ slightly
|
|
from their @Efl.Object or @Efl.Canvas.Object hierarchy. This is
|
|
meant for internal handling.
|
|
|
|
See also @.widget_top.
|
|
]]
|
|
set {}
|
|
get {
|
|
legacy: elm_widget_parent_get; /* internal in legacy */
|
|
}
|
|
values {
|
|
parent: Efl.Ui.Widget @nullable; [[Widget parent object]]
|
|
}
|
|
}
|
|
@property widget_top {
|
|
[[Root widget in the widget hierarchy.
|
|
|
|
This returns the top widget, in terms of widget hierarchy. This is
|
|
usually a window (@Efl.Ui.Win). This function walks the list of
|
|
@.widget_parent.
|
|
|
|
If this widget has no parent (in terms of widget hierarchy) this
|
|
will return $null.
|
|
|
|
Note: This may not be a display manager window in case of nested
|
|
canvases. If a "real" window is required, then you might want to
|
|
verify that the returned object is a @Efl.Ui.Win_Inlined, and then
|
|
get @Efl.Ui.Win_Inlined.inlined_parent to find an object in the
|
|
master window.
|
|
|
|
See also @.widget_parent.
|
|
]]
|
|
get {
|
|
legacy: elm_widget_top_get; /* internal in legacy */
|
|
}
|
|
values {
|
|
top: Efl.Ui.Widget; [[Top widget, usually a window.]]
|
|
}
|
|
}
|
|
|
|
/* Accessibility */
|
|
@property access_info {
|
|
[[Accessibility information.
|
|
|
|
This is a replacement string to be read by the accessibility
|
|
text-to-speech engine, if accessibility is enabled by configuration.
|
|
This will take precedence over the default text for this object,
|
|
which means for instance that the label of a button won't be read
|
|
out loud, instead $txt will be read out.
|
|
]]
|
|
values {
|
|
txt: string @nullable; [[Accessibility text description.]]
|
|
}
|
|
}
|
|
on_access_activate @protected @beta {
|
|
[[Hook function called when widget is activated through accessibility.
|
|
|
|
This meant to be overridden by subclasses to support accessibility.
|
|
This is an unstable API.
|
|
]]
|
|
params {
|
|
@in act: Efl.Ui.Activate; [[Type of activation.]]
|
|
}
|
|
return: bool; [[$true on success, $false otherwise]]
|
|
legacy: null; /* FIXME: legacy API does extra work */
|
|
}
|
|
on_access_update @protected @beta {
|
|
[[Hook function called when accessibility is changed on the widget.
|
|
|
|
This meant to be overridden by subclasses to support accessibility.
|
|
This is an unstable API.
|
|
]]
|
|
params {
|
|
@in enable: bool; [[$true if accessibility is enabled.]]
|
|
}
|
|
legacy: null; /* FIXME: legacy API does extra work */
|
|
}
|
|
|
|
/* Internal hooks. */
|
|
widget_sub_object_add @protected {
|
|
[[Virtual function handling sub objects being added.
|
|
|
|
Sub objects can be any canvas object, not necessarily widgets.
|
|
|
|
See also @.widget_parent.
|
|
]]
|
|
params {
|
|
@in sub_obj: Efl.Canvas.Object;
|
|
[[Sub object to be added. Not necessarily a widget itself.]]
|
|
}
|
|
return: bool; [[Indicates if the operation succeeded.]]
|
|
legacy: elm_widget_sub_object_add;
|
|
}
|
|
widget_sub_object_del @protected {
|
|
[[Virtual function handling sub objects being removed.
|
|
|
|
Sub objects can be any canvas object, not necessarily widgets.
|
|
|
|
See also @.widget_parent.
|
|
]]
|
|
params {
|
|
@in sub_obj: Efl.Canvas.Object;
|
|
[[Sub object to be removed. Should be a child of this widget.]]
|
|
}
|
|
return: bool; [[Indicates if the operation succeeded.]]
|
|
legacy: elm_widget_sub_object_del;
|
|
}
|
|
@property orientation_mode {
|
|
[[Whether the widget's automatic orientation is enabled or not.
|
|
|
|
Orientation mode is used for widgets to change their style or send
|
|
signals based on the canvas rotation (i.e. the window orientation).
|
|
If the orientation mode is enabled, the widget will emit signals
|
|
such as "elm,state,orient,N" where $N is one of 0, 90, 180, 270,
|
|
depending on the window orientation. Such signals may be handled by
|
|
the theme in order to provide a different look for the widget based
|
|
on the canvas orientation.
|
|
|
|
By default orientation mode is enabled.
|
|
|
|
See also @.on_orientation_update.
|
|
]]
|
|
values {
|
|
mode: Efl.Ui.Widget_Orientation_Mode(Efl.Ui.Widget_Orientation_Mode.default);
|
|
[[How window orientation should affect this widget.]]
|
|
}
|
|
}
|
|
on_orientation_update @protected {
|
|
[[Virtual function handling canvas orientation changes.
|
|
|
|
This method will be called recursively from the top widget (the
|
|
window) to all the children objects whenever the window rotation
|
|
is changed. The given $rotation will be one of 0, 90, 180, 270 or
|
|
the special value -1 if @.orientation_mode is $disabled.
|
|
|
|
If @.orientation_mode is $default, the widget implementation will
|
|
emit the signal "elm,state,orient,$R" will be emitted (where $R is
|
|
the rotation angle in degrees).
|
|
|
|
Note: This function may be called even if the orientation has not
|
|
actually changed, like when a widget needs to be reconfigured.
|
|
|
|
See also @.orientation_mode.
|
|
]]
|
|
params {
|
|
rotation: int; [[Orientation in degrees: 0, 90, 180, 270 or -1 if
|
|
@.orientation_mode is $disabled.]]
|
|
}
|
|
}
|
|
on_disabled_update @protected {
|
|
[[Virtual function called when the widget becomes disabled.
|
|
|
|
This may be triggered even if this widget is not disabled, as the
|
|
parent widget could be disabled and propagate its state.
|
|
]]
|
|
params {
|
|
disabled: bool; [[The new value of @.disabled.]]
|
|
}
|
|
return: bool; [[Indicates if the operation succeeded.]]
|
|
}
|
|
theme_apply @protected {
|
|
[[Virtual function called when the widget needs to re-apply its theme.
|
|
|
|
This may be called when the object is first created, or whenever
|
|
the widget is modified in any way that may require a reload of the
|
|
theme. This may include but is not limited to scale, theme, or
|
|
mirrored mode changes.
|
|
|
|
Note: even widgets not based on layouts may override this method
|
|
to handle widget updates (scale, mirrored mode, etc...).
|
|
]]
|
|
return: Efl.Ui.Theme_Apply_Result; [[Indicates success, and if the current
|
|
theme or default theme was used.]]
|
|
}
|
|
|
|
/* Scroll API. */
|
|
@property on_show_region_hook @protected {
|
|
[[Hook function called when the @.show_region is changed.
|
|
|
|
See also @.show_region.
|
|
]]
|
|
set {}
|
|
values {
|
|
func: Efl.Ui.Scrollable_On_Show_Region @nullable; [[Region hook function]]
|
|
}
|
|
}
|
|
@property show_region @protected {
|
|
[[Region inside the widget to show.
|
|
|
|
See also @.on_show_region_hook.
|
|
]]
|
|
set {
|
|
[[Request parent scrollers to pan around so that this region
|
|
of the widget becomes visible.
|
|
|
|
If $force is $true this will trigger scroller changes and
|
|
the @.on_show_region_hook to be called even if the region is
|
|
unchanged.
|
|
]]
|
|
values {
|
|
region: Eina.Rect; [[The region to show.]]
|
|
force: bool; [[Set to $true to force show even if unchanged.]]
|
|
}
|
|
}
|
|
get {
|
|
[[Returns the current region to show.]]
|
|
values {
|
|
region: Eina.Rect; [[The region to show.]]
|
|
}
|
|
}
|
|
}
|
|
|
|
/* FIXME: Scroll API. Not sure how those APIs should be exposed with
|
|
* the new scrollable API. */
|
|
scroll_hold_push {
|
|
[[Push scroll hold]]
|
|
}
|
|
scroll_hold_pop {
|
|
[[Pop scroller hold]]
|
|
}
|
|
scroll_freeze_push {
|
|
[[Push scroller freeze]]
|
|
}
|
|
scroll_freeze_pop {
|
|
[[Pop scroller freeze]]
|
|
}
|
|
|
|
/* Region of interest */
|
|
@property interest_region @protected {
|
|
[[Region of interest inside this widget, that should be given
|
|
priority to be visible inside a scroller.
|
|
|
|
When this widget or one of its subwidgets is given focus, this
|
|
region should be shown, which means any parent scroller should
|
|
attempt to display the given area of this widget. For instance, an
|
|
entry given focus should scroll to show the text cursor if that
|
|
cursor moves. In this example, this region defines the relative
|
|
geometry of the cursor within the widget.
|
|
|
|
Note: The region is relative to the top-left corner of the widget,
|
|
i.e. X,Y start from 0,0 to indicate the top-left corner of the
|
|
widget. W,H must be greater or equal to 1 for this region to be
|
|
taken into account, otherwise it is ignored.
|
|
|
|
See also @.interest_region_mode
|
|
]]
|
|
get {
|
|
legacy: elm_widget_focus_region_get;
|
|
}
|
|
values {
|
|
region: Eina.Rect;
|
|
[[The relative region to show. If width or height is <= 0 it
|
|
will be ignored, and no action will be taken.]]
|
|
}
|
|
}
|
|
@property interest_region_mode {
|
|
[[Defines how @.show_region should be calculated.
|
|
|
|
It is up to the implementation of @.show_region.get to take this
|
|
value into account (or ignore it).
|
|
]]
|
|
get {
|
|
legacy: elm_widget_focus_region_show_mode_get;
|
|
}
|
|
set {
|
|
legacy: elm_widget_focus_region_show_mode_set;
|
|
}
|
|
values {
|
|
mode: Efl.Ui.Interest_Region_Mode;
|
|
[[Whether to show a specific item or the widget as a whole.]]
|
|
}
|
|
}
|
|
|
|
/* Focus highlight (visual focus rectangle) properties */
|
|
@property focus_highlight_geometry @protected {
|
|
[[The rectangle region to be highlighted on focus.
|
|
|
|
This is a rectangle region where the focus highlight should be
|
|
displayed.
|
|
]]
|
|
get {
|
|
[[This is a read-only property.]]
|
|
}
|
|
values {
|
|
region: Eina.Rect; [[The rectangle area.]]
|
|
}
|
|
}
|
|
@property focus_highlight_enabled {
|
|
[[Whether focus highlight is enabled or not.
|
|
|
|
As of EFL 1.21 focus highlight properties apply to a single window,
|
|
not a single widget. As a consequence, calls to this function may
|
|
be forwarded to the parent window. Future versions of EFL may
|
|
implement widget-specific focus highlight properties.
|
|
|
|
See also @.widget_top.
|
|
See also @.focus_highlight_style.
|
|
See also @.focus_highlight_animate.
|
|
]]
|
|
set {
|
|
[[Set the enabled status for the focus highlight in a window.
|
|
|
|
This function will enable or disable the focus highlight,
|
|
regardless of the global setting for it.
|
|
]]
|
|
}
|
|
get {
|
|
[[Get the enabled value of the focus highlight for this window.]]
|
|
}
|
|
values {
|
|
enabled: bool; [[The enabled value for the highlight.]]
|
|
}
|
|
}
|
|
@property focus_highlight_style {
|
|
[[Control the widget focus highlight style.
|
|
|
|
If $style is $null, the default will be used.
|
|
|
|
As of EFL 1.21 focus highlight properties apply to a single window,
|
|
not a single widget. As a consequence, calls to this function may
|
|
be forwarded to the parent window. Future versions of EFL may
|
|
implement widget-specific focus highlight properties.
|
|
|
|
See also @.widget_top.
|
|
See also @.focus_highlight_enabled.
|
|
See also @.focus_highlight_animate.
|
|
]]
|
|
set {
|
|
/* FIXME: This is async... success here means nothing. */
|
|
return: bool; [[$true on success, $false otherwise.]]
|
|
}
|
|
get {
|
|
}
|
|
values {
|
|
style: string @nullable; [[The name of the focus highlight style.]]
|
|
}
|
|
}
|
|
@property focus_highlight_animate {
|
|
[[Whether focus highlight should animate or not.
|
|
|
|
As of EFL 1.21 focus highlight properties apply to a single window,
|
|
not a single widget. As a consequence, calls to this function may
|
|
be forwarded to the parent window. Future versions of EFL may
|
|
implement widget-specific focus highlight properties.
|
|
|
|
See also @.widget_top.
|
|
See also @.focus_highlight_style.
|
|
See also @.focus_highlight_enabled.
|
|
]]
|
|
set {
|
|
[[Set the animate status for the focus highlight for this window.
|
|
|
|
This function will enable or disable the animation of focus
|
|
highlight.
|
|
]]
|
|
}
|
|
get {
|
|
[[Get the animate value of the focus highlight for this window.]]
|
|
}
|
|
values {
|
|
animate: bool; [[The enabled value for the highlight animation.]]
|
|
}
|
|
}
|
|
@property focus_move_policy @beta {
|
|
[[The widget's focus move policy.]]
|
|
values {
|
|
policy: Efl.Ui.Focus.Move_Policy; [[Focus move policy]]
|
|
}
|
|
}
|
|
@property focus_move_policy_automatic @beta {
|
|
[[Control the widget's focus_move_policy mode setting.
|
|
|
|
@since 1.18]]
|
|
values {
|
|
automatic: bool; [[$true to follow system focus move policy change,
|
|
$false otherwise]]
|
|
}
|
|
}
|
|
|
|
/* FIXME: No more items in EO API */
|
|
@property focused_item @beta {
|
|
get {
|
|
[[Get the focused widget item.]]
|
|
return: Elm.Widget.Item; [[Focused item]]
|
|
}
|
|
}
|
|
|
|
/* Focus Manager API */
|
|
focus_state_apply @protected {
|
|
[[Register focus with the given configuration.
|
|
|
|
The implementation can feel free to change the logical flag as it
|
|
wants, but other than that it should strictly keep the configuration.
|
|
|
|
The implementation in elm.widget updates the current state into what
|
|
is passed as configured state, respecting manager changes,
|
|
registeration and unregistration based on if it should be registered
|
|
or unregistered.
|
|
|
|
A manager field that is $null means that the widget should not or was
|
|
not registered.
|
|
]]
|
|
params {
|
|
@in current_state : Efl.Ui.Widget_Focus_State;
|
|
[[The focus manager to register with.]]
|
|
@inout configured_state : Efl.Ui.Widget_Focus_State;
|
|
[[The evaluated Focus state that should be used.]]
|
|
@in redirect : Efl.Ui.Widget;
|
|
[[A redirect that will be set by the elm.widget implementation.]]
|
|
}
|
|
return: bool; [[Returns whether the widget is registered or not.]]
|
|
}
|
|
}
|
|
parts {
|
|
shadow: Efl.Ui.Widget_Part_Shadow;
|
|
background: Efl.Ui.Widget_Part_Bg;
|
|
}
|
|
implements {
|
|
class.constructor;
|
|
Efl.Object.constructor;
|
|
Efl.Object.finalize;
|
|
Efl.Object.destructor;
|
|
Efl.Object.provider_find;
|
|
Efl.Object.debug_name_override;
|
|
Efl.Gfx.Color.color { set; }
|
|
Efl.Gfx.Entity.visible { set; }
|
|
Efl.Gfx.Entity.position { set; }
|
|
Efl.Gfx.Entity.size { set; }
|
|
Efl.Gfx.Entity.scale { set; get; }
|
|
Efl.Canvas.Object.clip { set; }
|
|
Efl.Canvas.Object.no_render { set; }
|
|
Efl.Canvas.Object.is_frame_object { set; }
|
|
Efl.Canvas.Group.group_calculate;
|
|
Efl.Canvas.Group.group_member_del;
|
|
Efl.Canvas.Group.group_member_add;
|
|
Efl.Access.Object.i18n_name { get; }
|
|
Efl.Access.Object.state_set { get; }
|
|
Efl.Access.Object.access_children { get; }
|
|
Efl.Access.Object.attributes { get; }
|
|
Efl.Access.Component.focus_grab;
|
|
Efl.Ui.Focus.Object.focus_manager { get; }
|
|
Efl.Ui.Focus.Object.focus_parent { get; }
|
|
Efl.Ui.Focus.Object.focus_geometry { get; }
|
|
Efl.Ui.Focus.Object.focus { set; }
|
|
Efl.Ui.Base.mirrored { get; set; }
|
|
Efl.Ui.Base.mirrored_automatic { get; set; }
|
|
Efl.Ui.Cursor.cursor { get; set; }
|
|
Efl.Ui.Cursor.cursor_style { get; set; }
|
|
Efl.Ui.Cursor.cursor_theme_search_enabled { get; set; }
|
|
Efl.Ui.Focus.Object.on_focus_update;
|
|
Efl.Ui.Translatable.translation_update; [[This implements the calls to $gettext() and $text_set().]]
|
|
Efl.Part.part_get; [[Returns @Efl.Ui.Widget_Part.]]
|
|
}
|
|
events {
|
|
moved: Efl.Object; [[Called when widget moved]]
|
|
language,changed: void; [[Called when widget language changed]]
|
|
access,changed: void; [[Called when accessibility changed]]
|
|
}
|
|
}
|