elm_entry: remove all legacy usage from eo files

this takes the current generated output from eolian for legacy code in
efl and adds it to the tree, then removes legacy references from the
corresponding eo files. in the case where the entire eo file was for
a legacy object, that eo file has been removed from the tree

ref T7724

Reviewed-by: Cedric BAIL <cedric.bail@free.fr>
Differential Revision: https://phab.enlightenment.org/D8166
devs/q66/eolian-beta-types
Mike Blumenkrantz 4 years ago committed by Cedric BAIL
parent 5c41b53a3f
commit a8057a3403
  1. 5
      src/Makefile_Elementary.am
  2. 2
      src/bin/elementary/test_entry.c
  3. 2
      src/lib/elementary/efl_ui_layout.c
  4. 2
      src/lib/elementary/efl_ui_spin_button.c
  5. 2
      src/lib/elementary/efl_ui_tags.c
  6. 2
      src/lib/elementary/elc_combobox.c
  7. 2
      src/lib/elementary/elc_fileselector.c
  8. 2
      src/lib/elementary/elc_fileselector_entry.c
  9. 2
      src/lib/elementary/elc_multibuttonentry.c
  10. 2
      src/lib/elementary/elm_entry.c
  11. 928
      src/lib/elementary/elm_entry.eo
  12. 1190
      src/lib/elementary/elm_entry_eo.c
  13. 1448
      src/lib/elementary/elm_entry_eo.h
  14. 582
      src/lib/elementary/elm_entry_eo.legacy.c
  15. 1252
      src/lib/elementary/elm_entry_eo.legacy.h
  16. 2
      src/lib/elementary/elm_entry_legacy.h
  17. 2
      src/lib/elementary/elm_spinner.c
  18. 2
      src/lib/elementary/elm_view_form.c
  19. 2
      src/lib/elementary/elm_widget_entry.h
  20. 3
      src/lib/elementary/meson.build
  21. 2
      src/modules/elementary/prefs/elm_entry.c

@ -187,7 +187,6 @@ elm_private_eolian_files = \
elm_legacy_eolian_files = \
lib/elementary/efl_ui_clock_legacy.eo \
lib/elementary/elm_interface_fileselector.eo \
lib/elementary/elm_entry.eo \
lib/elementary/elm_fileselector.eo \
lib/elementary/elm_gengrid.eo \
lib/elementary/elm_gengrid_pan.eo \
@ -345,6 +344,8 @@ lib/elementary/elm_diskselector_eo.legacy.c \
lib/elementary/elm_diskselector_eo.c \
lib/elementary/elm_diskselector_item_eo.legacy.c \
lib/elementary/elm_diskselector_item_eo.c \
lib/elementary/elm_entry_eo.legacy.c \
lib/elementary/elm_entry_eo.c \
lib/elementary/elm_hoversel_eo.c \
lib/elementary/elm_hoversel_item_eo.c \
lib/elementary/elm_hoversel_item_eo.legacy.c
@ -428,6 +429,8 @@ lib/elementary/elm_diskselector_eo.h \
lib/elementary/elm_diskselector_eo.legacy.h \
lib/elementary/elm_diskselector_item_eo.h \
lib/elementary/elm_diskselector_item_eo.legacy.h \
lib/elementary/elm_entry_eo.h \
lib/elementary/elm_entry_eo.legacy.h \
lib/elementary/elm_hoversel_eo.h \
lib/elementary/elm_hoversel_eo.legacy.h \
lib/elementary/elm_hoversel_item_eo.h \

@ -5,7 +5,7 @@
#include <Elementary.h>
// FIXME: elm_entry is not part of EO API, the below test cases may be useless
#include "elm_entry.eo.h"
#include "elm_entry_eo.h"
#include "elm_popup.eo.h"
static void

@ -13,7 +13,7 @@
#include "elm_priv.h"
#include "elm_widget_layout.h"
#include "elm_part_helper.h"
#include "elm_entry.eo.h"
#include "elm_entry_eo.h"
#define MY_CLASS EFL_UI_LAYOUT_BASE_CLASS
#define MY_CLASS_PFX efl_ui_layout

@ -12,7 +12,7 @@
#include "elm_priv.h"
#include "efl_ui_spin_button_private.h"
#include "efl_ui_spin_private.h"
#include "elm_entry.eo.h"
#include "elm_entry_eo.h"
#define MY_CLASS EFL_UI_SPIN_BUTTON_CLASS

@ -5,7 +5,7 @@
#include <Elementary.h>
#include "elm_priv.h"
#include "efl_ui_tags_private.h"
#include "elm_entry.eo.h"
#include "elm_entry_eo.h"
#define MY_CLASS EFL_UI_TAGS_CLASS

@ -10,7 +10,7 @@
#include <Elementary.h>
#include "elm_priv.h"
#include "elm_widget_combobox.h"
#include "elm_entry.eo.h"
#include "elm_entry_eo.h"
#include "elm_genlist.eo.h"
#include "elm_hover.eo.h"

@ -21,7 +21,7 @@
#include "elm_fileselector_entry.eo.h"
#include "elm_interface_fileselector.h"
#include "elm_widget_fileselector.h"
#include "elm_entry.eo.h"
#include "elm_entry_eo.h"
#include "elm_fileselector.eo.h"
#include "elm_genlist.eo.h"
#include "elm_gengrid.eo.h"

@ -13,7 +13,7 @@
#include "elm_fileselector_entry.eo.h"
#include "elm_interface_fileselector.h"
#include "elm_widget_fileselector_entry.h"
#include "elm_entry.eo.h"
#include "elm_entry_eo.h"
#include "elm_fileselector.eo.h"
#include "elm_fileselector_entry_part.eo.h"

@ -13,7 +13,7 @@
#include "elm_priv.h"
#include "elm_widget_multibuttonentry.h"
#include "elm_multibuttonentry_part.eo.h"
#include "elm_entry.eo.h"
#include "elm_entry_eo.h"
#include "elm_part_helper.h"
#define MY_CLASS ELM_MULTIBUTTONENTRY_CLASS

@ -6230,4 +6230,4 @@ ELM_LAYOUT_TEXT_ALIASES_IMPLEMENT(MY_CLASS_PFX)
ELM_LAYOUT_TEXT_ALIASES_OPS(MY_CLASS_PFX), \
ELM_LAYOUT_SIZING_EVAL_OPS(elm_entry)
#include "elm_entry.eo.c"
#include "elm_entry_eo.c"

@ -1,928 +0,0 @@
import elm_general;
type Elm_Entry_Item_Provider_Cb: __undefined_type; [[Elementary entry item provider callback type]]
type Elm_Entry_Filter_Cb: __undefined_type; [[Elementary entry filter callback type]]
class Elm.Entry extends Efl.Ui.Layout_Base implements Elm.Interface_Scrollable, Efl.Ui.Clickable,
Efl.Access.Text, Efl.Access.Editable.Text, Efl.File,
Efl.Ui.Selectable, Efl.Ui.Scrollable, Efl.Access.Widget.Action,
Efl.Ui.Legacy
{
[[Elementary entry class]]
legacy_prefix: elm_entry;
eo_prefix: elm_obj_entry;
event_prefix: elm_entry;
methods {
@property scrollable {
set {
[[Enable or disable scrolling in entry
Normally the entry is not scrollable unless you enable it with this call.
]]
}
get {
[[Get the scrollable state of the entry
Normally the entry is not scrollable. This gets the scrollable state
of the entry.
]]
}
values {
scroll: bool; [[$true if it is to be scrollable, $false otherwise.]]
}
}
@property input_panel_show_on_demand {
set {
[[Set the attribute to show the input panel in case of only an user's explicit Mouse Up event.
It doesn't request to show the input panel even though it has focus.
@since 1.9
]]
}
get {
[[Get the attribute to show the input panel in case of only an user's explicit Mouse Up event.
@since 1.9
]]
}
values {
ondemand: bool; [[If $true, the input panel will be shown in case of only Mouse up event.
(Focus event will be ignored.)
]]
}
}
@property context_menu_disabled {
set {
[[This disables the entry's contextual (longpress) menu.]]
}
get {
[[This returns whether the entry's contextual (longpress) menu is
disabled.
]]
}
values {
disabled: bool; [[If $true, the menu is disabled.]]
}
}
@property cnp_mode {
set {
[[Control pasting of text and images for the widget.
Normally the entry allows both text and images to be pasted.
By setting cnp_mode to be #ELM_CNP_MODE_NO_IMAGE, this prevents images from being copy or past.
By setting cnp_mode to be #ELM_CNP_MODE_PLAINTEXT, this remove all tags in text .
Note: This only changes the behaviour of text.
]]
}
get {
[[Getting elm_entry text paste/drop mode.
Normally the entry allows both text and images to be pasted.
This gets the copy & paste mode of the entry.
]]
}
values {
cnp_mode: Elm.Cnp_Mode; [[One of #Elm_Cnp_Mode: #ELM_CNP_MODE_MARKUP, #ELM_CNP_MODE_NO_IMAGE, #ELM_CNP_MODE_PLAINTEXT.]]
}
}
@property file_text_format {
[[Text format used to load and save the file, which could be plain text or markup text.
Default is $ELM_TEXT_FORMAT_PLAIN_UTF8, if you want to use
$ELM_TEXT_FORMAT_MARKUP_UTF8 then you need to set the text format
before calling @Efl.File.load.
You could also set it before a call to @.file_save
in order to save with the given format.
]]
set {
[[Use it before calling @Efl.File.load or @.file_save.]]
}
values {
format: Elm.Text_Format(Elm.Text_Format.plain_utf8); [[ The file format ]]
}
}
@property input_panel_language {
set {
[[Set the language mode of the input panel.
This API can be used if you want to show the alphabet keyboard mode.
]]
}
get {
[[Get the language mode of the input panel.]]
}
values {
lang: Elm.Input.Panel.Lang; [[Language to be set to the input panel.]]
}
}
@property selection_handler_disabled {
set {
[[This disabled the entry's selection handlers.]]
}
get {
[[This returns whether the entry's selection handlers are disabled.]]
legacy: null;
}
values {
disabled: bool; [[If $true, the selection handlers are disabled.]]
}
}
@property input_panel_layout_variation {
set {
[[Set the input panel layout variation of the entry
@since 1.8
]]
}
get {
[[Get the input panel layout variation of the entry
@since 1.8
]]
}
values {
variation: int; [[Layout variation type.]]
}
}
@property autocapital_type {
set {
[[Set the autocapitalization type on the immodule.]]
}
get {
[[Get the autocapitalization type on the immodule.]]
}
values {
autocapital_type: Elm.Autocapital.Type; [[The type of autocapitalization.]]
}
}
@property editable {
set {
[[Sets if the entry is to be editable or not.
By default, entries are editable and when focused, any text input by the
user will be inserted at the current cursor position. But calling this
function with $editable as $false will prevent the user from
inputting text into the entry.
The only way to change the text of a non-editable entry is to use
\@ref elm_object_text_set, \@ref elm_entry_entry_insert and other related
functions.
]]
}
get {
[[Get whether the entry is editable or not.]]
}
values {
editable: bool; [[If $true, user input will be inserted in the entry,
if not, the entry is read-only and no user input is allowed.]]
}
}
@property anchor_hover_style {
set {
[[Set the style that the hover should use
When creating the popup hover, entry will request that it's
themed according to $style.
Setting style no $null means disabling automatic hover.
]]
}
get {
[[Get the style that the hover should use.]]
}
values {
style: string @nullable; [[The style to use for the underlying hover.]]
}
}
@property single_line {
set {
[[Sets the entry to single line mode.
In single line mode, entries don't ever wrap when the text reaches the
edge, and instead they keep growing horizontally. Pressing the $Enter
key will generate an $"activate" event instead of adding a new line.
When $single_line is $false, line wrapping takes effect again
and pressing enter will break the text into a different line
without generating any events.
]]
}
get {
[[Get whether the entry is set to be single line.]]
}
values {
single_line: bool; [[If $true, the text in the entry
will be on a single line.]]
}
}
@property password {
set {
[[Sets the entry to password mode.
In password mode, entries are implicitly single line and the display of
any text in them is replaced with asterisks (*).
]]
}
get {
[[Get whether the entry is set to password mode.]]
}
values {
password: bool; [[If $true, password mode is enabled.]]
}
}
@property input_panel_return_key_disabled {
set {
[[Set the return key on the input panel to be disabled.]]
}
get {
[[Get whether the return key on the input panel should be disabled or not.]]
}
values {
disabled: bool; [[The state to put in in: $true for
disabled, $false for enabled.]]
}
}
@property autosave {
set {
[[This sets the entry object to 'autosave' the loaded text file or not.]]
}
get {
[[This gets the entry object's 'autosave' status.]]
}
values {
auto_save: bool; [[Autosave the loaded file or not.]]
}
}
@property anchor_hover_parent {
set {
[[Set the parent of the hover popup
Sets the parent object to use by the hover created by the entry
when an anchor is clicked.
]]
}
get {
[[Get the parent of the hover popup
Get the object used as parent for the hover created by the entry
widget. If no parent is set, the same entry object will be used.
]]
}
values {
parent: Efl.Canvas.Object @nullable; [[The object to use as parent for the hover.]]
}
}
@property prediction_allow {
set {
[[Set whether the entry should allow to use the text prediction.]]
}
get {
[[Get whether the entry should allow to use the text prediction.]]
}
values {
prediction: bool; [[Whether the entry should allow to use the text prediction.]]
}
}
@property input_hint {
set {
[[Sets the input hint which allows input methods to fine-tune their behavior.]]
}
get {
[[Gets the value of input hint.]]
}
values {
hints: Elm.Input.Hints; [[Input hint.]]
}
}
@property input_panel_layout {
set {
[[Set the input panel layout of the entry.]]
}
get {
[[Get the input panel layout of the entry.]]
}
values {
layout: Elm.Input.Panel.Layout(Elm.Input.Panel.Layout.invalid); [[Layout type.]]
}
}
@property input_panel_return_key_type {
set {
[[Set the "return" key type. This type is used to set string or icon on the "return" key of the input panel.
An input panel displays the string or icon associated with this type.
Regardless of return key type, "activated" event will be generated when pressing return key in single line entry.
]]
}
get {
[[Get the "return" key type.]]
}
values {
return_key_type: Elm.Input.Panel.Return_Key.Type; [[The type of "return" key on the input panel.]]
}
}
@property input_panel_enabled {
set {
[[Sets the attribute to show the input panel automatically.]]
}
get {
[[Get the attribute to show the input panel automatically.]]
}
values {
enabled: bool; [[If $true, the input panel is appeared when entry is clicked or has a focus.]]
}
}
@property line_wrap {
set {
[[Set the line wrap type to use on multi-line entries.
Sets the wrap type used by the entry to any of the specified in
Elm_Wrap_Type. This tells how the text will be implicitly cut into a new
line (without inserting a line break or paragraph separator) when it
reaches the far edge of the widget.
Note that this only makes sense for multi-line entries. A widget set
to be single line will never wrap.
]]
}
get {
[[Get the wrap mode the entry was set to use.]]
}
values {
wrap: Elm.Wrap.Type; [[The wrap mode to use. See Elm_Wrap_Type for details on them.]]
}
}
@property cursor_pos {
set {
[[Sets the cursor position in the entry to the given value
The value in $pos is the index of the character position within the
contents of the string as returned by @.cursor_pos.get.
]]
}
get {
[[Get the current position of the cursor in the entry.]]
}
values {
pos: int; [[The position of the cursor.]]
}
}
@property icon_visible {
set {
[[Sets the visibility of the left-side widget of the entry,
set by \@ref elm_object_part_content_set.]]
}
values {
setting: bool; [[$true if the object should be displayed,
$false if not.]]
}
}
@property cursor_line_end {
set {
[[This moves the cursor to the end of the current line.]]
}
}
@property select_region {
set {
[[This selects a region of text within the entry.
@since 1.9
]]
}
get {
[[Get the current position of the selection cursors in the entry.
@since 1.18
]]
}
values {
start: int; [[The starting position.]]
end: int; [[The end position.]]
}
}
@property input_panel_return_key_autoenabled {
set {
[[Set whether the return key on the input panel is disabled automatically when entry has no text.
If $enabled is $true, The return key on input panel is disabled when the entry has no text.
The return key on the input panel is automatically enabled when the entry has text.
The default value is $false.
]]
}
values {
enabled: bool; [[If $enabled is $true, the return key is automatically disabled when the entry has no text.]]
}
}
@property end_visible {
set {
[[Sets the visibility of the end widget of the entry, set by
\@ref elm_object_part_content_set(ent, "end", content).]]
}
values {
setting: bool; [[$true if the object should be displayed,
false if not.]]
}
}
@property cursor_begin {
set {
[[This moves the cursor to the beginning of the entry.]]
}
}
@property cursor_line_begin {
set {
[[This moves the cursor to the beginning of the current line.]]
}
}
@property cursor_end {
set {
[[This moves the cursor to the end of the entry.]]
}
}
@property textblock {
get {
[[
Returns the actual textblock object of the entry.
This function exposes the internal textblock object that actually
contains and draws the text. This should be used for low-level
manipulations that are otherwise not possible.
Changing the textblock directly from here will not notify edje/elm to
recalculate the textblock size automatically, so any modifications
done to the textblock returned by this function should be followed by
a call to \@ref elm_entry_calc_force.
The return value is marked as const as an additional warning.
One should not use the returned object with any of the generic evas
functions (geometry_get/resize/move and etc), but only with the textblock
functions; The former will either not work at all, or break the correct
functionality.
IMPORTANT: Many functions may change (i.e delete and create a new one)
the internal textblock object. Do NOT cache the returned object, and try
not to mix calls on this object with regular elm_entry calls (which may
change the internal textblock object). This applies to all cursors
returned from textblock calls, and all the other derivative values.
]]
return: Efl.Canvas.Object; [[Textblock object]]
}
}
@property textblock_cursor_geometry {
get {
[[This function returns the geometry of the cursor.
It's useful if you want to draw something on the cursor (or where it is),
or for example in the case of scrolled entry where you want to show the
cursor.
]]
legacy: elm_entry_cursor_geometry_get;
return: bool; [[$true on success, $false otherwise]]
}
values {
x: int; [[X coordinate]]
y: int; [[Y coordinate]]
w: int; [[Width]]
h: int; [[Height]]
}
}
@property imf_context {
get {
[[Returns the input method context of the entry.
This function exposes the internal input method context.
IMPORTANT: Many functions may change (i.e delete and create a new one)
the internal input method context. Do NOT cache the returned object.
]]
return: void_ptr; [[Input method context]]
}
}
@property cursor_is_format {
get {
[[Get whether a format node exists at the current cursor position.
A format node is anything that defines how the text is rendered. It can
be a visible format node, such as a line break or a paragraph separator,
or an invisible one, such as bold begin or end tag.
This function returns whether any format node exists at the current
cursor position.
]]
return: bool; [[$true if format node exists, $false otherwise]]
}
}
@property textblock_cursor_content {
get {
[[Get the character pointed by the cursor at its current position.
This function returns a string with the utf8 character stored at the
current cursor position.
Only the text is returned, any format that may exist will not be part
of the return value. You must free the string when done with \@ref free.
]]
legacy: elm_entry_cursor_content_get;
return: mstring @owned @warn_unused; [[Character]]
}
}
@property selection {
get {
[[Get any selected text within the entry.
If there's any selected text in the entry, this function returns it as
a string in markup format. $null is returned if no selection exists or
if an error occurred.
The returned value points to an internal string and should not be freed
or modified in any way. If the $entry object is deleted or its
contents are changed, the returned pointer should be considered invalid.
]]
return: string; [[Selected string]]
}
}
@property cursor_is_visible_format {
get {
[[Get if the current cursor position holds a visible format node.]]
return: bool; [[$true if position has a visible format, $false otherwise]]
}
}
@property select_allow {
[[Allow selection in the entry.
@since 1.18
]]
set {
}
get {
}
values {
allow: bool; [[If $allow is true, the text selection is allowed.]]
}
}
cursor_prev {
[[This moves the cursor one place to the left within the entry.]]
return: bool; [[$true on success, $false otherwise]]
}
text_style_user_pop {
[[Remove the style in the top of user style stack.
@since 1.7
]]
}
item_provider_prepend {
[[This prepends a custom item provider to the list for that entry
This prepends the given callback.]]
params {
@in func: Elm_Entry_Item_Provider_Cb; [[The function called to provide the item object.]]
@in data: void_ptr @optional; [[The data passed to $func.]]
}
}
input_panel_show {
[[Show the input panel (virtual keyboard) based on the input panel property of entry such as layout, autocapital types, and so on.
Note that input panel is shown or hidden automatically according to the focus state of entry widget.
This API can be used in the case of manually controlling by using @.input_panel_enabled.set(en, $false).
]]
}
imf_context_reset {
[[Reset the input method context of the entry if needed.
This can be necessary in the case where modifying the buffer would confuse on-going input method behavior.
This will typically cause the Input Method Context to clear the preedit state.
]]
}
anchor_hover_end {
[[Ends the hover popup in the entry
When an anchor is clicked, the entry widget will create a hover
object to use as a popup with user provided content. This function
terminates this popup, returning the entry to its normal state.
]]
}
cursor_selection_begin {
[[This begins a selection within the entry as though
the user were holding down the mouse button to make a selection.]]
}
cursor_down {
[[This moves the cursor one line down within the entry.]]
return: bool; [[$true on success, $false otherwise]]
}
file_save {
[[This function writes any changes made to the file set with
\@ref elm_entry_file_set.]]
}
selection_copy {
[[This executes a "copy" action on the selected text in the entry.]]
}
text_style_user_push {
[[Push the style to the top of user style stack.
If there is styles in the user style stack, the properties in the top style
of user style stack will replace the properties in current theme.
The input style is specified in format tag='property=value' (i.e. DEFAULT='font=Sans font_size=60'hilight=' + font_weight=Bold').
@since 1.7
]]
params {
@in style: string; [[The style user to push.]]
}
}
item_provider_remove {
[[This removes a custom item provider to the list for that entry
This removes the given callback. See @.item_provider_append for
more information
]]
params {
@in func: Elm_Entry_Item_Provider_Cb; [[The function called to provide the item object.]]
@in data: void_ptr @optional; [[The data passed to $func.]]
}
}
text_style_user_peek @const {
[[Get the style on the top of user style stack.
See also @.text_style_user_push.
@since 1.7
]]
return: string; [[Style]]
}
context_menu_clear {
[[This clears and frees the items in a entry's contextual (longpress)
menu.
See also @.context_menu_item_add.
]]
}
cursor_up {
[[This moves the cursor one line up within the entry.]]
return: bool; [[$true on success, $false otherwise]]
}
entry_insert {
[[Inserts the given text into the entry at the current cursor position.
This inserts text at the cursor position as if it was typed
by the user (note that this also allows markup which a user
can't just "type" as it would be converted to escaped text, so this
call can be used to insert things like emoticon items or bold push/pop
tags, other font and color change tags etc.)
If any selection exists, it will be replaced by the inserted text.
The inserted text is subject to any filters set for the widget.
See also @.markup_filter_append.
]]
params {
@in entry: string; [[The text to insert.]]
}
}
input_panel_imdata_set {
[[Set the input panel-specific data to deliver to the input panel.
This API is used by applications to deliver specific data to the input panel.
The data format MUST be negotiated by both application and the input panel.
The size and format of data are defined by the input panel.
]]
params {
@in data: const(void_ptr); [[The specific data to be set to the input panel.]]
@in len: int; [[The length of data, in bytes, to send to the input panel.]]
}
}
input_panel_imdata_get @const {
[[Get the specific data of the current input panel.]]
params {
@out data: void; [[The specific data to be got from the input panel.]]
@out len: int; [[The length of data.]]
}
}
selection_paste {
[[This executes a "paste" action in the entry.]]
}
cursor_next {
[[This moves the cursor one place to the right within the entry.]]
return: bool; [[$true on success, $false otherwise]]
}
select_none {
[[This drops any existing text selection within the entry.]]
}
input_panel_hide {
[[Hide the input panel (virtual keyboard).
Note that input panel is shown or hidden automatically according to the focus state of entry widget.
This API can be used in the case of manually controlling by using @.input_panel_enabled.set(en, $false)
]]
}
select_all {
[[This selects all text within the entry.]]
}
cursor_selection_end {
[[This ends a selection within the entry as though
the user had just released the mouse button while making a selection.]]
}
selection_cut {
[[This executes a "cut" action on the selected text in the entry.]]
}
is_empty @const {
[[Get whether the entry is empty.
Empty means no text at all. If there are any markup tags, like an item
tag for which no provider finds anything, and no text is displayed, this
function still returns $false.
]]
return: bool(true); [[$true if empty, $false otherwise]]
}
markup_filter_remove {
[[Remove a markup filter from the list
Removes the given callback from the filter list. See
@.markup_filter_append for more information.
]]
params {
@in func: Elm_Entry_Filter_Cb; [[The filter function to remove.]]
@in data: void_ptr @optional; [[The user data passed when adding the function.]]
}
}
item_provider_append {
[[This appends a custom item provider to the list for that entry
This appends the given callback. The list is walked from beginning to end
with each function called given the item href string in the text. If the
function returns an object handle other than $null (it should create an
object to do this), then this object is used to replace that item. If
not the next provider is called until one provides an item object, or the
default provider in entry does.
See also \@ref entry-items.
]]
params {
@in func: Elm_Entry_Item_Provider_Cb; [[The function called to provide the item object.]]
@in data: void_ptr @optional; [[The data passed to $func.]]
}
}
markup_filter_append {
[[Append a markup filter function for text inserted in the entry
Append the given callback to the list. This functions will be called
whenever any text is inserted into the entry, with the text to be inserted
as a parameter. The type of given text is always markup.
The callback function is free to alter the text in any way it wants, but
it must remember to free the given pointer and update it.
If the new text is to be discarded, the function can free it and set its
text parameter to $null. This will also prevent any following filters from
being called.
]]
params {
@in func: Elm_Entry_Filter_Cb; [[The function to use as text filter.]]
@in data: void_ptr @optional; [[User data to pass to $func.]]
}
}
entry_append {
[[Appends $str to the text of the entry.
Adds the text in $str to the end of any text already present in the
widget.
The appended text is subject to any filters set for the widget.
See also @.markup_filter_append.
]]
params {
@in str: string; [[The text to be appended.]]
}
}
context_menu_item_add {
[[This adds an item to the entry's contextual menu.
A longpress on an entry will make the contextual menu show up, if this
hasn't been disabled with @.context_menu_disabled.set.
By default, this menu provides a few options like enabling selection mode,
which is useful on embedded devices that need to be explicit about it,
and when a selection exists it also shows the copy and cut actions.
With this function, developers can add other options to this menu to
perform any action they deem necessary.
]]
params {
@in label: string @optional; [[The item's text label.]]
@in icon_file: string @optional; [[The item's icon file.]]
@in icon_type: Elm.Icon.Type; [[The item's icon type.]]
@in func: Evas_Smart_Cb @optional; [[The callback to execute when the item is clicked.]]
@in data: const(void_ptr) @optional; [[The data to associate with the item for related functions.]]
}
}
markup_filter_prepend {
[[Prepend a markup filter function for text inserted in the entry
Prepend the given callback to the list.]]
params {
@in func: Elm_Entry_Filter_Cb; [[The function to use as text filter.]]
@in data: void_ptr @optional; [[User data to pass to $func.]]
}
}
prediction_hint_set {
[[Sets the prediction hint to use an intelligent reply suggestion service.
@since 1.20
]]
params {
prediction_hint: string; [[The prediction hint text.]]
}
}
prediction_hint_hash_set {
[[Sets the prediction hint data at the specified key.
@since 1.21
]]
return: bool; [[$true on success, $false otherwise]]
params {
key: string; [[The key of the prediction hint.]]
value: string; [[The data to replace.]]
}
}
prediction_hint_hash_del {
[[Removes the prediction hint data identified by a key.
@since 1.21
]]
return: bool; [[$true on success, $false otherwise]]
params {
key: string; [[The key of the prediction hint.]]
}
}
}
implements {
class.constructor;
Efl.Object.constructor;
Efl.Gfx.Entity.visible { set; }
Efl.Gfx.Entity.position { set; }
Efl.Gfx.Entity.size { set; }
Efl.Canvas.Group.group_member_add;
Efl.Layout.Signal.signal_callback_add;
Efl.Layout.Signal.signal_callback_del;
Efl.Layout.Signal.signal_emit;
Efl.Layout.Calc.calc_force;
Efl.Ui.Widget.on_access_activate;
Efl.Ui.Widget.theme_apply;
Efl.Ui.Widget_Focus_Manager.focus_manager_create;
Efl.Ui.Focus.Object.on_focus_update;
Efl.Ui.Widget.interest_region { get; }
Efl.Ui.Widget.disabled {set;}
Efl.Ui.Widget.widget_sub_object_del;
Elm.Interface_Scrollable.policy { set; }
Elm.Interface_Scrollable.bounce_allow { set; }
Efl.Access.Object.state_set { get; }
Efl.Access.Object.i18n_name { get; }
Efl.Access.Text.access_text { get; }
Efl.Access.Text.string { get; }
Efl.Access.Text.attribute { get; }
Efl.Access.Text.text_attributes { get; }
Efl.Access.Text.default_attributes { get; }
Efl.Access.Text.caret_offset { get; set; }
Efl.Access.Text.character { get; }
Efl.Access.Text.character_extents { get; }
Efl.Access.Text.character_count { get; }
Efl.Access.Text.offset_at_point { get; }
Efl.Access.Text.bounded_ranges { get; }
Efl.Access.Text.range_extents { get; }
Efl.Access.Text.access_selection { get; set; }
Efl.Access.Text.selections_count { get; }
Efl.Access.Text.selection_add;
Efl.Access.Text.selection_remove;
Efl.Access.Editable.Text.text_content { set; }
Efl.Access.Editable.Text.insert;
Efl.Access.Editable.Text.copy;
Efl.Access.Editable.Text.cut;
Efl.Access.Editable.Text.delete;
Efl.Access.Editable.Text.paste;
Efl.Access.Widget.Action.elm_actions { get; }
Efl.File.file { set; }
Efl.File.load;
Efl.Part.part_get;
}
events {
activated: void; [[Called when entry got activated]]
changed: void; [[Called when entry changed]]
/* FIXME: Canm be NULL but @nullable does not work on events */
changed,user: Elm.Entry_Change_Info; [[Called when the object changed due to user interaction]]
validate: Elm.Validate_Content; [[Called when validating]]
context,open: void; [[Called when context menu was opened]]
anchor,clicked: Elm.Entry_Anchor_Info; [[Called when anchor was clicked]]
rejected: void; [[Called when entry was rejected]]
maxlength,reached: void; [[Called when maximum entry length has been reached]]
preedit,changed: void; [[Called when entry preedit changed]]
press: void; [[Called when entry pressed]]
redo,request: void; [[Called when redo was requested]]
undo,request: void; [[Called when undo was requested]]
text,set,done: void; [[Called when text set finished]]
aborted: void; [[Called when entry was aborted]]
anchor,down: Elm.Entry_Anchor_Info; [[Called on anchor down]]
anchor,hover,opened: Elm.Entry_Anchor_Hover_Info; [[Called when hover opened]]
anchor,in: Elm.Entry_Anchor_Info; [[Called on anchor in]]
anchor,out: Elm.Entry_Anchor_Info; [[Called on anchor out]]
anchor,up: Elm.Entry_Anchor_Info; [[called on anchor up]]
cursor,changed: void; [[Called on cursor changed]]
cursor,changed,manual: void; [[Called on manual cursor change]]
}
}

File diff suppressed because it is too large Load Diff

File diff suppressed because it is too large Load Diff

@ -0,0 +1,582 @@
EAPI void
elm_entry_scrollable_set(Elm_Entry *obj, Eina_Bool scroll)
{
elm_obj_entry_scrollable_set(obj, scroll);
}
EAPI Eina_Bool
elm_entry_scrollable_get(const Elm_Entry *obj)
{
return elm_obj_entry_scrollable_get(obj);
}
EAPI void
elm_entry_input_panel_show_on_demand_set(Elm_Entry *obj, Eina_Bool ondemand)
{
elm_obj_entry_input_panel_show_on_demand_set(obj, ondemand);
}
EAPI Eina_Bool
elm_entry_input_panel_show_on_demand_get(const Elm_Entry *obj)
{
return elm_obj_entry_input_panel_show_on_demand_get(obj);
}
EAPI void
elm_entry_context_menu_disabled_set(Elm_Entry *obj, Eina_Bool disabled)
{
elm_obj_entry_context_menu_disabled_set(obj, disabled);
}
EAPI Eina_Bool
elm_entry_context_menu_disabled_get(const Elm_Entry *obj)
{
return elm_obj_entry_context_menu_disabled_get(obj);
}
EAPI void
elm_entry_cnp_mode_set(Elm_Entry *obj, Elm_Cnp_Mode cnp_mode)
{
elm_obj_entry_cnp_mode_set(obj, cnp_mode);
}
EAPI Elm_Cnp_Mode
elm_entry_cnp_mode_get(const Elm_Entry *obj)
{
return elm_obj_entry_cnp_mode_get(obj);
}
EAPI void
elm_entry_file_text_format_set(Elm_Entry *obj, Elm_Text_Format format)
{
elm_obj_entry_file_text_format_set(obj, format);
}
EAPI void
elm_entry_input_panel_language_set(Elm_Entry *obj, Elm_Input_Panel_Lang lang)
{
elm_obj_entry_input_panel_language_set(obj, lang);
}
EAPI Elm_Input_Panel_Lang
elm_entry_input_panel_language_get(const Elm_Entry *obj)
{
return elm_obj_entry_input_panel_language_get(obj);
}
EAPI void
elm_entry_selection_handler_disabled_set(Elm_Entry *obj, Eina_Bool disabled)
{
elm_obj_entry_selection_handler_disabled_set(obj, disabled);
}
EAPI void
elm_entry_input_panel_layout_variation_set(Elm_Entry *obj, int variation)
{
elm_obj_entry_input_panel_layout_variation_set(obj, variation);
}
EAPI int
elm_entry_input_panel_layout_variation_get(const Elm_Entry *obj)
{
return elm_obj_entry_input_panel_layout_variation_get(obj);
}
EAPI void
elm_entry_autocapital_type_set(Elm_Entry *obj, Elm_Autocapital_Type autocapital_type)
{
elm_obj_entry_autocapital_type_set(obj, autocapital_type);
}
EAPI Elm_Autocapital_Type
elm_entry_autocapital_type_get(const Elm_Entry *obj)
{
return elm_obj_entry_autocapital_type_get(obj);
}
EAPI void
elm_entry_editable_set(Elm_Entry *obj, Eina_Bool editable)
{
elm_obj_entry_editable_set(obj, editable);
}
EAPI Eina_Bool
elm_entry_editable_get(const Elm_Entry *obj)
{
return elm_obj_entry_editable_get(obj);
}
EAPI void
elm_entry_anchor_hover_style_set(Elm_Entry *obj, const char *style)
{
elm_obj_entry_anchor_hover_style_set(obj, style);
}
EAPI const char *
elm_entry_anchor_hover_style_get(const Elm_Entry *obj)
{
return elm_obj_entry_anchor_hover_style_get(obj);
}
EAPI void
elm_entry_single_line_set(Elm_Entry *obj, Eina_Bool single_line)
{
elm_obj_entry_single_line_set(obj, single_line);
}
EAPI Eina_Bool
elm_entry_single_line_get(const Elm_Entry *obj)
{
return elm_obj_entry_single_line_get(obj);
}
EAPI void
elm_entry_password_set(Elm_Entry *obj, Eina_Bool password)
{
elm_obj_entry_password_set(obj, password);
}
EAPI Eina_Bool
elm_entry_password_get(const Elm_Entry *obj)
{
return elm_obj_entry_password_get(obj);
}
EAPI void
elm_entry_input_panel_return_key_disabled_set(Elm_Entry *obj, Eina_Bool disabled)
{
elm_obj_entry_input_panel_return_key_disabled_set(obj, disabled);
}
EAPI Eina_Bool
elm_entry_input_panel_return_key_disabled_get(const Elm_Entry *obj)
{
return elm_obj_entry_input_panel_return_key_disabled_get(obj);
}
EAPI void
elm_entry_autosave_set(Elm_Entry *obj, Eina_Bool auto_save)
{
elm_obj_entry_autosave_set(obj, auto_save);
}
EAPI Eina_Bool
elm_entry_autosave_get(const Elm_Entry *obj)
{
return elm_obj_entry_autosave_get(obj);
}
EAPI void
elm_entry_anchor_hover_parent_set(Elm_Entry *obj, Efl_Canvas_Object *parent)
{
elm_obj_entry_anchor_hover_parent_set(obj, parent);
}
EAPI Efl_Canvas_Object *
elm_entry_anchor_hover_parent_get(const Elm_Entry *obj)
{
return elm_obj_entry_anchor_hover_parent_get(obj);
}
EAPI void
elm_entry_prediction_allow_set(Elm_Entry *obj, Eina_Bool prediction)
{
elm_obj_entry_prediction_allow_set(obj, prediction);
}
EAPI Eina_Bool
elm_entry_prediction_allow_get(const Elm_Entry *obj)
{
return elm_obj_entry_prediction_allow_get(obj);
}
EAPI void
elm_entry_input_hint_set(Elm_Entry *obj, Elm_Input_Hints hints)
{
elm_obj_entry_input_hint_set(obj, hints);
}
EAPI Elm_Input_Hints
elm_entry_input_hint_get(const Elm_Entry *obj)
{
return elm_obj_entry_input_hint_get(obj);
}
EAPI void
elm_entry_input_panel_layout_set(Elm_Entry *obj, Elm_Input_Panel_Layout layout)
{
elm_obj_entry_input_panel_layout_set(obj, layout);
}
EAPI Elm_Input_Panel_Layout
elm_entry_input_panel_layout_get(const Elm_Entry *obj)
{
return elm_obj_entry_input_panel_layout_get(obj);
}
EAPI void
elm_entry_input_panel_return_key_type_set(Elm_Entry *obj, Elm_Input_Panel_Return_Key_Type return_key_type)
{
elm_obj_entry_input_panel_return_key_type_set(obj, return_key_type);
}
EAPI Elm_Input_Panel_Return_Key_Type
elm_entry_input_panel_return_key_type_get(const Elm_Entry *obj)
{
return elm_obj_entry_input_panel_return_key_type_get(obj);
}
EAPI void
elm_entry_input_panel_enabled_set(Elm_Entry *obj, Eina_Bool enabled)
{
elm_obj_entry_input_panel_enabled_set(obj, enabled);
}
EAPI Eina_Bool
elm_entry_input_panel_enabled_get(const Elm_Entry *obj)
{
return elm_obj_entry_input_panel_enabled_get(obj);
}
EAPI void
elm_entry_line_wrap_set(Elm_Entry *obj, Elm_Wrap_Type wrap)
{
elm_obj_entry_line_wrap_set(obj, wrap);
}
EAPI Elm_Wrap_Type
elm_entry_line_wrap_get(const Elm_Entry *obj)
{
return elm_obj_entry_line_wrap_get(obj);
}
EAPI void
elm_entry_cursor_pos_set(Elm_Entry *obj, int pos)
{
elm_obj_entry_cursor_pos_set(obj, pos);
}
EAPI int
elm_entry_cursor_pos_get(const Elm_Entry *obj)
{
return elm_obj_entry_cursor_pos_get(obj);
}
EAPI void
elm_entry_icon_visible_set(Elm_Entry *obj, Eina_Bool setting)
{
elm_obj_entry_icon_visible_set(obj, setting);
}
EAPI void
elm_entry_cursor_line_end_set(Elm_Entry *obj)
{
elm_obj_entry_cursor_line_end_set(obj);
}
EAPI void
elm_entry_select_region_set(Elm_Entry *obj, int start, int end)
{
elm_obj_entry_select_region_set(obj, start, end);
}
EAPI void
elm_entry_select_region_get(const Elm_Entry *obj, int *start, int *end)
{
elm_obj_entry_select_region_get(obj, start, end);
}
EAPI void
elm_entry_input_panel_return_key_autoenabled_set(Elm_Entry *obj, Eina_Bool enabled)
{
elm_obj_entry_input_panel_return_key_autoenabled_set(obj, enabled);
}
EAPI void
elm_entry_end_visible_set(Elm_Entry *obj, Eina_Bool setting)
{
elm_obj_entry_end_visible_set(obj, setting);
}
EAPI void
elm_entry_cursor_begin_set(Elm_Entry *obj)
{
elm_obj_entry_cursor_begin_set(obj);
}
EAPI void
elm_entry_cursor_line_begin_set(Elm_Entry *obj)
{
elm_obj_entry_cursor_line_begin_set(obj);
}
EAPI void
elm_entry_cursor_end_set(Elm_Entry *obj)
{
elm_obj_entry_cursor_end_set(obj);
}
EAPI Efl_Canvas_Object *
elm_entry_textblock_get(const Elm_Entry *obj)
{
return elm_obj_entry_textblock_get(obj);
}
EAPI Eina_Bool
elm_entry_cursor_geometry_get(const Elm_Entry *obj, int *x, int *y, int *w, int *h)
{
return elm_obj_entry_textblock_cursor_geometry_get(obj, x, y, w, h);
}
EAPI void *
elm_entry_imf_context_get(const Elm_Entry *obj)
{
return elm_obj_entry_imf_context_get(obj);
}
EAPI Eina_Bool
elm_entry_cursor_is_format_get(const Elm_Entry *obj)
{
return elm_obj_entry_cursor_is_format_get(obj);
}
EAPI char *
elm_entry_cursor_content_get(const Elm_Entry *obj)
{
return elm_obj_entry_textblock_cursor_content_get(obj);
}
EAPI const char *
elm_entry_selection_get(const Elm_Entry *obj)
{
return elm_obj_entry_selection_get(obj);
}
EAPI Eina_Bool
elm_entry_cursor_is_visible_format_get(const Elm_Entry *obj)
{
return elm_obj_entry_cursor_is_visible_format_get(obj);
}
EAPI void
elm_entry_select_allow_set(Elm_Entry *obj, Eina_Bool allow)
{
elm_obj_entry_select_allow_set(obj, allow);
}
EAPI Eina_Bool
elm_entry_select_allow_get(const Elm_Entry *obj)
{
return elm_obj_entry_select_allow_get(obj);
}
EAPI Eina_Bool
elm_entry_cursor_prev(Elm_Entry *obj)
{
return elm_obj_entry_cursor_prev(obj);
}
EAPI void
elm_entry_text_style_user_pop(Elm_Entry *obj)
{
elm_obj_entry_text_style_user_pop(obj);
}
EAPI void
elm_entry_item_provider_prepend(Elm_Entry *obj, Elm_Entry_Item_Provider_Cb func, void *data)
{
elm_obj_entry_item_provider_prepend(obj, func, data);
}
EAPI void
elm_entry_input_panel_show(Elm_Entry *obj)
{
elm_obj_entry_input_panel_show(obj);
}
EAPI void
elm_entry_imf_context_reset(Elm_Entry *obj)
{
elm_obj_entry_imf_context_reset(obj);
}
EAPI void
elm_entry_anchor_hover_end(Elm_Entry *obj)
{
elm_obj_entry_anchor_hover_end(obj);
}
EAPI void
elm_entry_cursor_selection_begin(Elm_Entry *obj)
{
elm_obj_entry_cursor_selection_begin(obj);
}
EAPI Eina_Bool
elm_entry_cursor_down(Elm_Entry *obj)
{
return elm_obj_entry_cursor_down(obj);
}
EAPI void
elm_entry_file_save(Elm_Entry *obj)
{
elm_obj_entry_file_save(obj);
}
EAPI void
elm_entry_selection_copy(Elm_Entry *obj)
{
elm_obj_entry_selection_copy(obj);
}
EAPI void
elm_entry_text_style_user_push(Elm_Entry *obj, const char *style)
{
elm_obj_entry_text_style_user_push(obj, style);
}
EAPI void
elm_entry_item_provider_remove(Elm_Entry *obj, Elm_Entry_Item_Provider_Cb func, void *data)
{
elm_obj_entry_item_provider_remove(obj, func, data);
}
EAPI const char *
elm_entry_text_style_user_peek(const Elm_Entry *obj)
{
return elm_obj_entry_text_style_user_peek(obj);
}
EAPI void
elm_entry_context_menu_clear(Elm_Entry *obj)
{
elm_obj_entry_context_menu_clear(obj);
}
EAPI Eina_Bool
elm_entry_cursor_up(Elm_Entry *obj)
{
return elm_obj_entry_cursor_up(obj);
}
EAPI void
elm_entry_entry_insert(Elm_Entry *obj, const char *entry)
{
elm_obj_entry_insert(obj, entry);
}
EAPI void
elm_entry_input_panel_imdata_set(Elm_Entry *obj, const void *data, int len)
{
elm_obj_entry_input_panel_imdata_set(obj, data, len);
}
EAPI void
elm_entry_input_panel_imdata_get(const Elm_Entry *obj, void *data, int *len)
{
elm_obj_entry_input_panel_imdata_get(obj, data, len);
}
EAPI void
elm_entry_selection_paste(Elm_Entry *obj)
{
elm_obj_entry_selection_paste(obj);
}
EAPI Eina_Bool
elm_entry_cursor_next(Elm_Entry *obj)
{
return elm_obj_entry_cursor_next(obj);
}
EAPI void
elm_entry_select_none(Elm_Entry *obj)
{