enlightenment/efl
enlightenment
/
efl
8
7
Fork 14
Code Issues 13 Pull Requests 3 Projects Releases Wiki Activity

Efl.Text.Cursor 

Summary:
Implementation of new cursor text object.

This Patch Contains :
1- Remove Efl.Text.Cursor & Efl.Text_Markup_Interactive interfaces and replace them with one Class Efl.Text.Cursor
   => there are some modifications on cursor methods

2- Update all related classes to use Efl.Text.Cursor object instead of the old interfaces

3- If class uses Efl.Text_Cursor_Cursor (handle), mainly annotation it will stay as it is until we update other annotations into attribute_factory

4- Add main cursor property into efl.text.interactive

5- Add cursor_new method in efl.ui.text  (I think we may move it into efl.text.interactive interface)

There still some parts that need discussion: especially cursor movement functionality, I prefer to move function with Enum, instead of special function for each movement.

```
enum @beta Efl.Text.Cursor_Move_Type
{
   [[Text cursor movement types]]
   char_next,       [[Advances to the next character]]
   char_prev,       [[Advances to the previous character]]
   cluster_next,    [[Advances to the next grapheme cluster]]
   cluster_prev,    [[Advances to the previous grapheme cluster]]
   paragraph_start, [[Advances to the first character in this paragraph]]
   paragraph_end,   [[Advances to the last character in this paragraph]]
   word_start,      [[Advance to current word start]]
   word_end,        [[Advance to current word end]]
   line_start,      [[Advance to current line first character]]
   line_end,        [[Advance to current line last character]]
   paragraph_first, [[Advance to current paragraph first character]]
   paragraph_last,  [[Advance to current paragraph last character]]
   paragraph_next,  [[Advances to the start of the next text node]]
   paragraph_prev   [[Advances to the end of the previous text node]]
}
move {
         [[Move the cursor]]
         params {
            @in type: Efl.Text.Cursor_Move_Type; [[The type of movement]]
         }
         return: bool; [[True if actually moved]]
      }
```

or old way:
```
char_next {
         [[Advances to the next character]]
         // FIXME: Make the number of characters we moved by? Useful for all the other functions
         return: bool; [[True if actually moved]]
      }
      char_prev {
         [[Advances to the previous character]]
         return: bool; [[True if actually moved]]
      }

      char_delete {
         [[Deletes a single character from position pointed by given cursor.]]
      }

      cluster_next {
         [[Advances to the next grapheme cluster]]
         return: bool; [[True if actually moved]]
      }
      cluster_prev {
         [[Advances to the previous grapheme cluster]]
         return: bool; [[True if actually moved]]
      }

      // FIXME: paragraph_end is inconsistent with word_end. The one goes to the last character and the other after the last character.
      paragraph_start {
         [[Advances to the first character in this paragraph]]
         return: bool; [[True if actually moved]]
      }
      paragraph_end {
         [[Advances to the last character in this paragraph]]
         return: bool; [[True if actually moved]]
      }
      word_start {
         [[Advance to current word start]]
         return: bool; [[True if actually moved]]
      }
      word_end {
         [[Advance to current word end]]
         return: bool; [[True if actually moved]]
      }
      line_start {
         [[Advance to current line first character]]
         return: bool; [[True if actually moved]]
      }
      line_end {
          [[Advance to current line last character]]
         return: bool; [[True if actually moved]]
      }
      paragraph_first {
         [[Advance to current paragraph first character]]
         return: bool; [[True if actually moved]]
      }
      paragraph_last {
         [[Advance to current paragraph last character]]
         return: bool; [[True if actually moved]]
      }
      paragraph_next {
         [[Advances to the start of the next text node]]
         return: bool; [[True if actually moved]]
      }
      paragraph_prev {
         [[Advances to the end of the previous text node]]
         return: bool; [[True if actually moved]]
      }
```

Reviewers: woohyun, tasn, segfaultxavi

Reviewed By: woohyun

Subscribers: a.srour, bu5hm4n, segfaultxavi, cedric, #reviewers, #committers

Tags: #efl

Differential Revision: https://phab.enlightenment.org/D10542
This commit is contained in:
Ali Alzyod 2019-11-22 17:35:54 +09:00 committed by WooHyun Jung
parent 17ba8515f1
commit d7352f4db4
36 changed files with 1853 additions and 1866 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

52
src/bin/elementary/test_efl_ui_text.c
View File

@ -8,18 +8,18 @@
static void
_apply_style(Eo *obj, size_t start_pos, size_t end_pos, const char *style)
{
Efl_Text_Cursor_Cursor *start, *end;
Efl_Text_Cursor *start, *end;
start = efl_text_cursor_new(obj);
end = efl_text_cursor_new(obj);
start = efl_ui_text_cursor_create(obj);
end = efl_ui_text_cursor_create(obj);
efl_text_cursor_position_set(obj, start, start_pos);
efl_text_cursor_position_set(obj, end, end_pos);
efl_text_cursor_position_set(start, start_pos);
efl_text_cursor_position_set(end, end_pos);
efl_text_annotation_insert(obj, start, end, style);
efl_text_annotation_insert(obj, efl_text_cursor_handle_get(start), efl_text_cursor_handle_get(end), style);
efl_text_cursor_free(obj, start);
efl_text_cursor_free(obj, end);
efl_del(start);
efl_del(end);
}
static Eo *
@ -98,15 +98,15 @@ typedef struct
static void
_on_bt3_clicked(void *data, const Efl_Event *event EINA_UNUSED)
{
Efl_Text_Cursor_Cursor *sel_start, *sel_end;
Efl_Text_Cursor *sel_start, *sel_end;
Eo *en = data;
efl_text_interactive_selection_cursors_get(data, &sel_start, &sel_end);
const char *s = efl_canvas_text_range_text_get(data, sel_start, sel_end);
efl_text_interactive_selection_cursors_get(en, &sel_start, &sel_end);
const char *s = efl_text_cursor_range_text_get(sel_start, sel_end);
printf("SELECTION REGION: %d - %d\n",
efl_text_cursor_position_get(en, sel_start),
efl_text_cursor_position_get(en, sel_end));
efl_text_cursor_position_get( sel_start),
efl_text_cursor_position_get(sel_end));
printf("SELECTION:\n");
if (s) printf("%s\n", s);
}
@ -248,9 +248,9 @@ _on_factory_bt_image_clicked(void *data, const Efl_Event *event EINA_UNUSED)
static int image_idx = 0;
image_idx = (image_idx + 1) % IMAGES_SZ;
efl_text_cursor_item_insert(en,
efl_text_cursor_get(en, EFL_TEXT_CURSOR_GET_TYPE_MAIN),
images[image_idx], "size=32x32");
efl_text_cursor_item_insert(en, efl_text_cursor_handle_get(efl_text_interactive_main_cursor_get(en)),
images[image_idx], "size=32x32");
printf("Inserted image: key = %s\n", images[image_idx]);
}
@ -258,8 +258,8 @@ static void
_on_factory_bt_emoticon_clicked(void *data, const Efl_Event *event EINA_UNUSED)
{
Evas_Object *en = data;
efl_text_cursor_item_insert(en, efl_text_cursor_get(en, EFL_TEXT_CURSOR_GET_TYPE_MAIN),
"emoticon/evil-laugh", "size=32x32");
efl_text_cursor_item_insert(en, efl_text_cursor_handle_get(efl_text_interactive_main_cursor_get(en)),
"emoticon/evil-laugh", "size=32x32");
}
static struct
@ -287,7 +287,7 @@ void
test_ui_text_item_factory(void *data EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event_info EINA_UNUSED)
{
Evas_Object *win, *bx, *bx2, *bt, *en;
Efl_Text_Cursor_Cursor *main_cur, *cur;
Efl_Text_Cursor *main_cur, *cur;
char buf[128];
Eina_File *f;
@ -350,16 +350,16 @@ test_ui_text_item_factory(void *data EINA_UNUSED, Evas_Object *obj EINA_UNUSED,
efl_text_font_set(en, "Sans", 14);
efl_text_normal_color_set(en, 255, 255, 255, 255);
main_cur = efl_text_cursor_get(en, EFL_TEXT_CURSOR_GET_TYPE_MAIN);
cur = efl_text_cursor_new(en);
main_cur = efl_text_interactive_main_cursor_get(en);
cur = efl_ui_text_cursor_create(en);
efl_text_cursor_position_set(en, cur, 2);
efl_text_cursor_item_insert(en, cur, "emoticon/happy", "size=32x32");
efl_text_cursor_position_set(en, cur, 50);
efl_text_cursor_position_set(cur, 2);
efl_text_cursor_item_insert(en, efl_text_cursor_handle_get(cur), "emoticon/happy", "size=32x32");
efl_text_cursor_position_set(cur, 50);
snprintf(buf, sizeof(buf), "file://%s/images/sky_01.jpg", elm_app_data_dir_get());
efl_text_cursor_item_insert(en, cur, buf, "size=32x32");
efl_text_cursor_position_set(en, main_cur, 5);
efl_text_cursor_item_insert(en, efl_text_cursor_handle_get(cur), buf, "size=32x32");
efl_text_cursor_position_set(main_cur, 5);
efl_text_interactive_editable_set(en, EINA_TRUE);
efl_ui_text_scrollable_set(en, EINA_TRUE);

26
src/lib/edje/edje_entry.c
View File

@ -4083,7 +4083,7 @@ _cursor_get(Edje_Real_Part *rp, Edje_Cursor cur)
}
Eina_Bool
_edje_text_cursor_next(Edje_Real_Part *rp, Efl_Text_Cursor_Cursor *c)
_edje_text_cursor_next(Edje_Real_Part *rp, Efl_Text_Cursor_Handle *c)
{
Entry *en;
@ -4117,7 +4117,7 @@ _edje_entry_cursor_next(Edje_Real_Part *rp, Edje_Cursor cur)
Eina_Bool
_edje_text_cursor_prev(Edje_Real_Part *rp, Efl_Text_Cursor_Cursor *c)
_edje_text_cursor_prev(Edje_Real_Part *rp, Efl_Text_Cursor_Handle *c)
{
Entry *en;
@ -4152,7 +4152,7 @@ _edje_entry_cursor_prev(Edje_Real_Part *rp, Edje_Cursor cur)
}
Eina_Bool
_edje_text_cursor_up(Edje_Real_Part *rp, Efl_Text_Cursor_Cursor *c)
_edje_text_cursor_up(Edje_Real_Part *rp, Efl_Text_Cursor_Handle *c)
{
Entry *en;
Evas_Coord lx, ly, lw, lh, cx, cy, cw, ch;
@ -4192,7 +4192,7 @@ _edje_entry_cursor_up(Edje_Real_Part *rp, Edje_Cursor cur)
}
Eina_Bool
_edje_text_cursor_down(Edje_Real_Part *rp, Efl_Text_Cursor_Cursor *c)
_edje_text_cursor_down(Edje_Real_Part *rp, Efl_Text_Cursor_Handle *c)
{
Entry *en;
Evas_Coord lx, ly, lw, lh, cx, cy, cw, ch;
@ -4231,7 +4231,7 @@ _edje_entry_cursor_down(Edje_Real_Part *rp, Edje_Cursor cur)
}
void
_edje_text_cursor_begin(Edje_Real_Part *rp, Efl_Text_Cursor_Cursor *c)
_edje_text_cursor_begin(Edje_Real_Part *rp, Efl_Text_Cursor_Handle *c)
{
Entry *en;
int old_cur_pos;
@ -4266,7 +4266,7 @@ _edje_entry_cursor_begin(Edje_Real_Part *rp, Edje_Cursor cur)
}
void
_edje_text_cursor_end(Edje_Real_Part *rp, Efl_Text_Cursor_Cursor *c)
_edje_text_cursor_end(Edje_Real_Part *rp, Efl_Text_Cursor_Handle *c)
{
Entry *en;
int old_cur_pos;
@ -4300,7 +4300,7 @@ _edje_entry_cursor_end(Edje_Real_Part *rp, Edje_Cursor cur)
}
void
_edje_text_cursor_copy(Edje_Real_Part *rp, Efl_Text_Cursor_Cursor *d, Efl_Text_Cursor_Cursor *c)
_edje_text_cursor_copy(Edje_Real_Part *rp, Efl_Text_Cursor_Handle *d, Efl_Text_Cursor_Handle *c)
{
Entry *en;
@ -4330,7 +4330,7 @@ _edje_entry_cursor_copy(Edje_Real_Part *rp, Edje_Cursor cur, Edje_Cursor dst)
}
void
_edje_text_cursor_line_begin(Edje_Real_Part *rp, Efl_Text_Cursor_Cursor *c)
_edje_text_cursor_line_begin(Edje_Real_Part *rp, Efl_Text_Cursor_Handle *c)
{
Entry *en;
int old_cur_pos;
@ -4364,7 +4364,7 @@ _edje_entry_cursor_line_begin(Edje_Real_Part *rp, Edje_Cursor cur)
}
void
_edje_text_cursor_line_end(Edje_Real_Part *rp, Efl_Text_Cursor_Cursor *c)
_edje_text_cursor_line_end(Edje_Real_Part *rp, Efl_Text_Cursor_Handle *c)
{
Entry *en;
int old_cur_pos;
@ -4397,7 +4397,7 @@ _edje_entry_cursor_line_end(Edje_Real_Part *rp, Edje_Cursor cur)
}
Eina_Bool
_edje_text_cursor_coord_set(Edje_Real_Part *rp, Efl_Text_Cursor_Cursor *c,
_edje_text_cursor_coord_set(Edje_Real_Part *rp, Efl_Text_Cursor_Handle *c,
Evas_Coord x, Evas_Coord y)
{
Entry *en = rp->typedata.text->entry_data;
@ -4444,7 +4444,7 @@ _edje_entry_cursor_is_visible_format_get(Edje_Real_Part *rp, Edje_Cursor cur)
}
char *
_edje_text_cursor_content_get(Edje_Real_Part *rp EINA_UNUSED, Efl_Text_Cursor_Cursor *c)
_edje_text_cursor_content_get(Edje_Real_Part *rp EINA_UNUSED, Efl_Text_Cursor_Handle *c)
{
return evas_textblock_cursor_content_get(c);
}
@ -4460,7 +4460,7 @@ _edje_entry_cursor_content_get(Edje_Real_Part *rp, Edje_Cursor cur)
}
void
_edje_text_cursor_pos_set(Edje_Real_Part *rp, Efl_Text_Cursor_Cursor *c, int pos)
_edje_text_cursor_pos_set(Edje_Real_Part *rp, Efl_Text_Cursor_Handle *c, int pos)
{
if ((rp->type != EDJE_RP_TYPE_TEXT) ||
(!rp->typedata.text)) return;
@ -4489,7 +4489,7 @@ _edje_entry_cursor_pos_set(Edje_Real_Part *rp, Edje_Cursor cur, int pos)
}
int
_edje_text_cursor_pos_get(Edje_Real_Part *rp EINA_UNUSED, Efl_Text_Cursor_Cursor *c)
_edje_text_cursor_pos_get(Edje_Real_Part *rp EINA_UNUSED, Efl_Text_Cursor_Handle *c)
{
return evas_textblock_cursor_pos_get(c);
}

252
src/lib/edje/edje_legacy.c
View File

@ -1,6 +1,14 @@
/* Legacy API implementations based on internal EO calls */
#include "edje_private.h"
#include "edje_part_helper.h"
#define GET_REAL_PART_ON_FAIL_RETURN(x) Edje_Real_Part *rp;\
Edje *ed;\
ed = _edje_fetch(obj);\
if ((!ed) || (!part)) return x;\
rp = _edje_real_part_recursive_get(&ed, part);\
if (!rp) return x;\
EAPI Edje_Load_Error
edje_object_load_error_get(const Eo *obj)
@ -275,147 +283,93 @@ edje_object_part_drag_page(Evas_Object *obj, const char *part, double dx, double
}
EAPI void
edje_object_part_text_cursor_begin_set(Edje_Object *obj, const char *part, Edje_Cursor cur)
edje_object_part_text_cursor_begin_set(Edje_Object *obj, const char *part EINA_UNUSED, Edje_Cursor cur)
{
efl_text_cursor_paragraph_first(efl_part(obj, part),
efl_text_cursor_get(efl_part(obj, part), (int) cur));
GET_REAL_PART_ON_FAIL_RETURN()
_edje_text_cursor_begin(rp, _edje_text_cursor_get(rp, cur));
}
EAPI void
edje_object_part_text_cursor_end_set(Edje_Object *obj, const char *part, Edje_Cursor cur)
edje_object_part_text_cursor_end_set(Edje_Object *obj, const char *part EINA_UNUSED, Edje_Cursor cur)
{
efl_text_cursor_paragraph_last(efl_part(obj, part),
efl_text_cursor_get(efl_part(obj, part), (int) cur));
GET_REAL_PART_ON_FAIL_RETURN()
_edje_text_cursor_end(rp, _edje_text_cursor_get(rp, cur));
}
EAPI void
edje_object_part_text_cursor_pos_set(Edje_Object *obj, const char * part, Edje_Cursor cur, int pos)
edje_object_part_text_cursor_pos_set(Edje_Object *obj, const char * part EINA_UNUSED, Edje_Cursor cur, int pos)
{
efl_text_cursor_position_set(efl_part(obj, part),
efl_text_cursor_get(efl_part(obj, part), (int) cur), pos);
GET_REAL_PART_ON_FAIL_RETURN()
_edje_text_cursor_pos_set(rp, _edje_text_cursor_get(rp, cur), pos);
}
EAPI int
edje_object_part_text_cursor_pos_get(const Edje_Object *obj, const char * part, Edje_Cursor cur)
edje_object_part_text_cursor_pos_get(const Edje_Object *obj, const char * part EINA_UNUSED, Edje_Cursor cur)
{
return efl_text_cursor_position_get(efl_part(obj, part),
efl_text_cursor_get(efl_part(obj, part), (int) cur));
GET_REAL_PART_ON_FAIL_RETURN(0)
return _edje_text_cursor_pos_get(rp, _edje_text_cursor_get(rp, cur));
}
EAPI Eina_Bool
edje_object_part_text_cursor_coord_set(Edje_Object *obj, const char *part, Edje_Cursor cur, int x, int y)
edje_object_part_text_cursor_coord_set(Edje_Object *obj, const char *part EINA_UNUSED, Edje_Cursor cur, int x, int y)
{
efl_text_cursor_coord_set(efl_part(obj, part),
efl_text_cursor_get(efl_part(obj, part), (int) cur), x, y);
return EINA_TRUE;
GET_REAL_PART_ON_FAIL_RETURN(EINA_FALSE)
return _edje_text_cursor_coord_set(rp, _edje_text_cursor_get(rp, cur), x, y);
}
EAPI void
edje_object_part_text_cursor_line_begin_set(Edje_Object *obj, const char *part, Edje_Cursor cur)
edje_object_part_text_cursor_line_begin_set(Edje_Object *obj, const char *part EINA_UNUSED, Edje_Cursor cur)
{
efl_text_cursor_line_char_first(efl_part(obj, part),
efl_text_cursor_get(efl_part(obj, part), (int) cur));
GET_REAL_PART_ON_FAIL_RETURN()
_edje_text_cursor_line_begin(rp, _edje_text_cursor_get(rp, cur));
}
EAPI void
edje_object_part_text_cursor_line_end_set(Edje_Object *obj, const char *part, Edje_Cursor cur)
edje_object_part_text_cursor_line_end_set(Edje_Object *obj, const char *part EINA_UNUSED, Edje_Cursor cur)
{
efl_text_cursor_line_char_last(efl_part(obj, part),
efl_text_cursor_get(efl_part(obj, part), (int) cur));
GET_REAL_PART_ON_FAIL_RETURN()
_edje_text_cursor_line_end(rp, _edje_text_cursor_get(rp, cur));
}
EAPI Eina_Bool
edje_object_part_text_cursor_prev(Edje_Object *obj, const char *part, Edje_Cursor cur)
edje_object_part_text_cursor_prev(Edje_Object *obj, const char *part EINA_UNUSED, Edje_Cursor cur)
{
Efl_Text_Cursor_Cursor *c;
int old_pos, new_pos;
c = efl_text_cursor_get(efl_part(obj, part), (int) cur);
old_pos = efl_text_cursor_position_get(efl_part(obj, part), c);
efl_text_cursor_char_prev(efl_part(obj, part), c);
new_pos = efl_text_cursor_position_get(efl_part(obj, part), c);
if (old_pos != new_pos)
return EINA_TRUE;
return EINA_FALSE;
GET_REAL_PART_ON_FAIL_RETURN(EINA_FALSE)
return _edje_text_cursor_prev(rp, _edje_text_cursor_get(rp, cur));
}
EAPI Eina_Bool
edje_object_part_text_cursor_next(Edje_Object *obj, const char *part, Edje_Cursor cur)
edje_object_part_text_cursor_next(Edje_Object *obj, const char *part EINA_UNUSED, Edje_Cursor cur)
{
Efl_Text_Cursor_Cursor *c;
int old_pos, new_pos;
c = efl_text_cursor_get(efl_part(obj, part), (int) cur);
old_pos = efl_text_cursor_position_get(efl_part(obj, part), c);
efl_text_cursor_char_next(efl_part(obj, part), c);
new_pos = efl_text_cursor_position_get(efl_part(obj, part), c);
if (old_pos != new_pos)
return EINA_TRUE;
return EINA_FALSE;
GET_REAL_PART_ON_FAIL_RETURN(EINA_FALSE)
return _edje_text_cursor_next(rp, _edje_text_cursor_get(rp, cur));
}
EAPI Eina_Bool
edje_object_part_text_cursor_down(Edje_Object *obj, const char *part, Edje_Cursor cur)
edje_object_part_text_cursor_down(Edje_Object *obj, const char *part EINA_UNUSED, Edje_Cursor cur)
{
Efl_Text_Cursor_Cursor *c;
int old_pos, new_pos;
c = efl_text_cursor_get(efl_part(obj, part), (int) cur);
old_pos = efl_text_cursor_position_get(efl_part(obj, part), c);
efl_text_cursor_line_jump_by(efl_part(obj, part), c, 1);
new_pos = efl_text_cursor_position_get(efl_part(obj, part), c);
if (old_pos != new_pos)
return EINA_TRUE;
return EINA_FALSE;
GET_REAL_PART_ON_FAIL_RETURN(EINA_FALSE)
return _edje_text_cursor_down(rp, _edje_text_cursor_get(rp, cur));
}
EAPI Eina_Bool
edje_object_part_text_cursor_up(Edje_Object *obj, const char *part, Edje_Cursor cur)
edje_object_part_text_cursor_up(Edje_Object *obj, const char *part EINA_UNUSED, Edje_Cursor cur)
{
Efl_Text_Cursor_Cursor *c;
int old_pos, new_pos;
c = efl_text_cursor_get(efl_part(obj, part), (int) cur);
old_pos = efl_text_cursor_position_get(efl_part(obj, part), c);
efl_text_cursor_line_jump_by(efl_part(obj, part), c, -1);
new_pos = efl_text_cursor_position_get(efl_part(obj, part), c);
if (old_pos != new_pos)
return EINA_TRUE;
return EINA_FALSE;
GET_REAL_PART_ON_FAIL_RETURN(EINA_FALSE)
return _edje_text_cursor_up(rp, _edje_text_cursor_get(rp, cur));
}
EAPI void
edje_object_part_text_cursor_copy(Edje_Object *obj, const char *part, Edje_Cursor cur, Edje_Cursor dst)
edje_object_part_text_cursor_copy(Edje_Object *obj, const char *part EINA_UNUSED, Edje_Cursor cur, Edje_Cursor dst)
{
efl_text_cursor_copy(efl_part(obj, part),
efl_text_cursor_get(efl_part(obj, part), (int) dst),
efl_text_cursor_get(efl_part(obj, part), (int) cur)
);
GET_REAL_PART_ON_FAIL_RETURN()
_edje_text_cursor_copy(rp, _edje_text_cursor_get(rp, cur), _edje_text_cursor_get(rp, dst));
}
EAPI char *
edje_object_part_text_cursor_content_get(const Edje_Object *obj, const char *part, Edje_Cursor cur)
edje_object_part_text_cursor_content_get(const Edje_Object *obj, const char *part EINA_UNUSED, Edje_Cursor cur)
{
Edje_Real_Part *rp;
Edje *ed;
ed = efl_data_scope_get(obj, EFL_CANVAS_LAYOUT_CLASS);
if ((!ed) || (!part)) return NULL;
rp = _edje_real_part_recursive_get(&ed, part);
if (!rp) return NULL;
GET_REAL_PART_ON_FAIL_RETURN(NULL)
if (rp->part->entry_mode > EDJE_ENTRY_EDIT_MODE_NONE)
{
return _edje_entry_cursor_content_get(rp, cur);
@ -425,27 +379,18 @@ edje_object_part_text_cursor_content_get(const Edje_Object *obj, const char *par
}
EAPI void
edje_object_part_text_cursor_geometry_get(const Edje_Object *obj, const char * part, int *x, int *y, int *w, int *h)
edje_object_part_text_cursor_geometry_get(const Edje_Object *obj, const char * part EINA_UNUSED, int *x, int *y, int *w, int *h)
{
efl_text_cursor_geometry_get(efl_part(obj, part),
efl_text_cursor_get(efl_part(obj, part), EFL_TEXT_CURSOR_GET_TYPE_MAIN),
EFL_TEXT_CURSOR_TYPE_BEFORE,
x, y, w, h, NULL, NULL, NULL, NULL
);
GET_REAL_PART_ON_FAIL_RETURN()
evas_textblock_cursor_geometry_bidi_get(_edje_text_cursor_get(rp, EDJE_CURSOR_MAIN),
x, y, w, h, NULL, NULL, NULL, NULL, EVAS_TEXTBLOCK_CURSOR_BEFORE);
}
EAPI Eina_Bool
edje_object_part_text_hide_visible_password(Eo *obj, const char *part)
{
Edje_Real_Part *rp;
GET_REAL_PART_ON_FAIL_RETURN(EINA_FALSE)
Eina_Bool int_ret = EINA_FALSE;
Edje *ed;
ed = efl_data_scope_get(obj, EFL_CANVAS_LAYOUT_CLASS);
if ((!ed) || (!part)) return EINA_FALSE;
rp = _edje_real_part_recursive_get(&ed, part);
if (!rp) return EINA_FALSE;
if (rp->part->type != EDJE_PART_TYPE_TEXTBLOCK) return EINA_FALSE;
if ((rp->type != EDJE_RP_TYPE_TEXT) ||
(!rp->typedata.text))
@ -462,13 +407,7 @@ edje_object_part_text_hide_visible_password(Eo *obj, const char *part)
EAPI Eina_Bool
edje_object_part_text_cursor_is_format_get(const Eo *obj, const char *part, Edje_Cursor cur)
{
Edje_Real_Part *rp;
Edje *ed;
ed = _edje_fetch(obj);
if ((!ed) || (!part)) return EINA_FALSE;
rp = _edje_real_part_recursive_get(&ed, part);
if (!rp) return EINA_FALSE;
GET_REAL_PART_ON_FAIL_RETURN(EINA_FALSE)
if (rp->part->entry_mode > EDJE_ENTRY_EDIT_MODE_NONE)
{
return _edje_entry_cursor_is_format_get(rp, cur);
@ -479,13 +418,7 @@ edje_object_part_text_cursor_is_format_get(const Eo *obj, const char *part, Edje
EAPI Eina_Bool
edje_object_part_text_cursor_is_visible_format_get(const Eo *obj, const char *part, Edje_Cursor cur)
{
Edje_Real_Part *rp;
Edje *ed;
ed = _edje_fetch(obj);
if ((!ed) || (!part)) return EINA_FALSE;
rp = _edje_real_part_recursive_get(&ed, part);
if (!rp) return EINA_FALSE;
GET_REAL_PART_ON_FAIL_RETURN(EINA_FALSE)
if (rp->part->entry_mode > EDJE_ENTRY_EDIT_MODE_NONE)
{
return _edje_entry_cursor_is_visible_format_get(rp, cur);
@ -497,13 +430,7 @@ edje_object_part_text_cursor_is_visible_format_get(const Eo *obj, const char *pa
EAPI const Eina_List *
edje_object_part_text_anchor_list_get(const Eo *obj, const char *part)
{
Edje_Real_Part *rp;
Edje *ed;
ed = _edje_fetch(obj);
if ((!ed) || (!part)) return NULL;
rp = _edje_real_part_recursive_get(&ed, part);
if (!rp) return NULL;
GET_REAL_PART_ON_FAIL_RETURN(NULL)
if (rp->part->entry_mode > EDJE_ENTRY_EDIT_MODE_NONE)
return _edje_entry_anchors_list(rp);
@ -513,13 +440,7 @@ edje_object_part_text_anchor_list_get(const Eo *obj, const char *part)
EAPI const Eina_List *
edje_object_part_text_anchor_geometry_get(const Eo *obj, const char *part, const char *anchor)
{
Edje_Real_Part *rp;
Edje *ed;
ed = _edje_fetch(obj);
if ((!ed) || (!part)) return NULL;
rp = _edje_real_part_recursive_get(&ed, part);
if (!rp) return NULL;
GET_REAL_PART_ON_FAIL_RETURN(NULL)
if (rp->part->entry_mode > EDJE_ENTRY_EDIT_MODE_NONE)
return _edje_entry_anchor_geometry_get(rp, anchor);
@ -529,15 +450,9 @@ edje_object_part_text_anchor_geometry_get(const Eo *obj, const char *part, const
EAPI void
edje_object_part_text_style_user_push(Eo *obj EINA_UNUSED, const char *part, const char *style)
{
Edje_Real_Part *rp;
Evas_Textblock_Style *ts;
Edje *ed;
GET_REAL_PART_ON_FAIL_RETURN()
ed = efl_data_scope_get(obj, EFL_CANVAS_LAYOUT_CLASS);
if ((!ed) || (!part) || (!style)) return;
rp = _edje_real_part_recursive_get(&ed, part);
if (!rp) return;
if (rp->part->type != EDJE_PART_TYPE_TEXTBLOCK) return;
ts = evas_textblock_style_new();
@ -552,16 +467,9 @@ edje_object_part_text_style_user_push(Eo *obj EINA_UNUSED, const char *part, con
}
EAPI void
edje_object_part_text_style_user_pop(Eo *obj EINA_UNUSED, const char *part)
edje_object_part_text_style_user_pop(Eo *obj, const char *part)
{
Edje_Real_Part *rp;
Edje *ed;
ed = efl_data_scope_get(obj, EFL_CANVAS_LAYOUT_CLASS);
if ((!ed) || (!part)) return;
rp = _edje_real_part_recursive_get(&ed, part);
if (!rp) return;
GET_REAL_PART_ON_FAIL_RETURN()
if (rp->part->type != EDJE_PART_TYPE_TEXTBLOCK) return;
evas_object_textblock_style_user_pop(rp->object);
@ -579,7 +487,7 @@ edje_object_part_text_style_user_peek(const Eo *obj EINA_UNUSED, const char *par
const Evas_Textblock_Style *ts;
Edje *ed;
ed = efl_data_scope_get(obj, EFL_CANVAS_LAYOUT_CLASS);
ed = _edje_fetch(obj);
if ((!ed) || (!part)) return NULL;
rp = _edje_real_part_recursive_get(&ed, part);
@ -596,14 +504,7 @@ edje_object_part_text_style_user_peek(const Eo *obj EINA_UNUSED, const char *par
EAPI const Eina_List *
edje_object_part_text_item_list_get(const Eo *obj EINA_UNUSED, const char *part)
{
Edje_Real_Part *rp;
Edje *ed;
ed = efl_data_scope_get(obj, EFL_CANVAS_LAYOUT_CLASS);
if ((!ed) || (!part)) return NULL;
rp = _edje_real_part_recursive_get(&ed, part);
if (!rp) return NULL;
GET_REAL_PART_ON_FAIL_RETURN(NULL)
if (rp->part->entry_mode > EDJE_ENTRY_EDIT_MODE_NONE)
return _edje_entry_items_list(rp);
@ -613,14 +514,7 @@ edje_object_part_text_item_list_get(const Eo *obj EINA_UNUSED, const char *part)
EAPI Eina_Bool
edje_object_part_text_item_geometry_get(const Eo *obj EINA_UNUSED, const char *part, const char *item, Evas_Coord *cx, Evas_Coord *cy, Evas_Coord *cw, Evas_Coord *ch)
{
Edje_Real_Part *rp;
Edje *ed;
ed = efl_data_scope_get(obj, EFL_CANVAS_LAYOUT_CLASS);
if ((!ed) || (!part)) return EINA_FALSE;
rp = _edje_real_part_recursive_get(&ed, part);
if (!rp) return EINA_FALSE;
GET_REAL_PART_ON_FAIL_RETURN(EINA_FALSE)
if (rp->part->entry_mode > EDJE_ENTRY_EDIT_MODE_NONE)
{
return _edje_entry_item_geometry_get(rp, item, cx, cy, cw, ch);
@ -635,7 +529,7 @@ edje_object_text_insert_filter_callback_add(Eo *obj EINA_UNUSED, const char *par
Edje_Text_Insert_Filter_Callback *cb;
Edje *ed;
ed = efl_data_scope_get(obj, EFL_CANVAS_LAYOUT_CLASS);
ed = _edje_fetch(obj);
if ((!ed) || (!part)) return;
cb = calloc(1, sizeof(Edje_Text_Insert_Filter_Callback));
@ -653,7 +547,7 @@ edje_object_text_insert_filter_callback_del(Eo *obj EINA_UNUSED, const char *par
Eina_List *l;
Edje *ed;
ed = efl_data_scope_get(obj, EFL_CANVAS_LAYOUT_CLASS);
ed = _edje_fetch(obj);
if ((!ed) || (!part)) return NULL;
EINA_LIST_FOREACH(ed->text_insert_filter_callbacks, l, cb)
@ -679,7 +573,7 @@ edje_object_text_insert_filter_callback_del_full(Eo *obj EINA_UNUSED, const char
Eina_List *l;
Edje *ed;
ed = efl_data_scope_get(obj, EFL_CANVAS_LAYOUT_CLASS);
ed = _edje_fetch(obj);
if ((!ed) || (!part)) return NULL;
EINA_LIST_FOREACH(ed->text_insert_filter_callbacks, l, cb)
@ -705,7 +599,7 @@ edje_object_text_markup_filter_callback_add(Eo *obj EINA_UNUSED, const char *par
Edje_Markup_Filter_Callback *cb;
Edje *ed;
ed = efl_data_scope_get(obj, EFL_CANVAS_LAYOUT_CLASS);
ed = _edje_fetch(obj);
if ((!ed) || (!part)) return;
cb = calloc(1, sizeof(Edje_Markup_Filter_Callback));
@ -723,7 +617,7 @@ edje_object_text_markup_filter_callback_del(Eo *obj EINA_UNUSED, const char *par
Eina_List *l;
Edje *ed;
ed = efl_data_scope_get(obj, EFL_CANVAS_LAYOUT_CLASS);
ed = _edje_fetch(obj);
if ((!ed) || (!part)) return NULL;
EINA_LIST_FOREACH(ed->markup_filter_callbacks, l, cb)
@ -749,7 +643,7 @@ edje_object_text_markup_filter_callback_del_full(Eo *obj EINA_UNUSED, const char
Eina_List *l;
Edje *ed;
ed = efl_data_scope_get(obj, EFL_CANVAS_LAYOUT_CLASS);
ed = _edje_fetch(obj);
if ((!ed) || (!part)) return NULL;
EINA_LIST_FOREACH(ed->markup_filter_callbacks, l, cb)
@ -775,7 +669,7 @@ edje_object_part_text_user_insert(const Eo *obj, const char *part, const char *t
Edje_Real_Part *rp;
Edje *ed;
ed = efl_data_scope_get(obj, EFL_CANVAS_LAYOUT_CLASS);
ed = _edje_fetch(obj);
if ((!ed) || (!part)) return;
rp = _edje_real_part_recursive_get(&ed, part);
@ -828,7 +722,7 @@ edje_object_part_text_append(Eo *obj, const char *part, const char *text)
Edje *ed;
ed = efl_data_scope_get(obj, EFL_CANVAS_LAYOUT_CLASS);
ed = _edje_fetch(obj);
if ((!ed) || (!part)) return;
rp = _edje_real_part_recursive_get(&ed, part);
if (!rp) return;
@ -852,7 +746,7 @@ edje_object_part_text_escaped_set(Eo *obj, const char *part, const char *text)
Eina_Bool int_ret;
Edje *ed;
ed = efl_data_scope_get(obj, EFL_CANVAS_LAYOUT_CLASS);
ed = _edje_fetch(obj);
if ((!ed) || (!part)) return EINA_FALSE;
rp = _edje_real_part_recursive_get(&ed, part);
@ -1038,7 +932,7 @@ edje_object_part_text_unescaped_set(Eo *obj, const char *part, const char *text_
Eina_Bool int_ret = EINA_FALSE;
Edje *ed;
ed = efl_data_scope_get(obj, EFL_CANVAS_LAYOUT_CLASS);
ed = _edje_fetch(obj);
if ((!ed) || (!part)) return EINA_FALSE;
rp = _edje_real_part_recursive_get(&ed, part);
@ -1065,7 +959,7 @@ edje_object_part_text_unescaped_get(const Eo *obj EINA_UNUSED, const char *part)
Edje_Real_Part *rp;
Edje *ed;
ed = efl_data_scope_get(obj, EFL_CANVAS_LAYOUT_CLASS);
ed = _edje_fetch(obj);
if ((!ed) || (!part)) return NULL;
@ -1119,7 +1013,7 @@ edje_object_part_text_insert(Eo *obj, const char *part, const char *text)
Edje_Real_Part *rp;
Edje *ed;
ed = efl_data_scope_get(obj, EFL_CANVAS_LAYOUT_CLASS);
ed = _edje_fetch(obj);
if ((!ed) || (!part)) return;
rp = _edje_real_part_recursive_get(&ed, part);

15
src/lib/edje/edje_part_invalid.c
View File

@ -62,21 +62,6 @@ EDJE_PART_INVALID_VOID(efl_text_set, _efl_canvas_layout_part_invalid_efl_text_te
EDJE_PART_INVALID_CONST(const char *, 0, efl_text_get, _efl_canvas_layout_part_invalid_efl_text_text_get)
EDJE_PART_INVALID_VOID(efl_text_markup_set, _efl_canvas_layout_part_invalid_efl_text_markup_markup_set, const char *text)
EDJE_PART_INVALID_CONST(const char *, 0, efl_text_markup_get, _efl_canvas_layout_part_invalid_efl_text_markup_markup_get)
EDJE_PART_INVALID_CONST(Efl_Text_Cursor_Cursor *, 0, efl_text_cursor_get, _efl_canvas_layout_part_invalid_efl_text_cursor_text_cursor_get, Efl_Text_Cursor_Get_Type get_type)
EDJE_PART_INVALID_VOID(efl_text_cursor_paragraph_first, _efl_canvas_layout_part_invalid_efl_text_cursor_cursor_paragraph_first, Efl_Text_Cursor_Cursor *cur)
EDJE_PART_INVALID_VOID(efl_text_cursor_paragraph_last, _efl_canvas_layout_part_invalid_efl_text_cursor_cursor_paragraph_last, Efl_Text_Cursor_Cursor *cur)
EDJE_PART_INVALID_VOID(efl_text_cursor_position_set, _efl_canvas_layout_part_invalid_efl_text_cursor_cursor_position_set, Efl_Text_Cursor_Cursor *cur, int position)
EDJE_PART_INVALID_CONST(int, 0, efl_text_cursor_position_get, _efl_canvas_layout_part_invalid_efl_text_cursor_cursor_position_get, Efl_Text_Cursor_Cursor *cur)
EDJE_PART_INVALID_VOID(efl_text_cursor_coord_set, _efl_canvas_layout_part_invalid_efl_text_cursor_cursor_coord_set, Efl_Text_Cursor_Cursor *cur, int x, int y)
EDJE_PART_INVALID_VOID(efl_text_cursor_line_char_first, _efl_canvas_layout_part_invalid_efl_text_cursor_cursor_line_char_first, Efl_Text_Cursor_Cursor *cur)
EDJE_PART_INVALID_VOID(efl_text_cursor_line_char_last, _efl_canvas_layout_part_invalid_efl_text_cursor_cursor_line_char_last, Efl_Text_Cursor_Cursor *cur)
EDJE_PART_INVALID_VOID(efl_text_cursor_char_next, _efl_canvas_layout_part_invalid_efl_text_cursor_cursor_char_next, Efl_Text_Cursor_Cursor *cur)
EDJE_PART_INVALID_VOID(efl_text_cursor_char_prev, _efl_canvas_layout_part_invalid_efl_text_cursor_cursor_char_prev, Efl_Text_Cursor_Cursor *cur)
EDJE_PART_INVALID_VOID(efl_text_cursor_line_jump_by, _efl_canvas_layout_part_invalid_efl_text_cursor_cursor_line_jump_by, Efl_Text_Cursor_Cursor *cur, int by)
EDJE_PART_INVALID_VOID(efl_text_cursor_copy, _efl_canvas_layout_part_invalid_efl_text_cursor_cursor_copy, Efl_Text_Cursor_Cursor *dst, const Efl_Text_Cursor_Cursor *src)
EDJE_PART_INVALID_CONST(Eina_Unicode, 0, efl_text_cursor_content_get, _efl_canvas_layout_part_invalid_efl_text_cursor_cursor_content_get, const Efl_Text_Cursor_Cursor *cur)
EDJE_PART_INVALID_CONST(Eina_Bool, 0, efl_text_cursor_geometry_get, _efl_canvas_layout_part_invalid_efl_text_cursor_cursor_geometry_get, const Efl_Text_Cursor_Cursor *cur, Efl_Text_Cursor_Type ctype, int *cx, int *cy, int *cw, int *ch, int *cx2, int *cy2, int *cw2, int *ch2)
EDJE_PART_INVALID_VOID(efl_text_markup_interactive_cursor_markup_insert, _efl_canvas_layout_part_invalid_efl_text_markup_interactive_cursor_markup_insert, Efl_Text_Cursor_Cursor *cur, const char *markup)
EDJE_PART_INVALID(Eina_Iterator *, 0, efl_content_iterate, _efl_canvas_layout_part_invalid_efl_container_content_iterate)
EDJE_PART_INVALID(int, 0, efl_content_count, _efl_canvas_layout_part_invalid_efl_container_content_count)
EDJE_PART_INVALID(Eina_Bool, 0, efl_pack_clear, _efl_canvas_layout_part_invalid_efl_pack_pack_clear)

159
src/lib/edje/edje_part_text.c
View File

@ -38,165 +38,6 @@ _efl_canvas_layout_part_text_efl_text_markup_markup_set(Eo *obj,
_edje_efl_text_text_set(obj, pd->ed, pd->part, text, EINA_FALSE, EINA_TRUE);
}
EOLIAN static Efl_Text_Cursor_Cursor *
_efl_canvas_layout_part_text_efl_text_cursor_text_cursor_get(const Eo *obj,
void *_pd EINA_UNUSED, Efl_Text_Cursor_Get_Type get_type)
{
PROXY_DATA_GET(obj, pd);
return _edje_text_cursor_get(pd->rp, (int) get_type);
}
EOLIAN static void
_efl_canvas_layout_part_text_efl_text_cursor_cursor_paragraph_first(Eo *obj,
void *_pd EINA_UNUSED, Efl_Text_Cursor_Cursor *cur)
{
PROXY_DATA_GET(obj, pd);
_edje_text_cursor_begin(pd->rp, cur);
}
EOLIAN static void
_efl_canvas_layout_part_text_efl_text_cursor_cursor_paragraph_last(Eo *obj,
void *_pd EINA_UNUSED, Efl_Text_Cursor_Cursor *cur)
{
PROXY_DATA_GET(obj, pd);
_edje_text_cursor_end(pd->rp, cur);
}
EOLIAN static void
_efl_canvas_layout_part_text_efl_text_cursor_cursor_position_set(Eo *obj,
void *_pd EINA_UNUSED, Efl_Text_Cursor_Cursor *cur, int pos)
{
PROXY_DATA_GET(obj, pd);
_edje_text_cursor_pos_set(pd->rp, cur, pos);
}
EOLIAN static int
_efl_canvas_layout_part_text_efl_text_cursor_cursor_position_get(const Eo *obj,
void *_pd EINA_UNUSED, Efl_Text_Cursor_Cursor *cur)
{
PROXY_DATA_GET(obj, pd);
return _edje_text_cursor_pos_get(pd->rp, cur);
}
EOLIAN static void
_efl_canvas_layout_part_text_efl_text_cursor_cursor_coord_set(Eo *obj,
void *_pd EINA_UNUSED, Efl_Text_Cursor_Cursor *cur,
int x, int y)
{
PROXY_DATA_GET(obj, pd);
_edje_text_cursor_coord_set(pd->rp, cur, x, y);
}
EOLIAN static void
_efl_canvas_layout_part_text_efl_text_cursor_cursor_line_char_first(Eo *obj,
void *_pd EINA_UNUSED, Efl_Text_Cursor_Cursor *cur)
{
PROXY_DATA_GET(obj, pd);
_edje_text_cursor_line_begin(pd->rp, cur);
}
EOLIAN static void
_efl_canvas_layout_part_text_efl_text_cursor_cursor_line_char_last(Eo *obj,
void *_pd EINA_UNUSED, Efl_Text_Cursor_Cursor *cur)
{
PROXY_DATA_GET(obj, pd);
_edje_text_cursor_line_end(pd->rp, cur);
}
EOLIAN static void
_efl_canvas_layout_part_text_efl_text_cursor_cursor_char_prev(Eo *obj,
void *_pd EINA_UNUSED, Efl_Text_Cursor_Cursor *cur)
{
PROXY_DATA_GET(obj, pd);
_edje_text_cursor_prev(pd->rp, cur);
}
EOLIAN static void
_efl_canvas_layout_part_text_efl_text_cursor_cursor_char_next(Eo *obj,
void *_pd EINA_UNUSED, Efl_Text_Cursor_Cursor *cur)
{
PROXY_DATA_GET(obj, pd);
_edje_text_cursor_next(pd->rp, cur);
}
EOLIAN static void
_efl_canvas_layout_part_text_efl_text_cursor_cursor_line_jump_by(Eo *obj,
void *_pd EINA_UNUSED, Efl_Text_Cursor_Cursor *cur, int by)
{
PROXY_DATA_GET(obj, pd);
if (by == 1)
{
_edje_text_cursor_down(pd->rp, cur);
}
else if (by == -1)
{
_edje_text_cursor_up(pd->rp, cur);
}
}
EOLIAN static void
_efl_canvas_layout_part_text_efl_text_cursor_cursor_copy(Eo *obj,
void *_pd EINA_UNUSED,
Efl_Text_Cursor_Cursor *dst,
const Efl_Text_Cursor_Cursor *cur)
{
PROXY_DATA_GET(obj, pd);
_edje_text_cursor_copy(pd->rp, (Efl_Text_Cursor_Cursor *) cur, dst);
}
EOLIAN static Eina_Unicode
_efl_canvas_layout_part_text_efl_text_cursor_cursor_content_get(const Eo *obj,
void *_pd EINA_UNUSED,
const Efl_Text_Cursor_Cursor *cur)
{
Eina_Unicode *ustr;
Eina_Unicode uc = { 0 };
char *c;
int len;
PROXY_DATA_GET(obj, pd);
c = _edje_text_cursor_content_get(pd->rp, (Efl_Text_Cursor_Cursor *) cur);
ustr = eina_unicode_utf8_to_unicode(c, &len);
free(c);
if (ustr)
{
uc = *ustr;
free(ustr);
}
return uc;
}
EOLIAN static Eina_Bool
_efl_canvas_layout_part_text_efl_text_cursor_cursor_geometry_get(const Eo *obj,
void *_pd EINA_UNUSED,
const Efl_Text_Cursor_Cursor *cur EINA_UNUSED,
Efl_Text_Cursor_Type ctype EINA_UNUSED,
Evas_Coord *cx, Evas_Coord *cy, Evas_Coord *cw, Evas_Coord *ch,
Evas_Coord *cx2 EINA_UNUSED, Evas_Coord *cy2 EINA_UNUSED,
Evas_Coord *cw2 EINA_UNUSED, Evas_Coord *ch2 EINA_UNUSED)
{
PROXY_DATA_GET(obj, pd);
if (pd->rp->part->entry_mode > EDJE_ENTRY_EDIT_MODE_NONE)
{
_edje_entry_cursor_geometry_get(pd->rp, cx, cy, cw, ch, NULL);
if (cx) *cx -= pd->ed->x;
if (cy) *cy -= pd->ed->y;
}
return EINA_FALSE;
}
EOLIAN static void
_efl_canvas_layout_part_text_efl_text_markup_interactive_cursor_markup_insert(Eo *obj,
void *_pd EINA_UNUSED, Efl_Text_Cursor_Cursor *cur EINA_UNUSED,
const char *text)
{
PROXY_DATA_GET(obj, pd);
// Ignoring cursor type and always inserting with main cursor
_edje_object_part_text_insert(pd->ed, pd->rp, text);
// FIXME: entry should report the length of inserted text (after filtering)
}
/* More Efl.Text.* API (@since 1.22) */
EOLIAN static void

26
src/lib/edje/edje_private.h
View File

@ -3303,19 +3303,19 @@ const char *_edje_efl_text_text_get(const Eo *obj, Edje *ed, const char *part, E
Eina_Bool _edje_efl_text_markup_set(Eo *obj, Edje *ed, const char *part, const char *markup);
const char *_edje_efl_text_markup_get(Eo *obj, Edje *ed, const char *part);
Evas_Textblock_Cursor *_edje_text_cursor_get(Edje_Real_Part *rp, Edje_Cursor cur);
void _edje_text_cursor_begin(Edje_Real_Part *rp, Efl_Text_Cursor_Cursor *cur);
void _edje_text_cursor_end(Edje_Real_Part *rp, Efl_Text_Cursor_Cursor *cur);
void _edje_text_cursor_pos_set(Edje_Real_Part *rp, Efl_Text_Cursor_Cursor *cur, int pos);
int _edje_text_cursor_pos_get(Edje_Real_Part *rp, Efl_Text_Cursor_Cursor *cur);
Eina_Bool _edje_text_cursor_coord_set(Edje_Real_Part *rp, Efl_Text_Cursor_Cursor *cur, int x, int y);
void _edje_text_cursor_line_begin(Edje_Real_Part *rp, Efl_Text_Cursor_Cursor *cur);
void _edje_text_cursor_line_end(Edje_Real_Part *rp, Efl_Text_Cursor_Cursor *cur);
Eina_Bool _edje_text_cursor_next(Edje_Real_Part *rp, Efl_Text_Cursor_Cursor *cur);
Eina_Bool _edje_text_cursor_prev(Edje_Real_Part *rp, Efl_Text_Cursor_Cursor *cur);
Eina_Bool _edje_text_cursor_up(Edje_Real_Part *rp, Efl_Text_Cursor_Cursor *cur);
Eina_Bool _edje_text_cursor_down(Edje_Real_Part *rp, Efl_Text_Cursor_Cursor *cur);
void _edje_text_cursor_copy(Edje_Real_Part *rp, Efl_Text_Cursor_Cursor *dst, Efl_Text_Cursor_Cursor *cur);
char * _edje_text_cursor_content_get(Edje_Real_Part *rp, Efl_Text_Cursor_Cursor *cur);
void _edje_text_cursor_begin(Edje_Real_Part *rp, Efl_Text_Cursor_Handle *cur);
void _edje_text_cursor_end(Edje_Real_Part *rp, Efl_Text_Cursor_Handle *cur);
void _edje_text_cursor_pos_set(Edje_Real_Part *rp, Efl_Text_Cursor_Handle *cur, int pos);
int _edje_text_cursor_pos_get(Edje_Real_Part *rp, Efl_Text_Cursor_Handle *cur);
Eina_Bool _edje_text_cursor_coord_set(Edje_Real_Part *rp, Efl_Text_Cursor_Handle *cur, int x, int y);
void _edje_text_cursor_line_begin(Edje_Real_Part *rp, Efl_Text_Cursor_Handle *cur);
void _edje_text_cursor_line_end(Edje_Real_Part *rp, Efl_Text_Cursor_Handle *cur);
Eina_Bool _edje_text_cursor_next(Edje_Real_Part *rp, Efl_Text_Cursor_Handle *cur);
Eina_Bool _edje_text_cursor_prev(Edje_Real_Part *rp, Efl_Text_Cursor_Handle *cur);
Eina_Bool _edje_text_cursor_up(Edje_Real_Part *rp, Efl_Text_Cursor_Handle *cur);
Eina_Bool _edje_text_cursor_down(Edje_Real_Part *rp, Efl_Text_Cursor_Handle *cur);
void _edje_text_cursor_copy(Edje_Real_Part *rp, Efl_Text_Cursor_Handle *dst, Efl_Text_Cursor_Handle *cur);
char * _edje_text_cursor_content_get(Edje_Real_Part *rp, Efl_Text_Cursor_Handle *cur);
void _edje_object_part_text_insert(Edje *ed, Edje_Real_Part *rp, const char *text);
void _edje_internal_proxy_shutdown(void);

99
src/lib/edje/edje_textblock.c
View File

@ -34,7 +34,8 @@ _edje_part_recalc_single_textblock_min_max_calc_legacy(Edje_Real_Part *ep,
int *minw, int *minh,
int *maxw, int *maxh)
{
Evas_Coord tw, th, ins_l, ins_r, ins_t, ins_b;
Eina_Size2D size;
Evas_Coord ins_l, ins_r, ins_t, ins_b;
unsigned char minx2 = 0, miny2 = 0, maxx2 = 0, maxy2 = 0;
minx2 = chosen_desc->text.min_x;
@ -57,18 +58,18 @@ _edje_part_recalc_single_textblock_min_max_calc_legacy(Edje_Real_Part *ep,
{
int mw = 0, mh = 0;
tw = th = 0;
size.w = size.h = 0;
if (!minx2)
{
efl_gfx_entity_size_set(ep->object, EINA_SIZE2D(TO_INT(params->eval.w), TO_INT(params->eval.h)));
efl_canvas_text_size_formatted_get(ep->object, &tw, &th);
size = efl_canvas_text_size_formatted_get(ep->object);
}
else
evas_object_textblock_size_native_get(ep->object, &tw, &th);
size = efl_canvas_text_size_native_get(ep->object);
evas_object_textblock_style_insets_get(ep->object, &ins_l,
&ins_r, &ins_t, &ins_b);
mw = ins_l + tw + ins_r;
mh = ins_t + th + ins_b;
mw = ins_l + size.w + ins_r;
mh = ins_t + size.h + ins_b;
if (minw && minx2)
{
if (mw > *minw) *minw = mw;
@ -83,18 +84,18 @@ _edje_part_recalc_single_textblock_min_max_calc_legacy(Edje_Real_Part *ep,
{
int mw = 0, mh = 0;
tw = th = 0;
size.w = size.h = 0;
if (!maxx2)
{
efl_gfx_entity_size_set(ep->object, EINA_SIZE2D(TO_INT(params->eval.w), TO_INT(params->eval.h)));
efl_canvas_text_size_formatted_get(ep->object, &tw, &th);
size = efl_canvas_text_size_formatted_get(ep->object);
}
else
evas_object_textblock_size_native_get(ep->object, &tw, &th);
size = efl_canvas_text_size_native_get(ep->object);
evas_object_textblock_style_insets_get(ep->object, &ins_l, &ins_r,
&ins_t, &ins_b);
mw = ins_l + tw + ins_r;
mh = ins_t + th + ins_b;
mw = ins_l + size.w + ins_r;
mh = ins_t + size.h + ins_b;
if (maxw && maxx2)
{
if (mw > *maxw) *maxw = mw;
@ -115,6 +116,7 @@ _edje_part_recalc_single_textblock_min_max_calc(Edje_Real_Part *ep,
int *minw, int *minh,
int *maxw, int *maxh)
{
Eina_Size2D size;
Evas_Coord tw, th, ins_l, ins_r, ins_t, ins_b;
Evas_Coord min_calc_w = 0, min_calc_h = 0;
@ -178,14 +180,17 @@ _edje_part_recalc_single_textblock_min_max_calc(Edje_Real_Part *ep,
if (temp_w > 0)
{
efl_gfx_entity_size_set(ep->object, EINA_SIZE2D(temp_w, temp_h));
efl_canvas_text_size_formatted_get(ep->object, &tw, &th);
size = efl_canvas_text_size_formatted_get(ep->object);
tw = size.w;
th = size.h;
tw += ins_l + ins_r;
th += ins_t + ins_b;
}
else
{
efl_canvas_text_size_native_get(ep->object, NULL, &th);
size = efl_canvas_text_size_native_get(ep->object);
th = size.h;
th += ins_t + ins_b;
}
@ -216,7 +221,9 @@ _edje_part_recalc_single_textblock_min_max_calc(Edje_Real_Part *ep,
}
efl_gfx_entity_size_set(ep->object, EINA_SIZE2D(temp_w, temp_h));
efl_canvas_text_size_formatted_get(ep->object, &tw, &th);
size = efl_canvas_text_size_formatted_get(ep->object);
tw = size.w;
th = size.h;
tw += ins_l + ins_r;
th += ins_t + ins_b;
@ -225,7 +232,8 @@ _edje_part_recalc_single_textblock_min_max_calc(Edje_Real_Part *ep,
* don't get meaningless height for multiline */
if (temp_w <= 0)
{
efl_canvas_text_size_native_get(ep->object, NULL, &th);
size = efl_canvas_text_size_native_get(ep->object);
th = size.h;
th += ins_t + ins_b;
}
@ -238,7 +246,9 @@ _edje_part_recalc_single_textblock_min_max_calc(Edje_Real_Part *ep,
* text.min: 1 X
* text.max: 0 X without max width.
* It is a singleline Textblock. */
efl_canvas_text_size_native_get(ep->object, &tw, &th);
size = efl_canvas_text_size_native_get(ep->object);
tw = size.w;
th = size.h;
tw += ins_l + ins_r;
th += ins_t + ins_b;
@ -301,14 +311,17 @@ _edje_part_recalc_single_textblock_min_max_calc(Edje_Real_Part *ep,
if (temp_w > 0)
{
efl_gfx_entity_size_set(ep->object, EINA_SIZE2D(temp_w, temp_h));
efl_canvas_text_size_formatted_get(ep->object, &tw, &th);
size = efl_canvas_text_size_formatted_get(ep->object);
tw = size.w;
th = size.h;
tw += ins_l + ins_r;
th += ins_t + ins_b;
}
else
{
efl_canvas_text_size_native_get(ep->object, NULL, &th);
size = efl_canvas_text_size_native_get(ep->object);
th = size.h;
th += ins_t + ins_b;
}
@ -322,7 +335,9 @@ _edje_part_recalc_single_textblock_min_max_calc(Edje_Real_Part *ep,
/* text.min: 1 X
* text.max: 1 X
* Singleline. */
efl_canvas_text_size_native_get(ep->object, &tw, &th);
size = efl_canvas_text_size_native_get(ep->object);
tw = size.w;
th = size.h;
tw += ins_l + ins_r;
th += ins_t + ins_b;
@ -359,7 +374,9 @@ _edje_part_recalc_single_textblock_min_max_calc(Edje_Real_Part *ep,
* text.max: 1 1 */
efl_gfx_entity_size_set(ep->object, EINA_SIZE2D(temp_w, temp_h));
efl_canvas_text_size_formatted_get(ep->object, &tw, &th);
size = efl_canvas_text_size_formatted_get(ep->object);
tw = size.w;
th = size.h;
tw += ins_l + ins_r;
th += ins_t + ins_b;
@ -368,7 +385,8 @@ _edje_part_recalc_single_textblock_min_max_calc(Edje_Real_Part *ep,
* don't get meaningless height for multiline */
if (temp_w <= 0)
{
efl_canvas_text_size_native_get(ep->object, NULL, &th);
size = efl_canvas_text_size_native_get(ep->object);
th = size.h;
th += ins_t + ins_b;
}
@ -386,7 +404,9 @@ _edje_part_recalc_single_textblock_min_max_calc(Edje_Real_Part *ep,
temp_h = efl_gfx_entity_size_get(ep->object).h;
efl_gfx_entity_size_set(ep->object, EINA_SIZE2D(temp_w, temp_h));
efl_canvas_text_size_formatted_get(ep->object, &tw, &th);
size = efl_canvas_text_size_formatted_get(ep->object);
tw = size.w;
th = size.h;
tw += ins_l + ins_r;
th += ins_t + ins_b;
@ -395,7 +415,8 @@ _edje_part_recalc_single_textblock_min_max_calc(Edje_Real_Part *ep,
* don't get meaningless height for multiline */
if (temp_w <= 0)
{
efl_canvas_text_size_native_get(ep->object, NULL, &th);
size = efl_canvas_text_size_native_get(ep->object);
th = size.h;
th += ins_t + ins_b;
}
@ -429,9 +450,7 @@ _edje_part_textblock_style_text_set(Edje *ed,
if (chosen_desc->text.id_source >= 0)
{
Edje_Part_Description_Text *et;
ep->typedata.text->source = ed->table_parts[chosen_desc->text.id_source % ed->table_parts_size];
et = _edje_real_part_text_source_description_get(ep, NULL);
tmp = edje_string_get(&et->text.style);
if (tmp) style = tmp;
@ -509,7 +528,7 @@ _edje_part_recalc_single_textblock(FLOAT_T sc,
if (chosen_desc)
{
Evas_Coord tw, th;
Eina_Size2D size;
if (ep->part->scale)
evas_object_scale_set(ep->object, TO_DOUBLE(sc));
@ -526,33 +545,33 @@ _edje_part_recalc_single_textblock(FLOAT_T sc,
if (ep->part->scale) base_s = TO_DOUBLE(sc);
efl_gfx_entity_scale_set(ep->object, base_s);
efl_canvas_text_size_native_get(ep->object, &tw, &th);
size = efl_canvas_text_size_native_get(ep->object);
orig_s = base_s;
/* Now make it bigger so calculations will be more accurate
* and less influenced by hinting... */
{
orig_s = _edje_part_recalc_single_textblock_scale_range_adjust(chosen_desc, base_s,
orig_s * TO_INT(params->eval.w) / tw);
orig_s * TO_INT(params->eval.w) / size.w);
efl_gfx_entity_scale_set(ep->object, orig_s);
efl_canvas_text_size_native_get(ep->object, &tw, &th);
size = efl_canvas_text_size_native_get(ep->object);
}
if (chosen_desc->text.fit_x)
{
if (tw > 0)
if (size.w > 0)
{
s = _edje_part_recalc_single_textblock_scale_range_adjust(chosen_desc, base_s,
orig_s * TO_INT(params->eval.w) / tw);
orig_s * TO_INT(params->eval.w) / size.w);
efl_gfx_entity_scale_set(ep->object, s);
efl_canvas_text_size_native_get(ep->object, NULL, NULL);
efl_canvas_text_size_native_get(ep->object);
}
}
if (chosen_desc->text.fit_y)
{
if (th > 0)
if (size.h > 0)
{
double tmp_s = _edje_part_recalc_single_textblock_scale_range_adjust(chosen_desc, base_s,
orig_s * TO_INT(params->eval.h) / th);
orig_s * TO_INT(params->eval.h) / size.h);
/* If we already have X fit, restrict Y to be no bigger
* than what we got with X. */
if (!((chosen_desc->text.fit_x) && (tmp_s > s)))
@ -561,7 +580,7 @@ _edje_part_recalc_single_textblock(FLOAT_T sc,
}
efl_gfx_entity_scale_set(ep->object, s);
efl_canvas_text_size_native_get(ep->object, NULL, NULL);
efl_canvas_text_size_native_get(ep->object);
}
}
@ -569,14 +588,14 @@ _edje_part_recalc_single_textblock(FLOAT_T sc,
* actually end up being correct. */
{
int i = 5; /* Tries before we give up. */
Evas_Coord fw, fh;
efl_canvas_text_size_native_get(ep->object, &fw, &fh);
Eina_Size2D size;
size = efl_canvas_text_size_native_get(ep->object);
/* If we are still too big, try reducing the size to
* 95% each try. */
while ((i > 0) &&
((chosen_desc->text.fit_x && (fw > TO_INT(params->eval.w))) ||
(chosen_desc->text.fit_y && (fh > TO_INT(params->eval.h)))))
((chosen_desc->text.fit_x && (size.w > TO_INT(params->eval.w))) ||
(chosen_desc->text.fit_y && (size.h > TO_INT(params->eval.h)))))
{
double tmp_s = _edje_part_recalc_single_textblock_scale_range_adjust(chosen_desc, base_s, s * 0.95);
@ -586,7 +605,7 @@ _edje_part_recalc_single_textblock(FLOAT_T sc,
s = tmp_s;
efl_gfx_entity_scale_set(ep->object, s);
efl_canvas_text_size_native_get(ep->object, &fw, &fh);
size = efl_canvas_text_size_native_get(ep->object);
i--;
}
}

16
src/lib/edje/efl_canvas_layout_part_invalid.eo
View File

@ -1,7 +1,7 @@
class @beta Efl.Canvas.Layout_Part_Invalid extends Efl.Canvas.Layout_Part implements Efl.Content,
Efl.Pack_Linear, Efl.Ui.Layout_Orientable_Readonly,
Efl.Pack_Table, Efl.Text,
Efl.Text_Markup, Efl.Text_Markup_Interactive
Efl.Text_Markup
{
[[Common class for part proxy objects for @Efl.Canvas.Layout.
@ -29,20 +29,6 @@ class @beta Efl.Canvas.Layout_Part_Invalid extends Efl.Canvas.Layout_Part implem
// Efl.Canvas.Layout_Part_Text
Efl.Text.text { set; get; }
Efl.Text_Markup.markup { get; set; }
Efl.Text_Markup_Interactive.cursor_markup_insert;
Efl.Text_Cursor.text_cursor { get; }
Efl.Text_Cursor.cursor_paragraph_first;
Efl.Text_Cursor.cursor_paragraph_last;
Efl.Text_Cursor.cursor_position { set; get; }
Efl.Text_Cursor.cursor_coord_set;
Efl.Text_Cursor.cursor_line_char_first;
Efl.Text_Cursor.cursor_line_char_last;
Efl.Text_Cursor.cursor_char_next;
Efl.Text_Cursor.cursor_char_prev;
Efl.Text_Cursor.cursor_line_jump_by;
Efl.Text_Cursor.cursor_copy;
Efl.Text_Cursor.cursor_content { get; }
Efl.Text_Cursor.cursor_geometry { get; }
// Efl.Canvas.Layout_Part_Box
Efl.Container.content_iterate;
Efl.Container.content_count;

16
src/lib/edje/efl_canvas_layout_part_text.eo
View File

@ -11,7 +11,7 @@ enum @beta Efl.Canvas.Layout_Part_Text_Expand
}
class @beta Efl.Canvas.Layout_Part_Text extends Efl.Canvas.Layout_Part implements Efl.Text,
Efl.Text_Markup, Efl.Text_Markup_Interactive, Efl.Text_Format, Efl.Text_Font, Efl.Text_Style
Efl.Text_Markup, Efl.Text_Format, Efl.Text_Font, Efl.Text_Style
{
[[Represents a TEXT part of a layout
@ -36,20 +36,6 @@ Efl.Text_Markup, Efl.Text_Markup_Interactive, Efl.Text_Format, Efl.Text_Font, Ef
implements {
Efl.Text.text { set; get; }
Efl.Text_Markup.markup { get; set; }
Efl.Text_Markup_Interactive.cursor_markup_insert;
Efl.Text_Cursor.text_cursor { get; }
Efl.Text_Cursor.cursor_paragraph_first;
Efl.Text_Cursor.cursor_paragraph_last;
Efl.Text_Cursor.cursor_position { set; get; }
Efl.Text_Cursor.cursor_coord_set;
Efl.Text_Cursor.cursor_line_char_first;
Efl.Text_Cursor.cursor_line_char_last;
Efl.Text_Cursor.cursor_char_next;
Efl.Text_Cursor.cursor_char_prev;
Efl.Text_Cursor.cursor_line_jump_by;
Efl.Text_Cursor.cursor_copy;
Efl.Text_Cursor.cursor_content { get; }
Efl.Text_Cursor.cursor_geometry { get; }
Efl.Text_Format.ellipsis { set; get; }
Efl.Text_Format.wrap { set; get; }
Efl.Text_Font.font { set; get; }

5
src/lib/efl/Efl.h
View File

@ -68,7 +68,8 @@ extern "C" {
*/
typedef struct tm Efl_Time;
typedef struct _Efl_Text_Cursor_Cursor Efl_Text_Cursor_Cursor;
typedef struct _Efl_Text_Cursor_Handle Efl_Text_Cursor_Handle;
typedef struct _Efl_Text_Cursor_Handle _Efl_Text_Cursor_Handle;
typedef struct _Efl_Text_Annotate_Annotation Efl_Text_Annotate_Annotation;
#include "interfaces/efl_types.eot.h"
@ -210,10 +211,8 @@ typedef Efl_Gfx_Path_Command_Type Efl_Gfx_Path_Command;
#include "interfaces/efl_text_font.eo.h"
#include "interfaces/efl_text_style.eo.h"
#include "interfaces/efl_text_format.eo.h"
#include "interfaces/efl_text_cursor.eo.h"
#include "interfaces/efl_text_annotate.eo.h"
#include "interfaces/efl_text_markup.eo.h"
#include "interfaces/efl_text_markup_interactive.eo.h"
#include "interfaces/efl_text_markup_util.eo.h"
#ifdef EFL_BETA_API_SUPPORT

2
src/lib/efl/interfaces/efl_interfaces_main.c
View File

@ -24,10 +24,8 @@
#include "interfaces/efl_text_font.eo.c"
#include "interfaces/efl_text_style.eo.c"
#include "interfaces/efl_text_format.eo.c"
#include "interfaces/efl_text_cursor.eo.c"
#include "interfaces/efl_text_annotate.eo.c"
#include "interfaces/efl_text_markup.eo.c"
#include "interfaces/efl_text_markup_interactive.eo.c"
#include "interfaces/efl_gfx_entity.eo.c"
#include "interfaces/efl_gfx_buffer.eo.c"

16
src/lib/efl/interfaces/efl_text_annotate.eo
View File

@ -30,8 +30,8 @@ interface @beta Efl.Text_Annotate {
[[Returns an iterator of all the handles in a range.
]]
params {
@in start: ptr(const(Efl.Text_Cursor_Cursor)); [[Start of range]]
@in end: ptr(const(Efl.Text_Cursor_Cursor)); [[End of range]]
@in start: ptr(const(Efl.Text_Cursor_Handle)); [[Start of range]]
@in end: ptr(const(Efl.Text_Cursor_Handle)); [[End of range]]
}
return: iterator<ptr(Efl.Text_Annotate_Annotation)> @move; [[Handle of the Annotation]]
}
@ -42,8 +42,8 @@ interface @beta Efl.Text_Annotate {
handle will be returned for further handling.
]]
params {
@in start: ptr(Efl.Text_Cursor_Cursor); [[Start of range]]
@in end: ptr(Efl.Text_Cursor_Cursor); [[End of range]]
@in start: ptr(Efl.Text_Cursor_Handle); [[Start of range]]
@in end: ptr(Efl.Text_Cursor_Handle); [[End of range]]
@in format: string; [[Annotation format]]
}
return: ptr(Efl.Text_Annotate_Annotation); [[Handle of inserted annotation]]
@ -69,9 +69,9 @@ interface @beta Efl.Text_Annotate {
params {
@in annotation: ptr(const(Efl.Text_Annotate_Annotation)); [[Annotation
handle to query]]
@in start: ptr(Efl.Text_Cursor_Cursor); [[Cursor to be set to the start
@in start: ptr(Efl.Text_Cursor_Handle); [[Cursor to be set to the start
position of the annotation in the text]]
@in end: ptr(Efl.Text_Cursor_Cursor); [[Cursor to be set to the end
@in end: ptr(Efl.Text_Cursor_Handle); [[Cursor to be set to the end
position of the annotation in the text]]
}
}
@ -111,7 +111,7 @@ interface @beta Efl.Text_Annotate {
annotation: ptr(Efl.Text_Annotate_Annotation); [[Annotation]]
}
keys {
cur: ptr(Efl.Text_Cursor_Cursor); [[Cursor object]]
cur: ptr(Efl.Text_Cursor_Handle); [[Cursor object]]
}
}
cursor_item_insert {
@ -122,7 +122,7 @@ interface @beta Efl.Text_Annotate {
OBJECT REPLACEMENT CHARACTER and set a special annotation to it.
]]
params {
cur: ptr(Efl.Text_Cursor_Cursor); [[Cursor object]]
cur: ptr(Efl.Text_Cursor_Handle); [[Cursor object]]
@in item: string; [[Item key to be used in higher-up
code to query and decided what image, emoticon
etc. to embed.]]

246
src/lib/efl/interfaces/efl_text_cursor.eo
View File

@ -1,246 +0,0 @@
import eina_types;
import efl_text_types;
enum @beta Efl.Text_Cursor_Get_Type {
[[All available cursor states]]
default = 0, [[Main cursor state (alias to "main")]]
main, [[Main cursor state]]
selection_begin, [[Selection begin cursor state]]
selection_end, [[Selection end cursor state]]
preedit_start, [[Pre-edit start cursor state]]
preedit_end, [[Pre-edit end cursor state]]
user, [[User cursor state]]
user_extra [[User extra cursor state]]
}
enum @beta Efl.Text_Cursor_Type
{
[[Text cursor types]]
before, [[Cursor type before]]
under [[Cursor type under]]
}
interface @beta Efl.Text_Cursor {
[[Cursor API
]]
methods {
// Cursor
@property text_cursor {
[[The object's main cursor.
]]
get {
return: ptr(Efl.Text_Cursor_Cursor); [[Text cursor object]]
}
keys {
get_type: Efl.Text_Cursor_Get_Type; [[Cursor type]]
}
}
@property cursor_position {
[[Cursor position]]
set { }
get { }
values {
position: int; [[Cursor position]]
}
keys {
cur: ptr(Efl.Text_Cursor_Cursor); [[Cursor object]]
}
}
@property cursor_content {
[[The content of the cursor (the character under the cursor)]]
get {
}
values {
content: Eina.Unicode; [[The unicode codepoint of the character]]
}
keys {
cur: ptr(const(Efl.Text_Cursor_Cursor)); [[Cursor object]]
}
}
@property cursor_geometry {
[[Returns the geometry of two cursors ("split cursor"), if logical cursor is
between LTR/RTL text, also considering paragraph direction.
Upper cursor is shown for the text of the same direction as paragraph,
lower cursor - for opposite.
Split cursor geometry is valid only in '|' cursor mode.
In this case $true is returned and $cx2, $cy2, $cw2, $ch2 are set.
]]
get {
return: bool; [[ $true if split cursor, $false otherwise.]]
}
keys {
cur: ptr(const(Efl.Text_Cursor_Cursor)); [[Cursor object]]
ctype: Efl.Text_Cursor_Type; [[The type of the cursor.]]
}
values {
cx: int; [[The x of the cursor (or upper cursor)]]
cy: int; [[The y of the cursor (or upper cursor)]]
cw: int; [[The width of the cursor (or upper cursor)]]
ch: int; [[The height of the cursor (or upper cursor)]]
cx2: int; [[The x of the lower cursor]]
cy2: int; [[The y of the lower cursor]]
cw2: int; [[The width of the lower cursor]]
ch2: int; [[The height of the lower cursor]]
}
}
cursor_new {
[[Create new cursor]]
return: ptr(Efl.Text_Cursor_Cursor); [[Cursor object]]
}
cursor_free {
[[Free existing cursor]]
params {
cur: ptr(Efl.Text_Cursor_Cursor); [[Cursor object]]
}
}
cursor_equal {
[[Check if two cursors are equal]]
params {
@in cur1: ptr(const(Efl.Text_Cursor_Cursor)); [[Cursor 1 object]]
@in cur2: ptr(const(Efl.Text_Cursor_Cursor)); [[Cursor 2 object]]
}
return: bool; [[$true if cursors are equal, $false otherwise]]
}
cursor_compare {
[[Compare two cursors]]
params {
@in cur1: ptr(const(Efl.Text_Cursor_Cursor)); [[Cursor 1 object]]
@in cur2: ptr(const(Efl.Text_Cursor_Cursor)); [[Cursor 2 object]]
}
return: int; [[Difference between cursors]]
}
cursor_copy {
[[Copy existing cursor]]
params {
/* @out */ dst: ptr(Efl.Text_Cursor_Cursor); [[Destination cursor]]
@in src: ptr(const(Efl.Text_Cursor_Cursor)); [[Source cursor]]
}
}
cursor_char_next {
[[Advances to the next character]]
params {
/* @inout */ cur: ptr(Efl.Text_Cursor_Cursor); [[Cursor object]]
}
}
cursor_char_prev {
[[Advances to the previous character]]
params {
/* @inout */ cur: ptr(Efl.Text_Cursor_Cursor); [[Cursor object]]
}
}
cursor_cluster_next {
[[Advances to the next grapheme cluster]]
params {
/* @inout */ cur: ptr(Efl.Text_Cursor_Cursor); [[Cursor object]]
}
}
cursor_cluster_prev {
[[Advances to the previous grapheme cluster]]
params {
/* @inout */ cur: ptr(Efl.Text_Cursor_Cursor); [[Cursor object]]
}
}
cursor_paragraph_char_first {
[[Advances to the first character in this paragraph]]
params {
/* @inout */ cur: ptr(Efl.Text_Cursor_Cursor); [[Cursor object]]
}
}
cursor_paragraph_char_last {
[[Advances to the last character in this paragraph]]
params {
/* @inout */ cur: ptr(Efl.Text_Cursor_Cursor); [[Cursor object]]
}
}
cursor_word_start {
[[Advance to current word start]]
params {
/* @inout */ cur: ptr(Efl.Text_Cursor_Cursor); [[Cursor object]]
}
}
cursor_word_end {
[[Advance to current word end]]
params {
/* @inout */ cur: ptr(Efl.Text_Cursor_Cursor); [[Cursor object]]
}
}
cursor_line_char_first {
[[Advance to current line first character]]
params {
/* @inout */ cur: ptr(Efl.Text_Cursor_Cursor); [[Cursor object]]
}
}
cursor_line_char_last {
[[Advance to current line last character]]
params {
/* @inout */ cur: ptr(Efl.Text_Cursor_Cursor); [[Cursor object]]
}
}
cursor_paragraph_first {
[[Advance to current paragraph first character]]
params {
/* @inout */ cur: ptr(Efl.Text_Cursor_Cursor); [[Cursor object]]
}
}
cursor_paragraph_last {
[[Advance to current paragraph last character]]
params {
/* @inout */ cur: ptr(Efl.Text_Cursor_Cursor); [[Cursor object]]
}
}
cursor_paragraph_next {
[[Advances to the start of the next text node]]
params {
/* @inout */ cur: ptr(Efl.Text_Cursor_Cursor); [[Cursor object]]
}
}
cursor_paragraph_prev {
[[Advances to the end of the previous text node]]
params {
/* @inout */ cur: ptr(Efl.Text_Cursor_Cursor); [[Cursor object]]
}
}
cursor_line_jump_by {
[[Jump the cursor by the given number of lines]]
params {
/* @inout */ cur: ptr(Efl.Text_Cursor_Cursor); [[Cursor object]]
by: int; [[Number of lines]]
}
}
cursor_coord_set {
[[Set cursor coordinates]]
params {
/* @inout */ cur: ptr(Efl.Text_Cursor_Cursor); [[Cursor object]]
@in x: int; [[X coord to set by.]]
@in y: int; [[Y coord to set by.]]
}
}
cursor_cluster_coord_set {
[[Set cursor coordinates according to grapheme clusters.
It does not allow to put a cursor to the middle of a grapheme cluster.
]]
params {
/* @inout */ cur: ptr(Efl.Text_Cursor_Cursor); [[Cursor object]]
@in x: int; [[X coord to set by.]]
@in y: int; [[Y coord to set by.]]
}
}
cursor_text_insert {
[[Adds text to the current cursor position and set the cursor to
*after* the start of the text just added.
]]
params {
/* @inout */ cur: ptr(Efl.Text_Cursor_Cursor); [[Cursor object]]
@in text: string; [[Text to append (UTF-8 format).]]
}
return: int; [[Length of the appended text.]]
}
cursor_char_delete {
[[Deletes a single character from position pointed by given cursor.]]
params {
/* @inout */ cur: ptr(Efl.Text_Cursor_Cursor); [[Cursor object]]
}
}
}
}

25
src/lib/efl/interfaces/efl_text_markup_interactive.eo
View File

@ -1,25 +0,0 @@
interface @beta Efl.Text_Markup_Interactive extends Efl.Text_Cursor {
[[Markup data that populates the text object's style and format
]]
methods {
@property markup_range {
[[Markup of a given range in the text]]
values {
markup: mstring @move; [[The markup-text representation set to
this text of a given range]]
}
keys {
start: ptr(Efl.Text_Cursor_Cursor); [[Start of the markup region]]
end: ptr(Efl.Text_Cursor_Cursor); [[End of markup region]]
}
}
cursor_markup_insert {
[[Inserts a markup text to the text object in a given cursor position]]
params {
cur: ptr(Efl.Text_Cursor_Cursor); [[Cursor position to insert markup]]
@in markup: string; [[The markup text to insert]]
}
}
}
}

2
src/lib/efl/interfaces/efl_text_types.eot
View File

@ -24,5 +24,5 @@ struct @beta Efl.Ui.Text_Change_Info {
type @extern @beta Efl.Text_Annotate_Annotation: __undefined_type; [[EFL text annotations data structure]]
type @extern @beta Efl.Text_Cursor_Cursor: __undefined_type; [[Text cursor data structure]]
type @extern @beta Efl.Text_Cursor_Handle: __undefined_type; [[Text cursor data structure]]

2
src/lib/efl/interfaces/meson.build
View File

@ -44,10 +44,8 @@ pub_eo_files = [
'efl_text_font.eo',
'efl_text_style.eo',
'efl_text_format.eo',
'efl_text_cursor.eo',
'efl_text_annotate.eo',
'efl_text_markup.eo',
'efl_text_markup_interactive.eo',
'efl_text_markup_util.eo',
'efl_gfx_stack.eo',
'efl_gfx_view.eo',

11
src/lib/elementary/efl_text_interactive.eo
View File

@ -5,6 +5,13 @@ interface @beta Efl.Text_Interactive extends Efl.Text, Efl.Text_Font,
{
[[This is an interface interactive text inputs should implement]]
methods {
@property main_cursor {
[[The user visible cursor.]]
get {}
values {
cursor: Efl.Text.Cursor; [[The user visible cursor.]]
}
}
@property selection_allowed {
[[Whether or not selection is allowed on this object]]
set {}
@ -24,8 +31,8 @@ interface @beta Efl.Text_Interactive extends Efl.Text, Efl.Text_Font,
]]
get {}
values {
start: ptr(Efl.Text_Cursor_Cursor); [[The start of the selection]]
end: ptr(Efl.Text_Cursor_Cursor); [[The end of the selection]]
start: Efl.Text.Cursor; [[The start of the selection]]
end: Efl.Text.Cursor; [[The end of the selection]]
}
}
@property editable {

322
src/lib/elementary/efl_ui_internal_text_interactive.c
View File

@ -12,8 +12,9 @@
typedef struct _Efl_Ui_Internal_Text_Interactive_Data
{
Evas_Textblock_Cursor *sel_start, *sel_end;
Evas_Textblock_Cursor *preedit_start, *preedit_end;
Efl_Text_Cursor *sel_start, *sel_end;
Efl_Text_Cursor *main_cursor;
Efl_Text_Cursor *preedit_start, *preedit_end;
Eina_List *seq;
char *selection;
Eina_Bool composing : 1;
@ -34,12 +35,12 @@ typedef struct _Efl_Ui_Internal_Text_Interactive_Data
} Efl_Ui_Internal_Text_Interactive_Data;
static void _sel_range_del_emit(Evas_Object *obj, Efl_Ui_Internal_Text_Interactive_Data *en);
static void _sel_init(Evas_Textblock_Cursor *c, Evas_Object *o, Efl_Ui_Internal_Text_Interactive_Data *en);
static void _sel_enable(Evas_Textblock_Cursor *c EINA_UNUSED, Evas_Object *o EINA_UNUSED, Efl_Ui_Internal_Text_Interactive_Data *en);
static void _sel_extend(Evas_Textblock_Cursor *c, Evas_Object *o, Efl_Ui_Internal_Text_Interactive_Data *en);
static void _sel_init(Efl_Text_Cursor *c, Evas_Object *o, Efl_Ui_Internal_Text_Interactive_Data *en);
static void _sel_enable(Efl_Text_Cursor *c EINA_UNUSED, Evas_Object *o EINA_UNUSED, Efl_Ui_Internal_Text_Interactive_Data *en);
static void _sel_extend(Efl_Text_Cursor *c, Evas_Object *o, Efl_Ui_Internal_Text_Interactive_Data *en);
static void _sel_clear(Evas_Object *o EINA_UNUSED, Efl_Ui_Internal_Text_Interactive_Data *en);
static const char *_entry_selection_get(Efl_Ui_Internal_Text_Interactive *obj, Efl_Ui_Internal_Text_Interactive_Data *en);
static void _entry_imf_cursor_info_set(Eo *obj, Evas_Textblock_Cursor *cur, Efl_Ui_Internal_Text_Interactive_Data *en);
static void _entry_imf_cursor_info_set(Eo *obj, Efl_Text_Cursor *cur, Efl_Ui_Internal_Text_Interactive_Data *en);
#ifdef HAVE_ECORE_IMF
static void
@ -47,13 +48,13 @@ _preedit_clear(Efl_Ui_Internal_Text_Interactive_Data *en)
{
if (en->preedit_start)
{
evas_textblock_cursor_free(en->preedit_start);
efl_del(en->preedit_start);
en->preedit_start = NULL;
}
if (en->preedit_end)
{
evas_textblock_cursor_free(en->preedit_end);
efl_del(en->preedit_end);
en->preedit_end = NULL;
}
@ -61,21 +62,21 @@ _preedit_clear(Efl_Ui_Internal_Text_Interactive_Data *en)
}
static void
_preedit_del(Eo *obj, Efl_Ui_Internal_Text_Interactive_Data *en)
_preedit_del(Eo *obj EINA_UNUSED, Efl_Ui_Internal_Text_Interactive_Data *en)
{
if (!en || !en->have_preedit) return;
if (!en->preedit_start || !en->preedit_end) return;
if (efl_text_cursor_equal(obj, en->preedit_start, en->preedit_end)) return;
if (efl_text_cursor_equal(en->preedit_start, en->preedit_end)) return;
/* delete the preedit characters */
evas_textblock_cursor_range_delete(en->preedit_start, en->preedit_end);
efl_text_cursor_range_delete(en->preedit_start, en->preedit_end);
}
static Eina_Bool
_entry_imf_retrieve_surrounding_cb(void *data, Ecore_IMF_Context *ctx EINA_UNUSED, char **text, int *cursor_pos)
{
Efl_Canvas_Text *obj = data;
Efl_Text_Cursor_Cursor *cur = efl_text_cursor_get(obj, EFL_TEXT_CURSOR_GET_TYPE_MAIN);
Efl_Text_Cursor *cur = efl_text_interactive_main_cursor_get(obj);
const char *str;
if (text)
@ -92,7 +93,7 @@ _entry_imf_retrieve_surrounding_cb(void *data, Ecore_IMF_Context *ctx EINA_UNUSE
if (cursor_pos)
{
if (cur)
*cursor_pos = evas_textblock_cursor_pos_get(cur);
*cursor_pos = efl_text_cursor_position_get(cur);
else
*cursor_pos = 0;
}
@ -177,7 +178,7 @@ static void
_entry_imf_event_preedit_changed_cb(void *data, Ecore_IMF_Context *ctx EINA_UNUSED, void *event_info EINA_UNUSED)
{
Efl_Canvas_Text *obj = data;
Efl_Text_Cursor_Cursor *cur = efl_text_cursor_get(obj, EFL_TEXT_CURSOR_GET_TYPE_MAIN);
Efl_Text_Cursor *cur = efl_text_interactive_main_cursor_get(obj);
Efl_Ui_Internal_Text_Interactive_Data *en = efl_data_scope_get(obj, MY_CLASS);
int cursor_pos;
int preedit_start_pos, preedit_end_pos;
@ -215,7 +216,7 @@ _entry_imf_event_preedit_changed_cb(void *data, Ecore_IMF_Context *ctx EINA_UNUS
/* delete preedit characters */
_preedit_del(obj, en);
preedit_start_pos = evas_textblock_cursor_pos_get(cur);
preedit_start_pos = efl_text_cursor_position_get(cur);
/* insert preedit character(s) */
if (strlen(preedit_string) > 0)
@ -293,25 +294,25 @@ _entry_imf_event_preedit_changed_cb(void *data, Ecore_IMF_Context *ctx EINA_UNUS
{
/* set preedit start cursor */
if (!en->preedit_start)
en->preedit_start = evas_object_textblock_cursor_new(obj);
evas_textblock_cursor_copy(cur, en->preedit_start);
en->preedit_start = efl_canvas_text_cursor_create(obj);
efl_text_cursor_copy(cur, en->preedit_start);
/* set preedit end cursor */
if (!en->preedit_end)
en->preedit_end = evas_object_textblock_cursor_new(obj);
evas_textblock_cursor_copy(cur, en->preedit_end);
en->preedit_end = efl_canvas_text_cursor_create(obj);
efl_text_cursor_copy(cur, en->preedit_end);
preedit_end_pos = evas_textblock_cursor_pos_get(cur);
preedit_end_pos = efl_text_cursor_position_get(cur);
for (i = 0; i < (preedit_end_pos - preedit_start_pos); i++)
{
evas_textblock_cursor_char_prev(en->preedit_start);
efl_text_cursor_move(en->preedit_start, EFL_TEXT_CURSOR_MOVE_TYPE_CHAR_PREV);
}
en->have_preedit = EINA_TRUE;
/* set cursor position */
evas_textblock_cursor_pos_set(cur, preedit_start_pos + cursor_pos);
efl_text_cursor_position_set(cur, preedit_start_pos + cursor_pos);
}
_entry_imf_cursor_info_set(obj, cur, en);
@ -330,35 +331,35 @@ static void
_entry_imf_event_delete_surrounding_cb(void *data, Ecore_IMF_Context *ctx EINA_UNUSED, void *event_info)
{
Efl_Canvas_Text *obj = data;
Efl_Text_Cursor_Cursor *cur = efl_text_cursor_get(obj, EFL_TEXT_CURSOR_GET_TYPE_MAIN);
Efl_Text_Cursor *cur = efl_text_interactive_main_cursor_get(obj);
Efl_Ui_Internal_Text_Interactive_Data *en = efl_data_scope_get(obj, MY_CLASS);
Ecore_IMF_Event_Delete_Surrounding *ev = event_info;
Evas_Textblock_Cursor *del_start, *del_end;
Efl_Text_Cursor *del_start, *del_end;
Efl_Ui_Text_Change_Info info = { NULL, 0, 0, 0, 0 };
int cursor_pos;
int start, end;
char *tmp;
cursor_pos = evas_textblock_cursor_pos_get(cur);
cursor_pos = efl_text_cursor_position_get(cur);
del_start = evas_object_textblock_cursor_new(obj);
evas_textblock_cursor_pos_set(del_start, cursor_pos + ev->offset);
del_start = efl_canvas_text_cursor_create(obj);
efl_text_cursor_position_set(del_start, cursor_pos + ev->offset);
del_end = evas_object_textblock_cursor_new(obj);
evas_textblock_cursor_pos_set(del_end, cursor_pos + ev->offset + ev->n_chars);
del_end = efl_canvas_text_cursor_create(obj);
efl_text_cursor_position_set(del_end, cursor_pos + ev->offset + ev->n_chars);
start = evas_textblock_cursor_pos_get(del_start);
end = evas_textblock_cursor_pos_get(del_end);
start = efl_text_cursor_position_get(del_start);
end = efl_text_cursor_position_get(del_end);
if (start == end) goto end;
tmp = efl_canvas_text_range_text_get(obj, del_start, del_end);
tmp = efl_text_cursor_range_text_get(del_start, del_end);
info.insert = EINA_FALSE;
info.position = start;
info.length = end - start;
info.content = tmp;
evas_textblock_cursor_range_delete(del_start, del_end);
efl_text_cursor_range_delete(del_start, del_end);
efl_event_callback_call(obj, EFL_UI_TEXT_EVENT_CHANGED_USER, &info);
free(tmp);
@ -366,29 +367,29 @@ _entry_imf_event_delete_surrounding_cb(void *data, Ecore_IMF_Context *ctx EINA_U
_entry_imf_cursor_info_set(obj, cur, en);
end:
evas_textblock_cursor_free(del_start);
evas_textblock_cursor_free(del_end);
efl_del(del_start);
efl_del(del_end);
}
static void
_entry_imf_event_selection_set_cb(void *data, Ecore_IMF_Context *ctx EINA_UNUSED, void *event_info)
{
Efl_Canvas_Text *obj = data;
Efl_Text_Cursor_Cursor *cur = efl_text_cursor_get(obj, EFL_TEXT_CURSOR_GET_TYPE_MAIN);
Efl_Text_Cursor *cur = efl_text_interactive_main_cursor_get(obj);
Efl_Ui_Internal_Text_Interactive_Data *en = efl_data_scope_get(obj, MY_CLASS);
Ecore_IMF_Event_Selection *ev = event_info;
if (ev->start == ev->end)
{
efl_text_cursor_position_set(obj, cur, ev->start);
efl_text_cursor_position_set(cur, ev->start);
}
else
{
_sel_clear(obj, en);
evas_textblock_cursor_pos_set(cur, ev->start);
efl_text_cursor_position_set(cur, ev->start);
_sel_enable(cur, obj, en);
_sel_init(cur, obj, en);
evas_textblock_cursor_pos_set(cur, ev->end);
efl_text_cursor_position_set(cur, ev->end);
_sel_extend(cur, obj, en);
}
}
@ -416,14 +417,14 @@ _entry_imf_retrieve_selection_cb(void *data, Ecore_IMF_Context *ctx EINA_UNUSED,
#endif
static void
_entry_imf_cursor_location_set(Eo *obj, Efl_Text_Cursor_Cursor *cur, Efl_Ui_Internal_Text_Interactive_Data *en)
_entry_imf_cursor_location_set(Eo *obj EINA_UNUSED, Efl_Text_Cursor *cur, Efl_Ui_Internal_Text_Interactive_Data *en)
{
#ifdef HAVE_ECORE_IMF
Evas_Coord cx = 0, cy = 0, cw = 0, ch = 0;
Eina_Rect rect;
if (!en->imf_context) return;
efl_text_cursor_geometry_get(obj, cur, EFL_TEXT_CURSOR_TYPE_BEFORE, &cx, &cy, &cw, &ch, NULL, NULL, NULL, NULL);
ecore_imf_context_cursor_location_set(en->imf_context, cx, cy, cw, ch);
rect = efl_text_cursor_geometry_get(cur, EFL_TEXT_CURSOR_TYPE_BEFORE);
ecore_imf_context_cursor_location_set(en->imf_context, rect.x, rect.y, rect.w, rect.h);
// FIXME: ecore_imf_context_bidi_direction_set(en->imf_context, (Ecore_IMF_BiDi_Direction)dir);
#else
(void)en;
@ -431,7 +432,7 @@ _entry_imf_cursor_location_set(Eo *obj, Efl_Text_Cursor_Cursor *cur, Efl_Ui_Inte
}
static void
_entry_imf_cursor_info_set(Eo *obj, Evas_Textblock_Cursor *cur, Efl_Ui_Internal_Text_Interactive_Data *en)
_entry_imf_cursor_info_set(Eo *obj, Efl_Text_Cursor *cur, Efl_Ui_Internal_Text_Interactive_Data *en)
{
int cursor_pos;
@ -440,13 +441,13 @@ _entry_imf_cursor_info_set(Eo *obj, Evas_Textblock_Cursor *cur, Efl_Ui_Internal_
if (en->have_selection)
{
if (evas_textblock_cursor_compare(en->sel_start, en->sel_end) < 0)
cursor_pos = evas_textblock_cursor_pos_get(en->sel_start);
if (efl_text_cursor_compare(en->sel_start, en->sel_end) < 0)
cursor_pos = efl_text_cursor_position_get(en->sel_start);
else
cursor_pos = evas_textblock_cursor_pos_get(en->sel_end);
cursor_pos = efl_text_cursor_position_get(en->sel_end);
}
else
cursor_pos = evas_textblock_cursor_pos_get(cur);
cursor_pos = efl_text_cursor_position_get(cur);
ecore_imf_context_cursor_position_set(en->imf_context, cursor_pos);
@ -461,11 +462,11 @@ _focus_in_cb(void *data EINA_UNUSED, Evas *e EINA_UNUSED, Evas_Object *obj, void
{
#ifdef HAVE_ECORE_IMF
Efl_Ui_Internal_Text_Interactive_Data *en = efl_data_scope_get(obj, MY_CLASS);
Efl_Text_Cursor_Cursor *cur;
Efl_Text_Cursor *cur;
if (!en->imf_context) return;
cur = efl_text_cursor_get(obj, EFL_TEXT_CURSOR_GET_TYPE_MAIN);
cur = efl_text_interactive_main_cursor_get(obj);
ecore_imf_context_focus_in(en->imf_context);
_entry_imf_cursor_info_set(obj, cur, en);
#endif
@ -497,10 +498,10 @@ _focus_out_cb(void *data EINA_UNUSED, Evas *e EINA_UNUSED, Evas_Object *obj, voi
}
static const char *
_entry_selection_get(Efl_Ui_Internal_Text_Interactive *obj, Efl_Ui_Internal_Text_Interactive_Data *en)
_entry_selection_get(Efl_Ui_Internal_Text_Interactive *obj EINA_UNUSED, Efl_Ui_Internal_Text_Interactive_Data *en)
{
if ((!en->selection) && (en->have_selection))
en->selection = efl_canvas_text_range_text_get(obj, en->sel_start, en->sel_end);
en->selection = efl_text_cursor_range_text_get(en->sel_start, en->sel_end);
return en->selection;
}
@ -511,13 +512,13 @@ _sel_cursor_changed(void *data EINA_UNUSED, const Efl_Event *event EINA_UNUSED)
}
static void
_sel_init(Evas_Textblock_Cursor *c, Evas_Object *o EINA_UNUSED, Efl_Ui_Internal_Text_Interactive_Data *en)
_sel_init(Efl_Text_Cursor *c, Evas_Object *o EINA_UNUSED, Efl_Ui_Internal_Text_Interactive_Data *en)
{
if (en->have_selection)
return;
evas_textblock_cursor_copy(c, en->sel_start);
evas_textblock_cursor_copy(c, en->sel_end);
efl_text_cursor_copy(c, en->sel_start);
efl_text_cursor_copy(c, en->sel_end);
en->have_selection = EINA_FALSE;
if (en->selection)
@ -528,7 +529,7 @@ _sel_init(Evas_Textblock_Cursor *c, Evas_Object *o EINA_UNUSED, Efl_Ui_Internal_
}
static void
_sel_enable(Evas_Textblock_Cursor *c EINA_UNUSED,
_sel_enable(Efl_Text_Cursor *c EINA_UNUSED,
Evas_Object *o EINA_UNUSED, Efl_Ui_Internal_Text_Interactive_Data *en)
{
if (en->have_selection) return;
@ -543,13 +544,13 @@ _sel_enable(Evas_Textblock_Cursor *c EINA_UNUSED,
}
static void
_sel_extend(Evas_Textblock_Cursor *c, Evas_Object *o, Efl_Ui_Internal_Text_Interactive_Data *en)
_sel_extend(Efl_Text_Cursor *c, Evas_Object *o, Efl_Ui_Internal_Text_Interactive_Data *en)
{
if (!en->sel_end) return;
_sel_enable(c, o, en);
if (efl_text_cursor_equal(o, c, en->sel_end)) return;
if (efl_text_cursor_equal(c, en->sel_end)) return;
evas_textblock_cursor_copy(c, en->sel_end);
efl_text_cursor_copy(c, en->sel_end);
_entry_imf_cursor_info_set(o, c, en);
@ -573,7 +574,7 @@ _sel_clear(Evas_Object *o EINA_UNUSED, Efl_Ui_Internal_Text_Interactive_Data *en
if (en->have_selection)
{
en->have_selection = EINA_FALSE;
efl_text_cursor_copy(o, en->sel_start, en->sel_end);
efl_text_cursor_copy(en->sel_start, en->sel_end);
efl_event_callback_call(o, EFL_TEXT_INTERACTIVE_EVENT_TEXT_SELECTION_CHANGED, NULL);
}
}
@ -586,14 +587,14 @@ _efl_ui_internal_text_interactive_efl_text_interactive_select_none(
}
static void
_range_del_emit(Evas_Object *obj, Efl_Text_Cursor_Cursor *cur1, Efl_Text_Cursor_Cursor *cur2)
_range_del_emit(Evas_Object *obj, Efl_Text_Cursor *cur1, Efl_Text_Cursor *cur2)
{
size_t start, end;
char *tmp;
Efl_Ui_Text_Change_Info info = { NULL, 0, 0, 0, 0 };
start = evas_textblock_cursor_pos_get(cur1);
end = evas_textblock_cursor_pos_get(cur2);
start = efl_text_cursor_position_get(cur1);
end = efl_text_cursor_position_get(cur2);
if (start == end)
return;
@ -601,10 +602,10 @@ _range_del_emit(Evas_Object *obj, Efl_Text_Cursor_Cursor *cur1, Efl_Text_Cursor_
info.position = start;
info.length = end - start;
tmp = efl_canvas_text_range_text_get(obj, cur1, cur2);
tmp = efl_text_cursor_range_text_get(cur1, cur2);
info.content = tmp;
evas_textblock_cursor_range_delete(cur1, cur2);
efl_text_cursor_range_delete(cur1, cur2);
efl_event_callback_call(obj, EFL_UI_TEXT_EVENT_CHANGED_USER, &info);
efl_event_callback_call(obj, EFL_UI_TEXT_EVENT_CHANGED, NULL);
@ -619,11 +620,11 @@ _sel_range_del_emit(Evas_Object *obj, Efl_Ui_Internal_Text_Interactive_Data *en)
}
static void
_delete_emit(Eo *obj, Evas_Textblock_Cursor *c, Efl_Ui_Internal_Text_Interactive_Data *en EINA_UNUSED, size_t pos)
_delete_emit(Eo *obj, Efl_Text_Cursor *c, Efl_Ui_Internal_Text_Interactive_Data *en EINA_UNUSED, size_t pos)
{
Efl_Ui_Text_Change_Info info = { NULL, 0, 0, 0, 0 };
Eina_Unicode content[2];
content[0] = efl_text_cursor_content_get(obj, c);
content[0] = efl_text_cursor_content_get(c);
content[1] = 0;
if (!content[0])
return;
@ -635,7 +636,7 @@ _delete_emit(Eo *obj, Evas_Textblock_Cursor *c, Efl_Ui_Internal_Text_Interactive
info.length = 1;
info.content = tmp;
evas_textblock_cursor_char_delete(c);
efl_text_cursor_char_delete(c);
efl_event_callback_call(obj, EFL_UI_TEXT_EVENT_CHANGED_USER, &info);
efl_event_callback_call(obj, EFL_UI_TEXT_EVENT_CHANGED, NULL);
@ -673,7 +674,7 @@ _compose_seq_reset(Efl_Ui_Internal_Text_Interactive_Data *en)
* movement_forward: if the movement we are going to do is forward (towards the end of the textblock)
*/
static void
_key_down_sel_pre(Efl_Ui_Internal_Text_Interactive *obj, Efl_Text_Cursor_Cursor *cur, Efl_Ui_Internal_Text_Interactive_Data *en, Eina_Bool shift, Eina_Bool movement_forward)
_key_down_sel_pre(Efl_Ui_Internal_Text_Interactive *obj, Efl_Text_Cursor *cur, Efl_Ui_Internal_Text_Interactive_Data *en, Eina_Bool shift, Eina_Bool movement_forward)
{
if (en->select_allow)
{
@ -683,18 +684,18 @@ _key_down_sel_pre(Efl_Ui_Internal_Text_Interactive *obj, Efl_Text_Cursor_Cursor
}
else if (en->have_selection)
{
Eina_Bool sel_forward = evas_textblock_cursor_compare(en->sel_start, en->sel_end);
Eina_Bool sel_forward = efl_text_cursor_compare(en->sel_start, en->sel_end);
if ((sel_forward && movement_forward) || (!sel_forward && !movement_forward))
evas_textblock_cursor_copy(en->sel_end, cur);
efl_text_cursor_copy(en->sel_end, cur);
else
evas_textblock_cursor_copy(en->sel_start, cur);
efl_text_cursor_copy(en->sel_start, cur);
_sel_clear(obj, en);
}
}
}
static void
_key_down_sel_post(Efl_Ui_Internal_Text_Interactive *obj, Efl_Text_Cursor_Cursor *cur, Efl_Ui_Internal_Text_Interactive_Data *en, Eina_Bool shift)
_key_down_sel_post(Efl_Ui_Internal_Text_Interactive *obj, Efl_Text_Cursor *cur, Efl_Ui_Internal_Text_Interactive_Data *en, Eina_Bool shift)
{
if (en->select_allow)
{
@ -707,7 +708,7 @@ static void
_key_down_cb(void *data EINA_UNUSED, Evas *e EINA_UNUSED, Evas_Object *obj, void *event_info)
{
Evas_Event_Key_Down *ev = event_info;
Efl_Text_Cursor_Cursor *cur;
Efl_Text_Cursor *cur;
Eina_Bool control, alt, shift;
#if defined(__APPLE__) && defined(__MACH__)
Eina_Bool super, altgr;
@ -727,8 +728,8 @@ _key_down_cb(void *data EINA_UNUSED, Evas *e EINA_UNUSED, Evas_Object *obj, void
/* FIXME: Maybe allow selctions to happen even when not editable. */
if (!en->editable) return;
cur = efl_text_cursor_get(obj, EFL_TEXT_CURSOR_GET_TYPE_MAIN);
old_cur_pos = evas_textblock_cursor_pos_get(cur);
cur = efl_text_interactive_main_cursor_get(obj);
old_cur_pos = efl_text_cursor_position_get(cur);
if (old_cur_pos < 0) return;
control = evas_key_modifier_is_set(ev->modifiers, "Control");
@ -752,7 +753,7 @@ _key_down_cb(void *data EINA_UNUSED, Evas *e EINA_UNUSED, Evas_Object *obj, void
{
if (multiline)
{
if (shift || efl_canvas_text_legacy_newline_get(obj))
if (shift || efl_canvas_text_newline_as_paragraph_separator_get(obj))
{
string = "\n";
}
@ -779,7 +780,7 @@ _key_down_cb(void *data EINA_UNUSED, Evas *e EINA_UNUSED, Evas_Object *obj, void
{
_key_down_sel_pre(obj, cur, en, shift, EINA_FALSE);
efl_text_cursor_line_jump_by(obj, cur, -1);
efl_text_cursor_line_jump_by(cur, -1);
ev->event_flags |= EVAS_EVENT_FLAG_ON_HOLD;
_key_down_sel_post(obj, cur, en, shift);
@ -793,7 +794,7 @@ _key_down_cb(void *data EINA_UNUSED, Evas *e EINA_UNUSED, Evas_Object *obj, void
{
_key_down_sel_pre(obj, cur, en, shift, EINA_TRUE);
efl_text_cursor_line_jump_by(obj, cur, 1);
efl_text_cursor_line_jump_by(cur, 1);
ev->event_flags |= EVAS_EVENT_FLAG_ON_HOLD;
_key_down_sel_post(obj, cur, en, shift);
@ -805,12 +806,12 @@ _key_down_cb(void *data EINA_UNUSED, Evas *e EINA_UNUSED, Evas_Object *obj, void
_compose_seq_reset(en);
_key_down_sel_pre(obj, cur, en, shift, EINA_FALSE);
efl_text_cursor_char_prev(obj, cur);
efl_text_cursor_move(cur,EFL_TEXT_CURSOR_MOVE_TYPE_CHAR_PREV);
#if defined(__APPLE__) && defined(__MACH__)
if (altgr) efl_text_cursor_word_start(obj, cur);
if (altgr) efl_text_cursor_move(cur, EFL_TEXT_CURSOR_MOVE_TYPE_WORD_START);
#else
/* If control is pressed, go to the start of the word */
if (control) efl_text_cursor_word_start(obj, cur);
if (control) efl_text_cursor_move(cur, EFL_TEXT_CURSOR_MOVE_TYPE_WORD_START);
#endif
ev->event_flags |= EVAS_EVENT_FLAG_ON_HOLD;
@ -823,12 +824,12 @@ _key_down_cb(void *data EINA_UNUSED, Evas *e EINA_UNUSED, Evas_Object *obj, void
_key_down_sel_pre(obj, cur, en, shift, EINA_TRUE);
#if defined(__APPLE__) && defined(__MACH__)
if (altgr) efl_text_cursor_word_end(obj, cur);
if (altgr) efl_text_cursor_word_end(cur);
#else
/* If control is pressed, go to the end of the word */
if (control) efl_text_cursor_word_end(obj, cur);
if (control) efl_text_cursor_move(cur, EFL_TEXT_CURSOR_MOVE_TYPE_WORD_END);
#endif
efl_text_cursor_char_next(obj, cur);
efl_text_cursor_move(cur, EFL_TEXT_CURSOR_MOVE_TYPE_CHAR_NEXT);
ev->event_flags |= EVAS_EVENT_FLAG_ON_HOLD;
_key_down_sel_post(obj, cur, en, shift);
@ -839,16 +840,16 @@ _key_down_cb(void *data EINA_UNUSED, Evas *e EINA_UNUSED, Evas_Object *obj, void
if (control && !en->have_selection)
{
// del to start of previous word
Evas_Textblock_Cursor *tc = evas_object_textblock_cursor_new(obj);
Efl_Text_Cursor *tc = efl_canvas_text_cursor_create(obj);
efl_text_cursor_copy(obj, tc, cur);
evas_textblock_cursor_char_prev(cur);
evas_textblock_cursor_word_start(cur);
efl_text_cursor_copy(tc, cur);
efl_text_cursor_move(cur, EFL_TEXT_CURSOR_MOVE_TYPE_CHAR_PREV);
efl_text_cursor_move(cur, EFL_TEXT_CURSOR_MOVE_TYPE_WORD_START);
_range_del_emit(obj, cur, tc);
//efl_del(tc);
efl_text_cursor_free(obj, tc);
efl_del(tc);
}
else if ((alt) && (shift))
{
@ -862,7 +863,7 @@ _key_down_cb(void *data EINA_UNUSED, Evas *e EINA_UNUSED, Evas_Object *obj, void
}
else
{
if (evas_textblock_cursor_char_prev(cur))
if (efl_text_cursor_move(cur, EFL_TEXT_CURSOR_MOVE_TYPE_CHAR_PREV))
{
_delete_emit(obj, cur, en, old_cur_pos - 1);
}
@ -878,16 +879,16 @@ _key_down_cb(void *data EINA_UNUSED, Evas *e EINA_UNUSED, Evas_Object *obj, void
if (control)
{
// del to end of next word
Evas_Textblock_Cursor *tc = evas_object_textblock_cursor_new(obj);
Efl_Text_Cursor *tc = efl_canvas_text_cursor_create(obj);
efl_text_cursor_copy(obj, tc, cur);
evas_textblock_cursor_word_end(cur);
evas_textblock_cursor_char_next(cur);
efl_text_cursor_copy(tc, cur);
efl_text_cursor_move(cur, EFL_TEXT_CURSOR_MOVE_TYPE_WORD_END);
efl_text_cursor_move(cur, EFL_TEXT_CURSOR_MOVE_TYPE_CHAR_NEXT);
_range_del_emit(obj, cur, tc);
//efl_del(tc);
efl_text_cursor_free(obj, tc);
efl_del(tc);
}
else if (shift)
{
@ -915,9 +916,9 @@ _key_down_cb(void *data EINA_UNUSED, Evas *e EINA_UNUSED, Evas_Object *obj, void
_key_down_sel_pre(obj, cur, en, shift, EINA_FALSE);
if ((control) && (multiline))
efl_text_cursor_paragraph_first(obj, cur);
efl_text_cursor_move(cur, EFL_TEXT_CURSOR_MOVE_TYPE_PARAGRAPH_FIRST);
else
efl_text_cursor_line_char_first(obj, cur);
efl_text_cursor_move(cur, EFL_TEXT_CURSOR_MOVE_TYPE_LINE_START);
_key_down_sel_post(obj, cur, en, shift);
ev->event_flags |= EVAS_EVENT_FLAG_ON_HOLD;
@ -930,9 +931,9 @@ _key_down_cb(void *data EINA_UNUSED, Evas *e EINA_UNUSED, Evas_Object *obj, void
_key_down_sel_pre(obj, cur, en, shift, EINA_TRUE);
if ((control) && (multiline))
efl_text_cursor_paragraph_last(obj, cur);
efl_text_cursor_move(cur, EFL_TEXT_CURSOR_MOVE_TYPE_PARAGRAPH_LAST);
else
efl_text_cursor_line_char_last(obj, cur);
efl_text_cursor_move(cur, EFL_TEXT_CURSOR_MOVE_TYPE_LINE_END);
_key_down_sel_post(obj, cur, en, shift);
ev->event_flags |= EVAS_EVENT_FLAG_ON_HOLD;
@ -957,7 +958,7 @@ _key_down_cb(void *data EINA_UNUSED, Evas *e EINA_UNUSED, Evas_Object *obj, void
_compose_seq_reset(en);
_key_down_sel_pre(obj, cur, en, shift, EINA_FALSE);
efl_text_cursor_line_jump_by(obj, cur, -10);
efl_text_cursor_line_jump_by(cur, -10);
_key_down_sel_post(obj, cur, en, shift);
ev->event_flags |= EVAS_EVENT_FLAG_ON_HOLD;
@ -968,7 +969,7 @@ _key_down_cb(void *data EINA_UNUSED, Evas *e EINA_UNUSED, Evas_Object *obj, void
_compose_seq_reset(en);
_key_down_sel_pre(obj, cur, en, shift, EINA_TRUE);
efl_text_cursor_line_jump_by(obj, cur, 10);
efl_text_cursor_line_jump_by(cur, 10);
_key_down_sel_post(obj, cur, en, shift);
ev->event_flags |= EVAS_EVENT_FLAG_ON_HOLD;
@ -1046,11 +1047,11 @@ _key_down_cb(void *data EINA_UNUSED, Evas *e EINA_UNUSED, Evas_Object *obj, void
}
info.insert = EINA_TRUE;
info.content = string;
info.position = efl_text_cursor_position_get(obj, cur);
info.position = efl_text_cursor_position_get(cur);
info.length = eina_unicode_utf8_get_len(string);
efl_event_freeze(obj);
efl_text_cursor_text_insert(obj, cur, string);
efl_text_cursor_text_insert(cur, string);
efl_event_thaw(obj);
changed_user = EINA_TRUE;
@ -1070,38 +1071,38 @@ end:
}
static void
_cursor_char_coord_set(Efl_Canvas_Text *obj, Efl_Text_Cursor_Cursor *cur, Evas_Coord canvasx, Evas_Coord canvasy, Evas_Coord *_cx, Evas_Coord *_cy)
_cursor_char_coord_set(Efl_Canvas_Text *obj, Efl_Text_Cursor *cur, Evas_Coord canvasx, Evas_Coord canvasy, Evas_Coord *_cx, Evas_Coord *_cy)
{
Evas_Coord cx, cy;
Evas_Coord x, y, lh = 0, cly = 0;
Evas_Textblock_Cursor *line_cur;
Evas_Textblock_Cursor *tc;
Efl_Text_Cursor *line_cur;
Efl_Text_Cursor *tc;
tc = evas_object_textblock_cursor_new(obj);
evas_textblock_cursor_copy(cur, tc);
tc = efl_canvas_text_cursor_create(obj);
efl_text_cursor_copy(cur, tc);
evas_object_geometry_get(obj, &x, &y, NULL, NULL);
cx = canvasx - x;
cy = canvasy - y;
line_cur = evas_object_textblock_cursor_new(obj);
evas_textblock_cursor_paragraph_last(line_cur);
evas_textblock_cursor_line_geometry_get(line_cur, NULL, &cly, NULL, &lh);
line_cur = efl_canvas_text_cursor_create(obj);
efl_text_cursor_move(line_cur, EFL_TEXT_CURSOR_MOVE_TYPE_PARAGRAPH_LAST);
evas_textblock_cursor_line_geometry_get(efl_text_cursor_handle_get(line_cur), NULL, &cly, NULL, &lh);
/* Consider a threshold of half the line height */
if (cy > (cly + lh) && cy < (cly + lh + lh / 2))
{
cy = cly + lh - 1; // Make it inside Textblock
}
evas_textblock_cursor_paragraph_first(line_cur);
evas_textblock_cursor_line_geometry_get(line_cur, NULL, &cly, NULL, NULL);
efl_text_cursor_move(line_cur, EFL_TEXT_CURSOR_MOVE_TYPE_PARAGRAPH_FIRST);
evas_textblock_cursor_line_geometry_get(efl_text_cursor_handle_get(line_cur), NULL, &cly, NULL, NULL);
if (cy < cly && cy > (cly - lh / 2))
{
cy = cly;
}
evas_textblock_cursor_free(line_cur);
efl_del(line_cur);
/* No need to check return value if not able to set the char coord Textblock
* will take care */
evas_textblock_cursor_char_coord_set(cur, cx, cy);
efl_text_cursor_char_coord_set(cur, EINA_POSITION2D(cx, cy));
if (_cx) *_cx = cx;
if (_cy) *_cy = cy;
}
@ -1112,8 +1113,8 @@ _mouse_down_cb(void *data EINA_UNUSED, Evas *e EINA_UNUSED, Evas_Object *obj EIN
Evas_Coord cx, cy;
Evas_Event_Mouse_Down *ev = event_info;
Efl_Ui_Internal_Text_Interactive_Data *en = efl_data_scope_get(obj, MY_CLASS);
Efl_Text_Cursor_Cursor *cur = efl_text_cursor_get(obj, EFL_TEXT_CURSOR_GET_TYPE_MAIN);
Evas_Textblock_Cursor *tc = NULL;
Efl_Text_Cursor *cur = efl_text_interactive_main_cursor_get(obj);
Efl_Text_Cursor *tc = NULL;
Eina_Bool dosel = EINA_FALSE;
Eina_Bool shift;
@ -1142,12 +1143,12 @@ _mouse_down_cb(void *data EINA_UNUSED, Evas *e EINA_UNUSED, Evas_Object *obj EIN
{
if (shift)
{
tc = evas_object_textblock_cursor_new(obj);
evas_textblock_cursor_copy(cur, tc);
if (evas_textblock_cursor_compare(cur, en->sel_start) < 0)
evas_textblock_cursor_line_char_first(cur);
tc = efl_canvas_text_cursor_create(obj);
efl_text_cursor_copy(cur, tc);
if (efl_text_cursor_compare(cur, en->sel_start) < 0)
efl_text_cursor_move(cur, EFL_TEXT_CURSOR_MOVE_TYPE_LINE_START);
else
evas_textblock_cursor_line_char_last(cur);
efl_text_cursor_move(cur, EFL_TEXT_CURSOR_MOVE_TYPE_LINE_END);
_sel_extend(cur, obj, en);
}
else
@ -1155,11 +1156,11 @@ _mouse_down_cb(void *data EINA_UNUSED, Evas *e EINA_UNUSED, Evas_Object *obj EIN
en->have_selection = EINA_FALSE;
en->selecting = EINA_FALSE;
_sel_clear(obj, en);
tc = evas_object_textblock_cursor_new(obj);
evas_textblock_cursor_copy(cur, tc);
evas_textblock_cursor_line_char_first(cur);
tc = efl_canvas_text_cursor_create(obj);
efl_text_cursor_copy(cur, tc);
efl_text_cursor_move(cur, EFL_TEXT_CURSOR_MOVE_TYPE_LINE_START);
_sel_init(cur, obj, en);
evas_textblock_cursor_line_char_last(cur);
efl_text_cursor_move(cur, EFL_TEXT_CURSOR_MOVE_TYPE_LINE_END);
_sel_extend(cur, obj, en);
}
goto end;
@ -1168,14 +1169,14 @@ _mouse_down_cb(void *data EINA_UNUSED, Evas *e EINA_UNUSED, Evas_Object *obj EIN
{
if (shift)
{
tc = evas_object_textblock_cursor_new(obj);
evas_textblock_cursor_copy(cur, tc);
if (evas_textblock_cursor_compare(cur, en->sel_start) < 0)
evas_textblock_cursor_word_start(cur);
tc = efl_canvas_text_cursor_create(obj);
efl_text_cursor_copy(cur, tc);
if (efl_text_cursor_compare(cur, en->sel_start) < 0)
efl_text_cursor_move(cur, EFL_TEXT_CURSOR_MOVE_TYPE_WORD_START);
else
{
evas_textblock_cursor_word_end(cur);
evas_textblock_cursor_char_next(cur);
efl_text_cursor_move(cur, EFL_TEXT_CURSOR_MOVE_TYPE_WORD_END);
efl_text_cursor_move(cur, EFL_TEXT_CURSOR_MOVE_TYPE_CHAR_NEXT);
}
_sel_extend(cur, obj, en);
}
@ -1184,12 +1185,12 @@ _mouse_down_cb(void *data EINA_UNUSED, Evas *e EINA_UNUSED, Evas_Object *obj EIN
en->have_selection = EINA_FALSE;
en->selecting = EINA_FALSE;
_sel_clear(obj, en);
tc = evas_object_textblock_cursor_new(obj);
evas_textblock_cursor_copy(cur, tc);
evas_textblock_cursor_word_start(cur);
tc = efl_canvas_text_cursor_create(obj);
efl_text_cursor_copy(cur, tc);
efl_text_cursor_move(cur, EFL_TEXT_CURSOR_MOVE_TYPE_WORD_START);
_sel_init(cur, obj, en);
evas_textblock_cursor_word_end(cur);
evas_textblock_cursor_char_next(cur);
efl_text_cursor_move(cur, EFL_TEXT_CURSOR_MOVE_TYPE_WORD_END);
efl_text_cursor_move(cur, EFL_TEXT_CURSOR_MOVE_TYPE_CHAR_NEXT);
_sel_extend(cur, obj, en);
}
goto end;
@ -1223,7 +1224,7 @@ _mouse_up_cb(void *data EINA_UNUSED, Evas *e EINA_UNUSED, Evas_Object *obj, void
{
Evas_Coord cx, cy;
Efl_Ui_Internal_Text_Interactive_Data *en = efl_data_scope_get(obj, MY_CLASS);
Efl_Text_Cursor_Cursor *cur = efl_text_cursor_get(obj, EFL_TEXT_CURSOR_GET_TYPE_MAIN);
Efl_Text_Cursor *cur = efl_text_interactive_main_cursor_get(obj);
Evas_Event_Mouse_Up *ev = event_info;
if ((!ev) || (ev->button != 1)) return;
@ -1247,7 +1248,7 @@ _mouse_up_cb(void *data EINA_UNUSED, Evas *e EINA_UNUSED, Evas_Object *obj, void
if (en->select_allow)
{
efl_text_cursor_copy(obj, en->sel_end, cur);
efl_text_cursor_copy(en->sel_end, cur);
}
if (en->selecting)
{
@ -1264,10 +1265,10 @@ _mouse_move_cb(void *data EINA_UNUSED, Evas *e EINA_UNUSED, Evas_Object *obj, vo
{
Evas_Coord cx, cy;
Efl_Ui_Internal_Text_Interactive_Data *en = efl_data_scope_get(obj, MY_CLASS);
Efl_Text_Cursor_Cursor *cur = efl_text_cursor_get(obj, EFL_TEXT_CURSOR_GET_TYPE_MAIN);
Efl_Text_Cursor *cur = efl_text_interactive_main_cursor_get(obj);
Evas_Event_Mouse_Move *ev = event_info;
Evas_Coord x, y, w, h;
Evas_Textblock_Cursor *tc;
Efl_Text_Cursor *tc;
Eina_Bool multiline;
multiline = efl_text_multiline_get(obj);
@ -1286,35 +1287,41 @@ _mouse_move_cb(void *data EINA_UNUSED, Evas *e EINA_UNUSED, Evas_Object *obj, vo
if (en->selecting)
{
tc = evas_object_textblock_cursor_new(obj);
evas_textblock_cursor_copy(cur, tc);
tc = efl_canvas_text_cursor_create(obj);
efl_text_cursor_copy(cur, tc);
evas_object_geometry_get(obj, &x, &y, &w, &h);
cx = ev->cur.canvas.x - x;
cy = ev->cur.canvas.y - y;
if (multiline)
{
efl_text_cursor_coord_set(obj, cur, cx, cy);
efl_text_cursor_char_coord_set(cur, EINA_POSITION2D(cx, cy));
}
else
{
Evas_Coord lx, ly, lw, lh;
evas_textblock_cursor_paragraph_first(cur);
evas_textblock_cursor_line_geometry_get(cur, &lx, &ly, &lw, &lh);
efl_text_cursor_coord_set(obj, cur, cx, ly + (lh / 2));
efl_text_cursor_move(cur, EFL_TEXT_CURSOR_MOVE_TYPE_PARAGRAPH_FIRST);
evas_textblock_cursor_line_geometry_get(efl_text_cursor_handle_get(cur), &lx, &ly, &lw, &lh);
efl_text_cursor_char_coord_set(cur, EINA_POSITION2D(cx, ly + (lh / 2)));
}
if (en->select_allow)
{
_sel_extend(cur, obj, en);
if (!efl_text_cursor_equal(obj, en->sel_start, en->sel_end))
if (!efl_text_cursor_equal(en->sel_start, en->sel_end))
_sel_enable(cur, obj, en);
}
evas_textblock_cursor_free(tc);
efl_del(tc);
}
}
EOLIAN static Efl_Text_Cursor *
_efl_ui_internal_text_interactive_efl_text_interactive_main_cursor_get(const Eo *obj EINA_UNUSED, Efl_Ui_Internal_Text_Interactive_Data *pd)
{
return pd->main_cursor;
}
EOLIAN static Efl_Object *
_efl_ui_internal_text_interactive_efl_object_constructor(Eo *obj, Efl_Ui_Internal_Text_Interactive_Data *en)
{
@ -1334,12 +1341,11 @@ _efl_ui_internal_text_interactive_efl_object_finalize(Eo *obj, Efl_Ui_Internal_T
evas_object_event_callback_add(obj, EVAS_CALLBACK_MOUSE_UP, _mouse_up_cb, NULL);
evas_object_event_callback_add(obj, EVAS_CALLBACK_MOUSE_MOVE, _mouse_move_cb, NULL);
en->sel_start = evas_object_textblock_cursor_new(obj);
en->sel_end = evas_object_textblock_cursor_new(obj);
en->main_cursor = efl_canvas_text_cursor_create(obj);
en->sel_start = efl_canvas_text_cursor_create(obj);
en->sel_end = efl_canvas_text_cursor_create(obj);
efl_event_callback_add(obj, EFL_CANVAS_TEXT_EVENT_CURSOR_CHANGED,
_sel_cursor_changed, obj);
efl_event_callback_add(obj, EFL_CANVAS_TEXT_EVENT_CURSOR_CHANGED,
efl_event_callback_add(efl_text_interactive_main_cursor_get(obj), EFL_TEXT_CURSOR_EVENT_CHANGED,
_sel_cursor_changed, obj);
en->input_panel_enable = EINA_TRUE;
@ -1422,10 +1428,10 @@ _efl_ui_internal_text_interactive_efl_text_interactive_selection_allowed_get(con
}
EOLIAN static void
_efl_ui_internal_text_interactive_efl_text_interactive_selection_cursors_get(const Eo *obj EINA_UNUSED, Efl_Ui_Internal_Text_Interactive_Data *pd, Efl_Text_Cursor_Cursor **start, Evas_Textblock_Cursor **end)
_efl_ui_internal_text_interactive_efl_text_interactive_selection_cursors_get(const Eo *obj EINA_UNUSED, Efl_Ui_Internal_Text_Interactive_Data *pd, Efl_Text_Cursor **start, Efl_Text_Cursor **end)
{
if (efl_text_cursor_position_get(obj, pd->sel_start) >
efl_text_cursor_position_get(obj, pd->sel_end))
if (efl_text_cursor_position_get(pd->sel_start) >
efl_text_cursor_position_get(pd->sel_end))
{
if (start) *start = pd->sel_end;
if (end) *end = pd->sel_start;

1
src/lib/elementary/efl_ui_internal_text_interactive.eo
View File

@ -7,6 +7,7 @@ class @beta Efl.Ui.Internal.Text.Interactive extends Efl.Canvas.Text implements
implements {
Efl.Object.constructor;
Efl.Object.finalize;
Efl.Text_Interactive.main_cursor { get; }
Efl.Text_Interactive.selection_allowed { get; set; }
Efl.Text_Interactive.selection_cursors { get; }
Efl.Text_Interactive.editable { get; set; }

2
src/lib/elementary/efl_ui_internal_text_scroller.c
View File

@ -101,7 +101,7 @@ _efl_ui_internal_text_scroller_efl_canvas_group_group_calculate(Eo *obj,
efl_event_freeze(sd->text_obj);
efl_gfx_entity_size_set(sd->text_table, view.size);
efl_gfx_entity_size_set(sd->text_obj, view.size);
efl_canvas_text_size_formatted_get(sd->text_obj, &fsz.w, &fsz.h);
fsz = efl_canvas_text_size_formatted_get(sd->text_obj);
efl_gfx_entity_size_set(sd->text_table, sz);
efl_gfx_entity_size_set(sd->text_obj, sz);
efl_event_thaw(sd->text_obj);

228
src/lib/elementary/efl_ui_text.c
View File

@ -18,6 +18,7 @@
#include "elm_hoversel_eo.h"
#include "efl_ui_text_part.eo.h"
#include "elm_part_helper.h"
#include "efl_canvas_text_internal.h"
typedef struct _Efl_Ui_Text_Data Efl_Ui_Text_Data;
typedef struct _Efl_Ui_Text_Rectangle Efl_Ui_Text_Rectangle;
@ -77,7 +78,7 @@ struct _Efl_Ui_Text_Data
Efl_Ui_Input_Panel_Language_Type input_panel_lang;
Efl_Ui_Input_Panel_Return_Key_Type input_panel_return_key_type;
Efl_Ui_Input_Hints input_hints;
Efl_Text_Cursor_Cursor *sel_handler_cursor;
Efl_Text_Cursor *sel_handler_cursor;
void *input_panel_imdata;
int input_panel_imdata_len;
int input_panel_layout_variation;
@ -514,7 +515,8 @@ _update_selection_handler(Eo *obj)
Eina_Position2D off;
Evas_Coord hx, hy;
Eina_Bool hidden = EINA_FALSE;
Efl_Text_Cursor_Cursor *sel_start, *sel_end;
Efl_Text_Cursor *sel_start, *sel_end;
Eina_Rect rc_tmp;
efl_text_interactive_selection_cursors_get(obj, &sel_start, &sel_end);
@ -523,10 +525,11 @@ _update_selection_handler(Eo *obj)
//evas_object_geometry_get(sd->entry_edje, &ent_x, &ent_y, NULL, NULL);
efl_text_cursor_geometry_get(obj, sel_start,
EFL_TEXT_CURSOR_TYPE_BEFORE,
&sx, &sy, NULL, &sh,
NULL, NULL, NULL, NULL);
rc_tmp = efl_text_cursor_geometry_get(sel_start, EFL_TEXT_CURSOR_TYPE_BEFORE);
sx = rc_tmp.x;
sy = rc_tmp.y;
sh = rc_tmp.h;
off = _decoration_calc_offset(sd);
hx = off.x + sx;
hy = off.y + sy + sh;
@ -553,10 +556,11 @@ _update_selection_handler(Eo *obj)
}
hidden = EINA_FALSE;
efl_text_cursor_geometry_get(obj, sel_end,
EFL_TEXT_CURSOR_TYPE_BEFORE,
&ex, &ey, NULL, &eh,
NULL, NULL, NULL, NULL);
rc_tmp = efl_text_cursor_geometry_get(sel_end, EFL_TEXT_CURSOR_TYPE_BEFORE);
ex = rc_tmp.x;
ey = rc_tmp.y;
eh = rc_tmp.h;
hx = off.x + ex;
hy = off.y + ey + eh;
evas_object_move(sd->end_handler, hx, hy);
@ -600,31 +604,31 @@ static void
_selection_data_cb(void *data EINA_UNUSED, Eo *obj,
Efl_Ui_Selection_Data *sel_data)
{
Efl_Text_Cursor_Cursor *cur, *start, *end;
Efl_Text_Cursor *cur, *start, *end;
Efl_Ui_Text_Change_Info info = { NULL, 0, 0, 0, 0 };
char *buf = eina_slice_strdup(sel_data->content);
size_t len = sel_data->content.len;
efl_text_interactive_selection_cursors_get(obj, &start, &end);
if (!efl_text_cursor_equal(obj, start, end))
if (!efl_text_cursor_equal(start, end))
{
efl_canvas_text_range_delete(obj, start, end);
efl_text_cursor_range_delete(start, end);
EFL_UI_TEXT_DATA_GET(obj, sd);
_efl_ui_text_select_none(obj, sd);
}
cur = efl_text_cursor_get(obj, EFL_TEXT_CURSOR_GET_TYPE_MAIN);
cur = efl_text_interactive_main_cursor_get(obj);
info.insert = EINA_TRUE;
info.position = efl_text_cursor_position_get(obj, cur);
info.position = efl_text_cursor_position_get(cur);
info.length = len;
info.content = buf;
if (sel_data->format == EFL_UI_SELECTION_FORMAT_MARKUP)
{
efl_text_markup_interactive_cursor_markup_insert(obj, cur, buf);
efl_text_cursor_markup_insert(cur, buf);
}
else // TEXT
{
efl_text_cursor_text_insert(obj, cur, buf);
efl_text_cursor_text_insert(cur, buf);
}
efl_event_callback_call(obj, EFL_UI_TEXT_EVENT_CHANGED_USER, &info);
free(buf);
@ -829,6 +833,7 @@ _cursor_geometry_recalc(Evas_Object *obj)
Evas_Coord x, y, w, h;
Evas_Coord x2, y2, w2, h2;
Evas_Coord cx, cy, cw, ch;
Eina_Rect rc;
if (!sd->editable) return;
@ -836,12 +841,15 @@ _cursor_geometry_recalc(Evas_Object *obj)
x2 = y2 = w2 = h2 = 0;
x = y = w = h = 0;
Efl_Text_Cursor_Cursor *main_cur =
efl_text_cursor_get(obj, EFL_TEXT_CURSOR_GET_TYPE_MAIN);
Efl_Text_Cursor *main_cur =
efl_text_interactive_main_cursor_get(obj);
rc = efl_text_cursor_geometry_get(main_cur, EFL_TEXT_CURSOR_TYPE_BEFORE);
cx = rc.x;
cy = rc.y;
cw = rc.w;
ch = rc.h;
efl_text_cursor_geometry_get(obj, main_cur,
EFL_TEXT_CURSOR_TYPE_BEFORE,
&cx, &cy, &cw, &ch, NULL, NULL, NULL, NULL);
edje_object_size_min_restricted_calc(sd->cursor, &cw, NULL, cw, 0);
if (cw < 1) cw = 1;
if (ch < 1) ch = 1;
@ -918,9 +926,9 @@ _efl_ui_text_efl_canvas_group_group_calculate(Eo *obj, Efl_Ui_Text_Data *sd)
efl_gfx_entity_size_set(sd->text_obj, EINA_SIZE2D(sz.w, 0));
/* ignore current object size for single-line since we always need to know the actual size */
if (sd->single_line)
efl_canvas_text_size_native_get(sd->text_obj, &min.w, &min.h);
min = efl_canvas_text_size_native_get(sd->text_obj);
else
efl_canvas_text_size_formatted_get(sd->text_obj, &min.w, &min.h);
min = efl_canvas_text_size_formatted_get(sd->text_obj);
efl_gfx_entity_size_set(sd->text_obj, text_sz);
efl_event_thaw(sd->text_obj);
min.w += edmin.w;
@ -1008,11 +1016,8 @@ _efl_ui_text_efl_ui_widget_interest_region_get(const Eo *obj EINA_UNUSED, Efl_Ui
Evas_Coord edje_x, edje_y, elm_x, elm_y;
Eina_Rect r = {};
efl_text_cursor_geometry_get(obj,
efl_text_cursor_get(obj, EFL_TEXT_CURSOR_GET_TYPE_MAIN),
EFL_TEXT_CURSOR_TYPE_BEFORE,
&r.x, &r.y, &r.w, &r.h,
NULL, NULL, NULL, NULL);
r = efl_text_cursor_geometry_get(
efl_text_interactive_main_cursor_get(obj), EFL_TEXT_CURSOR_TYPE_BEFORE);
if (sd->single_line)
{
@ -1172,7 +1177,7 @@ _selection_store(Efl_Ui_Selection_Type seltype,
Evas_Object *obj)
{
char *sel;
Efl_Text_Cursor_Cursor *start, *end;
Efl_Text_Cursor *start, *end;
Efl_Ui_Selection_Format selformat = EFL_UI_SELECTION_FORMAT_MARKUP;
Eina_Slice slice;
Selection_Loss_Data *ldata;
@ -1181,7 +1186,7 @@ _selection_store(Efl_Ui_Selection_Type seltype,
EFL_UI_TEXT_DATA_GET(obj, sd);
efl_text_interactive_selection_cursors_get(obj, &start, &end);
sel = efl_text_markup_interactive_markup_range_get(obj, start, end);
sel = efl_text_cursor_range_markup_get(start, end);
if ((!sel) || (!sel[0])) return; /* avoid deleting our own selection */
@ -1228,7 +1233,7 @@ end:
static void
_cut_cb(Eo *obj)
{
Efl_Text_Cursor_Cursor *start, *end;
Efl_Text_Cursor *start, *end;
EFL_UI_TEXT_DATA_GET(obj, sd);
efl_event_callback_call(obj, EFL_UI_EVENT_SELECTION_CUT, NULL);
@ -1244,7 +1249,7 @@ _cut_cb(Eo *obj)
_selection_store(EFL_UI_SELECTION_TYPE_CLIPBOARD, obj);
efl_text_interactive_selection_cursors_get(obj, &start, &end);
efl_canvas_text_range_delete(obj, start, end);
efl_text_cursor_range_delete(start, end);
_efl_ui_text_select_none(obj, sd);
}
@ -1686,15 +1691,18 @@ _selection_handlers_offset_calc(Evas_Object *obj, Evas_Object *handler)
Evas_Coord cx, cy, cw, ch;
Evas_Coord hh;
Eina_Position2D pos;
Eina_Rect rc;
EFL_UI_TEXT_DATA_GET(obj, sd);
pos = efl_gfx_entity_position_get(sd->text_obj);
efl_text_cursor_geometry_get(obj,
efl_text_cursor_get(obj, EFL_TEXT_CURSOR_GET_TYPE_MAIN),
EFL_TEXT_CURSOR_TYPE_BEFORE,
&cx, &cy, &cw, &ch,
NULL, NULL, NULL, NULL);
rc = efl_text_cursor_geometry_get(
efl_text_interactive_main_cursor_get(obj), EFL_TEXT_CURSOR_TYPE_BEFORE);
cx = rc.x;
cy = rc.y;
cw = rc.w;
ch = rc.h;
edje_object_size_min_calc(handler, NULL, &hh);
sd->ox = pos.x + cx + (cw / 2);
@ -1720,8 +1728,8 @@ _start_handler_mouse_down_cb(void *data,
EFL_UI_TEXT_DATA_GET(data, sd);
int start_pos, end_pos, pos;
Efl_Text_Cursor_Cursor *sel_start, *sel_end;
Efl_Text_Cursor_Cursor *main_cur;
Efl_Text_Cursor *sel_start, *sel_end;
Efl_Text_Cursor *main_cur;
Eo *text_obj = sd->text_obj;
@ -1729,10 +1737,10 @@ _start_handler_mouse_down_cb(void *data,
/* Get the cursors */
efl_text_interactive_selection_cursors_get(text_obj, &sel_start, &sel_end);
main_cur = efl_text_cursor_get(text_obj, EFL_TEXT_CURSOR_GET_TYPE_MAIN);
main_cur = efl_text_interactive_main_cursor_get(text_obj);
start_pos = efl_text_cursor_position_get(text_obj, sel_start);
end_pos = efl_text_cursor_position_get(text_obj, sel_end);
start_pos = efl_text_cursor_position_get(sel_start);
end_pos = efl_text_cursor_position_get(sel_end);
if (start_pos <= end_pos)
{
@ -1744,7 +1752,7 @@ _start_handler_mouse_down_cb(void *data,
pos = end_pos;
sd->sel_handler_cursor = sel_end;
}
efl_text_cursor_position_set(text_obj, main_cur, pos);
efl_text_cursor_position_set(main_cur, pos);
_selection_handlers_offset_calc(data, sd->start_handler);
}
@ -1783,12 +1791,12 @@ _start_handler_mouse_move_cb(void *data,
cy = ev->cur.canvas.y - sd->oy - ey;
if (cx <= 0) cx = 1;
efl_text_cursor_coord_set(sd->text_obj, sd->sel_handler_cursor, cx, cy);
pos = efl_text_cursor_position_get(sd->text_obj, sd->sel_handler_cursor);
efl_text_cursor_char_coord_set(sd->sel_handler_cursor, EINA_POSITION2D(cx, cy));
pos = efl_text_cursor_position_get(sd->sel_handler_cursor);
/* Set the main cursor. */
efl_text_cursor_position_set(sd->text_obj,
efl_text_cursor_get(sd->text_obj, EFL_TEXT_CURSOR_GET_TYPE_MAIN), pos);
efl_text_cursor_position_set(
efl_text_interactive_main_cursor_get(sd->text_obj), pos);
efl_input_clickable_longpress_abort(data, 1);
sd->long_pressed = EINA_FALSE;
@ -1802,8 +1810,8 @@ _end_handler_mouse_down_cb(void *data,
{
EFL_UI_TEXT_DATA_GET(data, sd);
Efl_Text_Cursor_Cursor *sel_start, *sel_end;
Efl_Text_Cursor_Cursor *main_cur;
Efl_Text_Cursor *sel_start, *sel_end;
Efl_Text_Cursor *main_cur;
int pos, start_pos, end_pos;
sd->end_handler_down = EINA_TRUE;
@ -1811,10 +1819,10 @@ _end_handler_mouse_down_cb(void *data,
Eo *text_obj = sd->text_obj;
efl_text_interactive_selection_cursors_get(text_obj, &sel_start, &sel_end);
main_cur = efl_text_cursor_get(text_obj, EFL_TEXT_CURSOR_GET_TYPE_MAIN);
main_cur = efl_text_interactive_main_cursor_get(text_obj);
start_pos = efl_text_cursor_position_get(text_obj, sel_start);
end_pos = efl_text_cursor_position_get(text_obj, sel_end);
start_pos = efl_text_cursor_position_get(sel_start);
end_pos = efl_text_cursor_position_get(sel_end);
if (start_pos < end_pos)
{
@ -1827,7 +1835,7 @@ _end_handler_mouse_down_cb(void *data,
sd->sel_handler_cursor = sel_start;
}
efl_text_cursor_position_set(text_obj, main_cur, pos);
efl_text_cursor_position_set(main_cur, pos);
_selection_handlers_offset_calc(data, sd->end_handler);
}
@ -1866,10 +1874,10 @@ _end_handler_mouse_move_cb(void *data,
cy = ev->cur.canvas.y - sd->oy - ey;
if (cx <= 0) cx = 1;
efl_text_cursor_coord_set(sd->text_obj, sd->sel_handler_cursor, cx, cy);
pos = efl_text_cursor_position_get(sd->text_obj, sd->sel_handler_cursor);
efl_text_cursor_char_coord_set(sd->sel_handler_cursor, EINA_POSITION2D(cx, cy));
pos = efl_text_cursor_position_get(sd->sel_handler_cursor);
/* Set the main cursor. */
efl_text_cursor_position_set(sd->text_obj, efl_text_cursor_get(data, EFL_TEXT_CURSOR_GET_TYPE_MAIN), pos);
efl_text_cursor_position_set(efl_text_interactive_main_cursor_get(data), pos);
efl_input_clickable_longpress_abort(data, 1);
sd->long_pressed = EINA_FALSE;
}
@ -2195,7 +2203,7 @@ _efl_ui_text_efl_object_finalize(Eo *obj,
_efl_ui_text_changed_cb, obj);
efl_event_callback_add(sd->text_obj, EFL_TEXT_INTERACTIVE_EVENT_TEXT_SELECTION_CHANGED,
_efl_ui_text_selection_changed_cb, obj);
efl_event_callback_add(sd->text_obj, EFL_CANVAS_TEXT_EVENT_CURSOR_CHANGED,
efl_event_callback_add(efl_text_interactive_main_cursor_get(sd->text_obj), EFL_TEXT_CURSOR_EVENT_CHANGED,
_efl_ui_text_cursor_changed_cb, obj);
efl_event_callback_add(sd->text_obj, EFL_GFX_ENTITY_EVENT_POSITION_CHANGED,
_text_position_changed_cb, obj);
@ -2353,12 +2361,12 @@ _efl_ui_text_calc_force(Eo *obj, Efl_Ui_Text_Data *sd)
static const char*
_efl_ui_text_selection_get(const Eo *obj, Efl_Ui_Text_Data *sd)
{
Efl_Text_Cursor_Cursor *start_obj, *end_obj;
Efl_Text_Cursor *start_obj, *end_obj;
if ((sd->password)) return NULL;
efl_text_interactive_selection_cursors_get(obj, &start_obj, &end_obj);
return efl_canvas_text_range_text_get(obj, start_obj, end_obj);
return efl_text_cursor_range_text_get(start_obj, end_obj);
}
EOLIAN static void
@ -2377,12 +2385,26 @@ _efl_ui_text_selection_handler_disabled_get(const Eo *obj EINA_UNUSED, Efl_Ui_Te
static void
_efl_ui_text_entry_insert(Eo *obj, Efl_Ui_Text_Data *sd, const char *entry)
{
Efl_Text_Cursor_Cursor *cur_obj = efl_text_cursor_get(obj, EFL_TEXT_CURSOR_GET_TYPE_MAIN);
efl_text_cursor_text_insert(obj, cur_obj, entry);
Efl_Text_Cursor *cur_obj = efl_text_interactive_main_cursor_get(obj);
efl_text_cursor_text_insert(cur_obj, entry);
sd->text_changed = EINA_TRUE;
efl_canvas_group_change(obj);
}
EOLIAN static void
_efl_ui_text_cursor_add(Eo *obj, Efl_Ui_Text_Data *pd, Efl_Text_Cursor *cursor)
{
efl_text_cursor_text_object_set(cursor, pd->text_obj, obj);
}
EOLIAN static Efl_Text_Cursor *
_efl_ui_text_cursor_create(Eo *obj, Efl_Ui_Text_Data *pd)
{
Eo* cursor = efl_add(EFL_TEXT_CURSOR_CLASS, pd->text_obj);
efl_text_cursor_text_object_set(cursor, pd->text_obj, obj);
return cursor;
}
EOLIAN static void
_efl_ui_text_efl_text_interactive_editable_set(Eo *obj, Efl_Ui_Text_Data *sd, Eina_Bool editable)
{
@ -2443,14 +2465,14 @@ _efl_ui_text_select_none(Eo *obj EINA_UNUSED, Efl_Ui_Text_Data *sd)
static void
_efl_ui_text_select_region_set(Eo *obj, Efl_Ui_Text_Data *sd, int start, int end)
{
Efl_Text_Cursor_Cursor *sel_start, *sel_end;
Efl_Text_Cursor *sel_start, *sel_end;
if ((sd->password)) return;
efl_text_interactive_selection_cursors_get(obj, &sel_start, &sel_end);
efl_text_cursor_position_set(obj, sel_start, start);
efl_text_cursor_position_set(obj, sel_end, end);
efl_text_cursor_position_set(sel_start, start);
efl_text_cursor_position_set(sel_end, end);
}
EOLIAN static void
@ -2989,13 +3011,13 @@ fail:
EOLIAN static int
_efl_ui_text_efl_access_text_caret_offset_get(const Eo *obj, Efl_Ui_Text_Data *_pd EINA_UNUSED)
{
return efl_text_cursor_position_get(obj, efl_text_cursor_get(obj, EFL_TEXT_CURSOR_GET_TYPE_MAIN));
return efl_text_cursor_position_get(efl_text_interactive_main_cursor_get(obj));
}
EOLIAN static Eina_Bool
_efl_ui_text_efl_access_text_caret_offset_set(Eo *obj, Efl_Ui_Text_Data *_pd EINA_UNUSED, int offset)
{
efl_text_cursor_position_set(obj, efl_text_cursor_get(obj, EFL_TEXT_CURSOR_GET_TYPE_MAIN), offset);
efl_text_cursor_position_set(efl_text_interactive_main_cursor_get(obj), offset);
return EINA_TRUE;
}
@ -3267,19 +3289,19 @@ _efl_ui_text_efl_access_text_default_attributes_get(const Eo *obj, Efl_Ui_Text_D
{
Eina_List *ret = NULL;
Efl_Access_Text_Attribute *attr;
Efl_Text_Cursor_Cursor *start, *end;
Efl_Text_Cursor *start, *end;
Eina_Iterator *annotations;
Efl_Text_Annotate_Annotation *an;
/* Retrieve all annotations in the text. */
Eo *mobj = (Eo *)obj; /* XXX const */
start = efl_text_cursor_new(mobj);
end = efl_text_cursor_new(mobj);
start = efl_ui_text_cursor_create(mobj);
end = efl_ui_text_cursor_create(mobj);
efl_text_cursor_paragraph_first(mobj, start);
efl_text_cursor_paragraph_last(mobj, end);
efl_text_cursor_move(start, EFL_TEXT_CURSOR_MOVE_TYPE_PARAGRAPH_FIRST);
efl_text_cursor_move(end, EFL_TEXT_CURSOR_MOVE_TYPE_PARAGRAPH_LAST);
annotations = efl_text_range_annotations_get(obj, start, end);
annotations = efl_text_range_annotations_get(obj, efl_text_cursor_handle_get(start), efl_text_cursor_handle_get(end));
EINA_ITERATOR_FOREACH(annotations, an)
{
@ -3302,8 +3324,8 @@ _efl_ui_text_efl_access_editable_text_text_content_set(Eo *obj, Efl_Ui_Text_Data
EOLIAN static Eina_Bool
_efl_ui_text_efl_access_editable_text_insert(Eo *obj, Efl_Ui_Text_Data *pd, const char *string, int position)
{
Efl_Text_Cursor_Cursor *cur_obj = efl_text_cursor_get(obj, EFL_TEXT_CURSOR_GET_TYPE_MAIN);
efl_text_cursor_position_set(obj, cur_obj, position);
Efl_Text_Cursor *cur_obj = efl_text_interactive_main_cursor_get(obj);
efl_text_cursor_position_set(cur_obj, position);
_efl_ui_text_entry_insert(obj, pd, string);
return EINA_TRUE;
@ -3352,8 +3374,8 @@ _efl_ui_text_efl_access_editable_text_delete(Eo *obj, Efl_Ui_Text_Data *pd, int
EOLIAN static Eina_Bool
_efl_ui_text_efl_access_editable_text_paste(Eo *obj, Efl_Ui_Text_Data *_pd EINA_UNUSED, int position)
{
Efl_Text_Cursor_Cursor *cur_obj = efl_text_cursor_get(obj, EFL_TEXT_CURSOR_GET_TYPE_MAIN);
efl_text_cursor_position_set(obj, cur_obj, position);
Efl_Text_Cursor *cur_obj = efl_text_interactive_main_cursor_get(obj);
efl_text_cursor_position_set(cur_obj, position);
efl_ui_text_selection_paste(obj);
return EINA_TRUE;
}
@ -3451,11 +3473,11 @@ static void
_update_text_cursors(Eo *obj)
{
Evas_Coord xx, yy, ww, hh;
Evas_Coord xx2, yy2;
Eina_Position2D off;
Eina_Bool bidi_cursor;
Eo *text_obj;
Eina_Rect rc_tmp1;
Eina_Rect rc_tmp2;
Eina_Bool bidi_cursor;
EFL_UI_TEXT_DATA_GET(obj, sd);
if (!sd->deferred_decoration_cursor) return;
@ -3465,10 +3487,13 @@ _update_text_cursors(Eo *obj)
xx = yy = ww = hh = -1;
off =_decoration_calc_offset(sd);
bidi_cursor = efl_text_cursor_geometry_get(obj,
efl_text_cursor_get(text_obj, EFL_TEXT_CURSOR_GET_TYPE_MAIN),
EFL_TEXT_CURSOR_TYPE_BEFORE, &xx, &yy, &ww, &hh, &xx2, &yy2,
NULL, NULL);
rc_tmp1 = efl_text_cursor_geometry_get(efl_text_interactive_main_cursor_get(text_obj), EFL_TEXT_CURSOR_TYPE_BEFORE);
bidi_cursor = efl_text_cursor_lower_cursor_geometry_get(efl_text_interactive_main_cursor_get(text_obj), &rc_tmp2);
xx = rc_tmp1.x;
yy = rc_tmp1.y;
ww = rc_tmp1.w;
hh = rc_tmp1.h;
if (ww < 1) ww = 1;
if (hh < 1) hh = 1;
if (sd->cursor)
@ -3480,7 +3505,7 @@ _update_text_cursors(Eo *obj)
if (bidi_cursor)
{
evas_object_geometry_set(sd->cursor_bidi,
off.x + xx2, off.y + yy2 + (hh / 2),
off.x + rc_tmp2.x, off.y + rc_tmp2.y + (hh / 2),
ww, hh / 2);
evas_object_resize(sd->cursor, ww, hh / 2);
evas_object_show(sd->cursor_bidi);
@ -3513,7 +3538,7 @@ static void
_update_text_selection(Eo *obj, Eo *text_obj)
{
Eina_Position2D off;
Efl_Text_Cursor_Cursor *sel_start, *sel_end;
Efl_Text_Cursor *sel_start, *sel_end;
Eina_List *l;
Eina_Iterator *range;
@ -3529,8 +3554,7 @@ _update_text_selection(Eo *obj, Eo *text_obj)
efl_text_interactive_selection_cursors_get(text_obj, &sel_start, &sel_end);
range = efl_canvas_text_range_simple_geometry_get(text_obj,
sel_start, sel_end);
range = efl_text_cursor_range_geometry_get(sel_start, sel_end);
l = sd->sel;
EINA_ITERATOR_FOREACH(range, r)
@ -3680,7 +3704,7 @@ _anchors_update(Eo *obj, Efl_Ui_Text_Data *sd)
Evas_Object *smart, *clip;
Eina_Iterator *it;
Eina_Position2D off;
Efl_Text_Cursor_Cursor *start, *end;
Efl_Text_Cursor *start, *end;
Efl_Text_Annotate_Annotation *an;
Eina_List *i, *ii;
Anchor *anc;
@ -3692,16 +3716,16 @@ _anchors_update(Eo *obj, Efl_Ui_Text_Data *sd)
sd->gen++;
start = efl_text_cursor_new(sd->text_obj);
end = efl_text_cursor_new(sd->text_obj);
start = efl_canvas_text_cursor_create(sd->text_obj);
end = efl_canvas_text_cursor_create(sd->text_obj);
/* Retrieve all annotations in the text. */
efl_text_cursor_paragraph_first(obj, start);
efl_text_cursor_paragraph_last(obj, end);
efl_text_cursor_move(start, EFL_TEXT_CURSOR_MOVE_TYPE_PARAGRAPH_FIRST);
efl_text_cursor_move(end, EFL_TEXT_CURSOR_MOVE_TYPE_PARAGRAPH_LAST);
it = efl_text_range_annotations_get(obj, start, end);
efl_text_cursor_free(sd->text_obj, start);
efl_text_cursor_free(sd->text_obj, end);
it = efl_text_range_annotations_get(obj, efl_text_cursor_handle_get(start), efl_text_cursor_handle_get(end));
efl_del(start);
efl_del(end);
smart = evas_object_smart_parent_get(obj);
clip = evas_object_clip_get(sd->text_obj);
@ -3754,12 +3778,12 @@ _anchors_update(Eo *obj, Efl_Ui_Text_Data *sd)
Eina_List *l;
Eina_Rectangle *r;
size_t count;
start = efl_text_cursor_new(obj);
end = efl_text_cursor_new(obj);
start = efl_ui_text_cursor_create(obj);
end = efl_ui_text_cursor_create(obj);
efl_text_annotation_positions_get(obj, anc->annotation,
start, end);
efl_text_cursor_handle_get(start), efl_text_cursor_handle_get(end));
range = efl_canvas_text_range_geometry_get(obj, start, end);
range = efl_text_cursor_range_geometry_get(start, end);
count = eina_list_count(eina_iterator_container_get(range));
// Add additional rectangles if needed
@ -3967,13 +3991,13 @@ _efl_ui_text_selection_changed_cb(void *data, const Efl_Event *event EINA_UNUSED
{
if (efl_invalidated_get(event->object)) return;
Eo *obj = data;
Efl_Text_Cursor_Cursor *start, *end;
Efl_Text_Cursor *start, *end;
char *text;
EFL_UI_TEXT_DATA_GET(obj, sd);
efl_text_interactive_selection_cursors_get(obj, &start, &end);
text = efl_canvas_text_range_text_get(obj, start, end);
text = efl_text_cursor_range_text_get(start, end);
if (!text || (text[0] == '\0'))
{
_edje_signal_emit(sd, "selection,cleared", "efl.text");

13
src/lib/elementary/efl_ui_text.eo
View File

@ -86,7 +86,7 @@ class @beta Efl.Ui.Text extends Efl.Ui.Layout_Base implements Efl.Input.Clickabl
Efl.Access.Text, Efl.Access.Editable.Text, Efl.File,
Efl.Ui.Text_Selectable
composites
Efl.Text_Interactive, Efl.Text_Markup, Efl.Text_Cursor
Efl.Text_Interactive, Efl.Text_Markup
{
[[A flexible text widget which can be static (as a label) or editable by
the user (as a text entry). It provides all sorts of editing facilities
@ -286,6 +286,17 @@ class @beta Efl.Ui.Text extends Efl.Ui.Layout_Base implements Efl.Input.Clickabl
item_factory: Efl.Canvas.Text_Factory; [[Factory to create items]]
}
}
cursor_add {
[[Add cursor that will manipulate and iterate content of the text object.
It is typically more convenient to obtain a cursor directly from the text object using @.cursor_create.]]
params {
cursor: Efl.Text.Cursor; [[Text cursor.]]
}
}
cursor_create {
[[Creates and returns a new cursor for the text.]]
return: Efl.Text.Cursor @move; [[Text cursor.]]
}
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.

1
src/lib/evas/Efl_Canvas.h
View File

@ -83,6 +83,7 @@ extern "C" {
#include <canvas/efl_canvas_scene3d.eo.h>
*/
#include <canvas/efl_canvas_snapshot.eo.h>
#include <canvas/efl_text_cursor.eo.h>
#include <canvas/efl_canvas_text.eo.h>
#include <canvas/efl_canvas_text_factory.eo.h>
#include <canvas/efl_canvas_vg_node.eo.h>

1
src/lib/evas/Evas.h
View File

@ -210,7 +210,6 @@ extern "C" {
#include <canvas/efl_input_types.eot.h>
#include <Evas_Common.h>
#ifndef EFL_NOLEGACY_API_SUPPORT
#include <Evas_Legacy.h>
#endif

5
src/lib/evas/Evas_Common.h
View File

@ -3510,11 +3510,6 @@ typedef enum
#endif
#ifndef _EFL_TEXT_CURSOR_EO_H_
#define _EFL_TEXT_CURSOR_EO_H_
#endif
#ifndef _EFL_GFX_ENTITY_EO_H_
#define _EFL_GFX_ENTITY_EO_H_

2
src/lib/evas/Evas_Eo.h
View File

@ -154,7 +154,7 @@ struct _Efl_Canvas_Object_Animation_Event
*
* @{
*/
//#include "canvas/efl_canvas_text_cursor.eo.h"
#include "canvas/efl_text_cursor.eo.h"
#include "canvas/efl_canvas_text.eo.h"
#include "canvas/efl_canvas_text_factory.eo.h"
/**

109
src/lib/evas/canvas/efl_canvas_text.eo
View File

@ -2,8 +2,8 @@ import efl_text_types;
class @beta Efl.Canvas.Text extends Efl.Canvas.Object implements Efl.Text,
Efl.Canvas.Filter.Internal, Efl.Text_Font,
Efl.Text_Style, Efl.Text_Format, Efl.Text_Cursor,
Efl.Text_Annotate, Efl.Text_Markup, Efl.Text_Markup_Interactive, Efl.Ui.I18n
Efl.Text_Style, Efl.Text_Format,
Efl.Text_Annotate, Efl.Text_Markup, Efl.Ui.I18n
{
[[Efl canvas text class]]
methods {
@ -16,6 +16,18 @@ class @beta Efl.Canvas.Text extends Efl.Canvas.Object implements Efl.Text,
is_empty: bool; [[$true if empty, $false otherwise]]
}
}
cursor_add {
[[Add cursor that will manipulate and iterate content of the text object
It is typically more convenient to obtain a cursor directly from the text object using @.cursor_create.]]
params {
cursor: Efl.Text.Cursor; [[Text cursor.]]
}
}
cursor_create {
[[ Create new cursor and add it to text object
]]
return: Efl.Text.Cursor @move; [[Text cursor.]]
}
visible_range_get {
[[Returns the currently visible range.
@ -25,8 +37,8 @@ class @beta Efl.Canvas.Text extends Efl.Canvas.Object implements Efl.Text,
]]
return: bool; [[$true on success, $false otherwise]]
params {
@in start: ptr(Efl.Text_Cursor_Cursor); [[Range start position]]
@in end: ptr(Efl.Text_Cursor_Cursor); [[Range end position]]
@in start: Efl.Text.Cursor; [[Range start position]]
@in end: Efl.Text.Cursor; [[Range end position]]
}
}
@property style_insets {
@ -54,7 +66,7 @@ class @beta Efl.Canvas.Text extends Efl.Canvas.Object implements Efl.Text,
delim: string; [[A null terminated string of delimiters, e.g ",|" or $null if empty]]
}
}
@property legacy_newline {
@property newline_as_paragraph_separator {
[[When $true, newline character will behave as a paragraph separator.
]]
set {}
@ -105,8 +117,7 @@ class @beta Efl.Canvas.Text extends Efl.Canvas.Object implements Efl.Text,
]]
get {}
values {
w: int; [[The width of the object.]]
h: int; [[The height of the object.]]
size: Eina.Size2D; [[The size of the object]]
}
}
@property size_native {
@ -129,56 +140,7 @@ class @beta Efl.Canvas.Text extends Efl.Canvas.Object implements Efl.Text,
]]
get {}
values {
w: int; [[The width returned.]]
h: int; [[The height returned.]]
}
}
range_text_get @const {
[[Returns the text in the range between $cur1 and $cur2.
]]
return: mstring @move; [[The text in the given range]]
params {
@in cur1: ptr(const(Efl.Text_Cursor_Cursor)); [[Start of range]]
@in cur2: ptr(const(Efl.Text_Cursor_Cursor)); [[End of range]]
}
}
range_geometry_get {
[[Get the geometry of a range in the text.
The geometry is represented as rectangles for each of the line
segments in the given range [$cur1, $cur2].
]]
params {
@in cur1: ptr(const(Efl.Text_Cursor_Cursor)); [[Start of range]]
@in cur2: ptr(const(Efl.Text_Cursor_Cursor)); [[End of range]]
}
return: iterator<ptr(Eina.Rect)> @move; [[
Iterator on all geoemtries of the given range
]]
}
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 {
@in cur1: ptr(const(Efl.Text_Cursor_Cursor)); [[Start of range]]
@in cur2: ptr(const(Efl.Text_Cursor_Cursor)); [[End of range]]
}
return: iterator<ptr(Eina.Rect)> @move; [[
Iterator on all simple geometries of the given range
]]
}
range_delete {
[[Deletes the range between given cursors.
This removes all the text in given range [$start,$end].
]]
params {
@in cur1: ptr(Efl.Text_Cursor_Cursor); [[Range start position]]
@in cur2: ptr(Efl.Text_Cursor_Cursor); [[Range end position]]
size: Eina.Size2D; [[The size of the object]]
}
}
// Obstacles
@ -274,34 +236,6 @@ class @beta Efl.Canvas.Text extends Efl.Canvas.Object implements Efl.Text,
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;
Efl.Text_Cursor.cursor_cluster_next;
Efl.Text_Cursor.cursor_cluster_prev;
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;
Efl.Text_Cursor.cursor_cluster_coord_set;
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;
@ -312,13 +246,12 @@ class @beta Efl.Canvas.Text extends Efl.Canvas.Object implements Efl.Text,
Efl.Text_Annotate.cursor_item_annotation { get; }
Efl.Text_Annotate.cursor_item_insert;
Efl.Text_Markup.markup { set; get; }
Efl.Text_Markup_Interactive.cursor_markup_insert;
Efl.Text_Markup_Interactive.markup_range { get;}
Efl.Gfx.Entity.scale { set; }
}
events {
cursor,changed: void; [[Called when cursor changed]]
changed: void; [[Called when canvas text changed ]]
attributes,changed: void; [[Called when attributes change]]
layout,finished: void; [[Called when the object has been layed out]]
style_insets,changed: void; [[Called when the property @.style_insets changed.]]
}
}

18
src/lib/evas/canvas/efl_canvas_text_eo.legacy.c
View File

@ -1,8 +1,8 @@
EAPI Eina_Bool
evas_object_textblock_visible_range_get(Efl_Canvas_Text *obj, Efl_Text_Cursor_Cursor *start, Efl_Text_Cursor_Cursor *end)
evas_object_textblock_visible_range_get(Efl_Canvas_Text *obj EINA_UNUSED, Efl_Text_Cursor_Handle *start, Efl_Text_Cursor_Handle *end)
{
return efl_canvas_text_visible_range_get(obj, start, end);
return evas_textblock_cursor_visible_range_get(start, end);
}
EAPI void
@ -26,25 +26,31 @@ evas_object_textblock_bidi_delimiters_get(const Efl_Canvas_Text *obj)
EAPI void
evas_object_textblock_legacy_newline_set(Efl_Canvas_Text *obj, Eina_Bool mode)
{
efl_canvas_text_legacy_newline_set(obj, mode);
efl_canvas_text_newline_as_paragraph_separator_set(obj, mode);
}
EAPI Eina_Bool
evas_object_textblock_legacy_newline_get(const Efl_Canvas_Text *obj)
{
return efl_canvas_text_legacy_newline_get(obj);
return efl_canvas_text_newline_as_paragraph_separator_get(obj);
}
EAPI void
evas_object_textblock_size_formatted_get(const Efl_Canvas_Text *obj, int *w, int *h)
{
efl_canvas_text_size_formatted_get(obj, w, h);
Eina_Size2D size;
size = efl_canvas_text_size_formatted_get(obj);
if (w) *w = size.w;
if (h) *h = size.h;
}
EAPI void
evas_object_textblock_size_native_get(const Efl_Canvas_Text *obj, int *w, int *h)
{
efl_canvas_text_size_native_get(obj, w, h);
Eina_Size2D size;
size = efl_canvas_text_size_native_get(obj);
if (w) *w = size.w;
if (h) *h = size.h;
}
EAPI Eina_Bool

2
src/lib/evas/canvas/efl_canvas_text_eo.legacy.h
View File

@ -32,7 +32,7 @@ typedef Eo Efl_Canvas_Text;
*
* @ingroup Evas_Object_Textblock_Group
*/
EAPI Eina_Bool evas_object_textblock_visible_range_get(Efl_Canvas_Text *obj, Efl_Text_Cursor_Cursor *start, Efl_Text_Cursor_Cursor *end);
EAPI Eina_Bool evas_object_textblock_visible_range_get(Efl_Canvas_Text *obj, Efl_Text_Cursor_Handle *start, Efl_Text_Cursor_Handle *end);
/**
* @brief Gets the left, right, top and bottom insets of the text.

219
src/lib/evas/canvas/efl_canvas_text_internal.h Normal file
View File

@ -0,0 +1,219 @@
#ifndef _EFL_CANVAS_TEXT_INTERNAL_H
#define _EFL_CANVAS_TEXT_INTERNAL_H
#include <Evas.h>
#define _REPLACEMENT_CHAR_UTF8 "\xEF\xBF\xBC"
#define _PARAGRAPH_SEPARATOR_UTF8 "\xE2\x80\xA9"
#define _NEWLINE_UTF8 "\n"
#define _TAB_UTF8 "\t"
/* private struct for textblock object internal data */
/**
* @internal
* @typedef Efl_Canvas_Text_Data
* The actual textblock object.
*/
typedef struct _Evas_Object_Textblock Efl_Canvas_Text_Data;
/**
* @internal
* @typedef Evas_Object_Style_Tag
* The structure used for finding style tags.
*/
typedef struct _Evas_Object_Style_Tag Evas_Object_Style_Tag;
/**
* @internal
* @typedef Evas_Object_Style_Tag
* The structure used for finding style tags.
*/
typedef struct _Evas_Object_Style_Tag_Base Evas_Object_Style_Tag_Base;
/**
* @internal
* @typedef Evas_Object_Textblock_Node_Text
* A text node.
*/
typedef struct _Evas_Object_Textblock_Node_Text Evas_Object_Textblock_Node_Text;
/*
* Defined in Evas.h
typedef struct _Evas_Object_Textblock_Node_Format Evas_Object_Textblock_Node_Format;
*/
typedef struct _Evas_Textblock_Node_Format Evas_Textblock_Node_Format;
/**
* @internal
* @typedef Evas_Object_Textblock_Paragraph
* A layouting paragraph.
*/
typedef struct _Evas_Object_Textblock_Paragraph Evas_Object_Textblock_Paragraph;
/**
* @internal
* @typedef Evas_Object_Textblock_Line
* A layouting line.
*/
typedef struct _Evas_Object_Textblock_Line Evas_Object_Textblock_Line;
/**
* @internal
* @typedef Evas_Object_Textblock_Item
* A layouting item.
*/
typedef struct _Evas_Object_Textblock_Item Evas_Object_Textblock_Item;
/**
* @internal
* @typedef Evas_Object_Textblock_Item
* A layouting text item.
*/
typedef struct _Evas_Object_Textblock_Text_Item Evas_Object_Textblock_Text_Item;
/**
* @internal
* @typedef Evas_Object_Textblock_Format_Item
* A layouting format item.
*/
typedef struct _Evas_Object_Textblock_Format_Item Evas_Object_Textblock_Format_Item;
/**
* @internal
* @typedef Evas_Object_Textblock_Format
* A textblock format.
*/
typedef struct _Evas_Object_Textblock_Format Evas_Object_Textblock_Format;
/**
* @internal
* @typedef Evas_Textblock_Selection_Iterator
* A textblock selection iterator.
*/
typedef struct _Evas_Textblock_Selection_Iterator Evas_Textblock_Selection_Iterator;
/**
* @internal
* @typedef Efl_Text_Annotate_Annotation_Iterator
* A textblock annotation iterator.
*/
typedef struct _Efl_Text_Annotate_Annotation_Iterator Efl_Text_Annotate_Annotation_Iterator;
/**
* @internal
* @typedef Efl_Canvas_Text_Filter
* A structure holding gfx filter information for a text item
*/
typedef struct _Efl_Canvas_Text_Filter Efl_Canvas_Text_Filter;
/**
* @internal
* @typedef Efl_Canvas_Text_Filter_Post_Render
* Post-render data for async rendering of gfx filters
*/
typedef struct _Efl_Canvas_Text_Filter_Post_Render Efl_Canvas_Text_Filter_Post_Render;
/**
* @internal
* @typedef Efl_Canvas_Text_Filter_Program
* Filter name - code database
*/
typedef struct _Efl_Canvas_Text_Filter_Program Efl_Canvas_Text_Filter_Program;
/**
* @internal
* @typedef Text_Item_Filter
* Text item filter properties (run context, output buffer, ...)
*/
typedef struct _Text_Item_Filter Text_Item_Filter;
struct _Evas_Object_Style_Tag_Base
{
const char *tag; /**< Format Identifier: b=Bold, i=Italic etc. */
const char *replace; /**< Replacement string. "font_weight=Bold", "font_style=Italic" etc. */
size_t tag_len; /**< Strlen of tag. */
};
struct _Evas_Object_Style_Tag
{
EINA_INLIST;
Evas_Object_Style_Tag_Base tag; /**< Base style object for holding style information. */
};
struct _Evas_Object_Textblock_Node_Text
{
EINA_INLIST;
Eina_UStrbuf *unicode; /**< Actual paragraph text. */
char *utf8; /**< Text in utf8 format. */
Evas_Object_Textblock_Node_Format *format_node; /**< Points to the last format node before the paragraph, or if there is none, to the first format node within the paragraph.*/
Evas_Object_Textblock_Paragraph *par; /**< Points to the paragraph node of which this node is a part. */
Eina_Bool dirty : 1; /**< EINA_TRUE if already handled/format changed, else EINA_FALSE. */
Eina_Bool is_new : 1; /**< EINA_TRUE if its a new paragraph, else EINA_FALSE. */
};
struct _Evas_Textblock_Node_Format
{
EINA_INLIST;
const char *format; /**< Cached, parsed and translated version of orig_format. */
const char *orig_format; /**< Original format information. */
Evas_Object_Textblock_Node_Text *text_node; /**< The text node it's pointing to. */
Efl_Text_Annotate_Annotation *annotation; /**< Pointer to this node's annotation handle (if exists). */
size_t offset; /**< Offset from the last format node of the same text. */
struct {
unsigned char l, r, t, b;
} pad; /**< Amount of padding required. */
unsigned char anchor : 2; /**< ANCHOR_NONE, ANCHOR_A or ANCHOR_ITEM. */
Eina_Bool opener : 1; /**< EINA_TRUE if opener, else EINA_FALSE. */
Eina_Bool own_closer : 1; /**< EINA_TRUE if own_closer, else EINA_FALSE. */
Eina_Bool visible : 1; /**< EINA_TRUE if format is visible format, else EINA_FALSE. */
Eina_Bool format_change : 1; /**< EINA_TRUE if the format of the textblock has changed, else EINA_FALSE. */
Eina_Bool is_new : 1; /**< EINA_TRUE if its a new format node, else EINA_FALSE */
};
struct _Efl_Text_Cursor_Handle
{
Evas_Object *obj;
Eina_List *cur_objs;
size_t pos;
Evas_Object_Textblock_Node_Text *node;
unsigned int ref_count;
Eina_Bool changed : 1;
};
void evas_textblock_cursor_line_jump_by(Efl_Text_Cursor_Handle *cur, int by);
int _cursor_text_append(Efl_Text_Cursor_Handle *cur, const char *text);
// Used in Efl.Text.Cursor, where multible objects can have same handle.
Efl_Text_Cursor_Handle *
evas_textblock_cursor_ref(Efl_Text_Cursor_Handle *cursor, Eo * cursor_obj);
// Used in Efl.Text.Cursor, where multible objects can have same handle.
void
evas_textblock_cursor_unref(Efl_Text_Cursor_Handle *cursor, Eo * cursor_obj);
#ifdef EAPI
# undef EAPI
#endif
#ifdef _WIN32
# ifdef EFL_BUILD
# ifdef DLL_EXPORT
# define EAPI __declspec(dllexport)
# else
# define EAPI
# endif
# else
# define EAPI __declspec(dllimport)
# endif
#else
# ifdef __GNUC__
# if __GNUC__ >= 4
# define EAPI __attribute__ ((visibility("default")))
# else
# define EAPI
# endif
# else
# define EAPI
# endif
#endif
/**
* Internally sets given text_object into cursor object.
*
* @param canvas_text_obj the cursor object.
* @param canvas_text_obj the canvas text object, where cursor methods will take effect.
* @param text_obj the text_object that user can get using cursor text_object property.
*/
EAPI void efl_text_cursor_text_object_set(Eo *cursor, Eo *canvas_text_obj, Eo *text_obj);
#undef EAPI
#define EAPI
#endif

476
src/lib/evas/canvas/efl_text_cursor.c Normal file
View File

@ -0,0 +1,476 @@
#include "evas_common_private.h"
#include "evas_private.h"
#include "efl_canvas_text_internal.h"
#define MY_CLASS EFL_TEXT_CURSOR_CLASS
#define MY_CLASS_NAME "Efl.Text.Cursor"
typedef struct
{
Efl_Text_Cursor_Handle *handle;
Efl_Canvas_Object *text_obj;
} Efl_Text_Cursor_Data;
struct _Evas_Textblock_Selection_Iterator
{
Eina_Iterator iterator; /**< Eina Iterator. */
Eina_List *list; /**< Head of list. */
Eina_List *current; /**< Current node in loop. */
};
typedef struct _Evas_Textblock_Selection_Iterator Evas_Textblock_Selection_Iterator;
EOLIAN static void
_efl_text_cursor_position_set(Eo *obj EINA_UNUSED, Efl_Text_Cursor_Data *pd, int position)
{
evas_textblock_cursor_pos_set(pd->handle, position);
}
EOLIAN static int
_efl_text_cursor_position_get(const Eo *obj EINA_UNUSED, Efl_Text_Cursor_Data *pd)
{
return evas_textblock_cursor_pos_get(pd->handle);
}
EOLIAN static Eina_Unicode
_efl_text_cursor_content_get(const Eo *obj EINA_UNUSED, Efl_Text_Cursor_Data *pd)
{
if (pd->handle && pd->handle->node)
return eina_ustrbuf_string_get(pd->handle->node->unicode)[pd->handle->pos];
else
return 0;
}
EOLIAN static Eina_Rect
_efl_text_cursor_content_geometry_get(const Eo *obj EINA_UNUSED, Efl_Text_Cursor_Data *pd)
{
Eina_Rect rect = {0};
Eina_Bool item_is = evas_textblock_cursor_format_item_geometry_get(pd->handle, &(rect.x), &(rect.y), &(rect.w), &(rect.h));
if (item_is)
return rect;
evas_textblock_cursor_pen_geometry_get(pd->handle, &(rect.x), &(rect.y), &(rect.w), &(rect.h));
return rect;
}
EOLIAN static void
_efl_text_cursor_line_number_set(Eo *obj EINA_UNUSED, Efl_Text_Cursor_Data *pd, int line_number)
{
evas_textblock_cursor_line_set(pd->handle, line_number);
}
EOLIAN static int
_efl_text_cursor_line_number_get(const Eo *obj EINA_UNUSED, Efl_Text_Cursor_Data *pd)
{
Eina_Rect rect = {0};
return evas_textblock_cursor_line_geometry_get(pd->handle, &(rect.x), &(rect.y), &(rect.w), &(rect.h));
}
EOLIAN static Eina_Rect
_efl_text_cursor_cursor_geometry_get(const Eo *obj EINA_UNUSED, Efl_Text_Cursor_Data *pd, Efl_Text_Cursor_Type ctype)
{
Eina_Rect rc = {0};
Evas_Textblock_Cursor_Type cursor_type = (ctype == EFL_TEXT_CURSOR_TYPE_BEFORE) ? EVAS_TEXTBLOCK_CURSOR_BEFORE : EVAS_TEXTBLOCK_CURSOR_UNDER;
evas_textblock_cursor_geometry_bidi_get(pd->handle, &rc.x, &rc.y, &rc.w, &rc.h, NULL, NULL, NULL, NULL, cursor_type);
return rc;
}
EOLIAN static Eina_Bool
_efl_text_cursor_lower_cursor_geometry_get(const Eo *obj EINA_UNUSED, Efl_Text_Cursor_Data *pd, Eina_Rect *geometry2)
{
Eina_Rect rc = {0};
Eina_Bool b_ret = EINA_FALSE;
b_ret = evas_textblock_cursor_geometry_bidi_get(pd->handle, NULL, NULL, NULL, NULL, &rc.x, &rc.y, &rc.w, &rc.h, EVAS_TEXTBLOCK_CURSOR_BEFORE);
if (geometry2)
{
*geometry2 = rc;
}
return b_ret;
}
EOLIAN static Eina_Bool
_efl_text_cursor_equal(const Eo *obj EINA_UNUSED, Efl_Text_Cursor_Data *pd, const Efl_Text_Cursor *dst)
{
return evas_textblock_cursor_equal(pd->handle, efl_text_cursor_handle_get(dst));
}
EOLIAN static int
_efl_text_cursor_compare(const Eo *obj EINA_UNUSED, Efl_Text_Cursor_Data *pd, const Efl_Text_Cursor *dst)
{
return evas_textblock_cursor_compare(pd->handle, efl_text_cursor_handle_get(dst));
}
EOLIAN static void
_efl_text_cursor_copy(const Eo *obj EINA_UNUSED, Efl_Text_Cursor_Data *pd, Efl_Text_Cursor *dst)
{
if (!pd->handle) return;
Efl_Text_Cursor_Handle *handle = evas_object_textblock_cursor_new(pd->handle->obj);
evas_textblock_cursor_copy(pd->handle, handle);
efl_text_cursor_handle_set(dst, handle);
evas_textblock_cursor_unref(handle, NULL);
}
EOLIAN static Efl_Text_Cursor *
_efl_text_cursor_efl_duplicate_duplicate(const Eo *obj, Efl_Text_Cursor_Data *pd EINA_UNUSED)
{
Efl_Text_Cursor *dup = efl_new(MY_CLASS);
efl_text_cursor_copy(obj, dup);
return dup;
}
EOLIAN static Eina_Bool
_efl_text_cursor_move(Eo *obj EINA_UNUSED, Efl_Text_Cursor_Data *pd, Efl_Text_Cursor_Move_Type type)
{
Eina_Bool moved = EINA_FALSE;
int pos = evas_textblock_cursor_pos_get(pd->handle);
switch (type) {
case EFL_TEXT_CURSOR_MOVE_TYPE_CHAR_NEXT :
moved = evas_textblock_cursor_char_next(pd->handle);
break;
case EFL_TEXT_CURSOR_MOVE_TYPE_CHAR_PREV :
moved = evas_textblock_cursor_char_prev(pd->handle);
break;
case EFL_TEXT_CURSOR_MOVE_TYPE_CLUSTER_NEXT :
moved = evas_textblock_cursor_cluster_next(pd->handle);
break;
case EFL_TEXT_CURSOR_MOVE_TYPE_CLUSTER_PREV :
moved = evas_textblock_cursor_cluster_prev(pd->handle);
break;
case EFL_TEXT_CURSOR_MOVE_TYPE_PARAGRAPH_START :
evas_textblock_cursor_paragraph_char_first(pd->handle);
if (pos != evas_textblock_cursor_pos_get(pd->handle))
moved = EINA_TRUE;
break;
case EFL_TEXT_CURSOR_MOVE_TYPE_PARAGRAPH_END :
evas_textblock_cursor_paragraph_char_last(pd->handle);
if (pos != evas_textblock_cursor_pos_get(pd->handle))
moved = EINA_TRUE;
break;
case EFL_TEXT_CURSOR_MOVE_TYPE_WORD_START :
moved = evas_textblock_cursor_word_start(pd->handle);
break;
case EFL_TEXT_CURSOR_MOVE_TYPE_WORD_END :
moved = evas_textblock_cursor_word_end(pd->handle);
break;
case EFL_TEXT_CURSOR_MOVE_TYPE_LINE_START :
evas_textblock_cursor_line_char_first(pd->handle);
if (pos != evas_textblock_cursor_pos_get(pd->handle))
moved = EINA_TRUE;
break;
case EFL_TEXT_CURSOR_MOVE_TYPE_LINE_END :
evas_textblock_cursor_line_char_last(pd->handle);
if (pos != evas_textblock_cursor_pos_get(pd->handle))
moved = EINA_TRUE;
break;
case EFL_TEXT_CURSOR_MOVE_TYPE_PARAGRAPH_FIRST :
evas_textblock_cursor_paragraph_first(pd->handle);
if (pos != evas_textblock_cursor_pos_get(pd->handle))
moved = EINA_TRUE;
break;
case EFL_TEXT_CURSOR_MOVE_TYPE_PARAGRAPH_LAST :
evas_textblock_cursor_paragraph_last(pd->handle);
if (pos != evas_textblock_cursor_pos_get(pd->handle))
moved = EINA_TRUE;
break;
case EFL_TEXT_CURSOR_MOVE_TYPE_PARAGRAPH_NEXT :
moved = evas_textblock_cursor_paragraph_next(pd->handle);
break;
case EFL_TEXT_CURSOR_MOVE_TYPE_PARAGRAPH_PREV :
moved = evas_textblock_cursor_paragraph_prev(pd->handle);
break;
}
return moved;
}
EOLIAN static void
_efl_text_cursor_char_delete(Eo *obj EINA_UNUSED, Efl_Text_Cursor_Data *pd)
{
evas_textblock_cursor_char_delete(pd->handle);
}
EOLIAN static Eina_Bool
_efl_text_cursor_line_jump_by(Eo *obj EINA_UNUSED, Efl_Text_Cursor_Data *pd, int by)
{
if (!pd->handle) return EINA_FALSE;
Eina_Bool moved = EINA_FALSE;
int pos = evas_textblock_cursor_pos_get(pd->handle);
evas_textblock_cursor_line_jump_by(pd->handle, by);
moved = (pos == evas_textblock_cursor_pos_get(pd->handle));
return moved;
}
EOLIAN static void
_efl_text_cursor_char_coord_set(Eo *obj EINA_UNUSED, Efl_Text_Cursor_Data *pd, Eina_Position2D coord)
{
evas_textblock_cursor_char_coord_set(pd->handle, coord.x, coord.y);
}
EOLIAN static void
_efl_text_cursor_cluster_coord_set(Eo *obj EINA_UNUSED, Efl_Text_Cursor_Data *pd, Eina_Position2D coord)
{
evas_textblock_cursor_cluster_coord_set(pd->handle, coord.x, coord.y);
}
static int
_prepend_text_run2(Efl_Text_Cursor_Handle *cur, const char *s, const char *p)
{
if ((s) && (p > s))
{
char *ts;
ts = alloca(p - s + 1);
strncpy(ts, s, p - s);
ts[p - s] = 0;
return evas_textblock_cursor_text_prepend(cur, ts);
}
return 0;
}
int
_cursor_text_append(Efl_Text_Cursor_Handle *cur,
const char *text)
{
if (!text || !cur) return 0;
const char *off = text;
int len = 0;
Evas_Object_Protected_Data *obj = efl_data_scope_get(cur->obj, EFL_CANVAS_OBJECT_CLASS);
evas_object_async_block(obj);
while (*off)
{
char *format = NULL;
int n = 1;
if (!strncmp(_PARAGRAPH_SEPARATOR_UTF8, off,
strlen(_PARAGRAPH_SEPARATOR_UTF8)))
{
format = "ps";
n = strlen(_PARAGRAPH_SEPARATOR_UTF8);
}
else if (!strncmp(_NEWLINE_UTF8, off, strlen(_NEWLINE_UTF8)))
{
format = "br";
n = strlen(_NEWLINE_UTF8);
}
else if (!strncmp(_TAB_UTF8, off, strlen(_TAB_UTF8)))
{
format = "tab";
n = strlen(_TAB_UTF8);
}
if (format)
{
len += _prepend_text_run2(cur, text, off);
if (evas_textblock_cursor_format_prepend(cur, format))
{
len++;
}
text = off + n; /* sync text with next segment */
}
off += n;
}
len += _prepend_text_run2(cur, text, off);
return len;
}
EOLIAN static void
_efl_text_cursor_text_insert(Eo *obj EINA_UNUSED, Efl_Text_Cursor_Data *pd, const char *text)
{
_cursor_text_append(pd->handle, text);
}
EOLIAN static char *
_efl_text_cursor_range_text_get(const Eo *obj EINA_UNUSED, Efl_Text_Cursor_Data *pd, Efl_Text_Cursor *cur2)
{
return evas_textblock_cursor_range_text_get(pd->handle, efl_text_cursor_handle_get(cur2), EVAS_TEXTBLOCK_TEXT_PLAIN);
}
EOLIAN static void
_efl_text_cursor_markup_insert(Eo *obj EINA_UNUSED, Efl_Text_Cursor_Data *pd, const char *markup)
{
evas_object_textblock_text_markup_prepend(pd->handle, markup);
}
EOLIAN static char *
_efl_text_cursor_range_markup_get(const Eo *obj EINA_UNUSED, Efl_Text_Cursor_Data *pd, Efl_Text_Cursor *cur2)
{
return evas_textblock_cursor_range_text_get(pd->handle,efl_text_cursor_handle_get(cur2), EVAS_TEXTBLOCK_TEXT_MARKUP);
}
EOLIAN static Eina_Iterator *
_efl_text_cursor_range_geometry_get(Eo *obj EINA_UNUSED, Efl_Text_Cursor_Data *pd, Efl_Text_Cursor *cur2)
{
return evas_textblock_cursor_range_simple_geometry_get(pd->handle, efl_text_cursor_handle_get(cur2));
}
/** selection iterator */
/**
* @internal
* Returns the value of the current data of list node,
* and goes to the next list node.
*
* @param it the iterator.
* @param data the data of the current list node.
* @return EINA_FALSE if the current list node does not exists.
* Otherwise, returns EINA_TRUE.
*/
static Eina_Bool
_evas_textblock_selection_iterator_next(Evas_Textblock_Selection_Iterator *it, void **data)
{
if (!it->current)
return EINA_FALSE;
*data = eina_list_data_get(it->current);
it->current = eina_list_next(it->current);
return EINA_TRUE;
}
/**
* @internal
* Gets the iterator container (Eina_List) which created the iterator.
* @param it the iterator.
* @return A pointer to Eina_List.
*/
static Eina_List *
_evas_textblock_selection_iterator_get_container(Evas_Textblock_Selection_Iterator *it)
{
return it->list;
}
/**
* @internal
* Frees the iterator container (Eina_List).
* @param it the iterator.
*/
static void
_evas_textblock_selection_iterator_free(Evas_Textblock_Selection_Iterator *it)
{
Eina_Rectangle *tr;
EINA_LIST_FREE(it->list, tr)
free(tr);
EINA_MAGIC_SET(&it->iterator, 0);
free(it);
}
/**
* @internal
* Creates newly allocated iterator associated to a list.
* @param list The list.
* @return If the memory cannot be allocated, NULL is returned.
* Otherwise, a valid iterator is returned.
*/
static Eina_Iterator *
_evas_textblock_selection_iterator_new(Eina_List *list)
{
Evas_Textblock_Selection_Iterator *it;
it = calloc(1, sizeof(Evas_Textblock_Selection_Iterator));
if (!it) return NULL;
EINA_MAGIC_SET(&it->iterator, EINA_MAGIC_ITERATOR);
it->list = list;
it->current = list;
it->iterator.version = EINA_ITERATOR_VERSION;
it->iterator.next = FUNC_ITERATOR_NEXT(
_evas_textblock_selection_iterator_next);
it->iterator.get_container = FUNC_ITERATOR_GET_CONTAINER(
_evas_textblock_selection_iterator_get_container);
it->iterator.free = FUNC_ITERATOR_FREE(
_evas_textblock_selection_iterator_free);
return &it->iterator;
}
EOLIAN static Eina_Iterator *
_efl_text_cursor_range_precise_geometry_get(Eo *obj EINA_UNUSED, Efl_Text_Cursor_Data *pd, Efl_Text_Cursor *cur2)
{
Eina_List *rects = evas_textblock_cursor_range_geometry_get(pd->handle, efl_text_cursor_handle_get(cur2));
return _evas_textblock_selection_iterator_new(rects);
}
EOLIAN static void
_efl_text_cursor_range_delete(Eo *obj EINA_UNUSED, Efl_Text_Cursor_Data *pd, Efl_Text_Cursor *cur2)
{
evas_textblock_cursor_range_delete(pd->handle, efl_text_cursor_handle_get(cur2));
}
EOLIAN static void
_efl_text_cursor_handle_set(Eo *obj, Efl_Text_Cursor_Data *pd, Efl_Text_Cursor_Handle *handle)
{
if (handle == pd->handle)
return;
Efl_Text_Cursor_Handle *old_handle = pd->handle;
pd->handle = evas_textblock_cursor_ref(handle, obj);
if (old_handle)
{
evas_textblock_cursor_unref(old_handle, obj);
}
}
EOLIAN static Efl_Text_Cursor_Handle *
_efl_text_cursor_handle_get(const Eo *obj EINA_UNUSED, Efl_Text_Cursor_Data *pd)
{
return pd->handle;
}
void efl_text_cursor_text_object_set(Eo *cursor, Eo *canvas_text_obj, Eo *text_obj)
{
Efl_Text_Cursor_Data *pd = efl_data_scope_get(cursor, MY_CLASS);
Efl_Text_Cursor_Handle *handle = NULL;
if (efl_isa(canvas_text_obj, EFL_CANVAS_TEXT_CLASS))
{
pd->text_obj = text_obj;
handle = evas_object_textblock_cursor_new(canvas_text_obj);
}
else
{
ERR("Expect Canvas Text Object");
}
if (handle)
{
efl_text_cursor_handle_set(cursor, handle);
evas_textblock_cursor_unref(handle, NULL);
}
}
EOLIAN static Efl_Canvas_Object *
_efl_text_cursor_text_object_get(const Eo *obj EINA_UNUSED, Efl_Text_Cursor_Data *pd)
{
return pd->text_obj;
}
EOLIAN static void
_efl_text_cursor_efl_object_destructor(Eo *obj, Efl_Text_Cursor_Data *pd)
{
if (pd->handle)
{
evas_textblock_cursor_unref(pd->handle, obj);
pd->handle = NULL;
}
if (pd->text_obj)
{
pd->text_obj = NULL;
}
efl_destructor(efl_super(obj, MY_CLASS));
}
#include "efl_text_cursor.eo.c"

250
src/lib/evas/canvas/efl_text_cursor.eo Normal file
View File

@ -0,0 +1,250 @@
struct @beta Efl_Text_Cursor_Handle;
enum @beta Efl.Text.Cursor_Type
{
[[Text cursor types.]]
before, [[Cursor type before.]]
under [[Cursor type under.]]
}
enum @beta Efl.Text.Cursor_Move_Type
{
[[Text cursor movement types.]]
char_next, [[Advances to the next character.]]
char_prev, [[Advances to the previous character.]]
cluster_next, [[Advances to the next grapheme cluster, Grapheme cluster (A character sequence rendered together. See https://unicode.org/reports/tr29/).]]
cluster_prev, [[Advances to the previous grapheme cluster, Grapheme cluster (A character sequence rendered together. See https://unicode.org/reports/tr29/).]]
paragraph_start, [[Advances to the first character in this paragraph.]]
paragraph_end, [[Advances to the last character in this paragraph.]]
word_start, [[Advance to current word start.]]
word_end, [[Advance to current word end.]]
line_start, [[Advance to current line first character.]]
line_end, [[Advance to current line last character.]]
paragraph_first, [[Advance to first character in the first paragraph.]]
paragraph_last, [[Advance to last character in the last paragraph.]]
paragraph_next, [[Advances to the start of the next paragraph.]]
paragraph_prev [[Advances to the end of the previous paragraph.]]
}
// Missing pen_geometry get? - probably not, that's the cursor geometry with under.
// Should we always do split cursor and "under" should just be content geometry? -- probably!
// Problem with this is that it doesn't necessarily work correctly vertically.
class @beta Efl.Text.Cursor extends Efl.Object implements Efl.Duplicate{
[[Cursor API.]]
c_prefix: efl_text_cursor;
methods {
@property position {
[[Cursor position.]]
set { }
get { }
values {
position: int; [[Cursor position.]]
}
}
@property content {
[[The content of the cursor (the character under the cursor).]]
get {
}
values {
content: Eina.Unicode; [[The unicode codepoint of the character.]]
}
}
@property content_geometry {
[[The geometry of the item/char pointed by the cursor.]]
get { }
values {
geometry: Eina.Rect; [[The geometry in pixels.]]
}
}
@property line_number {
[[The line the cursor is on.]]
set { }
get { }
values {
line_number: int; [[The line number.]]
}
}
@property cursor_geometry {
[[Returns the geometry of cursor, if cursor is shown for the text
of the same direction as paragraph,else ("split cursor") will return
and you need to consider the lower ("split cursor") @.lower_cursor_geometry
Split cursor geometry is valid only in @Efl.Text.Cursor_Type.before cursor mode.]]
get {
}
keys {
ctype: Efl.Text.Cursor_Type; [[The type of the cursor.]]
}
values {
geometry: Eina.Rect; [[The geometry of the cursor (or upper cursor) in pixels.]]
}
}
@property lower_cursor_geometry {
[[Returns the geometry of the lower ("split cursor"), if logical cursor is
between LTR/RTL text.
To get the upper ("split cursor") @.cursor_geometry with @Efl.Text.Cursor_Type.before cursor mode.]]
get {
return: bool; [[$true if split cursor, $false otherwise.]]
}
values {
geometry: Eina.Rect; [[The geometry of the lower cursor in pixels.]]
}
}
equal @const {
[[Check if two cursors are equal - faster than compare if all you want is equality.]]
params {
dst: const(Efl.Text.Cursor); [[Destination Cursor.]]
}
return: bool; [[$true if cursors are equal, $false otherwise.]]
}
compare @const {
[[Compare two cursors
Return <0 if cursor position less than dst, 0 if cursor == dest and >0 otherwise.]]
params {
dst: const(Efl.Text.Cursor); [[Destination Cursor.]]
}
return: int; [[Difference between cursors.]]
}
copy @const {
[[Copy existing cursor to destination cursor, like position and cursor text object.]]
params {
dst: Efl.Text.Cursor; [[Destination Cursor.]]
}
}
move {
[[Move the cursor.]]
params {
@in type: Efl.Text.Cursor_Move_Type; [[The type of movement.]]
}
return: bool; [[True if actually moved.]]
}
char_delete {
[[Deletes a single character from position pointed by given cursor.]]
}
// FIXME: It's just implemented as range delete with cluster start + end.
// Sholud we have convenience wrappers for those though? This and cluster prev/next?
// cluster_delete {
line_jump_by {
[[Jump the cursor by the given number of lines.]]
params {
by: int; [[Number of lines.]]
}
return: bool; [[True if actually moved.]]
}
char_coord_set {
[[Set cursor coordinates.]]
params {
@in coord: Eina.Position2D; [[The coordinates to set to.]]
}
}
cluster_coord_set {
[[Set cursor coordinates according to grapheme clusters.
It does not allow to put a cursor to the middle of a grapheme cluster.]]
params {
@in coord: Eina.Position2D; [[The coordinates to set to.]]
}
}
// FIXME: Add a way to add with a length parameter (always have it?) so we just copy n characters, or all if -1. Useful for saving copies when inserting from another source.
text_insert {
[[Adds text to the current cursor position and set the cursor to
*after* the start of the text just added.]]
params {
@in text: string; [[Text to append (UTF-8 format).]]
}
}
markup_insert {
[[Inserts a markup text at cursor position.]]
params {
@in markup: string; [[Text to append (UTF-8 format).]]
}
}
range_markup_get @const {
[[Markup of a given range in the text.]]
return: mstring @move; [[The markup in the given range.]]
params {
cur2: Efl.Text.Cursor; [[End of range.]]
}
}
range_text_get @const {
[[Returns the text in the range between cursor and $cur2.]]
return: mstring @move; [[The text in the given range.]]
params {
cur2: Efl.Text.Cursor; [[End of range.]]
}
}
// FIXME: returning an iterator here feels a bit stupid
range_geometry_get {
[[Get the simple geometry in pixels of a range in the text.
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_precise_geometry_get.]]
params {
cur2: Efl.Text.Cursor; [[End of range.]]
}
return: iterator<Eina.Rect> @move; [[
Iterator on all geoemtries of the given range.]]
}
range_precise_geometry_get {
[[Get the "precise" geometry in pixels of a range.
The geometry is represented as rectangles for each of the line
segments in the given range [$cur1, $cur2].]]
params {
cur2: Efl.Text.Cursor; [[End of range.]]
}
return: iterator<Eina.Rect> @move; [[
Iterator on all simple geometries of the given range.]]
}
range_delete {
[[Deletes the range between given cursors.
This removes all the text in given range [$start,$end].]]
params {
@in cur2: Efl.Text.Cursor; [[Range end position.]]
}
}
@property handle {
[[This method should rarely be used by users. It gives you a lightweight handle to a cursor.
You can either replace the handle to change the object this is working on, or get it for caching
The handle is freed when the object is freed if set, but otherwise it remains under the control of the caller.]]
set { }
get { }
values {
handle: Efl_Text_Cursor_Handle @by_ref; [[The handle of the cursor object.]]
}
}
@property text_object {
[[The text object this cursor is associated with.]]
get { }
values {
text_obj: Efl.Canvas.Object; [[The text object.]]
}
}
}
events {
// FIXME: Needed for people who cache the position.
changed: void; [[Called when its position has changed.]]
}
implements {
Efl.Object.destructor;
Efl.Duplicate.duplicate;
}
}

1009
src/lib/evas/canvas/evas_object_textblock.c
View File

File diff suppressed because it is too large Load Diff

2
src/lib/evas/canvas/evas_textblock_legacy.h
View File

@ -147,7 +147,7 @@ typedef struct _Efl_Canvas_Text_Style Evas_Textblock_Style;
* @see evas_object_textblock_cursor_new
*
*/
typedef struct _Efl_Text_Cursor_Cursor Evas_Textblock_Cursor;
typedef struct _Efl_Text_Cursor_Handle Evas_Textblock_Cursor;
/**
* @typedef Evas_Object_Textblock_Node_Format

2
src/lib/evas/canvas/meson.build
View File

@ -54,6 +54,7 @@ pub_eo_files = [
'efl_canvas_group.eo',
'efl_gfx_mapping.eo',
'efl_canvas_event_grabber.eo',
'efl_text_cursor.eo',
'efl_canvas_text.eo',
'efl_canvas_object_animation.eo',
]
@ -207,6 +208,7 @@ evas_src += files([
'evas_canvas3d_node_callback.h',
'evas_canvas3d_eet.c',
'efl_canvas_object_animation.c',
'efl_text_cursor.c'
])
evas_include_directories += include_directories('.')

87
src/tests/evas/evas_test_textblock.c
View File

@ -4310,7 +4310,7 @@ _test_check_annotation(Evas_Object *tb,
size_t len, const char **formats)
{
Efl_Text_Annotate_Annotation *an;
Efl_Text_Cursor_Cursor *start, *end;
Efl_Text_Cursor_Handle *start, *end;
start = evas_object_textblock_cursor_new(tb);
end = evas_object_textblock_cursor_new(tb);
@ -4350,7 +4350,7 @@ EFL_START_TEST(evas_textblock_annotation)
{
START_TB_TEST();
Efl_Text_Annotate_Annotation *an, *an2;
Efl_Text_Cursor_Cursor *start, *end;
Efl_Text_Cursor_Handle *start, *end;
start = evas_object_textblock_cursor_new(tb);
end = evas_object_textblock_cursor_new(tb);
@ -4476,7 +4476,7 @@ EFL_START_TEST(evas_textblock_annotation)
/* Check that format is not extended if it's an "object item" */
evas_textblock_cursor_pos_set(cur, 5);
efl_text_cursor_text_insert(tb, cur, "a");
evas_textblock_cursor_text_prepend(cur, "a");
_test_check_annotation(tb, 5, 7, _COMP_PARAMS());
_test_check_annotation(tb, 0, 3, _COMP_PARAMS());
@ -4499,7 +4499,7 @@ EFL_START_TEST(evas_textblock_annotation)
_test_check_annotation(tb, 3, 3, _COMP_PARAMS("color=#fff"));
/* Old API */
evas_textblock_cursor_pos_set(cur, 5);
efl_text_cursor_text_insert(tb, cur, "a");
evas_textblock_cursor_text_prepend(cur, "a");
_test_check_annotation(tb, 0, 0, _COMP_PARAMS("color=#fff"));
_test_check_annotation(tb, 5, 5, _COMP_PARAMS());
@ -4511,7 +4511,7 @@ EFL_START_TEST(evas_textblock_annotation)
_test_check_annotation(tb, 4, 4, _COMP_PARAMS("color=#fff"));
evas_textblock_cursor_pos_set(cur, 4);
/* Cursor position is now: hello|\nworld */
efl_text_cursor_text_insert(tb, cur, "a");
evas_textblock_cursor_text_prepend(cur, "a");
_test_check_annotation(tb, 0, 0, _COMP_PARAMS("color=#fff"));
_test_check_annotation(tb, 5, 5, _COMP_PARAMS("color=#fff"));
@ -4519,7 +4519,6 @@ EFL_START_TEST(evas_textblock_annotation)
evas_textblock_cursor_pos_set(cur, 4);
an = efl_text_cursor_item_annotation_get(tb, cur);
ck_assert(!an);
an = efl_text_cursor_item_insert(tb, cur, "", "size=16x16");
evas_textblock_cursor_pos_set(cur, 4);
an = efl_text_cursor_item_annotation_get(tb, cur);
@ -4533,16 +4532,18 @@ EFL_END_TEST;
#define START_EFL_CANVAS_TEXT_TEST() \
Evas *evas; \
Eo *txt; \
Efl_Text_Cursor_Cursor *cur; \
Efl_Text_Cursor_Handle *cur; \
Efl_Text_Cursor *cur_obj; \
evas = EVAS_TEST_INIT_EVAS(); \
evas_font_hinting_set(evas, EVAS_FONT_HINTING_AUTO); \
txt = efl_add(EFL_CANVAS_TEXT_CLASS, evas); \
fail_if(!txt); \
efl_canvas_text_legacy_newline_set(txt, EINA_FALSE); \
efl_canvas_text_newline_as_paragraph_separator_set(txt, EINA_FALSE); \
efl_canvas_text_style_set(txt, NULL, style_buf); \
fail_if(!efl_canvas_text_style_get(txt, NULL) || \
strcmp(style_buf, efl_canvas_text_style_get(txt, NULL))); \
cur = efl_text_cursor_new(txt); \
strcmp(style_buf, efl_canvas_text_style_get(txt, NULL))); \
cur_obj = efl_canvas_text_cursor_create(txt);\
cur = efl_text_cursor_handle_get(cur_obj); \
fail_if(!cur); \
do \
{ \
@ -4552,7 +4553,7 @@ while (0)
#define END_EFL_CANVAS_TEXT_TEST() \
do \
{ \
efl_text_cursor_free(txt, cur); \
efl_del(cur_obj); \
efl_del(txt); \
evas_free(evas); \
} \
@ -4580,19 +4581,24 @@ EFL_START_TEST(efl_text)
Evas_Coord x, x2;
Evas_Coord nw, nh;
Evas_Coord cx, cx2;
Eina_Size2D size;
/* Split cursor in LTR paragraph.
* Russian 't' in the beginnning to create additional item.*/
/*01234 5 6789012345678 19 01234 */
efl_text_set(tb, "тest \u202bנסיוןabcנסיון\u202c bang");
efl_canvas_text_size_native_get(tb, &nw, &nh);
size = efl_canvas_text_size_native_get(tb);
nw = size.w;
nh = size.h;
efl_gfx_entity_size_set(tb, EINA_SIZE2D(nw, nh));
/* Logical cursor after "test " */
evas_textblock_cursor_pos_set(cur, 6);
fail_if(!efl_text_cursor_geometry_get(tb, cur,
EFL_TEXT_CURSOR_TYPE_BEFORE, &cx, NULL, NULL, NULL, &cx2,
NULL, NULL, NULL));
fail_if(!evas_textblock_cursor_geometry_bidi_get(cur,
&cx, NULL, NULL, NULL, &cx2,
NULL, NULL, NULL, EVAS_TEXTBLOCK_CURSOR_BEFORE));
evas_textblock_cursor_pos_set(cur, 18);
evas_textblock_cursor_pen_geometry_get(cur, &x, NULL, NULL, NULL);
evas_textblock_cursor_pos_set(cur, 20);
@ -4614,13 +4620,26 @@ EFL_START_TEST(efl_canvas_text_cursor)
efl_text_set(txt, buf);
fail_if(strcmp(efl_text_get(txt), buf));
efl_text_cursor_line_jump_by(txt, cur, -1);
pos = efl_text_cursor_position_get(txt, cur);
efl_text_cursor_line_jump_by(cur_obj, -1);
pos = efl_text_cursor_position_get(cur_obj);
ck_assert_int_eq(pos, 0);
efl_text_cursor_line_jump_by(txt, cur, 1);
pos = efl_text_cursor_position_get(txt, cur);
efl_text_cursor_line_jump_by(cur_obj, 1);
pos = efl_text_cursor_position_get(cur_obj);
ck_assert_int_eq(pos, 10);
Eo * cursor1 = efl_add(EFL_TEXT_CURSOR_CLASS, txt);
pos = efl_text_cursor_position_get(cursor1);
ck_assert_int_eq(pos, -1);
efl_text_cursor_position_set(cursor1, 10);
pos = efl_text_cursor_position_get(cursor1);
ck_assert_int_eq(pos, -1);
efl_canvas_text_cursor_add(txt, cursor1);
efl_text_cursor_position_set(cursor1, 1);
pos = efl_text_cursor_position_get(cursor1);
ck_assert_int_eq(pos, 1);
END_EFL_CANVAS_TEXT_TEST();
}
EFL_END_TEST
@ -4629,24 +4648,24 @@ EFL_END_TEST
EFL_START_TEST(efl_canvas_text_markup)
{
START_EFL_CANVAS_TEXT_TEST();
Efl_Text_Cursor_Cursor *start, *end;
Efl_Text_Cursor *start, *end;
char *res;
start = efl_text_cursor_new(txt);
end = efl_text_cursor_new(txt);
start = efl_canvas_text_cursor_create(txt);
end = efl_canvas_text_cursor_create(txt);
efl_text_set(txt, "\n\n\n");
efl_text_cursor_position_set(txt, start, 1);
efl_text_cursor_position_set(txt, end, 2);
res = efl_text_markup_interactive_markup_range_get(txt, start, end);
efl_text_cursor_position_set(start, 1);
efl_text_cursor_position_set(end, 2);
res = efl_text_cursor_range_markup_get(start, end);
ck_assert_str_eq(res, "<br>");
free(res);
efl_text_set(txt, "a\u2029bc\ndef\n\u2029");
efl_text_cursor_position_set(txt, start, 2);
efl_text_cursor_position_set(txt, end, 5);
res = efl_text_markup_interactive_markup_range_get(txt, start, end);
efl_text_cursor_position_set(start, 2);
efl_text_cursor_position_set(end, 5);
res = efl_text_cursor_range_markup_get(start, end);
ck_assert_str_eq(res, "bc<br>");
free(res);
@ -4661,16 +4680,16 @@ EFL_START_TEST(efl_canvas_text_markup_invalid_escape)
char * text1 = "Hello";
char * text2 = "Hello&123";
char * text3 = "Hello&123&456";
Evas_Coord fw1, fw2, fw3;
Eina_Size2D fw1, fw2, fw3;
efl_text_markup_set(txt,text1);
efl_canvas_text_size_native_get(txt, &fw1, NULL);
fw1 = efl_canvas_text_size_native_get(txt);
efl_text_markup_set(txt,text2);
efl_canvas_text_size_native_get(txt, &fw2, NULL);
fail_if(fw2 <= fw1);
fw2 = efl_canvas_text_size_native_get(txt);
fail_if(fw2.w <= fw1.w);
efl_text_markup_set(txt,text3);
efl_canvas_text_size_native_get(txt, &fw3, NULL);
fail_if(fw3 <= fw2);
fw3 = efl_canvas_text_size_native_get(txt);
fail_if(fw3.w <= fw2.w);
END_EFL_CANVAS_TEXT_TEST();
}