forked from enlightenment/efl
551 lines
23 KiB
Plaintext
551 lines
23 KiB
Plaintext
import elm_general;
|
|
import efl_ui;
|
|
|
|
type Elm_Tooltip_Item_Content_Cb: __undefined_type; [[Elementary tooltip item content callback type]]
|
|
type Elm_Object_Item_Signal_Cb: __undefined_type; [[Elementary object item signal callback type]]
|
|
|
|
class Elm.Widget.Item(Efl.Object, Efl.Access,
|
|
Efl.Access.Component)
|
|
{
|
|
[[Elementary widget item class]]
|
|
eo_prefix: elm_wdg_item;
|
|
legacy_prefix: elm_object_item;
|
|
methods {
|
|
@property tooltip_window_mode {
|
|
[[Control size restriction state of an object's tooltip
|
|
|
|
This function returns whether a tooltip is allowed to expand beyond
|
|
its parent window's canvas.
|
|
It will instead be limited only by the size of the display.]]
|
|
get {
|
|
}
|
|
set {
|
|
return: bool; [[$false on failure, $true on success]]
|
|
}
|
|
values {
|
|
disable: bool; [[If $true, size restrictions are disabled]]
|
|
}
|
|
}
|
|
@property tooltip_style {
|
|
[[Control a different style for this item tooltip.
|
|
|
|
Note: before you set a style you should define a tooltip with
|
|
@.tooltip_content_cb_set or
|
|
@.tooltip_text_set
|
|
|
|
See: elm_object_tooltip_style_set() for more details.]]
|
|
get {
|
|
}
|
|
set {
|
|
}
|
|
values {
|
|
style: string; [[The theme style used/to use (default, transparent, ...)]]
|
|
}
|
|
}
|
|
@property cursor {
|
|
[[Control the type of mouse pointer/cursor decoration to be shown,
|
|
when the mouse pointer is over the given item
|
|
|
|
This function works analogously as elm_object_cursor_set(), but
|
|
here the cursor's changing area is restricted to the item's
|
|
area, and not the whole widget's. Note that that item cursors
|
|
have precedence over widget cursors, so that a mouse over an
|
|
item with custom cursor set will always show that cursor.
|
|
|
|
If this function is called twice for an object, a previously set
|
|
cursor will be unset on the second call.]]
|
|
get {
|
|
}
|
|
set {
|
|
}
|
|
values {
|
|
cursor: string; [[The cursor type's name]]
|
|
}
|
|
}
|
|
@property cursor_style {
|
|
[[Control a different $style for a given custom cursor set for an item.
|
|
|
|
This function only makes sense when one is using custom mouse
|
|
cursor decorations defined in a theme file, which can have,
|
|
given a cursor name/type, alternate styles on it. It
|
|
works analogously as elm_object_cursor_style_set(), but here
|
|
applies only to item objects.
|
|
|
|
Warning: Before you set a cursor style you should have defined a
|
|
custom cursor previously on the item, with @.cursor.set]]
|
|
get {
|
|
}
|
|
set {
|
|
}
|
|
values {
|
|
style: string; [[The theme style to use/in use (e.g. $"default", $"transparent", etc)]]
|
|
}
|
|
}
|
|
@property cursor_engine_only {
|
|
[[Control if the (custom)cursor for a given item should be
|
|
searched in its theme, also, or should only rely on the
|
|
rendering engine.
|
|
|
|
Note: This call is of use only if you've set a custom cursor
|
|
for items, with @.cursor.set.
|
|
|
|
Note: By default, cursors will only be looked for between those
|
|
provided by the rendering engine.]]
|
|
get {
|
|
}
|
|
set {
|
|
}
|
|
values {
|
|
engine_only: bool; [[Use $true to have cursors looked for only on those provided by the rendering engine, $false to have them searched on the widget's theme, as well.]]
|
|
}
|
|
}
|
|
@property part_content {
|
|
[[Control a content of an object item
|
|
|
|
This sets a new object to an item as a content object. If any object was
|
|
already set as a content object in the same part, previous object will be
|
|
deleted automatically.]]
|
|
get {
|
|
}
|
|
set {
|
|
}
|
|
keys {
|
|
part: string @nullable; [[The content part name (NULL for the default content)]]
|
|
}
|
|
values {
|
|
content: Efl.Canvas.Object; [[The content of the object item]]
|
|
}
|
|
}
|
|
@property part_text {
|
|
[[Control a label of an object item
|
|
|
|
Note: Elementary object items may have many labels]]
|
|
get {
|
|
}
|
|
set {
|
|
}
|
|
keys {
|
|
part: string @nullable; [[The text part name (NULL for the default label)]]
|
|
}
|
|
values {
|
|
label: string; [[Text of the label]]
|
|
}
|
|
}
|
|
@property part_text_custom @protected {
|
|
get {
|
|
[[Get additional text part content]]
|
|
legacy: null;
|
|
}
|
|
set {
|
|
[[Save additional text part content]]
|
|
legacy: null;
|
|
}
|
|
keys {
|
|
part: string; [[Part name]]
|
|
}
|
|
values {
|
|
label: string; [[Label name]]
|
|
}
|
|
}
|
|
@property focus {
|
|
[[Control the object item focused
|
|
|
|
@since 1.10]]
|
|
get {
|
|
}
|
|
set {
|
|
}
|
|
values {
|
|
focused: bool; [[The focused state]]
|
|
}
|
|
}
|
|
@property style {
|
|
[[Control the style of an object item
|
|
|
|
@since 1.9]]
|
|
get {
|
|
}
|
|
set {
|
|
}
|
|
values {
|
|
style: string; [[The style of object item]]
|
|
}
|
|
}
|
|
@property disabled {
|
|
[[Control the disabled state of a widget item.
|
|
|
|
Elementary object item can be disabled, in which state they won't
|
|
receive input and, in general, will be themed differently from
|
|
their normal state, usually greyed out. Useful for contexts
|
|
where you don't want your users to interact with some of the
|
|
parts of you interface.
|
|
|
|
This sets the state for the widget item, either disabling it or
|
|
enabling it back.]]
|
|
get {
|
|
}
|
|
set {
|
|
}
|
|
values {
|
|
disable: bool; [[$true, if the widget item is disabled, $false if it's enabled (or on errors)]]
|
|
}
|
|
}
|
|
access_order_get {
|
|
[[Get highlight order
|
|
|
|
@since 1.8]]
|
|
return: const(list<Efl.Canvas.Object>); [[List of evas canvas objects]]
|
|
}
|
|
access_order_set {
|
|
[[Set highlight order
|
|
|
|
@since 1.8]]
|
|
params {
|
|
@in objs: list<Efl.Canvas.Object> @owned; [[Order of objects to pass highlight]]
|
|
}
|
|
}
|
|
widget_get @const {
|
|
[[Get the widget object's handle which contains a given item
|
|
|
|
Note: This returns the widget object itself that an item belongs to.
|
|
Note: Every elm_object_item supports this API]]
|
|
return: Efl.Canvas.Object; [[The widget object]]
|
|
}
|
|
del {
|
|
[[Delete the given item.]]
|
|
}
|
|
pre_notify_del @protected {
|
|
[[notify deletion of widget item]]
|
|
legacy: null;
|
|
}
|
|
tooltip_text_set {
|
|
[[Set the text to be shown in a given object item's tooltips.
|
|
|
|
Setup the text as tooltip to object. The item can have only one tooltip,
|
|
so any previous tooltip data - set with this function or
|
|
@.tooltip_content_cb_set - is removed.
|
|
|
|
See: elm_object_tooltip_text_set() for more details.]]
|
|
params {
|
|
text: string; [[The text to set in the content.]]
|
|
}
|
|
}
|
|
tooltip_translatable_text_set @protected {
|
|
[[Set widget item tooltip as a text string]]
|
|
legacy: null;
|
|
params {
|
|
text: string; [[Tooltip text]]
|
|
}
|
|
}
|
|
tooltip_unset {
|
|
[[Unset tooltip from item.
|
|
|
|
Remove tooltip from item. The callback provided as del_cb to
|
|
@.tooltip_content_cb_set will be called to notify
|
|
it is not used anymore.
|
|
|
|
See: elm_object_tooltip_unset() for more details.
|
|
See: @.tooltip_content_cb_set]]
|
|
}
|
|
cursor_unset {
|
|
[[Unset any custom mouse pointer/cursor decoration set to be
|
|
shown, when the mouse pointer is over the given
|
|
item, thus making it show the default cursor again.
|
|
|
|
Use this call to undo any custom settings on this item's cursor
|
|
decoration, bringing it back to defaults (no custom style set).
|
|
|
|
See: elm_object_cursor_unset()
|
|
See: @.cursor.set]]
|
|
}
|
|
part_content_unset {
|
|
[[Unset a content of an object item
|
|
|
|
Note: Elementary object items may have many contents]]
|
|
params {
|
|
part: string; [[The content part name to unset (NULL for the default content)]]
|
|
}
|
|
return: Efl.Canvas.Object; [[Content object]]
|
|
}
|
|
part_text_custom_update @protected {
|
|
[[Update additional text part content]]
|
|
legacy: null;
|
|
}
|
|
signal_callback_add {
|
|
[[Add a callback for a signal emitted by object item edje.
|
|
|
|
This function connects a callback function to a signal emitted by the
|
|
edje object of the object item.
|
|
Globs can occur in either the emission or source name.
|
|
|
|
@since 1.8]]
|
|
params {
|
|
emission: string; [[The signal's name.]]
|
|
source: string; [[The signal's source.]]
|
|
func: Elm_Object_Item_Signal_Cb; [[The callback function to be executed when the signal is emitted.]]
|
|
data: void_ptr; [[A pointer to data to pass to the callback function.]]
|
|
}
|
|
}
|
|
signal_callback_del {
|
|
[[Remove a signal-triggered callback from a object item edje object.
|
|
|
|
This function removes the last callback, previously attached to
|
|
a signal emitted by an underlying Edje object of $it, whose
|
|
parameters $emission, $source and $func match exactly with
|
|
those passed to a previous call to
|
|
@.signal_callback_add. The data pointer that was passed
|
|
to this call will be returned.
|
|
|
|
See: @.signal_callback_add
|
|
|
|
@since 1.8]]
|
|
params {
|
|
emission: string; [[The signal's name.]]
|
|
source: string; [[The signal's source.]]
|
|
func: Elm_Object_Item_Signal_Cb; [[The callback function to be executed when the signal is emitted.]]
|
|
}
|
|
return: void_ptr; [[The data pointer of the signal callback or $NULL, on errors.]]
|
|
}
|
|
signal_emit {
|
|
[[Send a signal to the edje object of the widget item.
|
|
|
|
This function sends a signal to the edje object of the obj item. An
|
|
edje program can respond to a signal by specifying matching
|
|
'signal' and 'source' fields.
|
|
Don't use this unless you want to also handle resetting of part states to default on
|
|
every unrealize in case of genlist/gengrid.]]
|
|
params {
|
|
emission: string; [[The signal's name.]]
|
|
source: string; [[The signal's source.]]
|
|
}
|
|
}
|
|
access_info_set {
|
|
[[Set the text to read out when in accessibility mode]]
|
|
params {
|
|
txt: string; [[The text that describes the widget to people with poor or no vision]]
|
|
}
|
|
}
|
|
access_object_get @const {
|
|
[[Get an accessible object of the object item.
|
|
|
|
@since 1.8]]
|
|
return: Efl.Canvas.Object; [[Accessible object of the object item or NULL for any error]]
|
|
}
|
|
domain_translatable_part_text_set {
|
|
[[Set the text for an object item's part, marking it as translatable.
|
|
|
|
The string to set as $text must be the original one. Do not pass the
|
|
return of $gettext() here. Elementary will translate the string
|
|
internally and set it on the object item using
|
|
@.part_text.set, also storing the original string so that it
|
|
can be automatically translated when the language is changed with
|
|
elm_language_set(). The $domain will be stored along to find the
|
|
translation in the correct catalog. It can be NULL, in which case it will use
|
|
whatever domain was set by the application with $textdomain(). This is
|
|
useful in case you are building a library on top of Elementary that will have
|
|
its own translatable strings, that should not be mixed with those of programs
|
|
using the library.
|
|
|
|
@since 1.8]]
|
|
params {
|
|
part: string; [[The name of the part to set]]
|
|
domain: string; [[The translation domain to use]]
|
|
label: string; [[The original, non-translated text to set]]
|
|
}
|
|
}
|
|
translatable_part_text_get @const {
|
|
[[Get the original string set as translatable for an object item.
|
|
|
|
When setting translated strings, the function @.part_text.get
|
|
will return the translation returned by $gettext(). To get the original
|
|
string use this function.
|
|
|
|
@since 1.8]]
|
|
params {
|
|
part: string; [[The name of the part that was set]]
|
|
}
|
|
return: string; [[The original, untranslated string]]
|
|
}
|
|
translate @protected {
|
|
[[Query translate]]
|
|
legacy: null;
|
|
}
|
|
domain_part_text_translatable_set {
|
|
[[Mark the part text to be translatable or not.
|
|
|
|
Once you mark the part text to be translatable, the text will be translated
|
|
internally regardless of @.part_text.set and
|
|
@.domain_translatable_part_text_set. In other case, if you
|
|
set the Elementary policy that all text will be translatable in default, you
|
|
can set the part text to not be translated by calling this API.
|
|
|
|
See: @.domain_translatable_part_text_set
|
|
See: @.part_text.set
|
|
See: elm_policy()
|
|
|
|
@since 1.8]]
|
|
params {
|
|
part: string; [[The part name of the translatable text]]
|
|
domain: string; [[The translation domain to use]]
|
|
translatable: bool; [[$true, the part text will be translated internally. $false, otherwise.]]
|
|
}
|
|
}
|
|
track {
|
|
[[This returns track object of the item.
|
|
|
|
Note: This gets a rectangle object that represents the object item's internal
|
|
object. If you want to check the geometry, visibility of the item, you
|
|
can call the evas apis such as evas_object_geometry_get(),
|
|
evas_object_visible_get() to the track object. Note that all of the
|
|
widget items may/may not have the internal object so this api may
|
|
return $NULL if the widget item doesn't have it. Additionally, the
|
|
widget item is managed/controlled by the widget, the widget item could
|
|
be changed(moved, resized even deleted) anytime by it's own widget's
|
|
decision. So please dont' change the track object as well as don't
|
|
keep the track object in your side as possible but get the track object
|
|
at the moment you need to refer. Otherwise, you need to add some
|
|
callbacks to the track object to track it's attributes changes.
|
|
|
|
Warning: After use the track object, please call the
|
|
@.untrack() paired to elm_object_item_track
|
|
definitely to free the track object properly. Don't delete the
|
|
track object.
|
|
|
|
See: @.untrack
|
|
See: @.track_get
|
|
|
|
@since 1.8]]
|
|
return: Efl.Canvas.Object; [[The track object]]
|
|
}
|
|
untrack {
|
|
[[This retrieve the track object of the item.
|
|
|
|
Note: This retrieves the track object that was returned from
|
|
@.track.
|
|
|
|
See: @.track
|
|
See: @.track_get
|
|
|
|
@since 1.8]]
|
|
}
|
|
track_get @const {
|
|
[[Get the track object reference count.
|
|
|
|
Note: This gets the reference count for the track object. Whenever you call
|
|
the @.track, the reference count will be increased by
|
|
one. Likely the reference count will be decreased again when you call
|
|
the @.untrack. Unless the reference count reaches to
|
|
zero, the track object won't be deleted. So please be sure to call
|
|
@.untrack() paired to the elm_object_item_track call
|
|
count.
|
|
|
|
See: @.track
|
|
See: @.track_get
|
|
|
|
@since 1.8]]
|
|
return: int; [[Track object reference count]]
|
|
}
|
|
track_cancel @protected {
|
|
[[Query track_cancel]]
|
|
legacy: null;
|
|
}
|
|
del_cb_set {
|
|
[[Set the function to be called when an item from the widget is
|
|
freed.
|
|
|
|
Note: Every elm_object_item supports this API]]
|
|
params {
|
|
del_cb: Evas_Smart_Cb @nullable; [[The function called]]
|
|
}
|
|
}
|
|
tooltip_content_cb_set {
|
|
[[Set the content to be shown in the tooltip item.
|
|
|
|
Setup the tooltip to item. The item can have only one tooltip,
|
|
so any previous tooltip data is removed. $func(with $data) will
|
|
be called every time that need show the tooltip and it should
|
|
return a valid Evas_Object. This object is then managed fully by
|
|
tooltip system and is deleted when the tooltip is gone.
|
|
|
|
See: elm_object_tooltip_content_cb_set() for more details.]]
|
|
params {
|
|
func: Elm_Tooltip_Item_Content_Cb @nullable; [[The function used to create the tooltip contents.]]
|
|
data: const(void_ptr) @optional; [[What to provide to $func as callback data/context.]]
|
|
del_cb: Evas_Smart_Cb @optional; [[Called when data is not needed anymore, either when another callback replaces $func, the tooltip is unset with @.tooltip_unset or the owner $item dies. This callback receives as the first parameter the given $data, and $event_info is the item.]]
|
|
|
|
}
|
|
}
|
|
access_register {
|
|
[[Register object item as an accessible object.
|
|
|
|
@since 1.8]]
|
|
return: Efl.Canvas.Object; [[Accessible object of the object item or NULL for any error]]
|
|
}
|
|
access_unregister {
|
|
[[Unregister accessible object of the object item.
|
|
|
|
@since 1.8]]
|
|
}
|
|
access_order_unset {
|
|
[[Unset highlight order
|
|
|
|
@since 1.8]]
|
|
}
|
|
disable @protected {
|
|
[[Disable widget item]]
|
|
legacy: null;
|
|
}
|
|
del_pre @protected {
|
|
[[Delete pre widget item]]
|
|
legacy: null;
|
|
return: bool; [[$true on success, $false otherwise]]
|
|
}
|
|
focus_next_object_get @const {
|
|
[[Get the next object with specific focus direction.
|
|
|
|
@since 1.16]]
|
|
params {
|
|
dir: Efl.Ui.Focus.Direction; [[Focus direction]]
|
|
}
|
|
return: Efl.Canvas.Object; [[Focus next object]]
|
|
}
|
|
focus_next_object_set {
|
|
[[Set the next object with specific focus direction.
|
|
|
|
@since 1.16]]
|
|
params {
|
|
next: Efl.Canvas.Object @nullable; [[Focus next object]]
|
|
dir: Efl.Ui.Focus.Direction; [[Focus direction]]
|
|
}
|
|
}
|
|
focus_next_item_get @const {
|
|
[[Get the next object item with specific focus direction.
|
|
|
|
@since 1.16]]
|
|
params {
|
|
dir: Efl.Ui.Focus.Direction; [[Focus direction]]
|
|
}
|
|
return: Elm.Widget.Item; [[Focus next object item]]
|
|
}
|
|
focus_next_item_set {
|
|
[[Set the next object item with specific focus direction.
|
|
|
|
@since 1.16]]
|
|
params {
|
|
next_item: Elm.Widget.Item @nullable; [[Focus next object item]]
|
|
dir: Efl.Ui.Focus.Direction; [[Focus direction]]
|
|
}
|
|
}
|
|
}
|
|
implements {
|
|
Efl.Object.constructor;
|
|
Efl.Object.destructor;
|
|
Efl.Access.state_set { get; }
|
|
Efl.Access.attributes { get; }
|
|
Efl.Access.Component.extents { get; set; }
|
|
Efl.Access.Component.alpha { get; }
|
|
Efl.Access.Component.layer { get; }
|
|
Efl.Access.Component.focus_grab;
|
|
}
|
|
}
|