2017-06-08 03:07:12 -07:00
|
|
|
import efl_text_types;
|
2016-05-24 06:11:03 -07:00
|
|
|
|
2019-02-14 08:37:02 -08:00
|
|
|
class @beta Efl.Canvas.Text extends Efl.Canvas.Object implements Efl.Text,
|
2018-04-06 04:30:40 -07:00
|
|
|
Efl.Canvas.Filter.Internal, Efl.Text_Font,
|
|
|
|
Efl.Text_Style, Efl.Text_Format, Efl.Text_Cursor,
|
2019-01-28 08:10:40 -08:00
|
|
|
Efl.Text_Annotate, Efl.Text_Markup, Efl.Text_Markup_Interactive, Efl.Ui.I18n
|
2016-05-24 06:11:03 -07:00
|
|
|
{
|
2016-11-15 07:05:06 -08:00
|
|
|
[[Efl canvas text class]]
|
2016-05-24 06:11:03 -07:00
|
|
|
methods {
|
Canvas text cursor: move to Efl.Canvas.Text namespace
Originally it was its own object.
There are some valid claims that there is no justification for it to
remain an object.
Furthermore, it's apparent that it added little benefit: changes of
each cursors, in practice, triggered a query for all objects of the
same textblock. There wasn't real advantage to have a finer resolution
of controlling the cursors with their own events.
This ports back a lot of code, and changes a lot of other code in the
higher-up widgets, such as Efl.Ui.Text and co.
The usage was replaces from:
efl_canvas_text_cursor_char_next(cur_obj)
to
efl_canvas_text_cursor_char_next(text_obj, cur_obj)
that is, it is an operations on the TEXT OBJECT, rather than on the
(now removed) cursor object.
So, one less efl object to worry about now.
Hopefully, the port went smooth.
2017-06-05 04:52:10 -07:00
|
|
|
@property is_empty {
|
|
|
|
[[Whether the object is empty (no text) or not
|
|
|
|
]]
|
|
|
|
get {
|
|
|
|
}
|
|
|
|
values {
|
|
|
|
is_empty: bool; [[$true if empty, $false otherwise]]
|
|
|
|
}
|
|
|
|
}
|
|
|
|
visible_range_get {
|
|
|
|
[[Returns the currently visible range.
|
|
|
|
|
2017-12-22 05:45:48 -08:00
|
|
|
The given $start and $end cursor act like out-variables here,
|
|
|
|
as they are set to the positions of the start and the end of the
|
Canvas text cursor: move to Efl.Canvas.Text namespace
Originally it was its own object.
There are some valid claims that there is no justification for it to
remain an object.
Furthermore, it's apparent that it added little benefit: changes of
each cursors, in practice, triggered a query for all objects of the
same textblock. There wasn't real advantage to have a finer resolution
of controlling the cursors with their own events.
This ports back a lot of code, and changes a lot of other code in the
higher-up widgets, such as Efl.Ui.Text and co.
The usage was replaces from:
efl_canvas_text_cursor_char_next(cur_obj)
to
efl_canvas_text_cursor_char_next(text_obj, cur_obj)
that is, it is an operations on the TEXT OBJECT, rather than on the
(now removed) cursor object.
So, one less efl object to worry about now.
Hopefully, the port went smooth.
2017-06-05 04:52:10 -07:00
|
|
|
visible range in the text, respectively.
|
|
|
|
]]
|
|
|
|
return: bool; [[$true on success, $false otherwise]]
|
|
|
|
params {
|
2018-04-06 04:30:40 -07:00
|
|
|
@in start: ptr(Efl.Text_Cursor_Cursor); [[Range start position]]
|
|
|
|
@in end: ptr(Efl.Text_Cursor_Cursor); [[Range end position]]
|
Canvas text cursor: move to Efl.Canvas.Text namespace
Originally it was its own object.
There are some valid claims that there is no justification for it to
remain an object.
Furthermore, it's apparent that it added little benefit: changes of
each cursors, in practice, triggered a query for all objects of the
same textblock. There wasn't real advantage to have a finer resolution
of controlling the cursors with their own events.
This ports back a lot of code, and changes a lot of other code in the
higher-up widgets, such as Efl.Ui.Text and co.
The usage was replaces from:
efl_canvas_text_cursor_char_next(cur_obj)
to
efl_canvas_text_cursor_char_next(text_obj, cur_obj)
that is, it is an operations on the TEXT OBJECT, rather than on the
(now removed) cursor object.
So, one less efl object to worry about now.
Hopefully, the port went smooth.
2017-06-05 04:52:10 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
@property style_insets {
|
|
|
|
[[Gets the left, right, top and bottom insets of the text.
|
|
|
|
|
|
|
|
The inset is any applied padding on the text.
|
|
|
|
]]
|
|
|
|
get {}
|
|
|
|
values {
|
|
|
|
l: int; [[Left padding]]
|
|
|
|
r: int; [[Right padding]]
|
|
|
|
t: int; [[Top padding]]
|
|
|
|
b: int; [[Bottom padding]]
|
|
|
|
}
|
|
|
|
}
|
2016-05-24 06:11:03 -07:00
|
|
|
@property bidi_delimiters {
|
|
|
|
[[BiDi delimiters are used for in-paragraph separation of bidi
|
2017-12-22 05:45:48 -08:00
|
|
|
segments. This is useful, for example, in the recipient fields of
|
2016-05-24 06:11:03 -07:00
|
|
|
e-mail clients where bidi oddities can occur when mixing RTL
|
|
|
|
and LTR.
|
|
|
|
]]
|
|
|
|
set {}
|
|
|
|
get {}
|
|
|
|
values {
|
2016-10-05 07:10:06 -07:00
|
|
|
delim: string; [[A null terminated string of delimiters, e.g ",|" or $null if empty]]
|
2016-05-24 06:11:03 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
@property legacy_newline {
|
2016-11-15 07:05:06 -08:00
|
|
|
[[When $true, newline character will behave as a paragraph separator.
|
2016-05-24 06:11:03 -07:00
|
|
|
]]
|
|
|
|
set {}
|
|
|
|
get {}
|
|
|
|
values {
|
2016-10-05 07:10:06 -07:00
|
|
|
mode: bool; [[$true for legacy mode, $false otherwise]]
|
2016-05-24 06:11:03 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
@property style {
|
2016-06-07 10:16:34 -07:00
|
|
|
[[The text style of the object.
|
|
|
|
|
|
|
|
$key is how you reference the style (for deletion or fetching). $NULL
|
|
|
|
as key indicates the style has the highest priority (default style).
|
|
|
|
The style priority is the order of creation, styles created first
|
|
|
|
are applied first with the exception of $NULL which is implicitly
|
|
|
|
first.
|
|
|
|
|
|
|
|
Set $style to $NULL to delete it.
|
|
|
|
]]
|
2016-05-24 06:11:03 -07:00
|
|
|
set {
|
|
|
|
}
|
|
|
|
get {
|
|
|
|
}
|
2016-06-07 10:16:34 -07:00
|
|
|
keys {
|
|
|
|
key: string; [[The name to the style. $NULL is the default style]]
|
|
|
|
}
|
2016-05-24 06:11:03 -07:00
|
|
|
values {
|
2016-10-05 07:10:06 -07:00
|
|
|
style: string; [[The style]]
|
2016-05-24 06:11:03 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
@property size_formatted {
|
|
|
|
[[The formatted width and height.
|
|
|
|
|
|
|
|
This calculates the actual size after restricting the
|
|
|
|
textblock to the current size of the object.
|
|
|
|
|
|
|
|
The main difference between this and @.size_native.get
|
|
|
|
is that the "native" function does not wrapping into account
|
|
|
|
it just calculates the real width of the object if it was
|
|
|
|
placed on an infinite canvas, while this function gives the
|
|
|
|
size after wrapping according to the size restrictions of the
|
|
|
|
object.
|
|
|
|
|
|
|
|
For example for a textblock containing the text:
|
|
|
|
"You shall not pass!" with no margins or padding and assuming
|
|
|
|
a monospace font and a size of 7x10 char widths (for simplicity)
|
|
|
|
has a native size of 19x1 and a formatted size of 5x4.
|
|
|
|
]]
|
|
|
|
get {}
|
|
|
|
values {
|
2017-05-15 01:23:11 -07:00
|
|
|
w: int; [[The width of the object.]]
|
|
|
|
h: int; [[The height of the object.]]
|
2016-05-24 06:11:03 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
@property size_native {
|
|
|
|
[[The native width and height.
|
|
|
|
|
|
|
|
This calculates the actual size without taking account the
|
|
|
|
current size of the object.
|
|
|
|
|
|
|
|
The main difference between this and @.size_formatted.get
|
|
|
|
is that the "native" function does not take wrapping into
|
|
|
|
account it just calculates the real width of the object if
|
|
|
|
it was placed on an infinite canvas, while the "formatted"
|
|
|
|
function gives the size after wrapping text according to
|
|
|
|
the size restrictions of the object.
|
|
|
|
|
|
|
|
For example for a textblock containing the text:
|
|
|
|
"You shall not pass!" with no margins or padding and assuming
|
|
|
|
a monospace font and a size of 7x10 char widths (for simplicity)
|
|
|
|
has a native size of 19x1 and a formatted size of 5x4.
|
|
|
|
]]
|
|
|
|
get {}
|
|
|
|
values {
|
2017-05-15 01:23:11 -07:00
|
|
|
w: int; [[The width returned.]]
|
|
|
|
h: int; [[The height returned.]]
|
2016-05-24 06:11:03 -07:00
|
|
|
}
|
|
|
|
}
|
2018-04-17 11:09:44 -07:00
|
|
|
range_text_get @const {
|
Canvas text cursor: move to Efl.Canvas.Text namespace
Originally it was its own object.
There are some valid claims that there is no justification for it to
remain an object.
Furthermore, it's apparent that it added little benefit: changes of
each cursors, in practice, triggered a query for all objects of the
same textblock. There wasn't real advantage to have a finer resolution
of controlling the cursors with their own events.
This ports back a lot of code, and changes a lot of other code in the
higher-up widgets, such as Efl.Ui.Text and co.
The usage was replaces from:
efl_canvas_text_cursor_char_next(cur_obj)
to
efl_canvas_text_cursor_char_next(text_obj, cur_obj)
that is, it is an operations on the TEXT OBJECT, rather than on the
(now removed) cursor object.
So, one less efl object to worry about now.
Hopefully, the port went smooth.
2017-06-05 04:52:10 -07:00
|
|
|
[[Returns the text in the range between $cur1 and $cur2.
|
2016-10-05 07:10:06 -07:00
|
|
|
]]
|
2019-09-06 08:01:05 -07:00
|
|
|
return: mstring @move; [[The text in the given range]]
|
Canvas text cursor: move to Efl.Canvas.Text namespace
Originally it was its own object.
There are some valid claims that there is no justification for it to
remain an object.
Furthermore, it's apparent that it added little benefit: changes of
each cursors, in practice, triggered a query for all objects of the
same textblock. There wasn't real advantage to have a finer resolution
of controlling the cursors with their own events.
This ports back a lot of code, and changes a lot of other code in the
higher-up widgets, such as Efl.Ui.Text and co.
The usage was replaces from:
efl_canvas_text_cursor_char_next(cur_obj)
to
efl_canvas_text_cursor_char_next(text_obj, cur_obj)
that is, it is an operations on the TEXT OBJECT, rather than on the
(now removed) cursor object.
So, one less efl object to worry about now.
Hopefully, the port went smooth.
2017-06-05 04:52:10 -07:00
|
|
|
params {
|
2019-08-29 04:46:35 -07:00
|
|
|
@in cur1: ptr(const(Efl.Text_Cursor_Cursor)); [[Start of range]]
|
|
|
|
@in cur2: ptr(const(Efl.Text_Cursor_Cursor)); [[End of range]]
|
2016-05-24 06:11:03 -07:00
|
|
|
}
|
|
|
|
}
|
Canvas text cursor: move to Efl.Canvas.Text namespace
Originally it was its own object.
There are some valid claims that there is no justification for it to
remain an object.
Furthermore, it's apparent that it added little benefit: changes of
each cursors, in practice, triggered a query for all objects of the
same textblock. There wasn't real advantage to have a finer resolution
of controlling the cursors with their own events.
This ports back a lot of code, and changes a lot of other code in the
higher-up widgets, such as Efl.Ui.Text and co.
The usage was replaces from:
efl_canvas_text_cursor_char_next(cur_obj)
to
efl_canvas_text_cursor_char_next(text_obj, cur_obj)
that is, it is an operations on the TEXT OBJECT, rather than on the
(now removed) cursor object.
So, one less efl object to worry about now.
Hopefully, the port went smooth.
2017-06-05 04:52:10 -07:00
|
|
|
range_geometry_get {
|
|
|
|
[[Get the geometry of a range in the text.
|
2016-10-05 07:10:06 -07:00
|
|
|
|
Canvas text cursor: move to Efl.Canvas.Text namespace
Originally it was its own object.
There are some valid claims that there is no justification for it to
remain an object.
Furthermore, it's apparent that it added little benefit: changes of
each cursors, in practice, triggered a query for all objects of the
same textblock. There wasn't real advantage to have a finer resolution
of controlling the cursors with their own events.
This ports back a lot of code, and changes a lot of other code in the
higher-up widgets, such as Efl.Ui.Text and co.
The usage was replaces from:
efl_canvas_text_cursor_char_next(cur_obj)
to
efl_canvas_text_cursor_char_next(text_obj, cur_obj)
that is, it is an operations on the TEXT OBJECT, rather than on the
(now removed) cursor object.
So, one less efl object to worry about now.
Hopefully, the port went smooth.
2017-06-05 04:52:10 -07:00
|
|
|
The geometry is represented as rectangles for each of the line
|
|
|
|
segments in the given range [$cur1, $cur2].
|
2016-10-05 07:10:06 -07:00
|
|
|
]]
|
Canvas text cursor: move to Efl.Canvas.Text namespace
Originally it was its own object.
There are some valid claims that there is no justification for it to
remain an object.
Furthermore, it's apparent that it added little benefit: changes of
each cursors, in practice, triggered a query for all objects of the
same textblock. There wasn't real advantage to have a finer resolution
of controlling the cursors with their own events.
This ports back a lot of code, and changes a lot of other code in the
higher-up widgets, such as Efl.Ui.Text and co.
The usage was replaces from:
efl_canvas_text_cursor_char_next(cur_obj)
to
efl_canvas_text_cursor_char_next(text_obj, cur_obj)
that is, it is an operations on the TEXT OBJECT, rather than on the
(now removed) cursor object.
So, one less efl object to worry about now.
Hopefully, the port went smooth.
2017-06-05 04:52:10 -07:00
|
|
|
params {
|
2019-08-29 04:46:35 -07:00
|
|
|
@in cur1: ptr(const(Efl.Text_Cursor_Cursor)); [[Start of range]]
|
|
|
|
@in cur2: ptr(const(Efl.Text_Cursor_Cursor)); [[End of range]]
|
2016-06-07 10:16:34 -07:00
|
|
|
}
|
2019-09-06 08:01:05 -07:00
|
|
|
return: iterator<ptr(Eina.Rect)> @move; [[
|
2017-09-15 07:44:26 -07:00
|
|
|
Iterator on all geoemtries of the given range
|
|
|
|
]]
|
Canvas text cursor: move to Efl.Canvas.Text namespace
Originally it was its own object.
There are some valid claims that there is no justification for it to
remain an object.
Furthermore, it's apparent that it added little benefit: changes of
each cursors, in practice, triggered a query for all objects of the
same textblock. There wasn't real advantage to have a finer resolution
of controlling the cursors with their own events.
This ports back a lot of code, and changes a lot of other code in the
higher-up widgets, such as Efl.Ui.Text and co.
The usage was replaces from:
efl_canvas_text_cursor_char_next(cur_obj)
to
efl_canvas_text_cursor_char_next(text_obj, cur_obj)
that is, it is an operations on the TEXT OBJECT, rather than on the
(now removed) cursor object.
So, one less efl object to worry about now.
Hopefully, the port went smooth.
2017-06-05 04:52:10 -07:00
|
|
|
}
|
|
|
|
range_simple_geometry_get {
|
|
|
|
[[Get the "simple" geometry of a range.
|
|
|
|
|
|
|
|
The geometry is the geometry in which rectangles in middle lines of
|
|
|
|
range are merged into one big rectangle. This is an optimized
|
|
|
|
version of @.range_geometry_get.
|
|
|
|
]]
|
|
|
|
params {
|
2019-08-29 04:46:35 -07:00
|
|
|
@in cur1: ptr(const(Efl.Text_Cursor_Cursor)); [[Start of range]]
|
|
|
|
@in cur2: ptr(const(Efl.Text_Cursor_Cursor)); [[End of range]]
|
Canvas text cursor: move to Efl.Canvas.Text namespace
Originally it was its own object.
There are some valid claims that there is no justification for it to
remain an object.
Furthermore, it's apparent that it added little benefit: changes of
each cursors, in practice, triggered a query for all objects of the
same textblock. There wasn't real advantage to have a finer resolution
of controlling the cursors with their own events.
This ports back a lot of code, and changes a lot of other code in the
higher-up widgets, such as Efl.Ui.Text and co.
The usage was replaces from:
efl_canvas_text_cursor_char_next(cur_obj)
to
efl_canvas_text_cursor_char_next(text_obj, cur_obj)
that is, it is an operations on the TEXT OBJECT, rather than on the
(now removed) cursor object.
So, one less efl object to worry about now.
Hopefully, the port went smooth.
2017-06-05 04:52:10 -07:00
|
|
|
}
|
2019-09-06 08:01:05 -07:00
|
|
|
return: iterator<ptr(Eina.Rect)> @move; [[
|
2017-09-15 07:44:26 -07:00
|
|
|
Iterator on all simple geometries of the given range
|
|
|
|
]]
|
Canvas text cursor: move to Efl.Canvas.Text namespace
Originally it was its own object.
There are some valid claims that there is no justification for it to
remain an object.
Furthermore, it's apparent that it added little benefit: changes of
each cursors, in practice, triggered a query for all objects of the
same textblock. There wasn't real advantage to have a finer resolution
of controlling the cursors with their own events.
This ports back a lot of code, and changes a lot of other code in the
higher-up widgets, such as Efl.Ui.Text and co.
The usage was replaces from:
efl_canvas_text_cursor_char_next(cur_obj)
to
efl_canvas_text_cursor_char_next(text_obj, cur_obj)
that is, it is an operations on the TEXT OBJECT, rather than on the
(now removed) cursor object.
So, one less efl object to worry about now.
Hopefully, the port went smooth.
2017-06-05 04:52:10 -07:00
|
|
|
}
|
|
|
|
range_delete {
|
|
|
|
[[Deletes the range between given cursors.
|
|
|
|
|
|
|
|
This removes all the text in given range [$start,$end].
|
|
|
|
]]
|
|
|
|
params {
|
2018-04-06 04:30:40 -07:00
|
|
|
@in cur1: ptr(Efl.Text_Cursor_Cursor); [[Range start position]]
|
|
|
|
@in cur2: ptr(Efl.Text_Cursor_Cursor); [[Range end position]]
|
2016-05-24 06:11:03 -07:00
|
|
|
}
|
|
|
|
}
|
Canvas text cursor: move to Efl.Canvas.Text namespace
Originally it was its own object.
There are some valid claims that there is no justification for it to
remain an object.
Furthermore, it's apparent that it added little benefit: changes of
each cursors, in practice, triggered a query for all objects of the
same textblock. There wasn't real advantage to have a finer resolution
of controlling the cursors with their own events.
This ports back a lot of code, and changes a lot of other code in the
higher-up widgets, such as Efl.Ui.Text and co.
The usage was replaces from:
efl_canvas_text_cursor_char_next(cur_obj)
to
efl_canvas_text_cursor_char_next(text_obj, cur_obj)
that is, it is an operations on the TEXT OBJECT, rather than on the
(now removed) cursor object.
So, one less efl object to worry about now.
Hopefully, the port went smooth.
2017-06-05 04:52:10 -07:00
|
|
|
// Obstacles
|
2016-05-24 06:11:03 -07:00
|
|
|
obstacle_add {
|
|
|
|
[[Add obstacle evas object $eo_obs to be observed during layout
|
|
|
|
of text.
|
|
|
|
|
|
|
|
The textblock does the layout of the text according to the
|
|
|
|
position of the obstacle.
|
|
|
|
]]
|
|
|
|
params {
|
2016-11-15 07:05:06 -08:00
|
|
|
@in eo_obs: Efl.Canvas.Object; [[Obstacle object]]
|
2016-05-24 06:11:03 -07:00
|
|
|
}
|
|
|
|
return: bool; [[$true on success, $false otherwise.]]
|
|
|
|
}
|
|
|
|
obstacle_del {
|
|
|
|
[[Removes $eo_obs from observation during text layout.
|
|
|
|
]]
|
|
|
|
params {
|
2016-11-15 07:05:06 -08:00
|
|
|
@in eo_obs: Efl.Canvas.Object; [[Obstacle object]]
|
2016-05-24 06:11:03 -07:00
|
|
|
}
|
|
|
|
return: bool; [[$true on success, $false otherwise.]]
|
|
|
|
}
|
|
|
|
obstacles_update {
|
|
|
|
[[Triggers for relayout due to obstacles' state change.
|
|
|
|
|
|
|
|
The obstacles alone don't affect the layout, until this is
|
|
|
|
called. Use this after doing changes (moving, positioning etc.)
|
|
|
|
in the obstacles that you would like to be considered in the
|
|
|
|
layout.
|
|
|
|
|
|
|
|
For example: if you have just repositioned the obstacles to
|
|
|
|
differrent coordinates relative to the textblock, you need to
|
|
|
|
call this so it will consider this new state and will relayout
|
|
|
|
the text.
|
|
|
|
]]
|
|
|
|
}
|
2017-09-04 09:16:27 -07:00
|
|
|
async_layout {
|
|
|
|
[[Requests to layout the text off the mainloop.
|
|
|
|
|
|
|
|
Once layout is complete, the result is returned as @Eina.Rect,
|
|
|
|
with w, h fields set.
|
|
|
|
]]
|
2019-11-05 06:59:46 -08:00
|
|
|
return: future<Eina.Rect>; [[Future for layout result]]
|
2017-09-04 09:16:27 -07:00
|
|
|
}
|
2016-05-24 06:11:03 -07:00
|
|
|
}
|
|
|
|
implements {
|
2016-08-10 07:23:04 -07:00
|
|
|
Efl.Object.constructor;
|
|
|
|
Efl.Object.destructor;
|
2016-12-27 07:37:41 -08:00
|
|
|
Efl.Canvas.Object.paragraph_direction { get; set; }
|
|
|
|
Efl.Text.text { get; set; }
|
2016-12-22 02:43:45 -08:00
|
|
|
Efl.Gfx.Filter.filter_program { get; set; }
|
2017-01-04 18:25:21 -08:00
|
|
|
Efl.Gfx.Filter.filter_data { get; set; }
|
2017-01-05 00:56:04 -08:00
|
|
|
Efl.Gfx.Filter.filter_source { get; set; }
|
2016-12-22 02:43:45 -08:00
|
|
|
Efl.Canvas.Filter.Internal.filter_dirty;
|
|
|
|
Efl.Canvas.Filter.Internal.filter_input_render;
|
|
|
|
Efl.Canvas.Filter.Internal.filter_state_prepare;
|
2018-04-06 04:30:40 -07:00
|
|
|
Efl.Text_Font.font { get; set; }
|
|
|
|
Efl.Text_Font.font_source { get; set; }
|
|
|
|
Efl.Text_Font.font_fallbacks { get; set; }
|
|
|
|
Efl.Text_Font.font_lang { get; set; }
|
|
|
|
Efl.Text_Font.font_weight { get; set; }
|
|
|
|
Efl.Text_Font.font_slant { get; set; }
|
|
|
|
Efl.Text_Font.font_width { get; set; }
|
|
|
|
Efl.Text_Font.font_bitmap_scalable { get; set; }
|
|
|
|
Efl.Text_Style.normal_color { get; set; }
|
|
|
|
Efl.Text_Style.backing_type { get; set; }
|
|
|
|
Efl.Text_Style.backing_color { get; set; }
|
|
|
|
Efl.Text_Style.underline_type { get; set; }
|
|
|
|
Efl.Text_Style.underline_color { get; set; }
|
|
|
|
Efl.Text_Style.underline_height { get; set; }
|
|
|
|
Efl.Text_Style.underline_dashed_color { get; set; }
|
|
|
|
Efl.Text_Style.underline_dashed_width { get; set; }
|
|
|
|
Efl.Text_Style.underline_dashed_gap { get; set; }
|
|
|
|
Efl.Text_Style.underline2_color { get; set; }
|
|
|
|
Efl.Text_Style.strikethrough_type { get; set; }
|
|
|
|
Efl.Text_Style.strikethrough_color { get; set; }
|
|
|
|
Efl.Text_Style.effect_type { get; set; }
|
|
|
|
Efl.Text_Style.outline_color { get; set; }
|
|
|
|
Efl.Text_Style.shadow_direction { get; set; }
|
|
|
|
Efl.Text_Style.shadow_color { get; set; }
|
|
|
|
Efl.Text_Style.glow_color { get; set; }
|
|
|
|
Efl.Text_Style.glow2_color { get; set; }
|
|
|
|
Efl.Text_Style.gfx_filter { get; set; }
|
|
|
|
Efl.Text_Format.ellipsis { get; set; }
|
|
|
|
Efl.Text_Format.wrap { get; set; }
|
|
|
|
Efl.Text_Format.multiline { get; set; }
|
|
|
|
Efl.Text_Format.halign { get; set; }
|
|
|
|
Efl.Text_Format.halign_auto_type { get; set; }
|
|
|
|
Efl.Text_Format.valign { get; set; }
|
|
|
|
Efl.Text_Format.linegap { get; set; }
|
|
|
|
Efl.Text_Format.linerelgap { get; set; }
|
|
|
|
Efl.Text_Format.tabstops { get; set; }
|
|
|
|
Efl.Text_Format.password { get; set; }
|
|
|
|
Efl.Text_Format.replacement_char { get; set; }
|
|
|
|
Efl.Text_Cursor.text_cursor { get; }
|
|
|
|
Efl.Text_Cursor.cursor_position { set; get; }
|
|
|
|
Efl.Text_Cursor.cursor_content { get; }
|
|
|
|
Efl.Text_Cursor.cursor_geometry { get; }
|
|
|
|
Efl.Text_Cursor.cursor_new;
|
|
|
|
Efl.Text_Cursor.cursor_free;
|
|
|
|
Efl.Text_Cursor.cursor_equal;
|
|
|
|
Efl.Text_Cursor.cursor_compare;
|
|
|
|
Efl.Text_Cursor.cursor_copy;
|
|
|
|
Efl.Text_Cursor.cursor_char_next;
|
|
|
|
Efl.Text_Cursor.cursor_char_prev;
|
evas textblock: add/apply cursor cluster APIs based on grapheme cluster
Summary:
Add a feature for moving cursor over a grapheme cluster.
It is applied to edje_entry.c and elm_entry.c for improving
cursor handling just like other modern text editors. ex) gedit
The patch on Evas needs to update libunibreak library.
So, the patch will update libunibreak, too.
@feature
Test Plan:
1. Put "ഹലോ" in your entry.
2. Your cursor can reach at the end of text from the beginning
only in 2 right key event with this feature.
Reviewers: raster, cedric, jpeg, herdsman, zmike, devilhorns
Reviewed By: herdsman, zmike
Subscribers: #reviewers, #committers, zmike, bowonryu, woohyun
Tags: #efl
Differential Revision: https://phab.enlightenment.org/D5490
2018-08-20 04:21:53 -07:00
|
|
|
Efl.Text_Cursor.cursor_cluster_next;
|
|
|
|
Efl.Text_Cursor.cursor_cluster_prev;
|
2018-04-06 04:30:40 -07:00
|
|
|
Efl.Text_Cursor.cursor_paragraph_char_first;
|
|
|
|
Efl.Text_Cursor.cursor_paragraph_char_last;
|
|
|
|
Efl.Text_Cursor.cursor_word_start;
|
|
|
|
Efl.Text_Cursor.cursor_word_end;
|
|
|
|
Efl.Text_Cursor.cursor_line_char_first;
|
|
|
|
Efl.Text_Cursor.cursor_line_char_last;
|
|
|
|
Efl.Text_Cursor.cursor_paragraph_first;
|
|
|
|
Efl.Text_Cursor.cursor_paragraph_last;
|
|
|
|
Efl.Text_Cursor.cursor_paragraph_next;
|
|
|
|
Efl.Text_Cursor.cursor_paragraph_prev;
|
|
|
|
Efl.Text_Cursor.cursor_line_jump_by;
|
|
|
|
Efl.Text_Cursor.cursor_coord_set;
|
evas textblock: add/apply cursor cluster APIs based on grapheme cluster
Summary:
Add a feature for moving cursor over a grapheme cluster.
It is applied to edje_entry.c and elm_entry.c for improving
cursor handling just like other modern text editors. ex) gedit
The patch on Evas needs to update libunibreak library.
So, the patch will update libunibreak, too.
@feature
Test Plan:
1. Put "ഹലോ" in your entry.
2. Your cursor can reach at the end of text from the beginning
only in 2 right key event with this feature.
Reviewers: raster, cedric, jpeg, herdsman, zmike, devilhorns
Reviewed By: herdsman, zmike
Subscribers: #reviewers, #committers, zmike, bowonryu, woohyun
Tags: #efl
Differential Revision: https://phab.enlightenment.org/D5490
2018-08-20 04:21:53 -07:00
|
|
|
Efl.Text_Cursor.cursor_cluster_coord_set;
|
2018-04-06 04:30:40 -07:00
|
|
|
Efl.Text_Cursor.cursor_text_insert;
|
|
|
|
Efl.Text_Cursor.cursor_char_delete;
|
|
|
|
Efl.Text_Annotate.annotation { set; get; }
|
|
|
|
Efl.Text_Annotate.range_annotations_get;
|
|
|
|
Efl.Text_Annotate.annotation_insert;
|
|
|
|
Efl.Text_Annotate.annotation_del;
|
|
|
|
Efl.Text_Annotate.annotation_is_item;
|
|
|
|
Efl.Text_Annotate.item_geometry_get;
|
|
|
|
Efl.Text_Annotate.annotation_positions_get;
|
|
|
|
Efl.Text_Annotate.cursor_item_annotation { get; }
|
|
|
|
Efl.Text_Annotate.cursor_item_insert;
|
|
|
|
Efl.Text_Markup.markup { set; get; }
|
2019-01-28 08:10:40 -08:00
|
|
|
Efl.Text_Markup_Interactive.cursor_markup_insert;
|
|
|
|
Efl.Text_Markup_Interactive.markup_range { get;}
|
2018-04-05 01:47:26 -07:00
|
|
|
Efl.Gfx.Entity.scale { set; }
|
2016-05-24 06:11:03 -07:00
|
|
|
}
|
2016-07-11 04:18:19 -07:00
|
|
|
events {
|
efl: Add missing event types
Summary:
All events must have a type now, otherwise bindings don't know how to handle
the event_info field.
Most of the missing event types were actually "void" (no event_info present).
Some struct definitions had to be moved to eo instead of h files, so they
are available to bindings. Some have not, and are marked with FIXME.
Some namespaces have been fixed (like Efl_Event_Cb -> Efl.Event_Cb).
In general, there are hundreds of changed files, but mostly to add a type which
was not present before, so there's no harm done.
Also, A lot of FIXMEs have been added which should be, like, fixed.
For example, some events can send different types of event_info, which is
very inconvenient (and error prone).
Test Plan: make with c# bindings works, make check and make examples work too.
Reviewers: cedric, q66, lauromoura
Subscribers: zmike
Tags: #efl
Differential Revision: https://phab.enlightenment.org/D6169
2018-05-11 08:20:40 -07:00
|
|
|
cursor,changed: void; [[Called when cursor changed]]
|
|
|
|
changed: void; [[Called when canvas text changed ]]
|
|
|
|
style_insets,changed: void; [[Called when the property @.style_insets changed.]]
|
2016-07-11 04:18:19 -07:00
|
|
|
}
|
2016-05-24 06:11:03 -07:00
|
|
|
}
|