kimcinoo
/
efl
forked from enlightenment/efl
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Merge branch 'master' into devs/hermet/lottie

This commit is contained in:
Hermet Park 2019-08-27 20:31:55 +09:00
parent 6b1bd2d334 979757c845
commit d0dd14c293
143 changed files with 3475 additions and 1649 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

25
data/elementary/config/default/base.src.in
View File

@ -1,5 +1,5 @@
group "Elm_Config" struct {
value "config_version" int: 131093;
value "config_version" int: 131094;
value "entry_select_allow" uchar: 1;
value "engine" string: "";
value "vsync" uchar: 0;
@ -2634,6 +2634,29 @@ group "Elm_Config" struct {
}
}
}
group "Elm_Config_Bindings_Widget" struct {
value "name" string: "Efl.Ui.Item";
group "key_bindings" list {
group "Elm_Config_Binding_Key" struct {
value "context" int: 0;
value "key" string: "Return";
value "action" string: "select";
value "params" string: "";
}
group "Elm_Config_Binding_Key" struct {
value "context" int: 0;
value "key" string: "KP_Enter";
value "action" string: "select";
value "params" string: "";
}
group "Elm_Config_Binding_Key" struct {
value "context" int: 0;
value "key" string: "space";
value "action" string: "select";
value "params" string: "";
}
}
}
group "Elm_Config_Bindings_Widget" struct {
value "name" string: "Efl.Ui.Tab_Bar";
group "key_bindings" list {

25
data/elementary/config/mobile/base.src.in
View File

@ -1,5 +1,5 @@
group "Elm_Config" struct {
value "config_version" int: 131093;
value "config_version" int: 131094;
value "entry_select_allow" uchar: 1;
value "engine" string: "";
value "vsync" uchar: 0;
@ -2631,6 +2631,29 @@ group "Elm_Config" struct {
}
}
}
group "Elm_Config_Bindings_Widget" struct {
value "name" string: "Efl.Ui.Item";
group "key_bindings" list {
group "Elm_Config_Binding_Key" struct {
value "context" int: 0;
value "key" string: "Return";
value "action" string: "select";
value "params" string: "";
}
group "Elm_Config_Binding_Key" struct {
value "context" int: 0;
value "key" string: "KP_Enter";
value "action" string: "select";
value "params" string: "";
}
group "Elm_Config_Binding_Key" struct {
value "context" int: 0;
value "key" string: "space";
value "action" string: "select";
value "params" string: "";
}
}
}
group "Elm_Config_Bindings_Widget" struct {
value "name" string: "Efl.Ui.Tab_Bar";
group "key_bindings" list {

25
data/elementary/config/standard/base.src.in
View File

@ -1,5 +1,5 @@
group "Elm_Config" struct {
value "config_version" int: 131093;
value "config_version" int: 131094;
value "entry_select_allow" uchar: 1;
value "engine" string: "";
value "vsync" uchar: 0;
@ -2628,6 +2628,29 @@ group "Elm_Config" struct {
}
}
}
group "Elm_Config_Bindings_Widget" struct {
value "name" string: "Efl.Ui.Item";
group "key_bindings" list {
group "Elm_Config_Binding_Key" struct {
value "context" int: 0;
value "key" string: "Return";
value "action" string: "select";
value "params" string: "";
}
group "Elm_Config_Binding_Key" struct {
value "context" int: 0;
value "key" string: "KP_Enter";
value "action" string: "select";
value "params" string: "";
}
group "Elm_Config_Binding_Key" struct {
value "context" int: 0;
value "key" string: "space";
value "action" string: "select";
value "params" string: "";
}
}
}
group "Elm_Config_Bindings_Widget" struct {
value "name" string: "Efl.Ui.Tab_Bar";
group "key_bindings" list {

14
data/elementary/themes/edc/efl/scroller.edc
View File

@ -313,7 +313,6 @@ group { name: "efl/scroller";
target: "y_vbar_down";
target: "arrow1_vbar_indent";
target: "arrow2_vbar_indent";
after: "check_pos_vbar";
}
program {
signal: "efl,action,hide,vbar"; source: "efl";
@ -378,11 +377,6 @@ group { name: "efl/scroller";
action_on_pos_vbar(10);
}
}
program { name: "check_pos_vbar";
script {
action_on_pos_vbar(10);
}
}
program { name: "loop_set_vbar";
signal: "efl,loop_y,set"; source: "efl";
script {
@ -600,7 +594,6 @@ group { name: "efl/scroller";
target: "x_hbar_right";
target: "arrow1_hbar_indent";
target: "arrow2_hbar_indent";
after: "check_pos_hbar";
}
program {
signal: "efl,action,hide,hbar"; source: "efl";
@ -653,13 +646,11 @@ group { name: "efl/scroller";
signal: "mouse,down,1*"; source: "sb_hbar_p1";
action: DRAG_VAL_PAGE -1.0 0.0;
target: "efl.dragable.hbar";
after: "check_pos_hbar";
}
program {
signal: "mouse,down,1*"; source: "sb_hbar_p2";
action: DRAG_VAL_PAGE 1.0 0.0;
target: "efl.dragable.hbar";
after: "check_pos_hbar";
}
program {
signal: "efl,action,scroll"; source: "efl";
@ -667,11 +658,6 @@ group { name: "efl/scroller";
action_on_pos_hbar(10);
}
}
program { name: "check_pos_hbar";
script {
action_on_pos_hbar(10);
}
}
program { name: "loop_set_hbar";
signal: "efl,loop_x,set"; source: "efl";
script {

4
src/bin/edje/edje_cc_out.c
View File

@ -736,10 +736,10 @@ check_program(Edje_Part_Collection *pc, Edje_Program *ep, Eet_File *ef)
/*
* we are accessing part with an id,
* if actions is ACTION_STOP or ACTION_TYPE_SCRIPT, then id is from the parts array.
* if actions is ACTION_STOP or ACTION_TYPE_SCRIPT, then id is NOT from the parts array.
* In order to not crash here, we should continue here.
*/
if (ep->action != EDJE_ACTION_TYPE_ACTION_STOP || ep->action != EDJE_ACTION_TYPE_SCRIPT)
if (ep->action == EDJE_ACTION_TYPE_ACTION_STOP || ep->action == EDJE_ACTION_TYPE_SCRIPT)
continue;
if (et->id >= (int) pc->parts_count)

21
src/bin/elementary/test_bg.c
View File

@ -318,7 +318,7 @@ _image_cb(void *data, const Efl_Event *ev)
{
efl_file_simple_get(ev->object, &f, &k);
o = efl_add(EFL_UI_IMAGE_CLASS, win,
efl_gfx_image_scale_type_set(efl_added, EFL_GFX_IMAGE_SCALE_TYPE_FIT_OUTSIDE),
efl_gfx_image_scale_type_set(efl_added, EFL_GFX_IMAGE_SCALE_TYPE_EXPAND),
efl_file_set(efl_added, f),
efl_file_key_set(efl_added, k)
);
@ -444,22 +444,29 @@ test_bg_scale_type(void *data EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *e
efl_pack(hbox, rd);
rd = efl_add(EFL_UI_RADIO_CLASS, hbox);
efl_ui_radio_state_value_set(rd, EFL_GFX_IMAGE_SCALE_TYPE_FIT_INSIDE);
efl_text_set(rd, "Fit Inside");
efl_ui_radio_state_value_set(rd, EFL_GFX_IMAGE_SCALE_TYPE_FIT);
efl_text_set(rd, "Fit");
efl_gfx_hint_weight_set(rd, EFL_GFX_HINT_EXPAND, 0.0);
efl_event_callback_add(rd, EFL_UI_EVENT_SELECTED_CHANGED, _cb_radio_changed_scale_type, o_bg);
efl_pack(hbox, rd);
rd = efl_add(EFL_UI_RADIO_CLASS, hbox);
efl_ui_radio_state_value_set(rd, EFL_GFX_IMAGE_SCALE_TYPE_FIT_OUTSIDE);
efl_text_set(rd, "Fit Outside");
efl_ui_radio_state_value_set(rd, EFL_GFX_IMAGE_SCALE_TYPE_FIT_WIDTH);
efl_text_set(rd, "Fit Horizontally");
efl_gfx_hint_weight_set(rd, EFL_GFX_HINT_EXPAND, 0.0);
efl_event_callback_add(rd, EFL_UI_EVENT_SELECTED_CHANGED, _cb_radio_changed_scale_type, o_bg);
efl_pack(hbox, rd);
rd = efl_add(EFL_UI_RADIO_CLASS, hbox);
efl_ui_radio_state_value_set(rd, EFL_GFX_IMAGE_SCALE_TYPE_NONE);
efl_text_set(rd, "None");
efl_ui_radio_state_value_set(rd, EFL_GFX_IMAGE_SCALE_TYPE_FIT_HEIGHT);
efl_text_set(rd, "Fit Verically");
efl_gfx_hint_weight_set(rd, EFL_GFX_HINT_EXPAND, 0.0);
efl_event_callback_add(rd, EFL_UI_EVENT_SELECTED_CHANGED, _cb_radio_changed_scale_type, o_bg);
efl_pack(hbox, rd);
rd = efl_add(EFL_UI_RADIO_CLASS, hbox);
efl_ui_radio_state_value_set(rd, EFL_GFX_IMAGE_SCALE_TYPE_EXPAND);
efl_text_set(rd, "Expand");
efl_gfx_hint_weight_set(rd, EFL_GFX_HINT_EXPAND, 0.0);
efl_event_callback_add(rd, EFL_UI_EVENT_SELECTED_CHANGED, _cb_radio_changed_scale_type, o_bg);
efl_pack(hbox, rd);

6
src/bin/elementary/test_image.c
View File

@ -105,8 +105,10 @@ static const struct {
} images_scale_type[] = {
{ EFL_GFX_IMAGE_SCALE_TYPE_NONE, "None" },
{ EFL_GFX_IMAGE_SCALE_TYPE_FILL, "Fill" },
{ EFL_GFX_IMAGE_SCALE_TYPE_FIT_INSIDE, "Fit Inside" },
{ EFL_GFX_IMAGE_SCALE_TYPE_FIT_OUTSIDE, "Fit Outside" },
{ EFL_GFX_IMAGE_SCALE_TYPE_FIT, "Fit" },
{ EFL_GFX_IMAGE_SCALE_TYPE_FIT_WIDTH, "Fit Horizontally" },
{ EFL_GFX_IMAGE_SCALE_TYPE_FIT_HEIGHT, "Fit Vertically" },
{ EFL_GFX_IMAGE_SCALE_TYPE_EXPAND, "Expand" },
{ EFL_GFX_IMAGE_SCALE_TYPE_TILE, "Tile" },
{ 0, NULL }
};

2
src/bin/elementary/test_part_bg.c
View File

@ -49,7 +49,7 @@ _scale_type_cb(void *data, const Efl_Event *ev EINA_UNUSED)
snprintf(buf, sizeof(buf), "%s/images/plant_01.jpg", elm_app_data_dir_get());
efl_file_simple_load(efl_part(target, "background"), buf, NULL);
type = efl_gfx_image_scale_type_get(efl_part(target, "background"));
type = (type + 1) % 5;
type = (type + 1) % 6;
efl_gfx_image_scale_type_set(efl_part(target, "background"), type);
}

31
src/bin/elementary/test_ui_collection.c
View File

@ -4,6 +4,18 @@
#include <Efl_Ui.h>
static void
_select_all(void *data, const Efl_Event *ev EINA_UNUSED)
{
efl_ui_select_all(data);
}
static void
_unselect_all(void *data, const Efl_Event *ev EINA_UNUSED)
{
efl_ui_unselect_all(data);
}
static void
_selection_changed_cb(void *data, const Efl_Event *ev EINA_UNUSED)
{
@ -192,7 +204,7 @@ void create_item_container_ui(const Efl_Class *collection_class, const Efl_Class
}
}
efl_pack_table(tbl, o, 1, 0, 1, 12);
efl_pack_table(tbl, o, 1, 0, 1, 14);
ctx->c = o;
o = efl_add(EFL_UI_BUTTON_CLASS, tbl,
@ -269,11 +281,26 @@ void create_item_container_ui(const Efl_Class *collection_class, const Efl_Class
efl_event_callback_add(o, EFL_INPUT_EVENT_CLICKED, _add_thousend_items, item_container);
efl_pack_table(tbl, o, 0, 10, 1, 1);
o = efl_add(EFL_UI_BUTTON_CLASS, tbl,
efl_gfx_hint_weight_set(efl_added, 0.0, 0.0),
efl_gfx_hint_align_set(efl_added, 0, 0.5));
efl_text_set(o, "Select All");
efl_event_callback_add(o, EFL_INPUT_EVENT_CLICKED, _select_all, item_container);
efl_pack_table(tbl, o, 0, 11, 1, 1);
o = efl_add(EFL_UI_BUTTON_CLASS, tbl,
efl_gfx_hint_weight_set(efl_added, 0.0, 0.0),
efl_gfx_hint_align_set(efl_added, 0, 0.5));
efl_text_set(o, "Unselect All");
efl_event_callback_add(o, EFL_INPUT_EVENT_CLICKED, _unselect_all, item_container);
efl_pack_table(tbl, o, 0, 12, 1, 1);
bx = efl_add(EFL_UI_RADIO_BOX_CLASS, tbl,
efl_gfx_hint_weight_set(efl_added, 0.0, 0.0),
efl_gfx_hint_align_set(efl_added, 0, 0.5));
efl_event_callback_add(bx, EFL_UI_RADIO_GROUP_EVENT_VALUE_CHANGED, _select_value_cb, item_container);
efl_pack_table(tbl, bx, 0, 11, 1, 1);
efl_pack_table(tbl, bx, 0, 13, 1, 1);
o = efl_add(EFL_UI_RADIO_CLASS, bx,
efl_ui_radio_state_value_set(efl_added, EFL_UI_SELECT_MODE_SINGLE));
efl_text_set(o, "Singleselect");

6
src/bin/elementary/test_ui_image.c
View File

@ -112,8 +112,10 @@ static const struct {
} images_scale_type[] = {
{ EFL_GFX_IMAGE_SCALE_TYPE_NONE, "None" },
{ EFL_GFX_IMAGE_SCALE_TYPE_FILL, "Fill" },
{ EFL_GFX_IMAGE_SCALE_TYPE_FIT_INSIDE, "Fit Inside" },
{ EFL_GFX_IMAGE_SCALE_TYPE_FIT_OUTSIDE, "Fit Outside" },
{ EFL_GFX_IMAGE_SCALE_TYPE_FIT, "Fit" },
{ EFL_GFX_IMAGE_SCALE_TYPE_FIT_WIDTH, "Fit Horizontally" },
{ EFL_GFX_IMAGE_SCALE_TYPE_FIT_HEIGHT, "Fit Vertically" },
{ EFL_GFX_IMAGE_SCALE_TYPE_EXPAND, "Expand" },
{ EFL_GFX_IMAGE_SCALE_TYPE_TILE, "Tile" },
{ 0, NULL }
};

78
src/bin/elementary/test_ui_popup.c
View File

@ -389,7 +389,7 @@ _alert_scroll_case1_cb(void *data, const Efl_Event *ev EINA_UNUSED)
{
char buf[PATH_MAX];
Eo *win = data;
Eo *efl_ui_popup= efl_add(EFL_UI_SCROLL_ALERT_POPUP_CLASS, win);
Eo *efl_ui_popup= efl_add(EFL_UI_ALERT_POPUP_CLASS, win);
efl_text_set(efl_part(efl_ui_popup, "title"), "title");
@ -397,7 +397,7 @@ _alert_scroll_case1_cb(void *data, const Efl_Event *ev EINA_UNUSED)
snprintf(buf, sizeof(buf), "%s/objects/test.edj", elm_app_data_dir_get());
efl_file_simple_load(layout, buf, "efl_ui_popup_scroll_content");
efl_content_set(efl_ui_popup, layout);
efl_ui_widget_scrollable_content_set(efl_ui_popup, layout);
efl_ui_alert_popup_button_set(efl_ui_popup, EFL_UI_ALERT_POPUP_BUTTON_POSITIVE, "Yes", NULL);
efl_ui_alert_popup_button_set(efl_ui_popup, EFL_UI_ALERT_POPUP_BUTTON_NEGATIVE, "No", NULL);
@ -413,7 +413,7 @@ _alert_scroll_case2_cb(void *data, const Efl_Event *ev EINA_UNUSED)
{
char buf[PATH_MAX];
Eo *win = data;
Eo *efl_ui_popup= efl_add(EFL_UI_SCROLL_ALERT_POPUP_CLASS, win);
Eo *efl_ui_popup= efl_add(EFL_UI_ALERT_POPUP_CLASS, win);
efl_text_set(efl_part(efl_ui_popup, "title"), "title");
@ -421,7 +421,7 @@ _alert_scroll_case2_cb(void *data, const Efl_Event *ev EINA_UNUSED)
snprintf(buf, sizeof(buf), "%s/objects/test.edj", elm_app_data_dir_get());
efl_file_simple_load(layout, buf, "efl_ui_popup_scroll_content");
efl_content_set(efl_ui_popup, layout);
efl_ui_widget_scrollable_content_set(efl_ui_popup, layout);
efl_ui_alert_popup_button_set(efl_ui_popup, EFL_UI_ALERT_POPUP_BUTTON_POSITIVE, "Yes", NULL);
efl_ui_alert_popup_button_set(efl_ui_popup, EFL_UI_ALERT_POPUP_BUTTON_NEGATIVE, "No", NULL);
@ -439,7 +439,7 @@ _alert_scroll_case3_cb(void *data, const Efl_Event *ev EINA_UNUSED)
{
char buf[PATH_MAX];
Eo *win = data;
Eo *efl_ui_popup= efl_add(EFL_UI_SCROLL_ALERT_POPUP_CLASS, win);
Eo *efl_ui_popup= efl_add(EFL_UI_ALERT_POPUP_CLASS, win);
efl_text_set(efl_part(efl_ui_popup, "title"), "title");
@ -447,7 +447,7 @@ _alert_scroll_case3_cb(void *data, const Efl_Event *ev EINA_UNUSED)
snprintf(buf, sizeof(buf), "%s/objects/test.edj", elm_app_data_dir_get());
efl_file_simple_load(layout, buf, "efl_ui_popup_scroll_content");
efl_content_set(efl_ui_popup, layout);
efl_ui_widget_scrollable_content_set(efl_ui_popup, layout);
efl_ui_alert_popup_button_set(efl_ui_popup, EFL_UI_ALERT_POPUP_BUTTON_POSITIVE, "Yes", NULL);
efl_ui_alert_popup_button_set(efl_ui_popup, EFL_UI_ALERT_POPUP_BUTTON_NEGATIVE, "No", NULL);
@ -465,7 +465,7 @@ _alert_scroll_case4_cb(void *data, const Efl_Event *ev EINA_UNUSED)
{
char buf[PATH_MAX];
Eo *win = data;
Eo *efl_ui_popup= efl_add(EFL_UI_SCROLL_ALERT_POPUP_CLASS, win);
Eo *efl_ui_popup= efl_add(EFL_UI_ALERT_POPUP_CLASS, win);
efl_text_set(efl_part(efl_ui_popup, "title"), "title");
@ -473,7 +473,7 @@ _alert_scroll_case4_cb(void *data, const Efl_Event *ev EINA_UNUSED)
snprintf(buf, sizeof(buf), "%s/objects/test.edj", elm_app_data_dir_get());
efl_file_simple_load(layout, buf, "efl_ui_popup_scroll_content");
efl_content_set(efl_ui_popup, layout);
efl_ui_widget_scrollable_content_set(efl_ui_popup, layout);
efl_ui_alert_popup_button_set(efl_ui_popup, EFL_UI_ALERT_POPUP_BUTTON_POSITIVE, "Yes", NULL);
efl_ui_alert_popup_button_set(efl_ui_popup, EFL_UI_ALERT_POPUP_BUTTON_NEGATIVE, "No", NULL);
@ -491,7 +491,7 @@ _alert_scroll_case5_cb(void *data, const Efl_Event *ev EINA_UNUSED)
{
char buf[PATH_MAX];
Eo *win = data;
Eo *efl_ui_popup= efl_add(EFL_UI_SCROLL_ALERT_POPUP_CLASS, win);
Eo *efl_ui_popup= efl_add(EFL_UI_ALERT_POPUP_CLASS, win);
efl_text_set(efl_part(efl_ui_popup, "title"), "title");
@ -499,7 +499,7 @@ _alert_scroll_case5_cb(void *data, const Efl_Event *ev EINA_UNUSED)
snprintf(buf, sizeof(buf), "%s/objects/test.edj", elm_app_data_dir_get());
efl_file_simple_load(layout, buf, "efl_ui_popup_scroll_content");
efl_content_set(efl_ui_popup, layout);
efl_ui_widget_scrollable_content_set(efl_ui_popup, layout);
efl_ui_alert_popup_button_set(efl_ui_popup, EFL_UI_ALERT_POPUP_BUTTON_POSITIVE, "Yes", NULL);
efl_ui_alert_popup_button_set(efl_ui_popup, EFL_UI_ALERT_POPUP_BUTTON_NEGATIVE, "No", NULL);
@ -558,7 +558,7 @@ efl_ui_text_alert_popup_clicked_cb(void *data EINA_UNUSED, const Efl_Event *ev)
Efl_Ui_Alert_Popup_Button_Clicked_Event *event = ev->info;
if (event->button_type == EFL_UI_ALERT_POPUP_BUTTON_POSITIVE)
efl_text_set(ev->object, "Text is changed");
efl_ui_widget_scrollable_text_set(ev->object, "Text is changed");
else
efl_del(ev->object);
}
@ -575,10 +575,10 @@ static void
_alert_text_case1_cb(void *data, const Efl_Event *ev EINA_UNUSED)
{
Eo *win = data;
Eo *efl_ui_popup= efl_add(EFL_UI_TEXT_ALERT_POPUP_CLASS, win);
Eo *efl_ui_popup= efl_add(EFL_UI_ALERT_POPUP_CLASS, win);
efl_text_set(efl_part(efl_ui_popup, "title"), "title");
efl_text_set(efl_ui_popup, "This is Text Popup");
efl_ui_widget_scrollable_text_set(efl_ui_popup, "This is Text Popup");
efl_ui_alert_popup_button_set(efl_ui_popup, EFL_UI_ALERT_POPUP_BUTTON_POSITIVE, "Yes", NULL);
efl_ui_alert_popup_button_set(efl_ui_popup, EFL_UI_ALERT_POPUP_BUTTON_NEGATIVE, "No", NULL);
@ -593,7 +593,7 @@ static void
_alert_text_case2_cb(void *data, const Efl_Event *ev EINA_UNUSED)
{
Eo *win = data;
Eo *efl_ui_popup= efl_add(EFL_UI_TEXT_ALERT_POPUP_CLASS, win);
Eo *efl_ui_popup= efl_add(EFL_UI_ALERT_POPUP_CLASS, win);
Eina_Strbuf *message_buf = eina_strbuf_new();
create_message(message_buf, "This is Text Popup ", 50);
@ -601,7 +601,7 @@ _alert_text_case2_cb(void *data, const Efl_Event *ev EINA_UNUSED)
efl_gfx_hint_size_min_set(efl_ui_popup, EINA_SIZE2D(200, 200));
efl_text_set(efl_part(efl_ui_popup, "title"), "title");
efl_text_set(efl_ui_popup, eina_strbuf_string_get(message_buf));
efl_ui_widget_scrollable_text_set(efl_ui_popup, eina_strbuf_string_get(message_buf));
efl_ui_alert_popup_button_set(efl_ui_popup, EFL_UI_ALERT_POPUP_BUTTON_POSITIVE, "Yes", NULL);
efl_ui_alert_popup_button_set(efl_ui_popup, EFL_UI_ALERT_POPUP_BUTTON_NEGATIVE, "No", NULL);
@ -616,13 +616,13 @@ static void
_alert_text_case3_cb(void *data, const Efl_Event *ev EINA_UNUSED)
{
Eo *win = data;
Eo *efl_ui_popup= efl_add(EFL_UI_TEXT_ALERT_POPUP_CLASS, win);
Eo *efl_ui_popup= efl_add(EFL_UI_ALERT_POPUP_CLASS, win);
efl_gfx_hint_size_min_set(efl_ui_popup, EINA_SIZE2D(200, 200));
efl_gfx_hint_size_max_set(efl_ui_popup, EINA_SIZE2D(300, 300));
efl_text_set(efl_part(efl_ui_popup, "title"), "title");
efl_text_set(efl_ui_popup, "This is Text Popup");
efl_ui_widget_scrollable_text_set(efl_ui_popup, "This is Text Popup");
efl_ui_alert_popup_button_set(efl_ui_popup, EFL_UI_ALERT_POPUP_BUTTON_POSITIVE, "Yes", NULL);
efl_ui_alert_popup_button_set(efl_ui_popup, EFL_UI_ALERT_POPUP_BUTTON_NEGATIVE, "No", NULL);
@ -635,12 +635,12 @@ static void
_alert_text_case4_cb(void *data, const Efl_Event *ev EINA_UNUSED)
{
Eo *win = data;
Eo *efl_ui_popup= efl_add(EFL_UI_TEXT_ALERT_POPUP_CLASS, win);
Eo *efl_ui_popup= efl_add(EFL_UI_ALERT_POPUP_CLASS, win);
efl_gfx_hint_size_min_set(efl_ui_popup, EINA_SIZE2D(200, 200));
efl_text_set(efl_part(efl_ui_popup, "title"), "title");
efl_text_set(efl_ui_popup, "This is Text Popup");
efl_ui_widget_scrollable_text_set(efl_ui_popup, "This is Text Popup");
efl_ui_alert_popup_button_set(efl_ui_popup, EFL_UI_ALERT_POPUP_BUTTON_POSITIVE, "Yes", NULL);
efl_ui_alert_popup_button_set(efl_ui_popup, EFL_UI_ALERT_POPUP_BUTTON_NEGATIVE, "No", NULL);
@ -655,10 +655,10 @@ static void
_alert_text_case5_cb(void *data, const Efl_Event *ev EINA_UNUSED)
{
Eo *win = data;
Eo *efl_ui_popup= efl_add(EFL_UI_TEXT_ALERT_POPUP_CLASS, win);
Eo *efl_ui_popup= efl_add(EFL_UI_ALERT_POPUP_CLASS, win);
efl_text_set(efl_part(efl_ui_popup, "title"), "title");
efl_text_set(efl_ui_popup, "This is Text Popup");
efl_ui_widget_scrollable_text_set(efl_ui_popup, "This is Text Popup");
efl_ui_alert_popup_button_set(efl_ui_popup, EFL_UI_ALERT_POPUP_BUTTON_POSITIVE, "Yes", NULL);
efl_ui_alert_popup_button_set(efl_ui_popup, EFL_UI_ALERT_POPUP_BUTTON_NEGATIVE, "No", NULL);
@ -674,13 +674,13 @@ static void
_alert_text_case6_cb(void *data, const Efl_Event *ev EINA_UNUSED)
{
Eo *win = data;
Eo *efl_ui_popup= efl_add(EFL_UI_TEXT_ALERT_POPUP_CLASS, win);
Eo *efl_ui_popup= efl_add(EFL_UI_ALERT_POPUP_CLASS, win);
Eina_Strbuf *message_buf = eina_strbuf_new();
create_message(message_buf, "This is Text Popup ", 50);
efl_text_set(efl_part(efl_ui_popup, "title"), "title");
efl_text_set(efl_ui_popup, eina_strbuf_string_get(message_buf));
efl_ui_widget_scrollable_text_set(efl_ui_popup, eina_strbuf_string_get(message_buf));
efl_ui_alert_popup_button_set(efl_ui_popup, EFL_UI_ALERT_POPUP_BUTTON_POSITIVE, "Yes", NULL);
efl_ui_alert_popup_button_set(efl_ui_popup, EFL_UI_ALERT_POPUP_BUTTON_NEGATIVE, "No", NULL);
@ -699,7 +699,7 @@ static void
_alert_text_case7_cb(void *data, const Efl_Event *ev EINA_UNUSED)
{
Eo *win = data;
Eo *efl_ui_popup= efl_add(EFL_UI_TEXT_ALERT_POPUP_CLASS, win);
Eo *efl_ui_popup= efl_add(EFL_UI_ALERT_POPUP_CLASS, win);
Eina_Strbuf *message_buf = eina_strbuf_new();
create_message(message_buf, "This is Text Popup ", 50);
@ -707,7 +707,7 @@ _alert_text_case7_cb(void *data, const Efl_Event *ev EINA_UNUSED)
efl_gfx_hint_size_min_set(efl_ui_popup, EINA_SIZE2D(200, 200));
efl_text_set(efl_part(efl_ui_popup, "title"), "title");
efl_text_set(efl_ui_popup, eina_strbuf_string_get(message_buf));
efl_ui_widget_scrollable_text_set(efl_ui_popup, eina_strbuf_string_get(message_buf));
efl_ui_alert_popup_button_set(efl_ui_popup, EFL_UI_ALERT_POPUP_BUTTON_POSITIVE, "Yes", NULL);
efl_ui_alert_popup_button_set(efl_ui_popup, EFL_UI_ALERT_POPUP_BUTTON_NEGATIVE, "No", NULL);
@ -724,13 +724,13 @@ static void
_alert_text_case8_cb(void *data, const Efl_Event *ev EINA_UNUSED)
{
Eo *win = data;
Eo *efl_ui_popup= efl_add(EFL_UI_TEXT_ALERT_POPUP_CLASS, win);
Eo *efl_ui_popup= efl_add(EFL_UI_ALERT_POPUP_CLASS, win);
Eina_Strbuf *message_buf = eina_strbuf_new();
create_message(message_buf, "This is Text Popup ", 50);
efl_text_set(efl_part(efl_ui_popup, "title"), "title");
efl_text_set(efl_ui_popup, eina_strbuf_string_get(message_buf));
efl_ui_widget_scrollable_text_set(efl_ui_popup, eina_strbuf_string_get(message_buf));
efl_ui_alert_popup_button_set(efl_ui_popup, EFL_UI_ALERT_POPUP_BUTTON_POSITIVE, "Yes", NULL);
efl_ui_alert_popup_button_set(efl_ui_popup, EFL_UI_ALERT_POPUP_BUTTON_NEGATIVE, "No", NULL);
@ -749,13 +749,13 @@ static void
_alert_text_case9_cb(void *data, const Efl_Event *ev EINA_UNUSED)
{
Eo *win = data;
Eo *efl_ui_popup= efl_add(EFL_UI_TEXT_ALERT_POPUP_CLASS, win);
Eo *efl_ui_popup= efl_add(EFL_UI_ALERT_POPUP_CLASS, win);
Eina_Strbuf *message_buf = eina_strbuf_new();
create_message(message_buf, "This is Text Popup ", 50);
efl_text_set(efl_part(efl_ui_popup, "title"), "title");
efl_text_set(efl_ui_popup, eina_strbuf_string_get(message_buf));
efl_ui_widget_scrollable_text_set(efl_ui_popup, eina_strbuf_string_get(message_buf));
efl_ui_alert_popup_button_set(efl_ui_popup, EFL_UI_ALERT_POPUP_BUTTON_POSITIVE, "Yes", NULL);
efl_ui_alert_popup_button_set(efl_ui_popup, EFL_UI_ALERT_POPUP_BUTTON_NEGATIVE, "No", NULL);
@ -774,13 +774,13 @@ static void
_alert_text_case10_cb(void *data, const Efl_Event *ev EINA_UNUSED)
{
Eo *win = data;
Eo *efl_ui_popup= efl_add(EFL_UI_TEXT_ALERT_POPUP_CLASS, win);
Eo *efl_ui_popup= efl_add(EFL_UI_ALERT_POPUP_CLASS, win);
Eina_Strbuf *message_buf = eina_strbuf_new();
create_message(message_buf, "This is Text Popup ", 10);
efl_text_set(efl_part(efl_ui_popup, "title"), "title");
efl_text_set(efl_ui_popup, eina_strbuf_string_get(message_buf));
efl_ui_widget_scrollable_text_set(efl_ui_popup, eina_strbuf_string_get(message_buf));
efl_ui_alert_popup_button_set(efl_ui_popup, EFL_UI_ALERT_POPUP_BUTTON_POSITIVE, "Yes", NULL);
efl_ui_alert_popup_button_set(efl_ui_popup, EFL_UI_ALERT_POPUP_BUTTON_NEGATIVE, "No", NULL);
@ -799,13 +799,13 @@ static void
_alert_text_case11_cb(void *data, const Efl_Event *ev EINA_UNUSED)
{
Eo *win = data;
Eo *efl_ui_popup= efl_add(EFL_UI_TEXT_ALERT_POPUP_CLASS, win);
Eo *efl_ui_popup= efl_add(EFL_UI_ALERT_POPUP_CLASS, win);
Eina_Strbuf *message_buf = eina_strbuf_new();
create_message(message_buf, "This is Text Popup ", 10);
efl_text_set(efl_part(efl_ui_popup, "title"), "title");
efl_text_set(efl_ui_popup, eina_strbuf_string_get(message_buf));
efl_ui_widget_scrollable_text_set(efl_ui_popup, eina_strbuf_string_get(message_buf));
efl_ui_alert_popup_button_set(efl_ui_popup, EFL_UI_ALERT_POPUP_BUTTON_POSITIVE, "Yes", NULL);
efl_ui_alert_popup_button_set(efl_ui_popup, EFL_UI_ALERT_POPUP_BUTTON_NEGATIVE, "No", NULL);
@ -824,13 +824,13 @@ static void
_alert_text_case12_cb(void *data, const Efl_Event *ev EINA_UNUSED)
{
Eo *win = data;
Eo *efl_ui_popup= efl_add(EFL_UI_TEXT_ALERT_POPUP_CLASS, win);
Eo *efl_ui_popup= efl_add(EFL_UI_ALERT_POPUP_CLASS, win);
Eina_Strbuf *message_buf = eina_strbuf_new();
create_message(message_buf, "This is Text Popup ", 10);
efl_text_set(efl_part(efl_ui_popup, "title"), "title");
efl_text_set(efl_ui_popup, eina_strbuf_string_get(message_buf));
efl_ui_widget_scrollable_text_set(efl_ui_popup, eina_strbuf_string_get(message_buf));
efl_ui_alert_popup_button_set(efl_ui_popup, EFL_UI_ALERT_POPUP_BUTTON_POSITIVE, "Yes", NULL);
efl_ui_alert_popup_button_set(efl_ui_popup, EFL_UI_ALERT_POPUP_BUTTON_NEGATIVE, "No", NULL);
@ -849,13 +849,13 @@ static void
_alert_text_case13_cb(void *data, const Efl_Event *ev EINA_UNUSED)
{
Eo *win = data;
Eo *efl_ui_popup= efl_add(EFL_UI_TEXT_ALERT_POPUP_CLASS, win);
Eo *efl_ui_popup= efl_add(EFL_UI_ALERT_POPUP_CLASS, win);
Eina_Strbuf *message_buf = eina_strbuf_new();
create_message(message_buf, "This is Text Popup ", 20);
efl_text_set(efl_part(efl_ui_popup, "title"), "title");
efl_text_set(efl_ui_popup, eina_strbuf_string_get(message_buf));
efl_ui_widget_scrollable_text_set(efl_ui_popup, eina_strbuf_string_get(message_buf));
efl_ui_alert_popup_button_set(efl_ui_popup, EFL_UI_ALERT_POPUP_BUTTON_POSITIVE, "Yes", NULL);
efl_ui_alert_popup_button_set(efl_ui_popup, EFL_UI_ALERT_POPUP_BUTTON_NEGATIVE, "No", NULL);
@ -874,13 +874,13 @@ static void
_alert_text_case14_cb(void *data, const Efl_Event *ev EINA_UNUSED)
{
Eo *win = data;
Eo *efl_ui_popup= efl_add(EFL_UI_TEXT_ALERT_POPUP_CLASS, win);
Eo *efl_ui_popup= efl_add(EFL_UI_ALERT_POPUP_CLASS, win);
Eina_Strbuf *message_buf = eina_strbuf_new();
create_message(message_buf, "This is Text Popup ", 50);
efl_text_set(efl_part(efl_ui_popup, "title"), "title");
efl_text_set(efl_ui_popup, eina_strbuf_string_get(message_buf));
efl_ui_widget_scrollable_text_set(efl_ui_popup, eina_strbuf_string_get(message_buf));
efl_ui_alert_popup_button_set(efl_ui_popup, EFL_UI_ALERT_POPUP_BUTTON_POSITIVE, "Yes", NULL);
efl_ui_alert_popup_button_set(efl_ui_popup, EFL_UI_ALERT_POPUP_BUTTON_NEGATIVE, "No", NULL);

6
src/bin/elementary/test_ui_spin_button.c
View File

@ -42,7 +42,7 @@ test_ui_spin_button(void *data EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *
efl_ui_range_value_set(efl_added, 6),
efl_ui_range_step_set(efl_added, 2),
efl_ui_spin_button_wraparound_set(efl_added, EINA_TRUE),
efl_ui_spin_button_editable_set(efl_added, EINA_TRUE),
efl_ui_spin_button_direct_text_input_set(efl_added, EINA_TRUE),
efl_event_callback_add(efl_added, EFL_UI_RANGE_EVENT_STEADY,_spin_delay_changed_cb, NULL),
efl_event_callback_add(efl_added, EFL_UI_RANGE_EVENT_CHANGED, _spin_changed_cb, NULL),
efl_pack(bx, efl_added));
@ -51,13 +51,13 @@ test_ui_spin_button(void *data EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *
efl_ui_range_limits_set(efl_added, -100.0, 100.0),
efl_ui_range_value_set(efl_added, 0),
efl_ui_format_string_set(efl_added, "test float %0.2f", EFL_UI_FORMAT_STRING_TYPE_SIMPLE),
efl_ui_spin_button_editable_set(efl_added, EINA_FALSE),
efl_ui_spin_button_direct_text_input_set(efl_added, EINA_FALSE),
efl_pack(bx, efl_added));
efl_add(EFL_UI_SPIN_BUTTON_CLASS, bx,
efl_ui_range_limits_set(efl_added, 1, 12),
efl_ui_range_value_set(efl_added, 1),
efl_ui_spin_button_editable_set(efl_added, EINA_FALSE),
efl_ui_spin_button_direct_text_input_set(efl_added, EINA_FALSE),
efl_ui_format_values_set(efl_added, EINA_C_ARRAY_ACCESSOR_NEW(special_values)),
efl_ui_layout_orientation_set(efl_added, EFL_UI_LAYOUT_ORIENTATION_VERTICAL),
efl_pack(bx, efl_added));

12
src/bin/elementary/test_ui_spotlight.c
View File

@ -940,10 +940,6 @@ test_ui_spotlight_stack(void *data EINA_UNUSED,
case 2:
view = view_add(BUTTON, spotlight);
break;
default:
view = view_add(LAYOUT, spotlight);
break;
}
efl_pack_end(spotlight, view);
}
@ -1039,10 +1035,6 @@ test_ui_spotlight_plain(void *data EINA_UNUSED,
case 2:
view = view_add(BUTTON, spotlight);
break;
default:
view = view_add(LAYOUT, spotlight);
break;
}
efl_pack_end(spotlight, view);
}
@ -1141,10 +1133,6 @@ test_ui_spotlight_scroll(void *data EINA_UNUSED,
case 2:
view = view_add(BUTTON, spotlight);
break;
default:
view = view_add(LAYOUT, spotlight);
break;
}
efl_pack_end(spotlight, view);
}

6
src/bin/elementary/test_ui_table.c
View File

@ -138,7 +138,8 @@ child_evt_cb(void *data, const Efl_Event *event)
int col, row, colspan, rowspan;
char buf[64];
efl_pack_table_position_get(event->object, it, &col, &row, &colspan, &rowspan);
efl_pack_table_cell_column_get(event->object, it, &col, &colspan);
efl_pack_table_cell_row_get(event->object, it, &row, &rowspan);
if (event->desc == EFL_CONTAINER_EVENT_CONTENT_ADDED)
sprintf(buf, "pack %d,%d %dx%d", col, row, colspan, rowspan);
else
@ -168,7 +169,8 @@ _custom_layout_update(Eo *pack, void *_pd EINA_UNUSED)
it = efl_content_iterate(pack);
EINA_ITERATOR_FOREACH(it, item)
{
if (efl_pack_table_position_get(pack, item, &c, &r, &cs, &rs))
if (efl_pack_table_cell_column_get(pack, item, &c, &cs) &&
efl_pack_table_cell_row_get(pack, item, &r, &rs))
{
Eina_Rect m;

6
src/bin/elementary/test_ui_table_static.c
View File

@ -86,10 +86,8 @@ _ch_table(void *data, const Efl_Event *ev)
Eo *table = data;
int x, y, w, h;
// FIXME: old elm_table API doesn't need table object
//elm_grid_pack_get(obj, &x, &y, &w, &h);
//elm_grid_pack_set(obj, x - 1, y - 1, w + 2, h + 2);
efl_pack_table_position_get(table, ev->object, &x, &y, &w, &h);
efl_pack_table_cell_column_get(table, ev->object, &x, &w);
efl_pack_table_cell_row_get(table, ev->object, &y, &h);
efl_pack_table(table, ev->object, x - 1, y - 1, w + 2, h + 2);
}

157
src/bin/eolian_mono/eolian/mono/function_definition.hh
View File

@ -6,10 +6,12 @@
#include "grammar/generator.hpp"
#include "grammar/klass_def.hpp"
#include "grammar/kleene.hpp"
#include "grammar/indentation.hpp"
#include "grammar/list.hpp"
#include "grammar/alternative.hpp"
#include "grammar/attribute_reorder.hpp"
#include "grammar/counter.hpp"
#include "logging.hh"
#include "type.hh"
#include "name_helpers.hh"
@ -261,7 +263,8 @@ struct property_extension_method_definition_generator
}
// Do we need BindablePart extensions for this class?
if (!helpers::inherits_from(cls, "Efl.Ui.LayoutPart"))
// IContent parts are handled directly through BindableFactoryParts
if (!helpers::inherits_from(cls, "Efl.Ui.LayoutPart") || helpers::inherits_from(cls, "Efl.IContent"))
return true;
if (property.setter.is_engaged())
@ -292,6 +295,11 @@ struct property_wrapper_definition_generator
template<typename OutputIterator, typename Context>
bool generate(OutputIterator sink, attributes::property_def const& property, Context const& context) const
{
using efl::eolian::grammar::attribute_reorder;
using efl::eolian::grammar::counter;
using efl::eolian::grammar::attributes::parameter_direction;
using efl::eolian::grammar::attributes::parameter_def;
if (blacklist::is_property_blacklisted(property, *implementing_klass, context))
return true;
@ -304,7 +312,7 @@ struct property_wrapper_definition_generator
return true;
auto get_params = property.getter.is_engaged() ? property.getter->parameters.size() : 0;
auto set_params = property.setter.is_engaged() ? property.setter->parameters.size() : 0;
//auto set_params = property.setter.is_engaged() ? property.setter->parameters.size() : 0;
// C# properties must have a single value.
//
@ -312,16 +320,62 @@ struct property_wrapper_definition_generator
// meaning they should have 0 parameters.
//
// For setters, we ignore the return type - usually boolean.
if (get_params > 0 || set_params > 1)
// if (get_params > 0 || set_params > 1)
// return true;
if (property.getter
&& std::find_if (property.getter->parameters.begin()
, property.getter->parameters.end()
, [] (parameter_def const& p)
{
return p.direction != parameter_direction::out;
}) != property.getter->parameters.end())
return true;
if (property.setter
&& std::find_if (property.setter->parameters.begin()
, property.setter->parameters.end()
, [] (parameter_def const& p)
{
return p.direction != parameter_direction::in;
}) != property.setter->parameters.end())
return true;
attributes::type_def prop_type;
if (property.getter && property.setter)
{
if (get_params != 0 && property.setter->parameters.size() != property.getter->parameters.size())
return true;
}
if (property.getter.is_engaged())
prop_type = property.getter->return_type;
else if (property.setter.is_engaged())
prop_type = property.setter->parameters[0].type;
else
std::vector<attributes::parameter_def> parameters;
if (property.setter.is_engaged())
{
std::transform (property.setter->parameters.begin(), property.setter->parameters.end()
, std::back_inserter(parameters)
, [] (parameter_def p) -> parameter_def
{
//p.direction = efl::eolian::attributes::parameter_direction::in;
return p;
});
}
else if (property.getter.is_engaged())
{
// if getter has parameters, then we ignore return type, otherwise
// we use the return type.
if (get_params == 0)
parameters.push_back({parameter_direction::in
, property.getter->return_type, "propertyResult", {}
, property.getter->unit});
else
std::transform (property.getter->parameters.begin(), property.getter->parameters.end()
, std::back_inserter(parameters)
, [] (parameter_def p) -> parameter_def
{
p.direction = parameter_direction::in;
return p;
});
}
else
{
EINA_CXX_DOM_LOG_ERR(eolian_mono::domain) << "Property must have either a getter or a setter." << std::endl;
return false;
@ -365,21 +419,88 @@ struct property_wrapper_definition_generator
set_scope = "";
}
if (!as_generator(
documentation(1)
<< scope_tab << scope << (is_static ? "static " : "") << type(true) << " " << managed_name << " {\n"
).generate(sink, std::make_tuple(property, prop_type), context))
return false;
if (parameters.size() == 1)
{
if (!as_generator(
documentation(1)
<< scope_tab << scope << (is_static ? "static " : "") << type(true) << " " << managed_name << " {\n"
).generate(sink, std::make_tuple(property, parameters[0].type), context))
return false;
}
else
{
if (!as_generator
(
documentation(1)
<< scope_tab << scope << (is_static ? "static (" : "(")
<< (attribute_reorder<1, -1>(type(true) /*<< " " << argument*/) % ", ") << ") "
<< managed_name << " {\n"
).generate(sink, std::make_tuple(property, parameters), context))
return false;
}
if (property.getter.is_engaged())
if (!as_generator(scope_tab << scope_tab << get_scope << "get " << (interface ? ";" : "{ return " + name_helpers::managed_method_name(*property.getter) + "(); }") << "\n"
if (property.getter.is_engaged() && interface)
{
if (!as_generator(scope_tab << scope_tab << set_scope << "get;\n"
).generate(sink, attributes::unused, context))
return false;
}
else if (property.getter.is_engaged() && get_params == 0/*parameters.size() == 1 && property.getter.is_engaged()*/)
{
if (!as_generator
(scope_tab << scope_tab << get_scope
<< "get " << "{ return " + name_helpers::managed_method_name(*property.getter) + "(); }\n"
).generate(sink, attributes::unused, context))
return false;
}
else if (parameters.size() >= 1 && property.getter)
{
if (!as_generator
(scope_tab << scope_tab << get_scope << "get "
<< "{\n"
<< *attribute_reorder<1, -1, 1>
(scope_tab(3) << type(true) << " _out_"
<< argument(false) << " = default(" << type(true) << ");\n"
)
<< scope_tab(3) << name_helpers::managed_method_name(*property.getter)
<< "(" << (("out _out_" << argument(false)) % ",") << ");\n"
<< scope_tab(3) << "return (" << (("_out_"<< argument(false)) % ",") << ");\n"
<< scope_tab(2) << "}" << "\n"
).generate(sink, std::make_tuple(parameters, parameters, parameters), context))
return false;
}
// else if (parameters.size() == 1)
// {
// if (!as_generator
// (scope_tab << scope_tab << get_scope << "get "
// << "{\n"
// << *attribute_reorder<1, -1, 1>(scope_tab(3) << type(true) << " _out_" << argument(false) << " = default(" << type(true) << ");\n")
// << scope_tab(3) << name_helpers::managed_method_name(*property.getter)
// << "(" << (("out _out_" << argument(false)) % ",") << ");\n"
// << scope_tab(3) << "return " << (("_out_"<< argument(false)) % ",") << ";\n"
// << scope_tab(2) << "}" << "\n"
// ).generate(sink, std::make_tuple(parameters, parameters, parameters), context))
// return false;
// }
if (property.setter.is_engaged())
if (!as_generator(scope_tab << scope_tab << set_scope << "set " << (interface ? ";" : "{ " + name_helpers::managed_method_name(*property.setter) + "(" + dir_mod + "value); }") << "\n"
if (property.setter.is_engaged() && interface)
{
if (!as_generator(scope_tab << scope_tab << set_scope << "set;\n"
).generate(sink, attributes::unused, context))
return false;
}
else if (parameters.size() == 1 && property.setter.is_engaged())
{
if (!as_generator(scope_tab << scope_tab << set_scope << "set " << "{ " + name_helpers::managed_method_name(*property.setter) + "(" + dir_mod + "value); }\n"
).generate(sink, attributes::unused, context))
return false;
}
else if (parameters.size() > 1 && property.setter.is_engaged())
{
if (!as_generator(scope_tab << scope_tab << set_scope << "set " << ("{ " + name_helpers::managed_method_name(*property.setter) + "(" + dir_mod) << ((" value.Item" << counter(1)) % ", ") << "); }" << "\n"
).generate(sink, parameters, context))
return false;
}
if (!as_generator(scope_tab << "}\n").generate(sink, attributes::unused, context))
return false;

35
src/bin/eolian_mono/eolian/mono/klass.hh
View File

@ -50,6 +50,11 @@ is_inherit_context(Context const& context)
return context_find_tag<class_context>(context).current_wrapper_kind == class_context::inherit;
}
enum partial_class
{
class_partial = 1
};
struct klass
{
template <typename OutputIterator, typename Context>
@ -109,9 +114,11 @@ struct klass
if(!as_generator("[Efl.Eo.BindingEntity]\n").generate(sink, attributes::unused, iface_cxt))
return false;
using efl::eolian::grammar::lit;
if(!as_generator
(
"public " /*<< class_type*/ "interface" /*<<*/ " " << string << " : "
lit("public ") << (is_partial ? "partial ":"")
/*<< class_type*/ << "interface" /*<<*/ " " << string << " : "
)
.generate(sink, name_helpers::klass_interface_name(cls), iface_cxt))
return false;
@ -191,7 +198,7 @@ struct klass
if(!as_generator
(
documentation
<< "sealed public class " << concrete_name << " :\n"
<< "sealed public " << (is_partial ? "partial ":"") << " class " << concrete_name << " :\n"
<< scope_tab << (root ? "Efl.Eo.EoWrapper" : "") << (klass_full_concrete_or_interface_name % "") << "\n"
<< scope_tab << ", " << interface_name << "\n"
<< scope_tab << *(", " << name_helpers::klass_full_concrete_or_interface_name) << "\n"
@ -284,7 +291,14 @@ struct klass
documentation
<< "[" << name_helpers::klass_full_native_inherit_name(cls) << "]\n"
<< "[Efl.Eo.BindingEntity]\n"
<< "public " << class_type << " " << name_helpers::klass_concrete_name(cls) << " : "
<< "public "
<< (is_partial
? class_type == "class"
? "partial class"
: "abstract partial class"
: class_type
)
<< " " << name_helpers::klass_concrete_name(cls) << " : "
<< (klass_full_concrete_or_interface_name % ",") // classes
<< (root ? "Efl.Eo.EoWrapper" : "") // ... or root
<< (inherit_interfaces.empty() ? "" : ", ")
@ -358,13 +372,15 @@ struct klass
}
if(!as_generator
(lit("#pragma warning disable CS1591\n") // Disabling warnings as DocFx will hide these classes
(lit("#if EFL_BETA\n")
<< "#pragma warning disable CS1591\n" // Disabling warnings as DocFx will hide these classes
<<"public static class " << (string % "_") << name_helpers::klass_inherit_name(cls)
<< "_ExtensionMethods {\n"
<< *((scope_tab << property_extension_method_definition(cls)) << "\n")
<< *((scope_tab << part_extension_method_definition(cls)) << "\n")
<< "}\n"
<< lit("#pragma warning restore CS1591\n"))
<< "#pragma warning restore CS1591\n"
<< "#endif\n")
.generate(sink, std::make_tuple(cls.namespaces, implementable_properties, cls.parts), context))
return false;
@ -598,9 +614,16 @@ struct klass
}
return true;
}
bool is_partial;
klass const operator()(partial_class) const
{
return klass{true};
}
};
struct klass const klass = {};
struct klass const klass = {false};
}

1
src/bin/eolian_mono/eolian/mono/name_helpers.hh
View File

@ -60,6 +60,7 @@ inline std::string escape_keyword(std::string const& name)
|| is_equal(name, "string")
|| is_equal(name, "internal")
|| is_equal(name, "fixed")
|| is_equal(name, "var")
|| is_equal(name, "base"))
return "kw_" + name;

24
src/bin/eolian_mono/eolian/mono/parameter.hh
View File

@ -488,23 +488,31 @@ struct marshall_parameter_generator
// FIXME This seems to be used only in the else branch of the native function definition. Is it really needed?
struct argument_generator
{
bool generate_direction;
argument_generator () : generate_direction(true) {}
argument_generator (bool r) : generate_direction(r) {}
template <typename OutputIterator, typename Context>
bool generate(OutputIterator sink, attributes::parameter_def const& param, Context const& context) const
{
std::string param_name = escape_keyword(param.param_name);
std::string direction = marshall_direction_modifier(param);
if (!param.type.original_type.visit(is_fp_visitor{}))
return as_generator(
direction << param_name
).generate(sink, attributes::unused, context);
return as_generator(
param_name << "_data, " << param_name << ", " << param_name << "_free_cb"
).generate(sink, attributes::unused, context);
if (generate_direction && !param.type.original_type.visit(is_fp_visitor{}))
return as_generator(direction << param_name).generate(sink, attributes::unused, context);
if (!generate_direction && !param.type.original_type.visit(is_fp_visitor{}))
return as_generator(param_name).generate(sink, attributes::unused, context);
else
return as_generator
(param_name << "_data, " << param_name << ", " << param_name << "_free_cb"
).generate(sink, attributes::unused, context);
}
argument_generator operator ()(bool r) const
{
return {r};
}
} const argument {};
struct native_argument_invocation_generator

11
src/bin/eolian_mono/eolian/mono/part_definition.hh
View File

@ -47,12 +47,19 @@ struct part_extension_method_definition_generator
/* auto unit = (const Eolian_Unit*) context_find_tag<eolian_state_context>(context).state; */
/* auto klass = get_klass(part.klass, unit); */
std::string bindableClass = "Efl.BindablePart";
// Efl.Content parts should be bound only throught FactoryBind
attributes::klass_def c(get_klass(part.klass, cls.unit), cls.unit);
if (helpers::inherits_from(c, "Efl.IContent"))
bindableClass = "Efl.BindableFactoryPart";
if (!as_generator(
scope_tab << "public static Efl.BindablePart<" << part_klass_name << "> " << name_helpers::managed_part_name(part) << "<T>(this Efl.Ui.ItemFactory<T> fac, Efl.Csharp.ExtensionTag<"
scope_tab << "public static " << bindableClass << "<" << part_klass_name << "> " << name_helpers::managed_part_name(part) << "<T>(this Efl.Ui.ItemFactory<T> fac, Efl.Csharp.ExtensionTag<"
<< name_helpers::klass_full_concrete_or_interface_name(cls)
<< ", T> x=null) where T : " << name_helpers::klass_full_concrete_or_interface_name(cls) << "\n"
<< scope_tab << "{\n"
<< scope_tab << scope_tab << "return new Efl.BindablePart<" << part_klass_name << ">(\"" << part.name << "\" ,fac);\n"
<< scope_tab << scope_tab << "return new " << bindableClass << "<" << part_klass_name << ">(\"" << part.name << "\" ,fac);\n"
<< scope_tab << "}\n"
).generate(sink, attributes::unused, context))
return false;

14
src/bin/eolian_mono/eolian_mono.cc
View File

@ -50,6 +50,7 @@ struct options_type
int v_major;
int v_minor;
bool want_beta;
bool want_partial;
std::map<const std::string, std::string> references_map;
};
@ -192,8 +193,9 @@ run(options_type const& opts)
efl::eolian::grammar::attributes::klass_def klass_def(klass, opts.unit);
std::vector<efl::eolian::grammar::attributes::klass_def> klasses{klass_def};
if (!eolian_mono::klass
.generate(iterator, klass_def, context))
auto klass_gen = !opts.want_partial ? eolian_mono::klass
: eolian_mono::klass(eolian_mono::class_partial);
if (!klass_gen.generate(iterator, klass_def, context))
{
throw std::runtime_error("Failed to generate class");
}
@ -297,6 +299,7 @@ _usage(const char *progname)
<< " -v, --version Print the version." << std::endl
<< " -b, --beta Enable @beta methods." << std::endl
<< " -e, --example-dir <dir> Folder to search for example files." << std::endl
<< " -p, --partial Create class as a partial class" << std::endl
<< " -h, --help Print this help." << std::endl;
exit(EXIT_FAILURE);
}
@ -328,9 +331,10 @@ opts_get(int argc, char **argv)
{ "references", required_argument, 0, 'r'},
{ "beta", no_argument, 0, 'b'},
{ "example-dir", required_argument, 0, 'e' },
{ "partial", no_argument, 0, 'p' },
{ 0, 0, 0, 0 }
};
const char* options = "I:D:o:c:M:m:ar:vhbe:";
const char* options = "I:D:o:c:M:m:ar:vhbpe:";
int c, idx;
while ( (c = getopt_long(argc, argv, options, long_options, &idx)) != -1)
@ -391,6 +395,10 @@ opts_get(int argc, char **argv)
opts.examples_dir = optarg;
if (!opts.examples_dir.empty() && opts.examples_dir.back() != '/') opts.examples_dir += "/";
}
else if (c == 'p')
{
opts.want_partial = true;
}
}
if (optind == argc-1)
{

25
src/bindings/mono/efl_mono/Bind.cs
View File

@ -82,6 +82,31 @@ public class BindablePart<T>
public string PartName { get; private set; }
/// <summary>The binder that will be used to bind the properties.</summary>
public Efl.Ui.IPropertyBind Binder { get; private set; }
}
/// <summary>Represents bindable factory parts as used by <see cref="Efl.Ui.ItemFactory&lt;T&gt;" /> instances.
/// </summary>
public class BindableFactoryPart<T>
{
/// <summary>Creates a new bindable factory part with the binder <c>binder</c>.</summary>
public BindableFactoryPart(string partName, Efl.Ui.IFactoryBind binder)
{
this.PartName = partName;
this.Binder = binder;
}
/// <summary>The name of the part this instance wraps.</summary>
public string PartName { get; private set; }
/// <summary>The binder that will be used to bind the properties.</summary>
public Efl.Ui.IFactoryBind Binder { get; private set; }
/// <summary>Binds the given factory to this part.</summary>
public Eina.Error BindFactory(Efl.Ui.IFactory factory)
{
this.Binder.FactoryBind(this.PartName, factory);
return Eina.Error.NO_ERROR;
}
}
namespace Csharp

12
src/bindings/mono/meson.build
View File

@ -80,6 +80,12 @@ blacklisted_files = [
'elm_multibuttonentry_part.eo',
'elm_atspi_bridge.eo',
'elm_atspi_app_object.eo',
'elm_interface_scrollable.eo',
'evas_canvas3d_types.eot',
]
manual_inheritance_files = [
'efl_object.eo'
]
beta_option = []
@ -105,13 +111,17 @@ foreach lib : mono_sublibs
subdir_file_location = join_paths(file_location, eo_file_subdir)
foreach mono_gen_file : mono_pub_eo_files
if not blacklisted_files.contains(mono_gen_file)
partial = []
if manual_inheritance_files.contains(mono_gen_file)
partial = '-p'
endif
mono_generator_target += custom_target('eolian_mono_gen_'+mono_gen_file.underscorify()+'',
input : join_paths(subdir_file_location, mono_gen_file),
output : [mono_gen_file + '.cs'],
command : [eolian_mono_gen, beta_option, '-I', meson.current_source_dir(), eolian_include_directories,
'--dllimport', package_name,
'-o', join_paths(meson.current_build_dir(), mono_gen_file + '.cs'),
'-e', get_option('mono-examples-dir'),
'-e', get_option('mono-examples-dir'), partial,
'@INPUT@'])
endif
endforeach

9
src/examples/ecore/efl_thread.c
View File

@ -82,7 +82,7 @@ _th_main(void *data EINA_UNUSED, const Efl_Event *ev)
Eo *obj2 = efl_add(EFL_THREAD_CLASS, obj,
efl_threadio_indata_set(efl_added, (void *)0x1234),
efl_core_command_line_command_array_set(efl_added, args),
efl_task_flags_set(efl_added, EFL_TASK_FLAGS_USE_STDOUT | EFL_TASK_FLAGS_USE_STDIN),
efl_task_flags_set(efl_added, EFL_TASK_FLAGS_USE_STDOUT | EFL_TASK_FLAGS_USE_STDIN | EFL_TASK_FLAGS_EXIT_WITH_PARENT),
efl_event_callback_add(efl_added, EFL_LOOP_EVENT_ARGUMENTS, _th_main, NULL),
efl_event_callback_add(efl_added, EFL_IO_READER_EVENT_CAN_READ_CHANGED, _read_change, NULL),
eina_future_then(efl_task_run(efl_added), _task_exit, efl_added)
@ -124,7 +124,10 @@ _task_exit(void *data, Eina_Value v, const Eina_Future *dead EINA_UNUSED)
// all output to read has stopped
Eo *obj = data;
printf("--- [%p] EXITED exit_code=%i outdata=%p\n", obj, efl_task_exit_code_get(obj), efl_threadio_outdata_get(obj));
efl_del(obj);
// thread object will be automatically deleted after as long as
// EFL_TASK_FLAGS_EXIT_WITH_PAREN is set on task flags, and this is
// actually the default unless you change the flags to be something
// else. if you don't use this then the task/thread becomes orphaned
return v;
}
@ -175,7 +178,7 @@ efl_main(void *data EINA_UNUSED, const Efl_Event *ev)
Eo *obj = efl_add(EFL_THREAD_CLASS, app,
efl_threadio_indata_set(efl_added, (void *)0x5678),
efl_core_command_line_command_array_set(efl_added, args),
efl_task_flags_set(efl_added, EFL_TASK_FLAGS_USE_STDOUT | EFL_TASK_FLAGS_USE_STDIN),
efl_task_flags_set(efl_added, EFL_TASK_FLAGS_USE_STDOUT | EFL_TASK_FLAGS_USE_STDIN | EFL_TASK_FLAGS_EXIT_WITH_PARENT),
efl_event_callback_add(efl_added, EFL_LOOP_EVENT_ARGUMENTS, _th_main, NULL),
efl_event_callback_add(efl_added, EFL_IO_READER_EVENT_CAN_READ_CHANGED, _read_change, NULL),
eina_future_then(efl_task_run(efl_added), _task_exit, efl_added)

2
src/examples/elementary/efl_ui_list_example_1.c
View File

@ -200,7 +200,7 @@ elm_main(int argc EINA_UNUSED, char **argv)
case 40:
efl_file_simple_load(efl_part(item, "background"), "./sky_01.jpg", NULL);
efl_gfx_image_scale_type_set(efl_part(item, "background"), EFL_GFX_IMAGE_SCALE_TYPE_FIT_OUTSIDE);
efl_gfx_image_scale_type_set(efl_part(item, "background"), EFL_GFX_IMAGE_SCALE_TYPE_EXPAND);
efl_pack_at(list, item, 39);
break;

3
src/examples/elementary/slider_cxx_example.cc
View File

@ -30,7 +30,8 @@ efl_main(void *data EINA_UNUSED, const Efl_Event *ev EINA_UNUSED)
efl::ui::Slider sl2(instantiate, win);
efl::ui::Image ic(instantiate, win);
ic.icon_set("folder");
ic.scalable_set(false, false);
ic.can_upscale_set(false);
ic.can_downscale_set(false);
// FIXME: C++ part API needs special reference handling! This will show ERR!
efl::eo::downcast<efl::Content>(sl2.part_get("elm.swallow.end"))
.content_set(ic);

6
src/examples/elementary/spinner_cxx_example.cc
View File

@ -50,7 +50,7 @@ efl_main(void *data EINA_UNUSED, const Efl_Event *ev EINA_UNUSED)
bx.pack_end(sp4);
efl::ui::Spin_Button sp5(instantiate, win);
sp5.editable_set(false);
sp5.direct_text_input_set(false);
sp5.hint_fill_set(true, false);
bx.pack_end(sp5);
@ -70,7 +70,7 @@ efl_main(void *data EINA_UNUSED, const Efl_Event *ev EINA_UNUSED)
};
efl::eina::accessor<Efl_Ui_Format_Value> values_acc(EINA_C_ARRAY_ACCESSOR_NEW(values));
efl::ui::Spin_Button sp6(instantiate, win);
sp6.editable_set(false);
sp6.direct_text_input_set(false);
sp6.range_limits_set(1, 12);
//sp6.format_values_set(values_acc);
sp6.hint_fill_set(true, false);
@ -79,7 +79,7 @@ efl_main(void *data EINA_UNUSED, const Efl_Event *ev EINA_UNUSED)
efl::ui::Spin_Button sp7(instantiate, win);
sp7.hint_fill_set(true, false);
bx.pack_end(sp7);
sp7.editable_set(true);
sp7.direct_text_input_set(true);
auto changed = std::bind ( [] (efl::ui::Range_Display obj)
{ std::cout << "Changed to " << obj.range_value_get() << std::endl; }

7
src/lib/ecore/ecore_private.h
View File

@ -144,6 +144,8 @@ struct _Efl_Loop_Data
Eina_List *win32_handlers_to_delete;
# endif
Eina_List *thread_children;
Eina_Inlist *message_queue;
unsigned int message_walking;
@ -176,7 +178,8 @@ struct _Efl_Loop_Data
char **environ_copy;
} env;
Eina_Bool do_quit;
Eina_Bool do_quit : 1;
Eina_Bool quit_on_last_thread_child_del : 1;
};
struct _Efl_Task_Data
@ -457,6 +460,8 @@ void _efl_loop_messages_call(Eo *obj, Efl_Loop_Data *pd, void *func, void *data)
void _efl_loop_message_send_info_set(Eo *obj, Eina_Inlist *node, Eo *loop, Efl_Loop_Data *loop_data);
void _efl_loop_message_unsend(Eo *obj);
void _efl_thread_child_remove(Eo *loop, Efl_Loop_Data *pd, Eo *child);
static inline Eina_Bool
_ecore_call_task_cb(Ecore_Task_Cb func,
void *data)

8
src/lib/ecore/efl_exe.c
View File

@ -98,7 +98,7 @@ _close_fds(Efl_Exe_Data *pd)
}
static void
_exec(const char *cmd, Efl_Exe_Flags flags)
_exec(const char *cmd, Efl_Exe_Flags flags, Efl_Task_Flags task_flags)
{
char use_sh = 1, *buf = NULL, **args = NULL;
@ -149,7 +149,7 @@ _exec(const char *cmd, Efl_Exe_Flags flags)
}
}
# ifdef HAVE_PRCTL
if (flags & EFL_EXE_FLAGS_EXIT_WITH_PARENT)
if (task_flags & EFL_TASK_FLAGS_EXIT_WITH_PARENT)
prctl(PR_SET_PDEATHSIG, SIGTERM);
# endif
@ -603,7 +603,7 @@ _efl_exe_efl_task_run(Eo *obj, Efl_Exe_Data *pd)
}
// actually execute!
_exec(cmd, pd->flags);
_exec(cmd, pd->flags, td->flags);
// we couldn't exec... uh oh. HAAAAAAAALP!
if ((errno == EACCES) || (errno == EINVAL) || (errno == ELOOP) ||
(errno == ENOEXEC) || (errno == ENOMEM))
@ -641,7 +641,7 @@ _efl_exe_efl_object_constructor(Eo *obj, Efl_Exe_Data *pd)
pd->fd.exited_read = -1;
#endif
pd->fd.can_write = EINA_TRUE;
pd->flags = EFL_EXE_FLAGS_EXIT_WITH_PARENT;
pd->flags = 0;
pd->exit_signal = -1;
return obj;
}

1
src/lib/ecore/efl_exe.eo
View File

@ -18,7 +18,6 @@ enum @beta Efl.Exe_Flags {
[[Flags to customize task behavior.]] // TODO: This needs more detail.
none = 0, [[No special flags.]]
group_leader = 1, [[Process will be executed in its own session.]]
exit_with_parent = 2, [[Exit process when parent process exits.]]
hide_io = 4 [[All console IO will be hidden.]]
}

23
src/lib/ecore/efl_loop.c
View File

@ -55,6 +55,26 @@ EOLIAN static Eina_Value *
_efl_loop_begin(Eo *obj, Efl_Loop_Data *pd)
{
_ecore_main_loop_begin(obj, pd);
if (pd->thread_children)
{
Eina_List *l, *ll;
Eo *child;
// request all child threads to die and defer the quit until
// the children have all died and returned.
// run main loop again to clean out children and their exits
pd->quit_on_last_thread_child_del = EINA_TRUE;
EINA_LIST_FOREACH_SAFE(pd->thread_children, l, ll, child)
{
Efl_Task_Flags task_flags = efl_task_flags_get(child);
if (task_flags & EFL_TASK_FLAGS_EXIT_WITH_PARENT)
efl_task_end(child);
else
_efl_thread_child_remove(obj, pd, child);
}
if (pd->thread_children) _ecore_main_loop_begin(obj, pd);
}
return &(pd->exit_code);
}
@ -304,7 +324,8 @@ EOLIAN static void
_efl_loop_efl_object_destructor(Eo *obj, Efl_Loop_Data *pd)
{
pd->future_message_handler = NULL;
while (pd->thread_children)
_efl_thread_child_remove(obj, pd, pd->thread_children->data);
efl_destructor(efl_super(obj, EFL_LOOP_CLASS));
}

8
src/lib/ecore/efl_task.c
View File

@ -50,6 +50,14 @@ _efl_task_efl_object_destructor(Eo *obj EINA_UNUSED, Efl_Task_Data *pd)
efl_destructor(efl_super(obj, MY_CLASS));
}
EOLIAN static Efl_Object *
_efl_task_efl_object_constructor(Eo *obj, Efl_Task_Data *pd)
{
obj = efl_constructor(efl_super(obj, EFL_TASK_CLASS));
pd->flags = EFL_TASK_FLAGS_EXIT_WITH_PARENT;
return obj;
}
EOLIAN static void
_efl_task_efl_object_parent_set(Eo *obj, Efl_Task_Data *pd EINA_UNUSED, Efl_Object *parent)
{

6
src/lib/ecore/efl_task.eo
View File

@ -18,6 +18,7 @@ enum Efl.Task_Flags {
use_stdin = 1, [[Task will require console input.]]
use_stdout = 2, [[Task will require console output.]]
no_exit_code_error = 4, [[Task will not produce an exit code upon termination.]]
exit_with_parent = 8, [[Exit when parent exits.]]
}
abstract Efl.Task extends Efl.Loop_Consumer
@ -42,7 +43,9 @@ abstract Efl.Task extends Efl.Loop_Consumer
}
}
@property flags {
[[Flags to further customize task's behavior.]]
[[Flags to further customize task's behavior. The default value:
exit_with_parent
]]
set { }
get { }
values {
@ -62,6 +65,7 @@ abstract Efl.Task extends Efl.Loop_Consumer
events {
}
implements {
Efl.Object.constructor;
Efl.Object.destructor;
Efl.Object.parent { set; }
}

45
src/lib/ecore/efl_thread.c
View File

@ -372,6 +372,7 @@ _thread_exit_eval(Eo *obj, Efl_Thread_Data *pd)
eina_promise_reject(p, exit_code + 1000000);
else eina_promise_resolve(p, eina_value_int_init(exit_code));
}
efl_del(obj);
}
}
@ -567,6 +568,48 @@ _efl_thread_efl_object_constructor(Eo *obj, Efl_Thread_Data *pd)
return obj;
}
static void
_child_thread_del_cb(void *data, const Efl_Event *event)
{
Eo *loop = data;
Efl_Loop_Data *loop_data = efl_data_scope_get(loop, EFL_LOOP_CLASS);
if (!loop_data) return;
_efl_thread_child_remove(loop, loop_data, event->object);
if (!loop_data->quit_on_last_thread_child_del) return;
if (loop_data->thread_children) return;
// no more children waiting exits - quit the loop
_ecore_main_loop_quit(loop, loop_data);
}
EFL_CALLBACKS_ARRAY_DEFINE(thread_child_del,
{ EFL_EVENT_DEL, _child_thread_del_cb });
void
_efl_thread_child_remove(Eo *loop, Efl_Loop_Data *pd, Eo *child)
{
pd->thread_children = eina_list_remove(pd->thread_children, child);
efl_event_callback_array_del(child, thread_child_del(), loop);
}
EOLIAN static Efl_Object *
_efl_thread_efl_object_finalize(Eo *obj, Efl_Thread_Data *pd EINA_UNUSED)
{
Eo *loop = efl_provider_find(obj, EFL_LOOP_CLASS);
if (loop != obj)
{
Efl_Loop_Data *loop_data = efl_data_scope_get(loop, EFL_LOOP_CLASS);
if (loop_data)
{
loop_data->thread_children =
eina_list_prepend(loop_data->thread_children, obj);
efl_event_callback_array_add(obj, thread_child_del(), loop);
}
}
return obj;
}
EOLIAN static void
_efl_thread_efl_object_destructor(Eo *obj, Efl_Thread_Data *pd)
{
@ -834,7 +877,7 @@ EOLIAN static void
_efl_thread_efl_task_end(Eo *obj EINA_UNUSED, Efl_Thread_Data *pd)
{
if (pd->end_sent) return;
if (pd->thdat)
if ((pd->thdat) && (!pd->exit_called))
{
Control_Data cmd;

1
src/lib/ecore/efl_thread.eo
View File

@ -4,6 +4,7 @@ class @beta Efl.Thread extends Efl.Task implements Efl.ThreadIO, Efl.Io.Reader,
}
implements {
Efl.Object.constructor;
Efl.Object.finalize;
Efl.Object.destructor;
Efl.Object.parent { set; }
Efl.Task.run;

2
src/lib/ecore_con/ecore_con_url_curl.c
View File

@ -347,7 +347,7 @@ error:
void
_c_shutdown(void)
{
if (!_c || _c->ref--) return;
if (!_c || --_c->ref) return;
if (_c->_curlm)
{
_c->curl_multi_cleanup(_c->_curlm);

270
src/lib/edje/edje_cache.c
View File

@ -156,6 +156,103 @@ _edje_programs_patterns_init(Edje_Part_Collection *edc)
ssp->sources_patterns = edje_match_programs_source_init(all, j);
}
static inline void
_edje_part_collection_fix(Edje_Part_Collection *edc)
{
if (edc->checked) return;
edc->checked = 1;
unsigned int j;
Edje_Part *ep;
Eina_List *hist;
for (j = 0; j < edc->parts_count; ++j)
{
Edje_Part *ep2;
ep = edc->parts[j];
/* Register any color classes in this parts descriptions. */
hist = NULL;
hist = eina_list_append(hist, ep);
ep2 = ep;
while (ep2->dragable.confine_id >= 0)
{
if (ep2->dragable.confine_id >= (int)edc->parts_count)
{
ERR("confine_to above limit. invalidating it.");
ep2->dragable.confine_id = -1;
break;
}
ep2 = edc->parts[ep2->dragable.confine_id];
if (eina_list_data_find(hist, ep2))
{
ERR("confine_to loops. invalidating loop.");
ep2->dragable.confine_id = -1;
break;
}
hist = eina_list_append(hist, ep2);
}
eina_list_free(hist);
hist = NULL;
hist = eina_list_append(hist, ep);
ep2 = ep;
while (ep2->dragable.event_id >= 0)
{
Edje_Part *prev;
if (ep2->dragable.event_id >= (int)edc->parts_count)
{
ERR("event_id above limit. invalidating it.");
ep2->dragable.event_id = -1;
break;
}
prev = ep2;
ep2 = edc->parts[ep2->dragable.event_id];
/* events_to may be used only with dragable */
if (!ep2->dragable.x && !ep2->dragable.y)
{
prev->dragable.event_id = -1;
break;
}
if (eina_list_data_find(hist, ep2))
{
ERR("events_to loops. invalidating loop.");
ep2->dragable.event_id = -1;
break;
}
hist = eina_list_append(hist, ep2);
}
eina_list_free(hist);
hist = NULL;
hist = eina_list_append(hist, ep);
ep2 = ep;
while (ep2->clip_to_id >= 0)
{
if (ep2->clip_to_id >= (int)edc->parts_count)
{
ERR("clip_to_id above limit. invalidating it.");
ep2->clip_to_id = -1;
break;
}
ep2 = edc->parts[ep2->clip_to_id];
if (eina_list_data_find(hist, ep2))
{
ERR("clip_to loops. invalidating loop.");
ep2->clip_to_id = -1;
break;
}
hist = eina_list_append(hist, ep2);
}
eina_list_free(hist);
hist = NULL;
}
}
static Edje_Part_Collection *
_edje_file_coll_open(Edje_File *edf, const char *coll)
{
@ -284,6 +381,8 @@ _edje_file_coll_open(Edje_File *edf, const char *coll)
}
}
_edje_part_collection_fix(edc);
return edc;
}
@ -463,30 +562,21 @@ _edje_file_dangling(Edje_File *edf)
#endif
Edje_File *
_edje_cache_file_coll_open(const Eina_File *file, const char *coll, int *error_ret, Edje_Part_Collection **edc_ret, Edje *ed EINA_UNUSED)
static inline void
_edje_file_cache_init()
{
Edje_File *edf;
Eina_List *l, *hist;
Edje_Part_Collection *edc;
Edje_Part *ep;
if (!_edje_id_hash)
_edje_id_hash = eina_hash_stringshared_new(NULL);
if (!_edje_file_hash)
{
_edje_file_hash = eina_hash_pointer_new(NULL);
goto find_list;
}
_edje_file_hash = eina_hash_pointer_new(NULL);
}
edf = eina_hash_find(_edje_file_hash, &file);
if (edf)
{
edf->references++;
goto open;
}
static inline Edje_File*
_edje_file_cache_trash_pop(const Eina_File *file)
{
Edje_File *edf;
Eina_List *l;
find_list:
EINA_LIST_FOREACH(_edje_file_cache, l, edf)
{
if (edf->f == file)
@ -494,121 +584,61 @@ find_list:
edf->references = 1;
_edje_file_cache = eina_list_remove_list(_edje_file_cache, l);
eina_hash_direct_add(_edje_file_hash, &edf->f, edf);
goto open;
return edf;
}
}
return NULL;
}
edf = _edje_file_open(file, error_ret, eina_file_mtime_get(file), !!coll);
if (!edf) return NULL;
static inline Edje_File*
_edje_file_cache_find(const Eina_File *file)
{
Edje_File *edf;
// initialize cache.
_edje_file_cache_init();
// serach in the file_hash.
edf = eina_hash_find(_edje_file_hash, &file);
if (edf)
{
edf->references++;
return edf;
}
// search in the trash list
return _edje_file_cache_trash_pop(file);
}
static inline void
_edje_file_cache_add(Edje_File *edf)
{
eina_hash_direct_add(_edje_file_hash, &edf->f, edf);
if (edf->id)
eina_hash_list_append(_edje_id_hash, edf->id, edf);
/* return edf; */
}
Edje_File *
_edje_cache_file_coll_open(const Eina_File *file, const char *coll, int *error_ret, Edje_Part_Collection **edc_ret, Edje *ed EINA_UNUSED)
{
Edje_File *edf;
Edje_Part_Collection *edc;
edf = _edje_file_cache_find(file);
if (!edf)
{
edf = _edje_file_open(file, error_ret, eina_file_mtime_get(file), !!coll);
if (!edf) return NULL;
_edje_file_cache_add(edf);
}
open:
if (!coll)
return edf;
edc = _edje_file_coll_open(edf, coll);
if (!edc)
{
*error_ret = EDJE_LOAD_ERROR_UNKNOWN_COLLECTION;
}
else
{
if (!edc->checked)
{
unsigned int j;
for (j = 0; j < edc->parts_count; ++j)
{
Edje_Part *ep2;
ep = edc->parts[j];
/* Register any color classes in this parts descriptions. */
hist = NULL;
hist = eina_list_append(hist, ep);
ep2 = ep;
while (ep2->dragable.confine_id >= 0)
{
if (ep2->dragable.confine_id >= (int)edc->parts_count)
{
ERR("confine_to above limit. invalidating it.");
ep2->dragable.confine_id = -1;
break;
}
ep2 = edc->parts[ep2->dragable.confine_id];
if (eina_list_data_find(hist, ep2))
{
ERR("confine_to loops. invalidating loop.");
ep2->dragable.confine_id = -1;
break;
}
hist = eina_list_append(hist, ep2);
}
eina_list_free(hist);
hist = NULL;
hist = eina_list_append(hist, ep);
ep2 = ep;
while (ep2->dragable.event_id >= 0)
{
Edje_Part *prev;
if (ep2->dragable.event_id >= (int)edc->parts_count)
{
ERR("event_id above limit. invalidating it.");
ep2->dragable.event_id = -1;
break;
}
prev = ep2;
ep2 = edc->parts[ep2->dragable.event_id];
/* events_to may be used only with dragable */
if (!ep2->dragable.x && !ep2->dragable.y)
{
prev->dragable.event_id = -1;
break;
}
if (eina_list_data_find(hist, ep2))
{
ERR("events_to loops. invalidating loop.");
ep2->dragable.event_id = -1;
break;
}
hist = eina_list_append(hist, ep2);
}
eina_list_free(hist);
hist = NULL;
hist = eina_list_append(hist, ep);
ep2 = ep;
while (ep2->clip_to_id >= 0)
{
if (ep2->clip_to_id >= (int)edc->parts_count)
{
ERR("clip_to_id above limit. invalidating it.");
ep2->clip_to_id = -1;
break;
}
ep2 = edc->parts[ep2->clip_to_id];
if (eina_list_data_find(hist, ep2))
{
ERR("clip_to loops. invalidating loop.");
ep2->clip_to_id = -1;
break;
}
hist = eina_list_append(hist, ep2);
}
eina_list_free(hist);
hist = NULL;
}
edc->checked = 1;
}
}
*error_ret = EDJE_LOAD_ERROR_UNKNOWN_COLLECTION;
if (edc_ret) *edc_ret = edc;

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

@ -95,7 +95,10 @@ EDJE_PART_INVALID_CONST(Efl_Ui_Layout_Orientation, 0, efl_ui_layout_orientation_
EDJE_PART_INVALID(Eina_Bool, 0, efl_pack_table, _efl_canvas_layout_part_invalid_efl_pack_table_pack_table, Efl_Gfx_Entity *subobj, int col, int row, int colspan, int rowspan)
EDJE_PART_INVALID(Efl_Gfx_Entity *, 0, efl_pack_table_content_get, _efl_canvas_layout_part_invalid_efl_pack_table_table_content_get, int col, int row)
EDJE_PART_INVALID(Eina_Iterator *, 0, efl_pack_table_contents_get, _efl_canvas_layout_part_invalid_efl_pack_table_table_contents_get, int col, int row, Eina_Bool below)
EDJE_PART_INVALID_CONST(Eina_Bool, 0, efl_pack_table_position_get, _efl_canvas_layout_part_invalid_efl_pack_table_table_position_get, Efl_Gfx_Entity *subobj, int *col, int *row, int *colspan, int *rowspan)
EDJE_PART_INVALID_CONST(Eina_Bool, 0, efl_pack_table_cell_column_get, _efl_canvas_layout_part_invalid_efl_pack_table_table_cell_column_get, Efl_Gfx_Entity *subobj, int *col, int *colspan)
EDJE_PART_INVALID_VOID(efl_pack_table_cell_column_set, _efl_canvas_layout_part_invalid_efl_pack_table_table_cell_column_set, Efl_Gfx_Entity *subobj, int col, int colspan)
EDJE_PART_INVALID_CONST(Eina_Bool, 0, efl_pack_table_cell_row_get, _efl_canvas_layout_part_invalid_efl_pack_table_table_cell_row_get, Efl_Gfx_Entity *subobj, int *row, int *rowspan)
EDJE_PART_INVALID_VOID(efl_pack_table_cell_row_set, _efl_canvas_layout_part_invalid_efl_pack_table_table_cell_row_set, Efl_Gfx_Entity *subobj, int row, int rowspan)
EDJE_PART_INVALID_VOID_CONST(efl_pack_table_size_get, _efl_canvas_layout_part_invalid_efl_pack_table_table_size_get, int *cols, int *rows)
EDJE_PART_INVALID_CONST(int, 0, efl_pack_table_columns_get, _efl_canvas_layout_part_invalid_efl_pack_table_table_columns_get)
EDJE_PART_INVALID_CONST(int, 0, efl_pack_table_rows_get, _efl_canvas_layout_part_invalid_efl_pack_table_table_rows_get)

40
src/lib/edje/edje_part_table.c
View File

@ -163,21 +163,53 @@ _efl_canvas_layout_part_table_efl_pack_table_table_contents_get(Eo *obj, void *_
}
EOLIAN static Eina_Bool
_efl_canvas_layout_part_table_efl_pack_table_table_position_get(const Eo *obj, void *_pd EINA_UNUSED, Efl_Gfx_Entity * subobj, int *col, int *row, int *colspan, int *rowspan)
_efl_canvas_layout_part_table_efl_pack_table_table_cell_column_get(const Eo *obj, void *_pd EINA_UNUSED, Efl_Gfx_Entity * subobj, int *col, int *colspan)
{
unsigned short c, r, cs, rs;
unsigned short c, cs;
Eina_Bool ret;
PROXY_DATA_GET(obj, pd);
ret = evas_object_table_pack_get(pd->rp->object, subobj, &c, &r, &cs, &rs);
ret = evas_object_table_pack_get(pd->rp->object, subobj, &c, NULL, &cs, NULL);
if (col) *col = c;
if (row) *row = r;
if (colspan) *colspan = cs;
return ret;
}
EOLIAN static void
_efl_canvas_layout_part_table_efl_pack_table_table_cell_column_set(Eo *obj, void *_pd EINA_UNUSED, Efl_Gfx_Entity * subobj, int col, int colspan)
{
unsigned short r, rs;
PROXY_DATA_GET(obj, pd);
evas_object_table_pack_get(pd->rp->object, subobj, NULL, &r, NULL, &rs);
evas_object_table_pack(pd->rp->object, subobj, col, r, colspan, rs);
}
EOLIAN static Eina_Bool
_efl_canvas_layout_part_table_efl_pack_table_table_cell_row_get(const Eo *obj, void *_pd EINA_UNUSED, Efl_Gfx_Entity * subobj, int *row, int *rowspan)
{
unsigned short r, rs;
Eina_Bool ret;
PROXY_DATA_GET(obj, pd);
ret = evas_object_table_pack_get(pd->rp->object, subobj, NULL, &r, NULL, &rs);
if (row) *row = r;
if (rowspan) *rowspan = rs;
return ret;
}
EOLIAN static void
_efl_canvas_layout_part_table_efl_pack_table_table_cell_row_set(Eo *obj, void *_pd EINA_UNUSED, Efl_Gfx_Entity * subobj, int row, int rowspan)
{
unsigned short c, cs;
PROXY_DATA_GET(obj, pd);
evas_object_table_pack_get(pd->rp->object, subobj, &c, NULL, &cs, NULL);
evas_object_table_pack(pd->rp->object, subobj, c, row, cs, rowspan);
}
/* Legacy API implementation */
#ifdef DEGUG

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

@ -2659,7 +2659,7 @@ Eina_Stringshare *_edje_seat_name_get(Edje *ed, Efl_Input_Device *device);
Efl_Input_Device *_edje_seat_get(Edje *ed, Eina_Stringshare *name);
Eina_Bool _edje_part_allowed_seat_find(Edje_Real_Part *rp, const char *seat_name);
const Edje_Signals_Sources_Patterns *_edje_signal_callback_patterns_ref(const Edje_Signal_Callback_Group *gp);
const Edje_Signals_Sources_Patterns *_edje_signal_callback_patterns_ref(Edje_Signal_Callback_Group *gp);
void _edje_signal_callback_patterns_unref(const Edje_Signals_Sources_Patterns *essp);
void _edje_signal_callback_reset(Edje_Signal_Callback_Flags *flags, unsigned int length);

3
src/lib/edje/edje_program.c
View File

@ -1710,7 +1710,8 @@ _edje_emit_cb(Edje *ed, const char *sig, const char *src, Edje_Message_Signal_Da
ed->walking_callbacks++;
ssp = _edje_signal_callback_patterns_ref(ed->callbacks);
ssp = _edje_signal_callback_patterns_ref
((Edje_Signal_Callback_Group *)ed->callbacks);
if (ssp)
{
m = (Edje_Signal_Callback_Matches *)ed->callbacks->matches;

124
src/lib/edje/edje_signal.c
View File

@ -16,18 +16,20 @@ _edje_signal_match_key_cmp(const void *key1, int key1_length EINA_UNUSED, const
const Edje_Signal_Callback_Matches *b = key2;
unsigned int i;
if (a->matches_count != b->matches_count) return a->matches_count - b->matches_count;
#define NOTEQUAL(x) (a->x != b->x)
#define LESSMORE(x) ((a->x > b->x) ? 1 : -1)
if (NOTEQUAL(matches_count)) return LESSMORE(matches_count);
for (i = 0; i < a->matches_count; ++i)
{
if (a->matches[i].signal != b->matches[i].signal) return a->matches[i].signal - b->matches[i].signal;
if (a->matches[i].source != b->matches[i].source) return a->matches[i].source - b->matches[i].source;
if (NOTEQUAL(matches[i].signal)) return LESSMORE(matches[i].signal);
if (NOTEQUAL(matches[i].source)) return LESSMORE(matches[i].source);
// Callback be it legacy or eo, have the same pointer size and so can be just compared like that
if (a->matches[i].legacy != b->matches[i].legacy) return (unsigned char *)a->matches[i].legacy - (unsigned char *)b->matches[i].legacy;
if (a->free_cb && b->free_cb &&
a->free_cb[i] != b->free_cb[i]) return (unsigned char *)a->free_cb[i] - (unsigned char *)b->free_cb[i];
if ((!a->free_cb && b->free_cb) ||
(a->free_cb && !b->free_cb))
return a->free_cb - b->free_cb;
if (NOTEQUAL(matches[i].legacy)) return LESSMORE(matches[i].legacy);
if (a->free_cb && b->free_cb)
{
if (NOTEQUAL(free_cb[i])) return LESSMORE(free_cb[i]);
}
else if (a->free_cb || b->free_cb) return LESSMORE(free_cb);
}
return 0;
}
@ -38,28 +40,24 @@ _edje_signal_match_key_hash(const void *key, int key_length EINA_UNUSED)
const Edje_Signal_Callback_Matches *a = key;
unsigned int hash, i;
hash = eina_hash_int32(&a->matches_count, sizeof (int));
hash = eina_hash_int32(&a->matches_count, sizeof(int));
for (i = 0; i < a->matches_count; ++i)
{
#ifdef EFL64
hash ^= eina_hash_int64((const unsigned long long int *)&a->matches[i].signal, sizeof (char *));
hash ^= eina_hash_int64((const unsigned long long int *)&a->matches[i].source, sizeof (char *));
hash ^= eina_hash_int64((const unsigned long long int *)&a->matches[i].legacy, sizeof (Edje_Signal_Cb));
if (a->free_cb)
hash ^= eina_hash_int64((const unsigned long long int *)&a->free_cb[i], sizeof (Eina_Free_Cb));
# define HASH(x) eina_hash_int64((const unsigned long long int *)&(a->x), sizeof(a->x))
#else
hash ^= eina_hash_int32((const unsigned int *)&a->matches[i].signal, sizeof (char *));
hash ^= eina_hash_int32((const unsigned int *)&a->matches[i].source, sizeof (char *));
// Callback be it legacy or eo, have the same pointer size and so using legacy for hash is enough
hash ^= eina_hash_int32((const unsigned int *)&a->matches[i].legacy, sizeof (Edje_Signal_Cb));
if (a->free_cb)
hash ^= eina_hash_int32((const unsigned int *)&a->free_cb[i], sizeof (Eina_Free_Cb));
# define HASH(x) eina_hash_int32((const unsigned int *)&(a->x), sizeof(a->x))
#endif
hash ^= HASH(matches[i].signal);
hash ^= HASH(matches[i].source);
// Callback be it legacy or eo, have the same pointer size and so using legacy for hash is enough
hash ^= HASH(matches[i].legacy);
if (a->free_cb) hash ^= HASH(free_cb[i]);
}
return hash;
}
static const Edje_Signal_Callback_Matches *
static Edje_Signal_Callback_Matches *
_edje_signal_callback_matches_dup(const Edje_Signal_Callback_Matches *src)
{
Edje_Signal_Callback_Matches *result;
@ -68,12 +66,10 @@ _edje_signal_callback_matches_dup(const Edje_Signal_Callback_Matches *src)
result = calloc(1, sizeof (Edje_Signal_Callback_Matches));
if (!result) return NULL;
result->hashed = EINA_FALSE;
result->matches = malloc
(sizeof(Edje_Signal_Callback_Match) * src->matches_count);
if (!result->matches) goto err;
result->matches_count = src->matches_count;
result->patterns = NULL;
EINA_REFCOUNT_REF(result);
if (src->free_cb)
@ -107,7 +103,6 @@ _edje_callbacks_patterns_clean(Edje_Signal_Callback_Group *gp)
Edje_Signal_Callback_Matches *tmp = (Edje_Signal_Callback_Matches *)gp->matches;
if (!tmp) return;
assert(EINA_REFCOUNT_GET(tmp) == 1);
_edje_signal_callback_patterns_unref(tmp->patterns);
tmp->patterns = NULL;
}
@ -220,6 +215,7 @@ _edje_signal_callback_grow(Edje_Signal_Callback_Group *gp)
m = realloc(tmp->matches, sizeof(Edje_Signal_Callback_Match) * tmp->matches_count);
if (!m) goto err;
tmp->matches = m;
memset(&(tmp->matches[tmp->matches_count - 1]), 0, sizeof(Edje_Signal_Callback_Match));
if (tmp->free_cb)
{
f = realloc(tmp->free_cb, sizeof(Eina_Free_Cb) * tmp->matches_count);
@ -230,9 +226,11 @@ _edje_signal_callback_grow(Edje_Signal_Callback_Group *gp)
cd = realloc(gp->custom_data, sizeof(void *) * tmp->matches_count);
if (!cd) goto err;
gp->custom_data = cd;
gp->custom_data[tmp->matches_count - 1] = NULL;
fl = realloc(gp->flags, sizeof(Edje_Signal_Callback_Flags) * tmp->matches_count);
if (!fl) goto err;
gp->flags = fl;
memset(&(gp->flags[tmp->matches_count - 1]), 0, sizeof(Edje_Signal_Callback_Flags));
return gp;
err:
ERR("Allocation error in rowing signal callback group");
@ -266,7 +264,10 @@ _edje_signal_callback_push(Edje_Signal_Callback_Group *gp,
{
// special case - it's a single ref so make it private
// and move it out of the shared hash to be private
eina_hash_del(signal_match, tmp, tmp);
if (!eina_hash_del(signal_match, tmp, tmp))
{
ERR("Can't del from hash!");
}
tmp->hashed = EINA_FALSE;
}
else
@ -274,7 +275,6 @@ _edje_signal_callback_push(Edje_Signal_Callback_Group *gp,
// already multiple refs to the match - so make a
// private copy of it we can modify
Edje_Signal_Callback_Matches *tmp_dup =
(Edje_Signal_Callback_Matches *)
_edje_signal_callback_matches_dup(tmp);
if (!tmp_dup) return EINA_FALSE;
// unreff tmp but it's > 1 ref so it'll be safe but we're not
@ -285,9 +285,9 @@ _edje_signal_callback_push(Edje_Signal_Callback_Group *gp,
}
gp->matches = tmp = tmp_dup;
}
assert(tmp->hashed == EINA_FALSE);
}
// tmp will not be hashed at this point so no need to del+add from hash
// search an empty spot now
for (i = 0; i < tmp->matches_count; i++)
{
@ -311,7 +311,12 @@ _edje_signal_callback_push(Edje_Signal_Callback_Group *gp,
_edje_callbacks_patterns_init(gp);
}
}
else goto err;
else
{
if (tmp->hashed)
eina_hash_add(signal_match, tmp, tmp);
goto err;
}
return EINA_TRUE;
err:
ERR("Allocation error in pushing callback");
@ -355,19 +360,27 @@ _edje_signal_callback_matches_unref(Edje_Signal_Callback_Matches *m,
EINA_REFCOUNT_UNREF(m)
{
_edje_signal_callback_patterns_unref(m->patterns);
if (m->hashed)
eina_hash_del(signal_match, m, m);
{
if (!eina_hash_del(signal_match, m, m))
{
ERR("Can't del from hash!");
}
}
for (i = 0; i < m->matches_count; ++i)
{
eina_stringshare_del(m->matches[i].signal);
eina_stringshare_del(m->matches[i].source);
m->matches[i].signal = NULL;
m->matches[i].source = NULL;
}
_edje_signal_callback_patterns_unref(m->patterns);
free(m->matches);
free(m->free_cb);
m->hashed = EINA_FALSE;
m->patterns = NULL;
m->matches = NULL;
m->free_cb = NULL;
m->hashed = EINA_FALSE;
free(m);
}
}
@ -431,6 +444,13 @@ _edje_signal_callback_move_last(Edje_Signal_Callback_Group *gp,
m = (Edje_Signal_Callback_Matches *)gp->matches;
if (!m) return;
if (m->hashed)
{
if (!eina_hash_del(signal_match, m, m))
{
ERR("Can't del from hash!");
}
}
for (j = --m->matches_count; j > i; --j)
{
if (!gp->flags[j].delete_me)
@ -439,6 +459,8 @@ _edje_signal_callback_move_last(Edje_Signal_Callback_Group *gp,
memcpy(&m->matches[i], &m->matches[j], sizeof(Edje_Signal_Callback_Match));
gp->flags[i] = gp->flags[j];
gp->custom_data[i] = gp->custom_data[j];
if (m->hashed)
eina_hash_add(signal_match, m, m);
return;
}
else
@ -447,10 +469,12 @@ _edje_signal_callback_move_last(Edje_Signal_Callback_Group *gp,
m->matches_count--;
}
}
if (m->hashed)
eina_hash_add(signal_match, m, m);
}
const Edje_Signals_Sources_Patterns *
_edje_signal_callback_patterns_ref(const Edje_Signal_Callback_Group *gp)
_edje_signal_callback_patterns_ref(Edje_Signal_Callback_Group *gp)
{
const Edje_Signal_Callback_Matches *m;
Edje_Signal_Callback_Matches *tmp;
@ -458,7 +482,7 @@ _edje_signal_callback_patterns_ref(const Edje_Signal_Callback_Group *gp)
tmp = (Edje_Signal_Callback_Matches *)gp->matches;
if (!tmp) return NULL;
if (tmp->hashed) goto got_it;
m = eina_hash_find(signal_match, gp->matches);
m = eina_hash_find(signal_match, tmp);
if (!m)
{
if (!(tmp->patterns && (EINA_REFCOUNT_GET(tmp->patterns) > 1)))
@ -476,19 +500,43 @@ _edje_signal_callback_patterns_ref(const Edje_Signal_Callback_Group *gp)
_edje_signal_callback_patterns_unref(tmp->patterns);
tmp->patterns = NULL;
_edje_callbacks_patterns_init((Edje_Signal_Callback_Group *)gp);
eina_hash_add(signal_match, tmp, tmp);
m = eina_hash_find(signal_match, tmp);
if (m)
{
WRN("Found exact match in signal matches this would conflict with");
goto got_it;
}
// We should be able to use direct_add, but if I do so valgrind stack explode and
// it bagain to be a pain to debug efl apps. I can't understand what is going on.
// eina_hash_direct_add(signal_match, tmp, tmp);
eina_hash_add(signal_match, tmp, tmp);
tmp->hashed = EINA_TRUE;
}
else
{
if (m == tmp)
{
ERR("Should not happen - gp->match == hash found match");
abort();
return NULL;
WRN("Should not happen - gp->match == hash found match");
goto got_it;
}
if (tmp->matches_count != m->matches_count)
{
unsigned int i, smaller, larger;
void **cd;
Edje_Signal_Callback_Flags *fl;
ERR("Match replacement match count don't match");
smaller = tmp->matches_count;
larger = m->matches_count;
if (larger > smaller)
{
cd = realloc(gp->custom_data, sizeof(void *) * larger);
for (i = smaller; i < larger; i++) cd[i] = NULL;
gp->custom_data = cd;
fl = realloc(gp->flags, sizeof(Edje_Signal_Callback_Flags) * larger);
for (i = smaller; i < larger; i++) memset(&(fl[i]), 0, sizeof(Edje_Signal_Callback_Flags));
gp->flags = fl;
}
}
_edje_signal_callback_matches_unref
((Edje_Signal_Callback_Matches *)tmp, gp->flags, gp->custom_data);

94
src/lib/edje/edje_textblock_styles.c
View File

@ -219,7 +219,11 @@ _edje_textblock_style_update(Edje *ed, Edje_Style *stl, Eina_Bool force)
eina_strbuf_free(txt);
}
/* Update all evas_styles which are in an edje
/*
* mark all the styles in the Edje_File dirty (except readonly styles)so that
* subsequent request to style will update before giving the style.
* Note: this will enable lazy style computation (only when some
* widget request for new style it will get computed).
*
* @param ed The edje containing styles which need to be updated
*/
@ -232,7 +236,7 @@ _edje_textblock_style_all_update(Edje *ed)
if (!ed->file) return;
EINA_LIST_FOREACH(ed->file->styles, l, stl)
_edje_textblock_style_update(ed, stl, EINA_FALSE);
if (stl && !stl->readonly) stl->cache = EINA_FALSE;
}
static inline Edje_Style *
@ -254,14 +258,57 @@ _edje_textblock_style_member_add(Edje *ed, Edje_Style *stl)
EINA_LIST_FOREACH(stl->tags, l, tag)
{
if (tag->text_class)
{
efl_observable_observer_add(_edje_text_class_member, tag->text_class, ed->obj);
/* Newly added text_class member should be updated
according to the latest text_class's status. */
_edje_textblock_style_update(ed, stl, EINA_TRUE);
}
efl_observable_observer_add(_edje_text_class_member, tag->text_class, ed->obj);
}
/* Newly added text_class member should be updated
according to the latest text_class's status. */
_edje_textblock_style_update(ed, stl, EINA_TRUE);
}
static inline void
_edje_textblock_style_observer_add(Edje_Style *stl, Efl_Observer* observer)
{
Eina_List* l;
Edje_Style_Tag *tag;
EINA_LIST_FOREACH(stl->tags, l, tag)
{
if (tag->text_class)
efl_observable_observer_add(_edje_text_class_member, tag->text_class, observer);
}
}
static inline void
_edje_textblock_style_observer_del(Edje_Style *stl, Efl_Observer* observer)
{
Eina_List* l;
Edje_Style_Tag *tag;
EINA_LIST_FOREACH(stl->tags, l, tag)
{
if (tag->text_class)
efl_observable_observer_del(_edje_text_class_member, tag->text_class, observer);
}
}
static inline void
_edje_textblock_style_add(Edje *ed, Edje_Style *stl)
{
if (!stl) return;
if (stl->readonly) return;
_edje_textblock_style_observer_add(stl, ed->obj);
_edje_textblock_style_update(ed, stl, EINA_TRUE);
}
static inline void
_edje_textblock_style_del(Edje *ed, Edje_Style *stl)
{
if (!stl) return;
_edje_textblock_style_observer_del(stl, ed->obj);
}
void
@ -280,7 +327,8 @@ _edje_textblock_styles_add(Edje *ed, Edje_Real_Part *ep)
desc = (Edje_Part_Description_Text *)pt->default_desc;
style = edje_string_get(&desc->text.style);
stl = _edje_textblock_style_search(ed, style);
_edje_textblock_style_member_add(ed, stl);
_edje_textblock_style_add(ed, stl);
/* If any other classes exist add them */
for (i = 0; i < pt->other.desc_count; ++i)
@ -288,7 +336,8 @@ _edje_textblock_styles_add(Edje *ed, Edje_Real_Part *ep)
desc = (Edje_Part_Description_Text *)pt->other.desc[i];
style = edje_string_get(&desc->text.style);
stl = _edje_textblock_style_search(ed, style);
_edje_textblock_style_member_add(ed, stl);
_edje_textblock_style_add(ed, stl);
}
}
@ -307,34 +356,15 @@ _edje_textblock_styles_del(Edje *ed, Edje_Part *pt)
stl = _edje_textblock_style_search(ed, style);
if (stl)
{
Edje_Style_Tag *tag;
Eina_List *l;
EINA_LIST_FOREACH(stl->tags, l, tag)
{
if (tag->text_class)
efl_observable_observer_del(_edje_text_class_member, tag->text_class, ed->obj);
}
}
_edje_textblock_style_del(ed, stl);
for (i = 0; i < pt->other.desc_count; ++i)
{
desc = (Edje_Part_Description_Text *)pt->other.desc[i];
style = edje_string_get(&desc->text.style);
stl = _edje_textblock_style_search(ed, style);
if (stl)
{
Edje_Style_Tag *tag;
Eina_List *l;
EINA_LIST_FOREACH(stl->tags, l, tag)
{
if (tag->text_class)
efl_observable_observer_del(_edje_text_class_member, tag->text_class, ed->obj);
}
}
_edje_textblock_style_del(ed, stl);
}
}

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

@ -63,7 +63,8 @@ class @beta Efl.Canvas.Layout_Part_Invalid extends Efl.Canvas.Layout_Part implem
Efl.Pack_Table.pack_table;
Efl.Pack_Table.table_content_get;
Efl.Pack_Table.table_contents_get;
Efl.Pack_Table.table_position { get; }
Efl.Pack_Table.table_cell_column { get; set; }
Efl.Pack_Table.table_cell_row { get; set; }
Efl.Pack_Table.table_size { get; }
Efl.Pack_Table.table_columns { get; }
Efl.Pack_Table.table_rows { get; }

3
src/lib/edje/efl_canvas_layout_part_table.eo
View File

@ -15,7 +15,8 @@ class @beta Efl.Canvas.Layout_Part_Table extends Efl.Canvas.Layout_Part implemen
Efl.Pack_Table.pack_table;
Efl.Pack_Table.table_content_get;
Efl.Pack_Table.table_contents_get;
Efl.Pack_Table.table_position { get; }
Efl.Pack_Table.table_cell_column { get; set; }
Efl.Pack_Table.table_cell_row { get; set; }
Efl.Pack_Table.table_size { get; }
Efl.Pack_Table.table_columns { get; }
Efl.Pack_Table.table_rows { get; }

43
src/lib/efl/interfaces/efl_gfx_image.eo
View File

@ -21,23 +21,30 @@ enum @beta Efl.Gfx.Image_Scale_Hint
enum @beta Efl.Gfx.Image_Scale_Type
{
[[Enumeration that defines scale types of an image.]]
none, [[Use the image's natural size.]]
fill, [[Scale the image so that it matches
the object's area exactly.
The image's aspect ratio might be changed.]]
fit_inside, [[Scale the image
so that it fits inside the object's area
fit, [[Scale the image
so that it fits completely inside the object's area
while maintaining the aspect ratio.
At least one of the dimensions of the image
should be equal to the corresponding dimension
will be equal to the corresponding dimension
of the object.]]
fit_outside, [[Scale the image
so that it covers the entire object area
fit_width, [[Scale the image
so that it covers the entire object area horizontally
while maintaining the aspect ratio.
At least one of the dimensions of the image
should be equal to the corresponding
dimension of the object.]]
The image may become taller than the object.]]
fit_height, [[Scale the image
so that it covers the entire object area vertically
while maintaining the aspect ratio.
The image may become wider than the object.]]
expand, [[Scale the image
so that it covers the entire object area on one axis
while maintaining the aspect ratio, preferring whichever
axis is largest.
The image may become larger than the object.]]
tile, [[Tile image at its original size.]]
none [[Not scale the image]]
}
struct Efl.Gfx.Image_Stretch_Region
@ -78,6 +85,24 @@ interface @beta Efl.Gfx.Image
scale_type: Efl.Gfx.Image_Scale_Type; [[Image scale type]]
}
}
@property can_upscale {
[[If $true, the image may be scaled to a larger size. If $false,
the image will never be resized larger than its native size.
This is set to $true by default.
]]
values {
upscale: bool; [[Allow image upscaling]]
}
}
@property can_downscale {
[[If $true, the image may be scaled to a smaller size. If $false,
the image will never be resized smaller than its native size.
This is set to $true by default.
]]
values {
downscale: bool; [[Allow image downscaling]]
}
}
@property ratio {
[[The native width/height ratio of the image.]]
get {

17
src/lib/efl/interfaces/efl_pack_table.eo
View File

@ -40,16 +40,27 @@ interface @beta Efl.Pack_Table extends Efl.Pack
@in row: int; [[Row number]]
}
}
@property table_position {
[[Position and span of the $subobj in this container, may be modified to move the $subobj]]
@property table_cell_column {
[[column of the $subobj in this container.]]
set {}
get { return: bool; [[Returns false if item is not a child]] }
keys {
subobj: Efl.Gfx.Entity; [[Child object]]
}
values {
col: int; [[Column number]]
row: int; [[Row number]]
colspan: int; [[Column span]]
}
}
@property table_cell_row {
[[row of the $subobj in this container.]]
set {}
get { return: bool; [[Returns false if item is not a child]] }
keys {
subobj: Efl.Gfx.Entity; [[Child object]]
}
values {
row: int; [[Row number]]
rowspan: int; [[Row span]]
}
}

19
src/lib/efl/interfaces/efl_ui_scrollbar.eo
View File

@ -1,3 +1,5 @@
import efl_ui_layout_orientable;
enum @beta Efl.Ui.Scrollbar_Mode
{
[[When should the scrollbar be shown.]]
@ -7,13 +9,6 @@ enum @beta Efl.Ui.Scrollbar_Mode
last [[For internal use only]]
}
enum @beta Efl.Ui.Scrollbar_Direction
{
[[What kind of scrollbar is this.]]
horizontal = 0, [[Goes along the X axis.]]
vertical, [[Goes along the Y axis.]]
last [[For internal use only]]
}
interface @beta Efl.Ui.Scrollbar
{
[[Interface used by widgets which can display scrollbars, enabling them to contain more content
@ -63,12 +58,12 @@ interface @beta Efl.Ui.Scrollbar
}
}
events {
bar,press: Efl.Ui.Scrollbar_Direction; [[Called when bar is pressed.]]
bar,unpress: Efl.Ui.Scrollbar_Direction; [[Called when bar is unpressed.]]
bar,drag: Efl.Ui.Scrollbar_Direction; [[Called when bar is dragged.]]
bar,press: Efl.Ui.Layout_Orientation; [[Called when bar is pressed.]]
bar,unpress: Efl.Ui.Layout_Orientation; [[Called when bar is unpressed.]]
bar,drag: Efl.Ui.Layout_Orientation; [[Called when bar is dragged.]]
bar,size,changed: void; [[Called when bar size is changed.]]
bar,pos,changed: void; [[Called when bar position is changed.]]
bar,show: Efl.Ui.Scrollbar_Direction; [[Callend when bar is shown.]]
bar,hide: Efl.Ui.Scrollbar_Direction; [[Called when bar is hidden.]]
bar,show: Efl.Ui.Layout_Orientation; [[Callend when bar is shown.]]
bar,hide: Efl.Ui.Layout_Orientation; [[Called when bar is hidden.]]
}
}

23
src/lib/efreet/efreet_cache.c
View File

@ -115,19 +115,36 @@ static void
_ipc_launch(void)
{
char buf[PATH_MAX];
int num = 0;
int num;
int try_gap = 10000; // 10ms
int tries = 200; // 200 * 10ms == 2sec
const char *s;
s = getenv("EFREETD_CONNECT_TRIES");
if (s)
{
num = atoi(s);
if (num >= 0) tries = num;
}
s = getenv("EFREETD_CONNECT_TRY_GAP");
if (s)
{
num = atoi(s);
if (num >= 0) try_gap = num;
}
if (run_in_tree)
bs_binary_get(buf, sizeof(buf), "efreet", "efreetd");
else
snprintf(buf, sizeof(buf), PACKAGE_BIN_DIR "/efreetd");
ecore_exe_run(buf, NULL);
while ((!ipc) && (num < 200))
num = 0;
while ((!ipc) && (num < tries))
{
num++;
usleep(10000);
usleep(try_gap);
ipc = ecore_ipc_server_connect(ECORE_IPC_LOCAL_USER, "efreetd", 0, NULL);
}
if (!ipc) ERR("Timeout in trying to start and then connect to efrteed");
}
static Eina_Bool

17
src/lib/eina/eina_array.h
View File

@ -411,6 +411,23 @@ static inline unsigned int eina_array_count_get(const Eina_Array *array) EINA_AR
*/
static inline unsigned int eina_array_count(const Eina_Array *array) EINA_ARG_NONNULL(1) EINA_WARN_UNUSED_RESULT;
/**
* @brief Search for the given data in an array.
*
* @param[in] array The array.
* @param[in] data need to be found.
* @param[out] out_idx The position of the data in the array if found.
* @return EINA_TRUE if found otherwise returns EINA_FALSE.
*
* This function searches for the data pointer @p data inside @p array, returning @c EINA_TRUE if found.
* The exact position where the pointer is found can be retrieved through @p out_idx.
* Please note that only the pointer is compared, not the actual data pointed by it.
*
* @since 1.23
*/
static inline Eina_Bool eina_array_find(const Eina_Array *array,
const void *data,
unsigned int *out_idx) EINA_ARG_NONNULL(1) EINA_WARN_UNUSED_RESULT;
/**
* @brief Gets a new iterator associated with an array.
*

18
src/lib/eina/eina_inline_array.x
View File

@ -92,6 +92,24 @@ eina_array_count(const Eina_Array *array)
return array->count;
}
static inline Eina_Bool
eina_array_find(const Eina_Array *array, const void *data, unsigned int *out_idx)
{
if (!array) return EINA_FALSE;
unsigned int i = 0;
for (; i < array->count; i++)
{
if (array->data[i] == data)
{
if (out_idx) *out_idx = i;
return EINA_TRUE;
}
}
return EINA_FALSE;
}
static inline Eina_Bool
eina_array_foreach(Eina_Array *array, Eina_Each_Cb cb, void *fdata)
{

1
src/lib/eina/eina_list.c
View File

@ -959,6 +959,7 @@ eina_list_move_list(Eina_List **to, Eina_List **from, Eina_List *data)
{
EINA_SAFETY_ON_NULL_RETURN_VAL(to, EINA_FALSE);
EINA_SAFETY_ON_NULL_RETURN_VAL(from, EINA_FALSE);
EINA_SAFETY_ON_NULL_RETURN_VAL(data, EINA_FALSE);
#ifdef EINA_LIST_MAGIC
if (*to) EINA_MAGIC_CHECK_LIST(*to, EINA_FALSE);

1
src/lib/eina/eina_vpath.c
View File

@ -327,6 +327,7 @@ EAPI char *
eina_vpath_resolve(const char* path)
{
char buf[PATH_MAX];
EINA_SAFETY_ON_NULL_RETURN_VAL(path, NULL);
if (_eina_vpath_resolve(path, buf, sizeof(buf)) > 0)
return strdup(buf);

43
src/lib/eio/efl_io_model.c
View File

@ -154,37 +154,25 @@ _efl_model_evt_added_ecore_cb(void *data, int type, void *event)
return EINA_TRUE;
}
static Eina_Bool
_efl_model_evt_deleted_ecore_cb(void *data, int type, void *event)
static void
_model_child_remove(Efl_Io_Model_Data *pd, Eina_Stringshare *path)
{
Efl_Io_Model_Info *mi;
Eina_List *l;
Eio_Monitor_Event *ev = event;
Efl_Io_Model *obj;
Efl_Io_Model_Data *pd = data;
Eina_Stringshare *spath = NULL;
Efl_Io_Model *obj = pd->self;
Efl_Model_Children_Event cevt = { 0 };
unsigned int i = 0;
if (type != EIO_MONITOR_DIRECTORY_DELETED && type != EIO_MONITOR_FILE_DELETED)
return EINA_TRUE;
if (ev->monitor != pd->monitor) return EINA_TRUE;
obj = pd->self;
spath = eina_stringshare_add(ev->filename);
// FIXME: Linear search is pretty slow
EINA_LIST_FOREACH(pd->files, l, mi)
{
if (mi->path == spath)
if (mi->path == path)
break ;
++i;
}
if (i >= eina_list_count(pd->files))
goto end;
return;
cevt.index = i;
cevt.child = mi->object;
@ -197,8 +185,22 @@ _efl_model_evt_deleted_ecore_cb(void *data, int type, void *event)
// This will only trigger the data destruction if no object is referencing them.
_efl_io_model_info_free(mi, EINA_FALSE);
}
end:
static Eina_Bool
_efl_model_evt_deleted_ecore_cb(void *data, int type, void *event)
{
Eio_Monitor_Event *ev = event;
Efl_Io_Model_Data *pd = data;
Eina_Stringshare *spath = NULL;
if (type != EIO_MONITOR_DIRECTORY_DELETED && type != EIO_MONITOR_FILE_DELETED)
return EINA_TRUE;
if (ev->monitor != pd->monitor) return EINA_TRUE;
spath = eina_stringshare_add(ev->filename);
_model_child_remove(pd, spath);
eina_stringshare_del(spath);
return EINA_TRUE;
@ -221,7 +223,12 @@ static void
_eio_done_unlink_cb(void *data, Eio_File *handler EINA_UNUSED)
{
Efl_Io_Model *child = data;
Efl_Io_Model_Data *child_pd, *pd;
child_pd = efl_data_scope_get(child, MY_CLASS);
pd = efl_data_scope_get(efl_parent_get(child), MY_CLASS);
_model_child_remove(pd, child_pd->path);
_eio_del_cleanup(child);
}

16
src/lib/eio/eio_monitor_poll.c
View File

@ -39,6 +39,7 @@ struct _Eio_Monitor_Stat
struct _Eio_Monitor_Backend
{
Eio_Monitor *parent;
Eina_Stringshare *path;
Eina_Stat self;
Eina_Hash *children;
@ -74,17 +75,14 @@ _eio_monitor_fallback_heavy_cb(void *data, Ecore_Thread *thread)
else
est = alloca(sizeof (Eina_Stat));
if (!backend->parent)
return;
if (_eio_stat(backend->parent->path, &st))
if (_eio_stat(backend->path, &st))
{
if (backend->initialised && !backend->destroyed)
{
ecore_thread_main_loop_begin();
deleted = backend->delete_me;
if (!deleted)
_eio_monitor_send(backend->parent, backend->parent->path, EIO_MONITOR_SELF_DELETED);
_eio_monitor_send(backend->parent, backend->path, EIO_MONITOR_SELF_DELETED);
ecore_thread_main_loop_end();
backend->destroyed = EINA_TRUE;
}
@ -137,12 +135,12 @@ _eio_monitor_fallback_heavy_cb(void *data, Ecore_Thread *thread)
ecore_thread_main_loop_begin();
deleted = backend->delete_me;
if (!deleted)
_eio_monitor_send(backend->parent, backend->parent->path, event);
_eio_monitor_send(backend->parent, backend->path, event);
ecore_thread_main_loop_end();
if (deleted) return;
}
it = eina_file_direct_ls(backend->parent->path);
it = eina_file_direct_ls(backend->path);
EINA_ITERATOR_FOREACH(it, info)
{
Eio_Monitor_Stat *cmp;
@ -344,6 +342,7 @@ eio_monitor_fallback_add(Eio_Monitor *monitor)
backend->children = eina_hash_string_superfast_new(free);
backend->parent = monitor;
backend->path = eina_stringshare_ref(monitor->path);
monitor->backend = backend;
monitor->fallback = EINA_TRUE;
@ -370,6 +369,7 @@ eio_monitor_fallback_del(Eio_Monitor *monitor)
if (backend->timer) ecore_timer_del(backend->timer);
eina_hash_set(timer_hash, &backend, NULL);
backend->timer = NULL;
backend->parent = NULL;
if (backend->work)
{
@ -377,7 +377,7 @@ eio_monitor_fallback_del(Eio_Monitor *monitor)
return;
}
backend->parent = NULL;
eina_stringshare_del(backend->path);
eina_hash_free(backend->children);
free(backend);
}

3
src/lib/elementary/Efl_Ui.h
View File

@ -172,6 +172,7 @@ EAPI void efl_ui_focus_relation_free(Efl_Ui_Focus_Relations *rel);
# include <efl_ui_theme.eo.h>
# include <efl_config_global.eo.h>
# include <efl_ui_widget.eo.h>
# include <efl_ui_widget_scrollable_content.eo.h>
# include <efl_ui_widget_common.h>
# include <efl_ui_widget_part.eo.h>
# include <efl_ui_layout_base.eo.h>
@ -268,8 +269,6 @@ typedef Eo Efl_Ui_Spotlight_Indicator;
# include <efl_ui_multi_selectable.eo.h>
# include <efl_ui_popup.eo.h>
# include <efl_ui_alert_popup.eo.h>
# include <efl_ui_scroll_alert_popup.eo.h>
# include <efl_ui_text_alert_popup.eo.h>
# include <efl_ui_popup_part_backwall.eo.h>
# include <efl_ui_grid.eo.h>
# include <efl_ui_list.eo.h>

2
src/lib/elementary/Elementary.h
View File

@ -311,8 +311,6 @@ typedef Eo Efl_Ui_Focus_Manager;
# include <efl_ui_text.eo.h>
# include <efl_ui_popup.eo.h>
# include <efl_ui_alert_popup.eo.h>
# include <efl_ui_scroll_alert_popup.eo.h>
# include <efl_ui_text_alert_popup.eo.h>
# include <efl_ui_popup_part_backwall.eo.h>
# include <efl_ui_text_factory_images.eo.h>
# include <efl_ui_text_factory_emoticons.eo.h>

12
src/lib/elementary/efl_ui_bg.c
View File

@ -44,7 +44,7 @@ _efl_ui_bg_efl_object_constructor(Eo *obj, Efl_Ui_Bg_Data *pd)
efl_content_set(efl_part(obj, "elm.swallow.rectangle"), efl_added));
pd->img = efl_add(EFL_UI_IMAGE_CLASS, obj,
efl_gfx_image_scale_type_set(efl_added, EFL_GFX_IMAGE_SCALE_TYPE_FIT_OUTSIDE),
efl_gfx_image_scale_type_set(efl_added, EFL_GFX_IMAGE_SCALE_TYPE_EXPAND),
efl_content_set(efl_part(obj, "elm.swallow.background"), efl_added));
}
else
@ -54,7 +54,7 @@ _efl_ui_bg_efl_object_constructor(Eo *obj, Efl_Ui_Bg_Data *pd)
efl_content_set(efl_part(obj, "efl.rectangle"), efl_added));
pd->img = efl_add(EFL_UI_IMAGE_CLASS, obj,
efl_gfx_image_scale_type_set(efl_added, EFL_GFX_IMAGE_SCALE_TYPE_FIT_OUTSIDE),
efl_gfx_image_scale_type_set(efl_added, EFL_GFX_IMAGE_SCALE_TYPE_EXPAND),
efl_content_set(efl_part(obj, "efl.background"), efl_added));
}
pd->file = NULL;
@ -87,7 +87,7 @@ elm_bg_option_set(Evas_Object *obj, Elm_Bg_Option option)
type = EFL_GFX_IMAGE_SCALE_TYPE_NONE;
break;
case ELM_BG_OPTION_SCALE:
type = EFL_GFX_IMAGE_SCALE_TYPE_FIT_OUTSIDE;
type = EFL_GFX_IMAGE_SCALE_TYPE_EXPAND;
break;
case ELM_BG_OPTION_TILE:
type = EFL_GFX_IMAGE_SCALE_TYPE_TILE;
@ -97,7 +97,7 @@ elm_bg_option_set(Evas_Object *obj, Elm_Bg_Option option)
break;
case ELM_BG_OPTION_LAST:
default:
type = EFL_GFX_IMAGE_SCALE_TYPE_FIT_OUTSIDE;
type = EFL_GFX_IMAGE_SCALE_TYPE_EXPAND;
}
efl_gfx_image_scale_type_set(obj, type);
}
@ -114,7 +114,7 @@ elm_bg_option_get(const Evas_Object *obj)
case EFL_GFX_IMAGE_SCALE_TYPE_NONE:
option = ELM_BG_OPTION_CENTER;
break;
case EFL_GFX_IMAGE_SCALE_TYPE_FIT_OUTSIDE:
case EFL_GFX_IMAGE_SCALE_TYPE_EXPAND:
option = ELM_BG_OPTION_SCALE;
break;
case EFL_GFX_IMAGE_SCALE_TYPE_TILE:
@ -123,7 +123,7 @@ elm_bg_option_get(const Evas_Object *obj)
case EFL_GFX_IMAGE_SCALE_TYPE_FILL:
option = ELM_BG_OPTION_STRETCH;
break;
case EFL_GFX_IMAGE_SCALE_TYPE_FIT_INSIDE:
case EFL_GFX_IMAGE_SCALE_TYPE_FIT:
default:
ERR("Scale type %d cannot be converted to Elm_Bg_Option", type);
break;

165
src/lib/elementary/efl_ui_collection.c
View File

@ -132,10 +132,12 @@ typedef struct {
Efl_Ui_Pan *pan;
Eina_List *selected;
Eina_List *items;
Efl_Ui_Selection *fallback;
Efl_Ui_Select_Mode mode;
Efl_Ui_Layout_Orientation dir;
Eina_Size2D content_min_size;
Efl_Ui_Position_Manager_Entity *pos_man;
Eina_Future *selection_changed_job;
struct {
Eina_Bool w;
Eina_Bool h;
@ -418,6 +420,8 @@ _efl_ui_collection_efl_object_invalidate(Eo *obj, Efl_Ui_Collection_Data *pd EIN
{
efl_ui_collection_position_manager_set(obj, NULL);
efl_ui_single_selectable_fallback_selection_set(obj, NULL);
deselect_all(pd);
while(pd->items)
@ -492,27 +496,78 @@ _efl_ui_collection_efl_ui_multi_selectable_select_mode_get(const Eo *obj EINA_UN
return pd->mode;
}
static Eina_Value
_schedule_selection_job_cb(Eo *o, void *data EINA_UNUSED, const Eina_Value value EINA_UNUSED)
{
MY_DATA_GET(o, pd);
pd->selection_changed_job = NULL;
efl_event_callback_call(o, EFL_UI_SINGLE_SELECTABLE_EVENT_SELECTION_CHANGED, NULL);
return EINA_VALUE_EMPTY;
}
static void
_schedule_selection_changed(Eo *obj, Efl_Ui_Collection_Data *pd)
{
Eina_Future *f;
if (pd->selection_changed_job) return;
f = efl_loop_job(efl_main_loop_get());
pd->selection_changed_job = efl_future_then(obj, f, _schedule_selection_job_cb);
}
static void
_apply_fallback(Eo *obj EINA_UNUSED, Efl_Ui_Collection_Data *pd)
{
if (pd->fallback && !pd->selected)
{
efl_ui_selectable_selected_set(pd->fallback, EINA_TRUE);
}
}
static inline void
_single_selection_behaviour(Eo *obj EINA_UNUSED, Efl_Ui_Collection_Data *pd, Efl_Ui_Selectable *new_selection)
{
//we might get the situation that the item is already in the list and selected again, so just free the list, it will be rebuild below
if (eina_list_data_get(pd->selected) == new_selection)
{
pd->selected = eina_list_free(pd->selected);
}
else
{
deselect_all(pd);
}
}
static void
_selection_changed(void *data, const Efl_Event *ev)
{
Eina_Bool selection = *((Eina_Bool*) ev->info);
Eo *obj = data;
MY_DATA_GET(obj, pd);
Efl_Ui_Selection *fallback;
//if this is the highest call in the tree of selection changes, safe the fallback and apply it later
//this way we ensure that we are not accidently adding fallback even if we just want to have a empty selection list
fallback = pd->fallback;
pd->fallback = NULL;
if (selection)
{
if (pd->mode == EFL_UI_SELECT_MODE_SINGLE_ALWAYS || pd->mode == EFL_UI_SELECT_MODE_SINGLE)
{
//we might get the situation that the item is already in the list and selected again, so just free the list, it will be rebuild below
if (eina_list_data_get(pd->selected) == ev->object)
{
pd->selected = eina_list_free(pd->selected);
}
else
{
deselect_all(pd);
}
_single_selection_behaviour(obj, pd, ev->object);
}
else if (pd->mode == EFL_UI_SELECT_MODE_MULTI && _elm_config->desktop_entry)
{
const Evas_Modifier *mod = evas_key_modifier_get(evas_object_evas_get(ev->object));
if (!(efl_input_clickable_interaction_get(ev->object)
&& evas_key_modifier_is_set(mod, "Control")))
_single_selection_behaviour(obj, pd, ev->object);
}
else if (pd->mode == EFL_UI_SELECT_MODE_NONE)
{
@ -520,13 +575,15 @@ _selection_changed(void *data, const Efl_Event *ev)
return;
}
pd->selected = eina_list_append(pd->selected, ev->object);
efl_event_callback_call(obj, EFL_UI_EVENT_ITEM_SELECTED, ev->object);
}
else
{
pd->selected = eina_list_remove(pd->selected, ev->object);
efl_event_callback_call(obj, EFL_UI_EVENT_ITEM_UNSELECTED, ev->object);
}
pd->fallback = fallback;
_apply_fallback(obj, pd);
_schedule_selection_changed(obj, pd);
}
static void
@ -940,6 +997,89 @@ _efl_ui_collection_efl_ui_focus_manager_move(Eo *obj, Efl_Ui_Collection_Data *pd
return new_obj;
}
static void
_selectable_range_apply(Eina_List *start, Eina_Bool flag)
{
Efl_Ui_Selectable *sel;
Eina_List *n;
EINA_LIST_FOREACH(start, n, sel)
{
efl_ui_selectable_selected_set(sel, flag);
}
}
EOLIAN static void
_efl_ui_collection_efl_ui_multi_selectable_select_all(Eo *obj EINA_UNUSED, Efl_Ui_Collection_Data *pd)
{
_selectable_range_apply(pd->items, EINA_TRUE);
}
EOLIAN static void
_efl_ui_collection_efl_ui_multi_selectable_unselect_all(Eo *obj EINA_UNUSED, Efl_Ui_Collection_Data *pd)
{
_selectable_range_apply(pd->items, EINA_FALSE);
}
static void
_range_selection_find(Eo *obj, Efl_Ui_Collection_Data *pd, Efl_Ui_Selectable *a, Efl_Ui_Selectable *b, Eina_Bool flag)
{
Eina_List *n;
Efl_Ui_Selectable *c;
Eina_List *start = NULL, *end = NULL;
EINA_SAFETY_ON_FALSE_RETURN(efl_ui_widget_parent_get(a) == obj);
EINA_SAFETY_ON_FALSE_RETURN(efl_ui_widget_parent_get(b) == obj);
EINA_LIST_FOREACH(pd->items, n, c)
{
if (!start)
{
if (c == a)
start = n;
else if (c == b)
start = n;
}
else if (!end)
{
if (c == a)
end = n;
else if (c == b)
end = n;
}
/* if we have found the first element, start applying the flag */
if (start)
efl_ui_selectable_selected_set(c, flag);
if (end)
break;
}
}
EOLIAN static void
_efl_ui_collection_efl_ui_multi_selectable_select_range(Eo *obj, Efl_Ui_Collection_Data *pd, Efl_Ui_Selectable *a, Efl_Ui_Selectable *b)
{
_range_selection_find(obj, pd, a, b, EINA_TRUE);
}
EOLIAN static void
_efl_ui_collection_efl_ui_multi_selectable_unselect_range(Eo *obj, Efl_Ui_Collection_Data *pd, Efl_Ui_Selectable *a, Efl_Ui_Selectable *b)
{
_range_selection_find(obj, pd, a, b, EINA_FALSE);
}
EOLIAN static void
_efl_ui_collection_efl_ui_single_selectable_fallback_selection_set(Eo *obj EINA_UNUSED, Efl_Ui_Collection_Data *pd, Efl_Ui_Selectable *fallback)
{
pd->fallback = fallback;
_apply_fallback(obj, pd);
}
EOLIAN static Efl_Ui_Selectable*
_efl_ui_collection_efl_ui_single_selectable_fallback_selection_get(const Eo *obj EINA_UNUSED, Efl_Ui_Collection_Data *pd)
{
return pd->fallback;
}
#include "efl_ui_collection.eo.c"
#define ITEM_IS_OUTSIDE_VISIBLE(id) id < collection_pd->start_id || id > collection_pd->end_id
@ -1020,4 +1160,5 @@ _efl_ui_collection_focus_manager_efl_ui_focus_manager_manager_focus_set(Eo *obj,
efl_ui_focus_manager_focus_set(efl_super(obj, EFL_UI_COLLECTION_FOCUS_MANAGER_CLASS), focus);
}
#include "efl_ui_collection_focus_manager.eo.c"

6
src/lib/elementary/efl_ui_collection.eo
View File

@ -3,7 +3,6 @@ class @beta Efl.Ui.Collection extends Efl.Ui.Layout_Base implements
Efl.Ui.Scrollbar,
Efl.Pack_Linear, Efl.Pack_Layout,
Efl.Ui.Layout_Orientable,
Efl.Ui.Container_Selectable,
Efl.Ui.Multi_Selectable,
Efl.Ui.Focus.Manager_Sub,
Efl.Ui.Widget_Focus_Manager
@ -67,6 +66,11 @@ class @beta Efl.Ui.Collection extends Efl.Ui.Layout_Base implements
Efl.Ui.Single_Selectable.last_selected { get; }
Efl.Ui.Multi_Selectable.selected_items_get;
Efl.Ui.Multi_Selectable.select_mode {get; set;}
Efl.Ui.Multi_Selectable.select_all;
Efl.Ui.Multi_Selectable.unselect_all;
Efl.Ui.Multi_Selectable.select_range;
Efl.Ui.Multi_Selectable.unselect_range;
Efl.Ui.Single_Selectable.fallback_selection {get; set;}
}
events {
item,pressed : Efl.Ui.Item; [[A $press event occurred over an item.]]

6
src/lib/elementary/efl_ui_datepicker.c
View File

@ -162,21 +162,21 @@ _fields_init(Eo *obj)
pd->year = efl_add(EFL_UI_SPIN_BUTTON_CLASS, obj,
efl_ui_range_limits_set(efl_added, 1900, 2037),
efl_ui_spin_button_wraparound_set(efl_added, EINA_TRUE),
efl_ui_spin_button_editable_set(efl_added, EINA_TRUE),
efl_ui_spin_button_direct_text_input_set(efl_added, EINA_TRUE),
efl_ui_layout_orientation_set(efl_added, EFL_UI_LAYOUT_ORIENTATION_VERTICAL),
efl_event_callback_add(efl_added, EFL_UI_RANGE_EVENT_CHANGED,_field_changed_cb, obj));
pd->month = efl_add(EFL_UI_SPIN_BUTTON_CLASS, obj,
efl_ui_range_limits_set(efl_added, 1, 12),
efl_ui_spin_button_wraparound_set(efl_added, EINA_TRUE),
efl_ui_spin_button_editable_set(efl_added, EINA_TRUE),
efl_ui_spin_button_direct_text_input_set(efl_added, EINA_TRUE),
efl_ui_layout_orientation_set(efl_added, EFL_UI_LAYOUT_ORIENTATION_VERTICAL),
efl_event_callback_add(efl_added, EFL_UI_RANGE_EVENT_CHANGED,_field_changed_cb, obj));
pd->day = efl_add(EFL_UI_SPIN_BUTTON_CLASS, obj,
efl_ui_range_limits_set(efl_added, 1, 31),
efl_ui_spin_button_wraparound_set(efl_added, EINA_TRUE),
efl_ui_spin_button_editable_set(efl_added, EINA_TRUE),
efl_ui_spin_button_direct_text_input_set(efl_added, EINA_TRUE),
efl_ui_layout_orientation_set(efl_added, EFL_UI_LAYOUT_ORIENTATION_VERTICAL),
efl_event_callback_add(efl_added, EFL_UI_RANGE_EVENT_CHANGED,_field_changed_cb, obj));

9
src/lib/elementary/efl_ui_format.c
View File

@ -136,11 +136,14 @@ _do_format_string(Efl_Ui_Format_Data *pd, Eina_Strbuf *str, const Eina_Value val
case FORMAT_TYPE_TM:
{
struct tm v;
char *buf;
char *buf = NULL;
eina_value_get(&value, &v);
buf = eina_strftime(pd->format_string, &v);
eina_strbuf_append(str, buf);
free(buf);
if (buf)
{
eina_strbuf_append(str, buf);
free(buf);
}
break;
}
default:

223
src/lib/elementary/efl_ui_image.c
View File

@ -49,7 +49,6 @@ static const Evas_Smart_Cb_Description _smart_callbacks[] = {
static Eina_Bool _key_action_activate(Evas_Object *obj, const char *params);
static Eina_Error _efl_ui_image_smart_internal_file_set(Eo *obj, Efl_Ui_Image_Data *sd);
static void _efl_ui_image_remote_copier_cancel(Eo *obj, Efl_Ui_Image_Data *sd);
void _efl_ui_image_sizing_eval(Evas_Object *obj);
static void _efl_ui_image_model_properties_changed_cb(void *data, const Efl_Event *event);
static void _on_size_hints_changed(void *data, const Efl_Event *e);
static Eina_Bool _efl_ui_image_download(Eo *obj, Efl_Ui_Image_Data *sd, const char *url);
@ -165,16 +164,18 @@ _img_new(Evas_Object *obj)
}
static void
_image_sizing_eval(Efl_Ui_Image_Data *sd, Evas_Object *img)
_image_sizing_eval(Eo *obj, Efl_Ui_Image_Data *sd, Evas_Object *img)
{
Evas_Coord x = 0, y = 0, w = 1, h = 1;
int ox, oy, ow, oh;
evas_object_geometry_get(obj, &ox, &oy, &ow, &oh);
if (efl_isa(img, EFL_CANVAS_LAYOUT_CLASS))
{
x = sd->img_x;
y = sd->img_y;
w = sd->img_w;
h = sd->img_h;
x = ox;
y = oy;
w = ow;
h = oh;
goto done;
}
else
@ -186,7 +187,7 @@ _image_sizing_eval(Efl_Ui_Image_Data *sd, Evas_Object *img)
evas_object_image_size_get(img, &iw, &ih);
//Exception Case
if ((iw == 0) || (ih == 0) || (sd->img_w == 0) || (sd->img_h == 0))
if ((iw == 0) || (ih == 0) || (ow == 0) || (oh == 0))
{
evas_object_resize(img, 0, 0);
evas_object_resize(sd->hit_rect, 0, 0);
@ -200,7 +201,7 @@ _image_sizing_eval(Efl_Ui_Image_Data *sd, Evas_Object *img)
if (ih < 1) ih = 1;
//2. Calculate internal image size (w x h)
// according to (iw x ih), (sd->img_w x sd->img_h), and scale_type
// according to (iw x ih), (ow x oh), and scale_type
switch (sd->scale_type)
{
case EFL_GFX_IMAGE_SCALE_TYPE_NONE:
@ -208,56 +209,63 @@ _image_sizing_eval(Efl_Ui_Image_Data *sd, Evas_Object *img)
h = ih;
break;
case EFL_GFX_IMAGE_SCALE_TYPE_FILL:
w = sd->img_w;
h = sd->img_h;
w = ow;
h = oh;
break;
case EFL_GFX_IMAGE_SCALE_TYPE_FIT_INSIDE:
w = sd->img_w;
case EFL_GFX_IMAGE_SCALE_TYPE_FIT:
w = ow;
h = ((double)ih * w) / (double)iw;
if (h > sd->img_h)
if (h > oh)
{
h = sd->img_h;
h = oh;
w = ((double)iw * h) / (double)ih;
}
if (((!sd->scale_up) && (w > iw))
|| ((!sd->scale_down) && (w < iw)))
{
w = iw;
h = ih;
}
break;
case EFL_GFX_IMAGE_SCALE_TYPE_FIT_OUTSIDE:
w = sd->img_w;
h = ((double)ih * w) / (double)iw;
if (h < sd->img_h)
{
h = sd->img_h;
w = ((double)iw * h) / (double)ih;
}
if (((!sd->scale_up) && (w > iw))
|| ((!sd->scale_down) && (w < iw)))
break;
case EFL_GFX_IMAGE_SCALE_TYPE_FIT_WIDTH:
w = ow;
h = ((double)ih * w) / (double)iw;
break;
case EFL_GFX_IMAGE_SCALE_TYPE_FIT_HEIGHT:
h = oh;
w = ((double)iw * h) / (double)ih;
break;
case EFL_GFX_IMAGE_SCALE_TYPE_EXPAND:
if (ow > oh)
{
w = iw;
h = ih;
w = ow;
h = ((double)ih * w) / (double)iw;
}
else
{
h = oh;
w = ((double)iw * h) / (double)ih;
}
break;
case EFL_GFX_IMAGE_SCALE_TYPE_TILE:
x = sd->img_x;
y = sd->img_y;
w = sd->img_w;
h = sd->img_h;
evas_object_geometry_get(obj, &x, &y, &w, &h);
evas_object_image_fill_set(img, x, y, iw, ih);
goto done;
}
if (((!sd->scale_up) && (w > iw))
|| ((!sd->scale_down) && (w < iw)))
{
w = iw;
}
if (((!sd->scale_up) && (h > ih))
|| ((!sd->scale_down) && (h < ih)))
{
h = ih;
}
//3. Calculate offset according to align value
if (!elm_widget_is_legacy(sd->self))
{
offset_x = ((sd->img_w - w) * sd->align_x);
offset_y = ((sd->img_h - h) * sd->align_y);
offset_x = ((ow - w) * sd->align_x);
offset_y = ((oh - h) * sd->align_y);
}
else
{
@ -265,12 +273,12 @@ _image_sizing_eval(Efl_Ui_Image_Data *sd, Evas_Object *img)
if (EINA_DBL_EQ(alignh, EVAS_HINT_FILL)) alignh = 0.5;
if (EINA_DBL_EQ(alignv, EVAS_HINT_FILL)) alignv = 0.5;
offset_x = ((sd->img_w - w) * alignh);
offset_y = ((sd->img_h - h) * alignv);
offset_x = ((ow - w) * alignh);
offset_y = ((oh - h) * alignv);
}
x = sd->img_x + offset_x;
y = sd->img_y + offset_y;
x = ox + offset_x;
y = oy + offset_y;
//4. Fill, move, resize
if (offset_x >= 0) offset_x = 0;
@ -280,13 +288,13 @@ _image_sizing_eval(Efl_Ui_Image_Data *sd, Evas_Object *img)
if (offset_x < 0)
{
x = sd->img_x;
w = sd->img_w;
x = ox;
w = ow;
}
if (offset_y < 0)
{
y = sd->img_y;
h = sd->img_h;
y = oy;
h = oh;
}
}
done:
@ -527,7 +535,7 @@ _efl_ui_image_edje_file_set(Evas_Object *obj)
return _efl_ui_image_async_file_set(obj, sd);
/* FIXME: do i want to update icon on file change ? */
_efl_ui_image_sizing_eval(obj);
efl_canvas_group_change(obj);
return 0;
}
@ -626,38 +634,26 @@ _efl_ui_image_efl_canvas_group_group_del(Eo *obj, Efl_Ui_Image_Data *sd)
efl_canvas_group_del(efl_super(obj, MY_CLASS));
}
/* this function exists solely to call efl_canvas_group_change */
EOLIAN static void
_efl_ui_image_efl_gfx_entity_position_set(Eo *obj, Efl_Ui_Image_Data *sd, Eina_Position2D pos)
_efl_ui_image_efl_gfx_entity_position_set(Eo *obj, Efl_Ui_Image_Data *sd EINA_UNUSED, Eina_Position2D pos)
{
if (_evas_object_intercept_call(obj, EVAS_OBJECT_INTERCEPT_CB_MOVE, 0, pos.x, pos.y))
return;
efl_gfx_entity_position_set(efl_super(obj, MY_CLASS), pos);
if ((sd->img_x == pos.x) && (sd->img_y == pos.y)) return;
sd->img_x = pos.x;
sd->img_y = pos.y;
/* takes care of moving */
_efl_ui_image_sizing_eval(obj);
efl_canvas_group_change(obj);
}
/* this function exists solely to call efl_canvas_group_change */
EOLIAN static void
_efl_ui_image_efl_gfx_entity_size_set(Eo *obj, Efl_Ui_Image_Data *sd, Eina_Size2D sz)
_efl_ui_image_efl_gfx_entity_size_set(Eo *obj, Efl_Ui_Image_Data *sd EINA_UNUSED, Eina_Size2D sz)
{
if (_evas_object_intercept_call(obj, EVAS_OBJECT_INTERCEPT_CB_RESIZE, 0, sz.w, sz.h))
return;
if ((sd->img_w == sz.w) && (sd->img_h == sz.h)) goto super;
sd->img_w = sz.w;
sd->img_h = sz.h;
/* takes care of resizing */
_efl_ui_image_sizing_eval(obj);
super:
efl_gfx_entity_size_set(efl_super(obj, MY_CLASS), sz);
efl_canvas_group_change(obj);
}
static void
@ -736,7 +732,7 @@ _efl_ui_image_efl_ui_widget_theme_apply(Eo *obj, Efl_Ui_Image_Data *sd EINA_UNUS
int_ret = efl_ui_widget_theme_apply(efl_super(obj, MY_CLASS));
if (int_ret == EFL_UI_THEME_APPLY_ERROR_GENERIC) return int_ret;
_efl_ui_image_sizing_eval(obj);
efl_canvas_group_change(obj);
return int_ret;
}
@ -751,15 +747,14 @@ _key_action_activate(Evas_Object *obj, const char *params EINA_UNUSED)
return EINA_TRUE;
}
void
_efl_ui_image_sizing_eval(Evas_Object *obj)
static void
_efl_ui_image_efl_canvas_group_group_calculate(Eo *obj, Efl_Ui_Image_Data *sd)
{
EFL_UI_IMAGE_DATA_GET_OR_RETURN(obj, sd);
Evas_Coord minw = -1, minh = -1, maxw = -1, maxh = -1;
Eina_Size2D sz;
double ts;
sd->in_calc = EINA_TRUE;
// TODO: remove this function after using the widget's scale value instead of image's scale value,
if (sd->no_scale)
sd->scale = 1.0;
@ -811,9 +806,10 @@ _efl_ui_image_sizing_eval(Evas_Object *obj)
if (!sd->edje)
efl_gfx_image_orientation_set(sd->img, sd->orient);
_image_sizing_eval(sd, sd->img);
if (sd->prev_img) _image_sizing_eval(sd, sd->prev_img);
_image_sizing_eval(obj, sd, sd->img);
if (sd->prev_img) _image_sizing_eval(obj, sd, sd->prev_img);
}
sd->in_calc = EINA_FALSE;
}
static void
@ -844,9 +840,11 @@ _efl_ui_image_file_set_do(Evas_Object *obj)
}
static void
_on_size_hints_changed(void *data EINA_UNUSED, const Efl_Event *ev)
_on_size_hints_changed(void *data, const Efl_Event *ev)
{
_efl_ui_image_sizing_eval(ev->object);
Efl_Ui_Image_Data *pd = data;
if (!pd->in_calc)
efl_canvas_group_change(ev->object);
}
static void
@ -871,7 +869,7 @@ _efl_ui_image_efl_object_constructor(Eo *obj, Efl_Ui_Image_Data *pd)
evas_object_smart_callbacks_descriptions_set(obj, _smart_callbacks);
efl_access_object_role_set(obj, EFL_ACCESS_ROLE_IMAGE);
pd->scale_type = EFL_GFX_IMAGE_SCALE_TYPE_FIT_INSIDE;
pd->scale_type = EFL_GFX_IMAGE_SCALE_TYPE_FIT;
pd->self = obj;
return obj;
@ -987,7 +985,7 @@ _efl_ui_image_efl_file_unload(Eo *obj, Efl_Ui_Image_Data *sd)
evas_object_image_preload(sd->img, EINA_FALSE);
}
_efl_ui_image_sizing_eval(obj);
efl_canvas_group_change(obj);
}
static Eina_Error
@ -1042,7 +1040,7 @@ _efl_ui_image_smart_internal_file_set(Eo *obj, Efl_Ui_Image_Data *sd)
evas_object_image_preload(sd->img, EINA_FALSE);
}
_efl_ui_image_sizing_eval(obj);
efl_canvas_group_change(obj);
return 0;
}
@ -1400,7 +1398,7 @@ _efl_ui_image_efl_gfx_image_orientable_image_orientation_set(Eo *obj, Efl_Ui_Ima
if (sd->orient == orient) return;
sd->orient = orient;
_efl_ui_image_sizing_eval(obj);
efl_canvas_group_change(obj);
}
EOLIAN static Efl_Gfx_Image_Orientation
@ -1587,7 +1585,7 @@ _efl_ui_image_efl_gfx_image_scale_type_set(Eo *obj EINA_UNUSED, Efl_Ui_Image_Dat
sd->scale_type = scale_type;
_efl_ui_image_sizing_eval(obj);
efl_canvas_group_change(obj);
}
EOLIAN static Efl_Gfx_Image_Scale_Type
@ -1597,25 +1595,39 @@ _efl_ui_image_efl_gfx_image_scale_type_get(const Eo *obj EINA_UNUSED, Efl_Ui_Ima
}
EOLIAN static void
_efl_ui_image_scalable_set(Eo *obj, Efl_Ui_Image_Data *sd, Eina_Bool up, Eina_Bool down)
_efl_ui_image_efl_gfx_image_can_upscale_set(Eo *obj, Efl_Ui_Image_Data *sd, Eina_Bool can_upscale)
{
if ((up == sd->scale_up) && (down == sd->scale_down)) return;
if (can_upscale == sd->scale_up) return;
sd->scale_up = !!up;
sd->scale_down = !!down;
sd->scale_up = !!can_upscale;
_efl_ui_image_sizing_eval(obj);
efl_canvas_group_change(obj);
}
EOLIAN static Eina_Bool
_efl_ui_image_efl_gfx_image_can_upscale_get(const Eo *obj EINA_UNUSED, Efl_Ui_Image_Data *sd)
{
return sd->scale_up;
}
EOLIAN static void
_efl_ui_image_scalable_get(const Eo *obj EINA_UNUSED, Efl_Ui_Image_Data *sd, Eina_Bool *scale_up, Eina_Bool *scale_down)
_efl_ui_image_efl_gfx_image_can_downscale_set(Eo *obj, Efl_Ui_Image_Data *sd, Eina_Bool can_downscale)
{
if (scale_up) *scale_up = sd->scale_up;
if (scale_down) *scale_down = sd->scale_down;
if (can_downscale == sd->scale_down) return;
sd->scale_down = !!can_downscale;
efl_canvas_group_change(obj);
}
EOLIAN static Eina_Bool
_efl_ui_image_efl_gfx_image_can_downscale_get(const Eo *obj EINA_UNUSED, Efl_Ui_Image_Data *sd)
{
return sd->scale_down;
}
EOLIAN static void
_efl_ui_image_align_set(Eo *obj, Efl_Ui_Image_Data *sd, double align_x, double align_y)
_efl_ui_image_efl_gfx_arrangement_content_align_set(Eo *obj, Efl_Ui_Image_Data *sd, double align_x, double align_y)
{
if (align_x > 1.0)
align_x = 1.0;
@ -1632,11 +1644,11 @@ _efl_ui_image_align_set(Eo *obj, Efl_Ui_Image_Data *sd, double align_x, double a
sd->align_x = align_x;
sd->align_y = align_y;
_efl_ui_image_sizing_eval(obj);
efl_canvas_group_change(obj);
}
EOLIAN static void
_efl_ui_image_align_get(const Eo *obj EINA_UNUSED, Efl_Ui_Image_Data *sd, double *align_x, double *align_y)
_efl_ui_image_efl_gfx_arrangement_content_align_get(const Eo *obj EINA_UNUSED, Efl_Ui_Image_Data *sd, double *align_x, double *align_y)
{
if (align_x) *align_x = sd->align_x;
if (align_y) *align_y = sd->align_y;
@ -1791,7 +1803,7 @@ _internal_efl_ui_image_icon_set(Evas_Object *obj, const char *name, Eina_Bool *f
if (ret)
{
eina_stringshare_replace(&sd->stdicon, name);
_efl_ui_image_sizing_eval(obj);
efl_canvas_group_change(obj);
return EINA_TRUE;
}
else
@ -1986,7 +1998,7 @@ elm_image_smooth_set(Evas_Object *obj, Eina_Bool smooth)
{
EINA_SAFETY_ON_FALSE_RETURN(efl_isa(obj, MY_CLASS));
efl_gfx_image_smooth_scale_set(obj, smooth);
_efl_ui_image_sizing_eval(obj);
efl_canvas_group_change(obj);
}
EAPI Eina_Bool
@ -2018,7 +2030,7 @@ elm_image_file_set(Evas_Object *obj, const char *file, const char *group)
EFL_UI_IMAGE_CHECK(obj) EINA_FALSE;
ret = efl_file_simple_load(obj, file, group);
_efl_ui_image_sizing_eval(obj);
efl_canvas_group_change(obj);
return ret;
}
@ -2071,7 +2083,7 @@ elm_image_memfile_set(Evas_Object *obj, const void *img, size_t size, const char
return EINA_FALSE;
}
_efl_ui_image_sizing_eval(obj);
efl_canvas_group_change(obj);
return EINA_TRUE;
}
@ -2089,13 +2101,13 @@ elm_image_fill_outside_set(Evas_Object *obj, Eina_Bool fill_outside)
if (sd->aspect_fixed)
{
if (sd->fill_inside) sd->scale_type = EFL_GFX_IMAGE_SCALE_TYPE_FIT_INSIDE;
else sd->scale_type = EFL_GFX_IMAGE_SCALE_TYPE_FIT_OUTSIDE;
if (sd->fill_inside) sd->scale_type = EFL_GFX_IMAGE_SCALE_TYPE_FIT;
else sd->scale_type = EFL_GFX_IMAGE_SCALE_TYPE_EXPAND;
}
else
sd->scale_type = EFL_GFX_IMAGE_SCALE_TYPE_FILL;
_efl_ui_image_sizing_eval(obj);
efl_canvas_group_change(obj);
}
EAPI Eina_Bool
@ -2191,7 +2203,7 @@ elm_image_no_scale_set(Evas_Object *obj, Eina_Bool no_scale)
EFL_UI_IMAGE_DATA_GET(obj, sd);
sd->no_scale = no_scale;
_efl_ui_image_sizing_eval(obj);
efl_canvas_group_change(obj);
}
EAPI Eina_Bool
@ -2210,7 +2222,7 @@ elm_image_resizable_set(Evas_Object *obj, Eina_Bool up, Eina_Bool down)
sd->scale_up = !!up;
sd->scale_down = !!down;
_efl_ui_image_sizing_eval(obj);
efl_canvas_group_change(obj);
}
EAPI void
@ -2234,13 +2246,13 @@ elm_image_aspect_fixed_set(Evas_Object *obj, Eina_Bool fixed)
if (sd->aspect_fixed)
{
if (sd->fill_inside) sd->scale_type = EFL_GFX_IMAGE_SCALE_TYPE_FIT_INSIDE;
else sd->scale_type = EFL_GFX_IMAGE_SCALE_TYPE_FIT_OUTSIDE;
if (sd->fill_inside) sd->scale_type = EFL_GFX_IMAGE_SCALE_TYPE_FIT;
else sd->scale_type = EFL_GFX_IMAGE_SCALE_TYPE_EXPAND;
}
else
sd->scale_type = EFL_GFX_IMAGE_SCALE_TYPE_FILL;
_efl_ui_image_sizing_eval(obj);
efl_canvas_group_change(obj);
}
EAPI Eina_Bool
@ -2258,7 +2270,8 @@ ELM_WIDGET_KEY_DOWN_DEFAULT_IMPLEMENT(efl_ui_image, Efl_Ui_Image_Data)
/* Internal EO APIs and hidden overrides */
#define EFL_UI_IMAGE_EXTRA_OPS \
EFL_CANVAS_GROUP_ADD_DEL_OPS(efl_ui_image)
EFL_CANVAS_GROUP_ADD_DEL_OPS(efl_ui_image), \
EFL_CANVAS_GROUP_CALC_OPS(efl_ui_image)
#include "efl_ui_image.eo.c"

31
src/lib/elementary/efl_ui_image.eo
View File

@ -20,8 +20,8 @@ class @beta Efl.Ui.Image extends Efl.Ui.Widget implements Efl.Input.Clickable, E
Efl.File, Efl.Gfx.Image, Efl.Gfx.Image_Load_Controller, Efl.Player, Efl.Gfx.View,
Efl.Access.Component, Efl.Access.Widget.Action, Efl.Gfx.Color,
Efl.Gfx.Image_Orientable,
Efl.Layout.Calc,
Efl.Layout.Group, Efl.Layout.Signal
Efl.Layout.Calc, Efl.Layout.Group, Efl.Layout.Signal,
Efl.Gfx.Arrangement
{
[[Efl UI image class
@ -30,28 +30,6 @@ class @beta Efl.Ui.Image extends Efl.Ui.Widget implements Efl.Input.Clickable, E
]]
event_prefix: efl_ui_image;
methods {
@property scalable {
[[Enable or disable scaling up or down the internal image.
]]
values {
scale_up: bool; [[If $true, the internal image might be scaled up
if necessary according to the scale type.
if $false, the internal image is not scaled up
no matter what the scale type is.]]
scale_down: bool; [[If $true, the internal image might be scaled down
if necessary according to the scale type.
if $false, the internal image is not scaled down
no matter what the scale type is.]]
}
}
@property align {
[[Controls how the internal image is positioned inside an image object.
]]
values {
align_x: double; [[Alignment in the horizontal axis (0 <= align_x <= 1).]]
align_y: double; [[Alignment in the vertical axis (0 <= align_y <= 1).]]
}
}
@property icon {
set {
[[Set the image by icon standards names.
@ -97,6 +75,8 @@ class @beta Efl.Ui.Image extends Efl.Ui.Widget implements Efl.Input.Clickable, E
Efl.Gfx.Entity.position { set; }
Efl.Gfx.Entity.size { set; }
Efl.Gfx.View.view_size { get; }
Efl.Gfx.Image.can_upscale { get; set; }
Efl.Gfx.Image.can_downscale { get; set; }
Efl.Gfx.Image.image_size { get; }
Efl.Gfx.Image_Load_Controller.load_size { get; set; }
Efl.Gfx.Image.smooth_scale { get; set; }
@ -123,8 +103,9 @@ class @beta Efl.Ui.Image extends Efl.Ui.Widget implements Efl.Input.Clickable, E
Efl.Ui.Widget.widget_input_event_handler;
Efl.Access.Component.extents { get; }
Efl.Access.Widget.Action.elm_actions { get; }
Efl.Gfx.Arrangement.content_align { get; set; }
}
events {
drop: string; [[Called when drop from drag and drop happened]] /* FIXME - Belongs to DnD interface */
drop @beta: string; [[Called when drop from drag and drop happened]] /* FIXME - Belongs to DnD interface */
}
}

32
src/lib/elementary/efl_ui_image_zoomable.c
View File

@ -1389,7 +1389,7 @@ _efl_ui_image_zoomable_vbar_drag_cb(void *data,
{
_efl_ui_image_zoomable_bar_read_and_update(data);
Efl_Ui_Scrollbar_Direction type = EFL_UI_SCROLLBAR_DIRECTION_VERTICAL;
Efl_Ui_Layout_Orientation type = EFL_UI_LAYOUT_ORIENTATION_VERTICAL;
efl_event_callback_call(data, EFL_UI_SCROLLBAR_EVENT_BAR_DRAG, &type);
}
@ -1399,7 +1399,7 @@ _efl_ui_image_zoomable_vbar_press_cb(void *data,
const char *emission EINA_UNUSED,
const char *source EINA_UNUSED)
{
Efl_Ui_Scrollbar_Direction type = EFL_UI_SCROLLBAR_DIRECTION_VERTICAL;
Efl_Ui_Layout_Orientation type = EFL_UI_LAYOUT_ORIENTATION_VERTICAL;
efl_event_callback_call(data, EFL_UI_SCROLLBAR_EVENT_BAR_PRESS, &type);
}
@ -1409,7 +1409,7 @@ _efl_ui_image_zoomable_vbar_unpress_cb(void *data,
const char *emission EINA_UNUSED,
const char *source EINA_UNUSED)
{
Efl_Ui_Scrollbar_Direction type = EFL_UI_SCROLLBAR_DIRECTION_VERTICAL;
Efl_Ui_Layout_Orientation type = EFL_UI_LAYOUT_ORIENTATION_VERTICAL;
efl_event_callback_call(data, EFL_UI_SCROLLBAR_EVENT_BAR_UNPRESS, &type);
}
@ -1459,7 +1459,7 @@ _efl_ui_image_zoomable_hbar_drag_cb(void *data,
{
_efl_ui_image_zoomable_bar_read_and_update(data);
Efl_Ui_Scrollbar_Direction type = EFL_UI_SCROLLBAR_DIRECTION_HORIZONTAL;
Efl_Ui_Layout_Orientation type = EFL_UI_LAYOUT_ORIENTATION_HORIZONTAL;
efl_event_callback_call(data, EFL_UI_SCROLLBAR_EVENT_BAR_DRAG, &type);
}
@ -1469,7 +1469,7 @@ _efl_ui_image_zoomable_hbar_press_cb(void *data,
const char *emission EINA_UNUSED,
const char *source EINA_UNUSED)
{
Efl_Ui_Scrollbar_Direction type = EFL_UI_SCROLLBAR_DIRECTION_HORIZONTAL;
Efl_Ui_Layout_Orientation type = EFL_UI_LAYOUT_ORIENTATION_HORIZONTAL;
efl_event_callback_call(data, EFL_UI_SCROLLBAR_EVENT_BAR_PRESS, &type);
}
@ -1479,7 +1479,7 @@ _efl_ui_image_zoomable_hbar_unpress_cb(void *data,
const char *emission EINA_UNUSED,
const char *source EINA_UNUSED)
{
Efl_Ui_Scrollbar_Direction type = EFL_UI_SCROLLBAR_DIRECTION_HORIZONTAL;
Efl_Ui_Layout_Orientation type = EFL_UI_LAYOUT_ORIENTATION_HORIZONTAL;
efl_event_callback_call(data, EFL_UI_SCROLLBAR_EVENT_BAR_UNPRESS, &type);
}
@ -1534,20 +1534,20 @@ _efl_ui_image_zoomable_bar_show_cb(void *data, const Efl_Event *event)
{
Eo *obj = data;
ELM_WIDGET_DATA_GET_OR_RETURN(obj, wd);
Efl_Ui_Scrollbar_Direction type = *(Efl_Ui_Scrollbar_Direction *)(event->info);
Efl_Ui_Layout_Orientation type = *(Efl_Ui_Layout_Orientation *)(event->info);
if (elm_widget_is_legacy(obj))
{
if (type == EFL_UI_SCROLLBAR_DIRECTION_HORIZONTAL)
if (type == EFL_UI_LAYOUT_ORIENTATION_HORIZONTAL)
edje_object_signal_emit(wd->resize_obj, "elm,action,show,hbar", "elm");
else if (type == EFL_UI_SCROLLBAR_DIRECTION_VERTICAL)
else if (type == EFL_UI_LAYOUT_ORIENTATION_VERTICAL)
edje_object_signal_emit(wd->resize_obj, "elm,action,show,vbar", "elm");
}
else
{
if (type == EFL_UI_SCROLLBAR_DIRECTION_HORIZONTAL)
if (type == EFL_UI_LAYOUT_ORIENTATION_HORIZONTAL)
edje_object_signal_emit(wd->resize_obj, "efl,action,show,hbar", "efl");
else if (type == EFL_UI_SCROLLBAR_DIRECTION_VERTICAL)
else if (type == EFL_UI_LAYOUT_ORIENTATION_VERTICAL)
edje_object_signal_emit(wd->resize_obj, "efl,action,show,vbar", "efl");
}
}
@ -1557,20 +1557,20 @@ _efl_ui_image_zoomable_bar_hide_cb(void *data, const Efl_Event *event)
{
Eo *obj = data;
ELM_WIDGET_DATA_GET_OR_RETURN(obj, wd);
Efl_Ui_Scrollbar_Direction type = *(Efl_Ui_Scrollbar_Direction *)(event->info);
Efl_Ui_Layout_Orientation type = *(Efl_Ui_Layout_Orientation *)(event->info);
if (elm_widget_is_legacy(obj))
{
if (type == EFL_UI_SCROLLBAR_DIRECTION_HORIZONTAL)
if (type == EFL_UI_LAYOUT_ORIENTATION_HORIZONTAL)
edje_object_signal_emit(wd->resize_obj, "elm,action,hide,hbar", "elm");
else if (type == EFL_UI_SCROLLBAR_DIRECTION_VERTICAL)
else if (type == EFL_UI_LAYOUT_ORIENTATION_VERTICAL)
edje_object_signal_emit(wd->resize_obj, "elm,action,hide,vbar", "elm");
}
else
{
if (type == EFL_UI_SCROLLBAR_DIRECTION_HORIZONTAL)
if (type == EFL_UI_LAYOUT_ORIENTATION_HORIZONTAL)
edje_object_signal_emit(wd->resize_obj, "efl,action,hide,hbar", "efl");
else if (type == EFL_UI_SCROLLBAR_DIRECTION_VERTICAL)
else if (type == EFL_UI_LAYOUT_ORIENTATION_VERTICAL)
edje_object_signal_emit(wd->resize_obj, "efl,action,hide,vbar", "efl");
}
}

30
src/lib/elementary/efl_ui_item.c
View File

@ -12,6 +12,31 @@
#define MY_CLASS_NAME "Efl.Ui.Item"
static Eina_Bool _key_action_select(Evas_Object *obj, const char *params EINA_UNUSED);
static const Elm_Action key_actions[] = {
{"select", _key_action_select},
{NULL, NULL}
};
static Eina_Bool
_key_action_select(Evas_Object *obj, const char *params EINA_UNUSED)
{
efl_ui_selectable_selected_set(obj, EINA_TRUE);
return EINA_FALSE;
}
static Efl_Ui_Select_Mode
_fetch_state(Eo *obj)
{
if (efl_isa(obj, EFL_UI_MULTI_SELECTABLE_INTERFACE))
return efl_ui_select_mode_get(obj);
if (efl_isa(obj, EFL_UI_SINGLE_SELECTABLE_INTERFACE))
return EFL_UI_SELECT_MODE_SINGLE;
ERR("Uncaught state");
return EFL_UI_SELECT_MODE_NONE;
}
static void
_item_select(Eo *obj, Efl_Ui_Item_Data *pd)
{
@ -19,7 +44,7 @@ _item_select(Eo *obj, Efl_Ui_Item_Data *pd)
if (pd->container)
{
m = efl_ui_select_mode_get(pd->container);
m = _fetch_state(pd->container);
if (m == EFL_UI_SELECT_MODE_NONE || (pd->selected && m != EFL_UI_SELECT_MODE_SINGLE_ALWAYS))
return;
}
@ -68,7 +93,7 @@ _item_unpressed(void *data, const Efl_Event *ev EINA_UNUSED)
if (!efl_ui_item_container_get(obj)) return;
efl_layout_signal_emit(obj, "efl,state,unpressed", "efl");
m = efl_ui_select_mode_get(efl_ui_item_container_get(obj));
m = _fetch_state(pd->container);
if ((m != EFL_UI_SELECT_MODE_SINGLE_ALWAYS) && (pd->selected))
efl_ui_selectable_selected_set(obj, EINA_FALSE);
@ -183,6 +208,7 @@ _efl_ui_item_item_parent_get(const Eo *obj EINA_UNUSED, Efl_Ui_Item_Data *pd)
return pd->parent;
}
ELM_WIDGET_KEY_DOWN_DEFAULT_IMPLEMENT(efl_ui_item, Efl_Ui_Item_Data)
#include "efl_ui_item.eo.c"
#include "efl_ui_selectable.eo.c"

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

@ -55,5 +55,6 @@ abstract @beta Efl.Ui.Item extends Efl.Ui.Layout_Base implements Efl.Ui.Selectab
Efl.Object.finalize;
Efl.Object.destructor;
Efl.Ui.Selectable.selected {get; set;}
Efl.Ui.Widget.widget_input_event_handler;
}
}

49
src/lib/elementary/efl_ui_layout_pack.c
View File

@ -322,24 +322,65 @@ _efl_ui_layout_part_table_efl_pack_table_table_contents_get(Eo *obj EINA_UNUSED,
}
EOLIAN static Eina_Bool
_efl_ui_layout_part_table_efl_pack_table_table_position_get(const Eo *obj EINA_UNUSED, Efl_Ui_Layout_Table_Data *pd, Efl_Gfx_Entity * subobj, int *col, int *row, int *colspan, int *rowspan)
_efl_ui_layout_part_table_efl_pack_table_table_cell_column_get(const Eo *obj EINA_UNUSED, Efl_Ui_Layout_Table_Data *pd, Efl_Gfx_Entity * subobj, int *col, int *colspan)
{
unsigned short c, r, cs, rs;
unsigned short c, cs;
Eina_Bool ret;
edje_object_freeze(pd->obj);
Eo *pack = (Eo *) edje_object_part_object_get(pd->obj, pd->part);
edje_object_thaw(pd->obj);
ret = evas_object_table_pack_get(pack, subobj, &c, &r, &cs, &rs);
ret = evas_object_table_pack_get(pack, subobj, &c, NULL, &cs, NULL);
if (col) *col = c;
if (row) *row = r;
if (colspan) *colspan = cs;
return ret;
}
EOLIAN static void
_efl_ui_layout_part_table_efl_pack_table_table_cell_column_set(Eo *obj EINA_UNUSED, Efl_Ui_Layout_Table_Data *pd, Efl_Gfx_Entity * subobj, int col, int colspan)
{
unsigned short r, rs;
edje_object_freeze(pd->obj);
Eo *pack = (Eo *) edje_object_part_object_get(pd->obj, pd->part);
edje_object_thaw(pd->obj);
evas_object_table_pack_get(pack, subobj, NULL, &r, NULL, &rs);
evas_object_table_pack(pack, subobj, col, r, colspan, rs);
}
EOLIAN static Eina_Bool
_efl_ui_layout_part_table_efl_pack_table_table_cell_row_get(const Eo *obj EINA_UNUSED, Efl_Ui_Layout_Table_Data *pd, Efl_Gfx_Entity * subobj, int *row, int *rowspan)
{
unsigned short r, rs;
Eina_Bool ret;
edje_object_freeze(pd->obj);
Eo *pack = (Eo *) edje_object_part_object_get(pd->obj, pd->part);
edje_object_thaw(pd->obj);
ret = evas_object_table_pack_get(pack, subobj, NULL, &r, NULL, &rs);
if (row) *row = r;
if (rowspan) *rowspan = rs;
return ret;
}
EOLIAN static void
_efl_ui_layout_part_table_efl_pack_table_table_cell_row_set(Eo *obj EINA_UNUSED, Efl_Ui_Layout_Table_Data *pd, Efl_Gfx_Entity * subobj, int row, int rowspan)
{
unsigned short c, cs;
edje_object_freeze(pd->obj);
Eo *pack = (Eo *) edje_object_part_object_get(pd->obj, pd->part);
edje_object_thaw(pd->obj);
evas_object_table_pack_get(pack, subobj, &c, NULL, &cs, NULL);
evas_object_table_pack(pack, subobj, c, row, cs, rowspan);
}
EOLIAN static void
_efl_ui_layout_part_table_efl_pack_table_table_size_get(const Eo *obj EINA_UNUSED, Efl_Ui_Layout_Table_Data *pd, int *cols, int *rows)
{

3
src/lib/elementary/efl_ui_layout_part_table.eo
View File

@ -27,7 +27,8 @@ class @beta Efl.Ui.Layout_Part_Table extends Efl.Object implements Efl.Pack_Tabl
Efl.Pack_Table.pack_table;
Efl.Pack_Table.table_content_get;
Efl.Pack_Table.table_contents_get;
Efl.Pack_Table.table_position { get; }
Efl.Pack_Table.table_cell_column { get; set; }
Efl.Pack_Table.table_cell_row { get; set; }
Efl.Pack_Table.table_size { get; }
Efl.Pack_Table.table_columns { get; }
Efl.Pack_Table.table_rows { get; }

24
src/lib/elementary/efl_ui_list_view.c
View File

@ -288,7 +288,7 @@ _efl_ui_list_view_vbar_drag_cb(void *data,
{
_efl_ui_list_view_bar_read_and_update(data);
Efl_Ui_Scrollbar_Direction type = EFL_UI_SCROLLBAR_DIRECTION_VERTICAL;
Efl_Ui_Layout_Orientation type = EFL_UI_LAYOUT_ORIENTATION_VERTICAL;
efl_event_callback_call(data, EFL_UI_SCROLLBAR_EVENT_BAR_DRAG, &type);
}
@ -298,7 +298,7 @@ _efl_ui_list_view_vbar_press_cb(void *data,
const char *emission EINA_UNUSED,
const char *source EINA_UNUSED)
{
Efl_Ui_Scrollbar_Direction type = EFL_UI_SCROLLBAR_DIRECTION_VERTICAL;
Efl_Ui_Layout_Orientation type = EFL_UI_LAYOUT_ORIENTATION_VERTICAL;
efl_event_callback_call(data, EFL_UI_SCROLLBAR_EVENT_BAR_PRESS, &type);
}
@ -308,7 +308,7 @@ _efl_ui_list_view_vbar_unpress_cb(void *data,
const char *emission EINA_UNUSED,
const char *source EINA_UNUSED)
{
Efl_Ui_Scrollbar_Direction type = EFL_UI_SCROLLBAR_DIRECTION_VERTICAL;
Efl_Ui_Layout_Orientation type = EFL_UI_LAYOUT_ORIENTATION_VERTICAL;
efl_event_callback_call(data, EFL_UI_SCROLLBAR_EVENT_BAR_UNPRESS, &type);
}
@ -358,7 +358,7 @@ _efl_ui_list_view_hbar_drag_cb(void *data,
{
_efl_ui_list_view_bar_read_and_update(data);
Efl_Ui_Scrollbar_Direction type = EFL_UI_SCROLLBAR_DIRECTION_HORIZONTAL;
Efl_Ui_Layout_Orientation type = EFL_UI_LAYOUT_ORIENTATION_HORIZONTAL;
efl_event_callback_call(data, EFL_UI_SCROLLBAR_EVENT_BAR_DRAG, &type);
}
@ -368,7 +368,7 @@ _efl_ui_list_view_hbar_press_cb(void *data,
const char *emission EINA_UNUSED,
const char *source EINA_UNUSED)
{
Efl_Ui_Scrollbar_Direction type = EFL_UI_SCROLLBAR_DIRECTION_HORIZONTAL;
Efl_Ui_Layout_Orientation type = EFL_UI_LAYOUT_ORIENTATION_HORIZONTAL;
efl_event_callback_call(data, EFL_UI_SCROLLBAR_EVENT_BAR_PRESS, &type);
}
@ -378,7 +378,7 @@ _efl_ui_list_view_hbar_unpress_cb(void *data,
const char *emission EINA_UNUSED,
const char *source EINA_UNUSED)
{
Efl_Ui_Scrollbar_Direction type = EFL_UI_SCROLLBAR_DIRECTION_HORIZONTAL;
Efl_Ui_Layout_Orientation type = EFL_UI_LAYOUT_ORIENTATION_HORIZONTAL;
efl_event_callback_call(data, EFL_UI_SCROLLBAR_EVENT_BAR_UNPRESS, &type);
}
@ -417,11 +417,11 @@ _efl_ui_list_view_bar_show_cb(void *data, const Efl_Event *event)
{
Eo *obj = data;
ELM_WIDGET_DATA_GET_OR_RETURN(obj, wd);
Efl_Ui_Scrollbar_Direction type = *(Efl_Ui_Scrollbar_Direction *)(event->info);
Efl_Ui_Layout_Orientation type = *(Efl_Ui_Layout_Orientation *)(event->info);
if (type == EFL_UI_SCROLLBAR_DIRECTION_HORIZONTAL)
if (type == EFL_UI_LAYOUT_ORIENTATION_HORIZONTAL)
edje_object_signal_emit(wd->resize_obj, "efl,action,show,hbar", "efl");
else if (type == EFL_UI_SCROLLBAR_DIRECTION_VERTICAL)
else if (type == EFL_UI_LAYOUT_ORIENTATION_VERTICAL)
edje_object_signal_emit(wd->resize_obj, "efl,action,show,vbar", "efl");
}
@ -430,11 +430,11 @@ _efl_ui_list_view_bar_hide_cb(void *data, const Efl_Event *event)
{
Eo *obj = data;
ELM_WIDGET_DATA_GET_OR_RETURN(obj, wd);
Efl_Ui_Scrollbar_Direction type = *(Efl_Ui_Scrollbar_Direction *)(event->info);
Efl_Ui_Layout_Orientation type = *(Efl_Ui_Layout_Orientation *)(event->info);
if (type == EFL_UI_SCROLLBAR_DIRECTION_HORIZONTAL)
if (type == EFL_UI_LAYOUT_ORIENTATION_HORIZONTAL)
edje_object_signal_emit(wd->resize_obj, "efl,action,hide,hbar", "efl");
else if (type == EFL_UI_SCROLLBAR_DIRECTION_VERTICAL)
else if (type == EFL_UI_LAYOUT_ORIENTATION_VERTICAL)
edje_object_signal_emit(wd->resize_obj, "efl,action,hide,vbar", "efl");
}

33
src/lib/elementary/efl_ui_multi_selectable.eo
View File

@ -28,5 +28,38 @@ interface @beta Efl.Ui.Multi_Selectable extends Efl.Ui.Single_Selectable
[[Get the selected items in a iterator. The iterator sequence will be decided by selection.]]
return: iterator<Efl.Ui.Selectable> @owned @no_unused; [[User has to free the iterator after usage.]]
}
select_range {
[[Select a range of @Efl.Ui.Selectable.
This will select the range of selectables from a to b or from b to a depending on which one comes first.
If a or b are not part of the widget, a error is returned, and no change is applied.
$null is not allowed as either of the parameters.
Both of the passed values will also be selected.
]]
params {
a : Efl.Ui.Selectable; [[One side of the range.]]
b : Efl.Ui.Selectable; [[The other side of the range.]]
}
}
unselect_range {
[[Unselect a range of @Efl.Ui.Selectable.
This will unselect the range of selectables from a to b or from b to a depending on which one comes first.
If a or b are not part of the widget, a error is returned, and no change is applied.
$null is not allowed as either of the parameters.
Both of the passed values will also be unselected.
]]
params {
a : Efl.Ui.Selectable; [[One side of the range.]]
b : Efl.Ui.Selectable; [[The other side of the range.]]
}
}
select_all {
[[Select all @Efl.Ui.Selectable]]
}
unselect_all {
[[Unselect all @Efl.Ui.Selectable]]
}
}
}

96
src/lib/elementary/efl_ui_popup.c
View File

@ -5,7 +5,7 @@
#define EFL_PART_PROTECTED
#define EFL_UI_POPUP_PROTECTED
#define EFL_PART_PROTECTED
#define EFL_UI_WIDGET_SCROLLABLE_CONTENT_PROTECTED
#include <Elementary.h>
#include "elm_priv.h"
@ -479,6 +479,57 @@ _efl_ui_popup_timeout_get(const Eo *obj EINA_UNUSED, Efl_Ui_Popup_Data *pd)
return pd->timeout;
}
/* this will ONLY be called during _sizing_eval() */
static void
_scrollable_content_size_cb(void *data EINA_UNUSED, const Efl_Event *ev)
{
Eina_Size2D *size = ev->info;
efl_gfx_entity_size_set(ev->object, *size);
/* finish group calc chain */
efl_canvas_group_calculate(efl_super(ev->object, EFL_UI_WIDGET_SCROLLABLE_CONTENT_MIXIN));
}
static void
_sizing_eval(Eo *obj)
{
Eina_Size2D min;
/* trigger layout calc */
efl_canvas_group_calculate(efl_super(obj, MY_CLASS));
if (efl_ui_widget_scrollable_content_did_group_calc_get(obj)) return;
min = efl_gfx_hint_size_combined_min_get(obj);
Eina_Size2D size = efl_gfx_entity_size_get(obj);
Eina_Size2D new_size;
new_size.w = (min.w > size.w ? min.w : size.w);
new_size.h = (min.h > size.h ? min.h : size.h);
efl_gfx_entity_size_set(obj, new_size);
}
EOLIAN static void
_efl_ui_popup_efl_canvas_group_group_calculate(Eo *obj, Efl_Ui_Popup_Data *pd)
{
/* When efl_canvas_group_change() is called, just flag is set instead of size
* calculation.
* The actual size calculation is done here when the object is rendered to
* avoid duplicate size calculations. */
efl_canvas_group_need_recalculate_set(obj, EINA_FALSE);
pd->in_calc = EINA_TRUE;
_sizing_eval(obj);
pd->in_calc = EINA_FALSE;
if (pd->anchor)
_anchor_calc(obj);
else
_calc_align(obj);
Eina_Rect p_geom = efl_gfx_entity_geometry_get(pd->win_parent);
efl_gfx_entity_position_set(pd->backwall, EINA_POSITION2D(0, 0));
efl_gfx_entity_size_set(pd->backwall, EINA_SIZE2D(p_geom.w, p_geom.h));
}
EOLIAN static Eo *
_efl_ui_popup_efl_object_constructor(Eo *obj, Efl_Ui_Popup_Data *pd)
{
@ -489,6 +540,7 @@ _efl_ui_popup_efl_object_constructor(Eo *obj, Efl_Ui_Popup_Data *pd)
obj = efl_constructor(efl_super(obj, MY_CLASS));
efl_canvas_object_type_set(obj, MY_CLASS_NAME);
efl_event_callback_add(obj, EFL_GFX_ENTITY_EVENT_HINTS_CHANGED, _hints_changed_cb, pd);
efl_event_callback_add(obj, EFL_UI_WIDGET_SCROLLABLE_CONTENT_EVENT_OPTIMAL_SIZE_CALC, _scrollable_content_size_cb, pd);
elm_widget_can_focus_set(obj, EINA_TRUE);
if (elm_widget_theme_object_set(obj, wd->resize_obj,
@ -529,48 +581,6 @@ _efl_ui_popup_efl_object_destructor(Eo *obj, Efl_Ui_Popup_Data *pd)
efl_destructor(efl_super(obj, MY_CLASS));
}
static void
_sizing_eval(Eo *obj)
{
Eina_Size2D min;
/* trigger layout calc */
efl_canvas_group_calculate(efl_super(obj, MY_CLASS));
min = efl_gfx_hint_size_combined_min_get(obj);
Eina_Size2D size = efl_gfx_entity_size_get(obj);
Eina_Size2D new_size;
new_size.w = (min.w > size.w ? min.w : size.w);
new_size.h = (min.h > size.h ? min.h : size.h);
efl_gfx_entity_size_set(obj, new_size);
}
EOLIAN static void
_efl_ui_popup_efl_canvas_group_group_calculate(Eo *obj, Efl_Ui_Popup_Data *pd)
{
/* When efl_canvas_group_change() is called, just flag is set instead of size
* calculation.
* The actual size calculation is done here when the object is rendered to
* avoid duplicate size calculations. */
efl_canvas_group_need_recalculate_set(obj, EINA_FALSE);
if (!pd->in_calc)
{
pd->in_calc = EINA_TRUE;
_sizing_eval(obj);
pd->in_calc = EINA_FALSE;
}
if (pd->anchor)
_anchor_calc(obj);
else
_calc_align(obj);
Eina_Rect p_geom = efl_gfx_entity_geometry_get(pd->win_parent);
efl_gfx_entity_position_set(pd->backwall, EINA_POSITION2D(0, 0));
efl_gfx_entity_size_set(pd->backwall, EINA_SIZE2D(p_geom.w, p_geom.h));
}
/* Standard widget overrides */
ELM_PART_CONTENT_DEFAULT_IMPLEMENT(efl_ui_popup, Efl_Ui_Popup_Data)

2
src/lib/elementary/efl_ui_popup.eo
View File

@ -8,7 +8,7 @@ enum @beta Efl.Ui.Popup_Align {
bottom [[Popup aligned to bottom]]
}
class @beta Efl.Ui.Popup extends Efl.Ui.Layout_Base implements Efl.Content, Efl.Ui.Focus.Layer
class @beta Efl.Ui.Popup extends Efl.Ui.Layout_Base implements Efl.Content, Efl.Ui.Focus.Layer, Efl.Ui.Widget_Scrollable_Content
{
[[EFL UI popup class]]
methods {

257
src/lib/elementary/efl_ui_scroll_alert_popup.c
View File

@ -1,257 +0,0 @@
#ifdef HAVE_CONFIG_H
# include "elementary_config.h"
#endif
#define EFL_PART_PROTECTED
#include <Elementary.h>
#include "elm_priv.h"
#include "efl_ui_popup_private.h"
#include "efl_ui_scroll_alert_popup_private.h"
#include "efl_ui_scroll_alert_popup_part.eo.h"
#include "elm_part_helper.h"
#define MY_CLASS EFL_UI_SCROLL_ALERT_POPUP_CLASS
#define MY_CLASS_NAME "Efl.Ui.Scroll_Alert_Popup"
static void
_scroller_sizing_eval(Eo *obj, Efl_Ui_Scroll_Alert_Popup_Data *pd,
Eina_Size2D obj_min, Eina_Size2D scr_min)
{
Eina_Size2D max_size, min_size;
max_size = efl_gfx_hint_size_max_get(obj);
if (max_size.w != -1)
max_size.w = (obj_min.w > max_size.w) ? obj_min.w : max_size.w;
if (max_size.h != -1)
max_size.h = (obj_min.h > max_size.h) ? obj_min.h : max_size.h;
min_size = efl_gfx_hint_size_min_get(obj);
Eina_Size2D size;
size.w = (obj_min.w > min_size.w) ? obj_min.w : min_size.w;
size.h = (obj_min.h > min_size.h) ? obj_min.h : min_size.h;
Eina_Size2D new_min = obj_min;
if ((max_size.w == -1) && (max_size.h == -1))
{
efl_ui_scrollable_match_content_set(pd->scroller, EINA_FALSE, EINA_FALSE);
efl_gfx_entity_size_set(obj, size);
}
else if ((max_size.w == -1) && (max_size.h != -1))
{
if (max_size.h < scr_min.h)
{
efl_ui_scrollable_match_content_set(pd->scroller, EINA_FALSE, EINA_FALSE);
efl_gfx_entity_size_set(obj, EINA_SIZE2D(size.w, max_size.h));
}
else
{
new_min.h = scr_min.h;
efl_ui_scrollable_match_content_set(pd->scroller, EINA_FALSE, EINA_TRUE);
efl_gfx_entity_size_set(obj, EINA_SIZE2D(size.w, scr_min.h));
}
}
else if ((max_size.w != -1) && (max_size.h == -1))
{
if (max_size.w < scr_min.w)
{
efl_ui_scrollable_match_content_set(pd->scroller, EINA_FALSE, EINA_FALSE);
efl_gfx_entity_size_set(obj, EINA_SIZE2D(max_size.w, size.h));
}
else
{
new_min.w = scr_min.w;
efl_ui_scrollable_match_content_set(pd->scroller, EINA_TRUE, EINA_FALSE);
efl_gfx_entity_size_set(obj, EINA_SIZE2D(scr_min.w, size.h));
}
}
else if ((max_size.w != -1) && (max_size.h != -1))
{
Eina_Size2D new_size;
Eina_Bool min_limit_w = EINA_FALSE;
Eina_Bool min_limit_h = EINA_FALSE;
if (max_size.w < scr_min.w)
{
new_size.w = max_size.w;
}
else
{
min_limit_w = EINA_TRUE;
new_min.w = scr_min.w;
new_size.w = scr_min.w;
}
if (max_size.h < scr_min.h)
{
new_size.h = max_size.h;
}
else
{
min_limit_h = EINA_TRUE;
new_min.h = scr_min.h;
new_size.h = scr_min.h;
}
efl_ui_scrollable_match_content_set(pd->scroller, min_limit_w, min_limit_h);
efl_gfx_entity_size_set(obj, new_size);
}
efl_canvas_group_calculate(pd->scroller);
efl_gfx_hint_size_restricted_min_set(obj, new_min);
}
static void
_sizing_eval(Eo *obj, Efl_Ui_Scroll_Alert_Popup_Data *pd)
{
ELM_WIDGET_DATA_GET_OR_RETURN(obj, wd);
Evas_Coord obj_minw = -1, obj_minh = -1;
Evas_Coord scr_minw = -1, scr_minh = -1;
//Calculate popup's min size including scroller's min size
{
efl_ui_scrollable_match_content_set(pd->scroller, EINA_TRUE, EINA_TRUE);
efl_canvas_group_calculate(pd->scroller);
elm_coords_finger_size_adjust(1, &scr_minw, 1, &scr_minh);
edje_object_size_min_restricted_calc
(wd->resize_obj, &scr_minw, &scr_minh, scr_minw, scr_minh);
}
//Calculate popup's min size except scroller's min size
{
efl_ui_scrollable_match_content_set(pd->scroller, EINA_FALSE, EINA_FALSE);
efl_canvas_group_calculate(pd->scroller);
elm_coords_finger_size_adjust(1, &obj_minw, 1, &obj_minh);
edje_object_size_min_restricted_calc
(wd->resize_obj, &obj_minw, &obj_minh, obj_minw, obj_minh);
}
_scroller_sizing_eval(obj, pd, EINA_SIZE2D(obj_minw, obj_minh), EINA_SIZE2D(scr_minw, scr_minh));
}
EOLIAN static void
_efl_ui_scroll_alert_popup_efl_canvas_group_group_calculate(Eo *obj, Efl_Ui_Scroll_Alert_Popup_Data *pd)
{
EFL_UI_POPUP_DATA_GET_OR_RETURN(obj, ppd);
ppd->in_calc = EINA_TRUE;
_sizing_eval(obj, pd);
efl_canvas_group_need_recalculate_set(pd->scroller, EINA_FALSE);
efl_canvas_group_need_recalculate_set(obj, EINA_FALSE);
//Not to calculate size by super class
efl_canvas_group_calculate(efl_super(obj, MY_CLASS));
ppd->in_calc = EINA_FALSE;
}
static Eina_Bool
_efl_ui_scroll_alert_popup_content_set(Eo *obj, Efl_Ui_Scroll_Alert_Popup_Data *pd, const char *part, Eo *content)
{
//For efl_content_set()
if (part && !strcmp(part, "efl.content"))
{
pd->content = content;
//Content should have expand propeties since the scroller is not layout layer
efl_gfx_hint_weight_set(pd->content, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
efl_gfx_hint_fill_set(pd->content, EINA_TRUE, EINA_TRUE);
efl_content_set(pd->scroller, pd->content);
}
else
{
efl_content_set(efl_part(efl_super(obj, MY_CLASS), part), content);
}
return EINA_TRUE;
}
Eo *
_efl_ui_scroll_alert_popup_content_get(Eo *obj, Efl_Ui_Scroll_Alert_Popup_Data *pd, const char *part)
{
//For efl_content_set()
if (part && !strcmp(part, "efl.content"))
return pd->content;
return efl_content_get(efl_part(efl_super(obj, MY_CLASS), part));
}
static Eo *
_efl_ui_scroll_alert_popup_content_unset(Eo *obj, Efl_Ui_Scroll_Alert_Popup_Data *pd, const char *part)
{
//For efl_content_set()
if (part && !strcmp(part, "efl.content"))
{
Eo *content = pd->content;
if (!content) return content;
pd->content = NULL;
return efl_content_unset(pd->scroller);
}
return efl_content_unset(efl_part(efl_super(obj, MY_CLASS), part));
}
static Eina_Bool
_efl_ui_scroll_alert_popup_text_set(Eo *obj, Efl_Ui_Scroll_Alert_Popup_Data *pd EINA_UNUSED, const char *part, const char *label)
{
efl_text_set(efl_part(efl_super(obj, MY_CLASS), part), label);
return EINA_TRUE;
}
const char *
_efl_ui_scroll_alert_popup_text_get(Eo *obj EINA_UNUSED, Efl_Ui_Scroll_Alert_Popup_Data *pd EINA_UNUSED, const char *part)
{
return efl_text_get(efl_part(efl_super(obj, MY_CLASS), part));
}
EOLIAN static Eo *
_efl_ui_scroll_alert_popup_efl_object_constructor(Eo *obj,
Efl_Ui_Scroll_Alert_Popup_Data *pd)
{
ELM_WIDGET_DATA_GET_OR_RETURN(obj, wd, NULL);
if (!elm_widget_theme_klass_get(obj))
elm_widget_theme_klass_set(obj, "scroll_alert_popup");
obj = efl_constructor(efl_super(obj, MY_CLASS));
efl_canvas_object_type_set(obj, MY_CLASS_NAME);
pd->scroller = efl_add(EFL_UI_SCROLLER_CLASS, obj,
efl_ui_widget_style_set(efl_added, "popup/no_inset_shadow"),
efl_ui_scrollbar_bar_mode_set(efl_added, EFL_UI_SCROLLBAR_MODE_AUTO, EFL_UI_SCROLLBAR_MODE_AUTO));
efl_content_set(efl_part(efl_super(obj, MY_CLASS), "efl.content"),
pd->scroller);
return obj;
}
/* Efl.Part begin */
static Eina_Bool
_part_is_efl_ui_scroll_alert_popup_part(const Eo *obj EINA_UNUSED, const char *part)
{
//Use Efl.Ui.Widget's "background" and "shadow" parts
if (eina_streq(part, "background") || eina_streq(part, "shadow"))
return EINA_FALSE;
return EINA_TRUE;
}
ELM_PART_OVERRIDE_PARTIAL(efl_ui_scroll_alert_popup, EFL_UI_SCROLL_ALERT_POPUP, Efl_Ui_Scroll_Alert_Popup_Data, _part_is_efl_ui_scroll_alert_popup_part)
ELM_PART_OVERRIDE_CONTENT_SET(efl_ui_scroll_alert_popup, EFL_UI_SCROLL_ALERT_POPUP, Efl_Ui_Scroll_Alert_Popup_Data)
ELM_PART_OVERRIDE_CONTENT_GET(efl_ui_scroll_alert_popup, EFL_UI_SCROLL_ALERT_POPUP, Efl_Ui_Scroll_Alert_Popup_Data)
ELM_PART_OVERRIDE_CONTENT_UNSET(efl_ui_scroll_alert_popup, EFL_UI_SCROLL_ALERT_POPUP, Efl_Ui_Scroll_Alert_Popup_Data)
ELM_PART_OVERRIDE_TEXT_SET(efl_ui_scroll_alert_popup, EFL_UI_SCROLL_ALERT_POPUP, Efl_Ui_Scroll_Alert_Popup_Data)
ELM_PART_OVERRIDE_TEXT_GET(efl_ui_scroll_alert_popup, EFL_UI_SCROLL_ALERT_POPUP, Efl_Ui_Scroll_Alert_Popup_Data)
#include "efl_ui_scroll_alert_popup_part.eo.c"
/* Efl.Part end */
#include "efl_ui_scroll_alert_popup.eo.c"

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

@ -1,11 +0,0 @@
import eina_types;
class @beta Efl.Ui.Scroll_Alert_Popup extends Efl.Ui.Alert_Popup
{
[[EFL UI Scroll Alert Popup class]]
implements {
Efl.Object.constructor;
Efl.Canvas.Group.group_calculate;
Efl.Part.part_get;
}
}

10
src/lib/elementary/efl_ui_scroll_alert_popup_part.eo
View File

@ -1,10 +0,0 @@
class @beta Efl.Ui.Scroll_Alert_Popup_Part extends Efl.Ui.Layout_Part implements Efl.Content, Efl.Text
{
[[Efl UI Scroll Alert Popup internal part class]]
data: null;
implements {
Efl.Content.content { get; set; }
Efl.Content.content_unset;
Efl.Text.text { set; get; }
}
}

13
src/lib/elementary/efl_ui_scroll_alert_popup_private.h
View File

@ -1,13 +0,0 @@
#ifndef EFL_UI_SCROLL_ALERT_POPUP_H
#define EFL_UI_SCROLL_ALERT_POPUP_H
#include "Elementary.h"
typedef struct _Efl_Ui_Scroll_Alert_Popup_Data Efl_Ui_Scroll_Alert_Popup_Data;
struct _Efl_Ui_Scroll_Alert_Popup_Data
{
Eo *scroller;
Eo *content;
};
#endif

8
src/lib/elementary/efl_ui_scroll_manager.c
View File

@ -2038,12 +2038,12 @@ _efl_ui_scroll_manager_scrollbar_h_visibility_apply(Efl_Ui_Scroll_Manager_Data *
{
if (sd->hbar_visible)
{
Efl_Ui_Scrollbar_Direction type = EFL_UI_SCROLLBAR_DIRECTION_HORIZONTAL;
Efl_Ui_Layout_Orientation type = EFL_UI_LAYOUT_ORIENTATION_HORIZONTAL;
efl_event_callback_call(sd->parent, EFL_UI_SCROLLBAR_EVENT_BAR_SHOW, &type);
}
else
{
Efl_Ui_Scrollbar_Direction type = EFL_UI_SCROLLBAR_DIRECTION_HORIZONTAL;
Efl_Ui_Layout_Orientation type = EFL_UI_LAYOUT_ORIENTATION_HORIZONTAL;
efl_event_callback_call(sd->parent, EFL_UI_SCROLLBAR_EVENT_BAR_HIDE, &type);
}
}
@ -2053,12 +2053,12 @@ _efl_ui_scroll_manager_scrollbar_v_visibility_apply(Efl_Ui_Scroll_Manager_Data *
{
if (sd->vbar_visible)
{
Efl_Ui_Scrollbar_Direction type = EFL_UI_SCROLLBAR_DIRECTION_VERTICAL;
Efl_Ui_Layout_Orientation type = EFL_UI_LAYOUT_ORIENTATION_VERTICAL;
efl_event_callback_call(sd->parent, EFL_UI_SCROLLBAR_EVENT_BAR_SHOW, &type);
}
else
{
Efl_Ui_Scrollbar_Direction type = EFL_UI_SCROLLBAR_DIRECTION_VERTICAL;
Efl_Ui_Layout_Orientation type = EFL_UI_LAYOUT_ORIENTATION_VERTICAL;
efl_event_callback_call(sd->parent, EFL_UI_SCROLLBAR_EVENT_BAR_HIDE, &type);
}
}

55
src/lib/elementary/efl_ui_scroll_util.c
View File

@ -12,6 +12,8 @@ typedef struct {
Eo *obj;
Eo *smanager;
int freeze_want;
Eina_Bool scroll_count : 1;
Eina_Bool need_scroll : 1;
} Scroll_Connector_Context;
static void
@ -52,6 +54,21 @@ _scroll_connector_edje_drag_cb(void *data,
_scroll_connector_bar_read_and_update(ctx);
}
static void
_scroll(void *data,
Evas_Object *obj,
const char *emission EINA_UNUSED,
const char *source EINA_UNUSED)
{
Scroll_Connector_Context *ctx = data;
ctx->scroll_count = EINA_FALSE;
if (!ctx->need_scroll) return;
ctx->need_scroll = EINA_FALSE;
efl_layout_signal_emit(obj, "efl,action,scroll", "efl");
}
static void
_scroll_connector_edje_drag_start_cb(void *data,
Evas_Object *obj EINA_UNUSED,
@ -89,11 +106,11 @@ _scroll_connector_vbar_drag_cb(void *data,
const char *source EINA_UNUSED)
{
Scroll_Connector_Context *ctx = data;
Efl_Ui_Scrollbar_Direction type;
Efl_Ui_Layout_Orientation type;
_scroll_connector_bar_read_and_update(ctx);
type = EFL_UI_SCROLLBAR_DIRECTION_VERTICAL;
type = EFL_UI_LAYOUT_ORIENTATION_VERTICAL;
efl_event_callback_call(ctx->obj, EFL_UI_SCROLLBAR_EVENT_BAR_DRAG, &type);
}
@ -104,7 +121,7 @@ _scroll_connector_vbar_press_cb(void *data,
const char *source EINA_UNUSED)
{
Scroll_Connector_Context *ctx = data;
Efl_Ui_Scrollbar_Direction type = EFL_UI_SCROLLBAR_DIRECTION_VERTICAL;
Efl_Ui_Layout_Orientation type = EFL_UI_LAYOUT_ORIENTATION_VERTICAL;
efl_event_callback_call(ctx->obj, EFL_UI_SCROLLBAR_EVENT_BAR_PRESS, &type);
}
@ -116,7 +133,7 @@ _scroll_connector_vbar_unpress_cb(void *data,
const char *source EINA_UNUSED)
{
Scroll_Connector_Context *ctx = data;
Efl_Ui_Scrollbar_Direction type = EFL_UI_SCROLLBAR_DIRECTION_VERTICAL;
Efl_Ui_Layout_Orientation type = EFL_UI_LAYOUT_ORIENTATION_VERTICAL;
efl_event_callback_call(ctx->obj, EFL_UI_SCROLLBAR_EVENT_BAR_UNPRESS, &type);
}
@ -128,7 +145,7 @@ _scroll_connector_hbar_drag_cb(void *data,
const char *source EINA_UNUSED)
{
Scroll_Connector_Context *ctx = data;
Efl_Ui_Scrollbar_Direction type = EFL_UI_SCROLLBAR_DIRECTION_HORIZONTAL;
Efl_Ui_Layout_Orientation type = EFL_UI_LAYOUT_ORIENTATION_HORIZONTAL;
_scroll_connector_bar_read_and_update(ctx);
efl_event_callback_call(ctx->obj, EFL_UI_SCROLLBAR_EVENT_BAR_DRAG, &type);
@ -141,7 +158,7 @@ _scroll_connector_hbar_press_cb(void *data,
const char *source EINA_UNUSED)
{
Scroll_Connector_Context *ctx = data;
Efl_Ui_Scrollbar_Direction type = EFL_UI_SCROLLBAR_DIRECTION_HORIZONTAL;
Efl_Ui_Layout_Orientation type = EFL_UI_LAYOUT_ORIENTATION_HORIZONTAL;
efl_event_callback_call(ctx->obj, EFL_UI_SCROLLBAR_EVENT_BAR_PRESS, &type);
}
@ -153,7 +170,7 @@ _scroll_connector_hbar_unpress_cb(void *data,
const char *source EINA_UNUSED)
{
Scroll_Connector_Context *ctx = data;
Efl_Ui_Scrollbar_Direction type = EFL_UI_SCROLLBAR_DIRECTION_HORIZONTAL;
Efl_Ui_Layout_Orientation type = EFL_UI_LAYOUT_ORIENTATION_HORIZONTAL;
efl_event_callback_call(ctx->obj, EFL_UI_SCROLLBAR_EVENT_BAR_UNPRESS, &type);
}
@ -170,7 +187,6 @@ _scroll_connector_bar_size_changed_cb(void *data, const Efl_Event *event EINA_UN
efl_ui_scrollbar_bar_size_get(ctx->smanager, &width, &height);
edje_object_part_drag_size_set(wd->resize_obj, "efl.dragable.hbar", width, 1.0);
edje_object_part_drag_size_set(wd->resize_obj, "efl.dragable.vbar", 1.0, height);
efl_layout_signal_emit(wd->resize_obj, "efl,action,scroll", "efl");
}
static void
@ -194,7 +210,13 @@ _scroll_connector_bar_pos_changed_cb(void *data, const Efl_Event *event EINA_UNU
efl_ui_scrollbar_bar_position_get(ctx->smanager, &posx, &posy);
edje_object_part_drag_value_set(wd->resize_obj, "efl.dragable.hbar", posx, 0.0);
edje_object_part_drag_value_set(wd->resize_obj, "efl.dragable.vbar", 0.0, posy);
efl_layout_signal_emit(wd->resize_obj, "efl,action,scroll", "efl");
if (ctx->scroll_count)
ctx->need_scroll = EINA_TRUE;
else
{
efl_layout_signal_emit(wd->resize_obj, "efl,action,scroll", "efl");
ctx->scroll_count = EINA_TRUE;
}
}
static void
@ -202,11 +224,11 @@ _scroll_connector_bar_show_cb(void *data, const Efl_Event *event)
{
Scroll_Connector_Context *ctx = data;
ELM_WIDGET_DATA_GET_OR_RETURN(ctx->obj, wd);
Efl_Ui_Scrollbar_Direction type = *(Efl_Ui_Scrollbar_Direction *)(event->info);
Efl_Ui_Layout_Orientation type = *(Efl_Ui_Layout_Orientation *)(event->info);
if (type == EFL_UI_SCROLLBAR_DIRECTION_HORIZONTAL)
if (type == EFL_UI_LAYOUT_ORIENTATION_HORIZONTAL)
efl_layout_signal_emit(wd->resize_obj, "efl,action,show,hbar", "efl");
else if (type == EFL_UI_SCROLLBAR_DIRECTION_VERTICAL)
else if (type == EFL_UI_LAYOUT_ORIENTATION_VERTICAL)
efl_layout_signal_emit(wd->resize_obj, "efl,action,show,vbar", "efl");
}
@ -215,11 +237,11 @@ _scroll_connector_bar_hide_cb(void *data, const Efl_Event *event)
{
Scroll_Connector_Context *ctx = data;
ELM_WIDGET_DATA_GET_OR_RETURN(ctx->obj, wd);
Efl_Ui_Scrollbar_Direction type = *(Efl_Ui_Scrollbar_Direction *)(event->info);
Efl_Ui_Layout_Orientation type = *(Efl_Ui_Layout_Orientation *)(event->info);
if (type == EFL_UI_SCROLLBAR_DIRECTION_HORIZONTAL)
if (type == EFL_UI_LAYOUT_ORIENTATION_HORIZONTAL)
efl_layout_signal_emit(wd->resize_obj, "efl,action,hide,hbar", "efl");
else if (type == EFL_UI_SCROLLBAR_DIRECTION_VERTICAL)
else if (type == EFL_UI_LAYOUT_ORIENTATION_VERTICAL)
efl_layout_signal_emit(wd->resize_obj, "efl,action,hide,vbar", "efl");
}
@ -266,6 +288,9 @@ efl_ui_scroll_connector_bind(Eo *obj, Eo *manager)
ctx, _scroll_connector_hbar_press_cb, NULL);
efl_layout_signal_callback_add(obj, "efl,hbar,unpress", "efl",
ctx, _scroll_connector_hbar_unpress_cb, NULL);
efl_layout_signal_callback_add(obj, "efl,action,scroll", "efl",
ctx, _scroll, NULL);
//from the object to the theme
efl_event_callback_add(obj, EFL_UI_SCROLLBAR_EVENT_BAR_SIZE_CHANGED,
_scroll_connector_bar_size_changed_cb, ctx);

15
src/lib/elementary/efl_ui_single_selectable.eo
View File

@ -13,5 +13,20 @@ interface @beta Efl.Ui.Single_Selectable {
selectable : Efl.Ui.Selectable; [[The latest selected item.]]
}
}
@property fallback_selection {
[[A object that will be selected in case nothing is selected
A object set to this property will be selected instead of no item beeing selected. Which means, there will be always at least one element selected.
If this property is NULL, the state of "no item is selected" can be reached.
Setting this property as a result of selection events results in undefined behavior.
]]
values {
fallback : Efl.Ui.Selectable;
}
}
}
events {
selection_changed : void; [[Called when there is a change in the selection state, this event will collect all the item selection change events that are happening within one loop iteration. This means, you will only get this event once, even if a lot of items have changed. If you are interested in detailed changes, subscribe to the selection,changed event of Efl.Ui.Selectable.]]
}
}

835
src/lib/elementary/efl_ui_slider_interval.c
View File

@ -4,6 +4,7 @@
#define EFL_ACCESS_OBJECT_PROTECTED
#define EFL_ACCESS_WIDGET_ACTION_PROTECTED
#define EFL_ACCESS_VALUE_PROTECTED
#include <Elementary.h>
#include "elm_priv.h"
@ -14,7 +15,15 @@
#define MY_CLASS_PFX efl_ui_slider_interval
#define MY_CLASS_NAME "Efl.Ui.Slider_Interval"
#define SLIDER_DELAY_CHANGED_INTERVAL 1.2
#define SLIDER_DELAY_CHANGED_INTERVAL 0.2
#define SLIDER_STEP 0.05
static Eina_Bool _key_action_drag(Evas_Object *obj, const char *params);
static const Elm_Action key_actions[] = {
{"drag", _key_action_drag},
{NULL, NULL}
};
static Eina_Bool
_delay_change(void *data)
@ -30,77 +39,34 @@ _delay_change(void *data)
return ECORE_CALLBACK_CANCEL;
}
void
_efl_ui_slider_interval_val_fetch(Evas_Object *obj, Efl_Ui_Slider_Interval_Data *pd, Eina_Bool user_event)
static inline Eina_Bool
_is_horizontal(Efl_Ui_Layout_Orientation dir)
{
double posx = 0.0, posy = 0.0, pos = 0.0, val;
double posx2 = 0.0, posy2 = 0.0, pos2 = 0.0, val2;
EFL_UI_SLIDER_DATA_GET(obj, sd);
ELM_WIDGET_DATA_GET_OR_RETURN(obj, wd);
efl_ui_drag_value_get(efl_part(wd->resize_obj, "efl.dragable.slider"),
&posx, &posy);
if (efl_ui_layout_orientation_is_horizontal(sd->dir, EINA_TRUE)) pos = posx;
else pos = posy;
efl_ui_drag_value_get(efl_part(wd->resize_obj, "efl.dragable2.slider"),
&posx2, &posy2);
if (efl_ui_layout_orientation_is_horizontal(sd->dir, EINA_TRUE)) pos2 = posx2;
else pos2 = posy2;
val = (pos * (sd->val_max - sd->val_min)) + sd->val_min;
val2 = (pos2 * (sd->val_max - sd->val_min)) + sd->val_min;
if (val > pd->intvl_to)
{
val = pd->intvl_to;
efl_ui_slider_val_set(obj);
}
else if (val2 < pd->intvl_from)
{
val2 = pd->intvl_from;
efl_ui_slider_val_set(obj);
}
if (fabs(val - pd->intvl_from) > DBL_EPSILON)
{
sd->val = val;
pd->intvl_from = val;
if (user_event)
{
efl_event_callback_call(obj, EFL_UI_RANGE_EVENT_CHANGED, NULL);
efl_event_callback_legacy_call(obj, EFL_UI_RANGE_EVENT_CHANGED, NULL);
ecore_timer_del(pd->delay);
pd->delay = ecore_timer_add(SLIDER_DELAY_CHANGED_INTERVAL, _delay_change, obj);
}
}
if (fabs(val2 - pd->intvl_to) > DBL_EPSILON)
{
pd->intvl_to = val2;
if (user_event)
{
efl_event_callback_call(obj, EFL_UI_RANGE_EVENT_CHANGED, NULL);
efl_event_callback_legacy_call(obj, EFL_UI_RANGE_EVENT_CHANGED, NULL);
ecore_timer_del(pd->delay);
pd->delay = ecore_timer_add(SLIDER_DELAY_CHANGED_INTERVAL, _delay_change, obj);
}
}
return efl_ui_layout_orientation_is_horizontal(dir, EINA_TRUE);
}
void
_efl_ui_slider_interval_val_set(Evas_Object *obj, Efl_Ui_Slider_Interval_Data *pd)
static void
_emit_events(Eo *obj, Efl_Ui_Slider_Interval_Data *sd)
{
efl_event_callback_call(obj, EFL_UI_RANGE_EVENT_CHANGED, NULL);
if (sd->val == sd->val_min)
efl_event_callback_call(obj, EFL_UI_RANGE_EVENT_MIN_REACHED, NULL);
if (sd->val == sd->val_max)
efl_event_callback_call(obj, EFL_UI_RANGE_EVENT_MAX_REACHED, NULL);
}
static void
_val_set(Evas_Object *obj)
{
double pos, pos2;
EFL_UI_SLIDER_DATA_GET(obj, sd);
EFL_UI_SLIDER_INTERVAL_DATA_GET(obj, sd);
ELM_WIDGET_DATA_GET_OR_RETURN(obj, wd);
if (sd->val_max > sd->val_min)
{
pos = (pd->intvl_from - sd->val_min) / (sd->val_max - sd->val_min);
pos2 = (pd->intvl_to - sd->val_min) / (sd->val_max - sd->val_min);
pos = (sd->intvl_from - sd->val_min) / (sd->val_max - sd->val_min);
pos2 = (sd->intvl_to - sd->val_min) / (sd->val_max - sd->val_min);
}
else
{
@ -128,15 +94,74 @@ _efl_ui_slider_interval_val_set(Evas_Object *obj, Efl_Ui_Slider_Interval_Data *p
evas_object_smart_changed(obj);
}
void
_efl_ui_slider_interval_down_knob(Evas_Object *obj, Efl_Ui_Slider_Interval_Data *pd, double button_x, double button_y)
static void
_val_fetch(Evas_Object *obj, Eina_Bool user_event)
{
EFL_UI_SLIDER_DATA_GET(obj, sd);
double posx = 0.0, posy = 0.0, pos = 0.0, val;
double posx2 = 0.0, posy2 = 0.0, pos2 = 0.0, val2;
EFL_UI_SLIDER_INTERVAL_DATA_GET(obj, sd);
ELM_WIDGET_DATA_GET_OR_RETURN(obj, wd);
efl_ui_drag_value_get(efl_part(wd->resize_obj, "efl.dragable.slider"),
&posx, &posy);
if (efl_ui_layout_orientation_is_horizontal(sd->dir, EINA_TRUE)) pos = posx;
else pos = posy;
efl_ui_drag_value_get(efl_part(wd->resize_obj, "efl.dragable2.slider"),
&posx2, &posy2);
if (efl_ui_layout_orientation_is_horizontal(sd->dir, EINA_TRUE)) pos2 = posx2;
else pos2 = posy2;
val = (pos * (sd->val_max - sd->val_min)) + sd->val_min;
val2 = (pos2 * (sd->val_max - sd->val_min)) + sd->val_min;
if (val > sd->intvl_to)
{
val = sd->intvl_to;
_val_set(obj);
}
else if (val2 < sd->intvl_from)
{
val2 = sd->intvl_from;
_val_set(obj);
}
if (fabs(val - sd->intvl_from) > DBL_EPSILON)
{
sd->val = val;
sd->intvl_from = val;
if (user_event)
{
efl_event_callback_call(obj, EFL_UI_RANGE_EVENT_CHANGED, NULL);
efl_event_callback_legacy_call(obj, EFL_UI_RANGE_EVENT_CHANGED, NULL);
ecore_timer_del(sd->delay);
sd->delay = ecore_timer_add(SLIDER_DELAY_CHANGED_INTERVAL, _delay_change, obj);
}
}
if (fabs(val2 - sd->intvl_to) > DBL_EPSILON)
{
sd->intvl_to = val2;
if (user_event)
{
efl_event_callback_call(obj, EFL_UI_RANGE_EVENT_CHANGED, NULL);
efl_event_callback_legacy_call(obj, EFL_UI_RANGE_EVENT_CHANGED, NULL);
ecore_timer_del(sd->delay);
sd->delay = ecore_timer_add(SLIDER_DELAY_CHANGED_INTERVAL, _delay_change, obj);
}
}
}
static void
_down_knob(Evas_Object *obj, double button_x, double button_y)
{
EFL_UI_SLIDER_INTERVAL_DATA_GET(obj, sd);
ELM_WIDGET_DATA_GET_OR_RETURN(obj, wd);
double posx = 0.0, posy = 0.0, posx2 = 0.0, posy2 = 0.0, diff1, diff2, diff3;
pd->intvl_flag = 0;
sd->intvl_flag = 0;
efl_ui_drag_value_get(efl_part(wd->resize_obj, "efl.dragable.slider"),
&posx, &posy);
@ -160,13 +185,13 @@ _efl_ui_slider_interval_down_knob(Evas_Object *obj, Efl_Ui_Slider_Interval_Data
{
efl_ui_drag_value_set(efl_part(wd->resize_obj, "efl.dragable.slider"),
button_x, button_y);
pd->intvl_flag = 1;
sd->intvl_flag = 1;
}
else if (diff1 > diff2)
{
efl_ui_drag_value_set(efl_part(wd->resize_obj, "efl.dragable2.slider"),
button_x, button_y);
pd->intvl_flag = 2;
sd->intvl_flag = 2;
}
else
{
@ -174,28 +199,29 @@ _efl_ui_slider_interval_down_knob(Evas_Object *obj, Efl_Ui_Slider_Interval_Data
{
efl_ui_drag_value_set(efl_part(wd->resize_obj, "efl.dragable.slider"),
button_x, button_y);
pd->intvl_flag = 1;
sd->intvl_flag = 1;
}
else
{
efl_ui_drag_value_set(efl_part(wd->resize_obj, "efl.dragable2.slider"),
button_x, button_y);
pd->intvl_flag = 2;
sd->intvl_flag = 2;
}
}
}
void
_efl_ui_slider_interval_move_knob(Evas_Object *obj, Efl_Ui_Slider_Interval_Data *pd, double button_x, double button_y)
static void
_move_knob(Evas_Object *obj, double button_x, double button_y)
{
EFL_UI_SLIDER_INTERVAL_DATA_GET(obj, sd);
ELM_WIDGET_DATA_GET_OR_RETURN(obj, wd);
if (pd->intvl_flag == 1)
if (sd->intvl_flag == 1)
{
efl_ui_drag_value_set(efl_part(wd->resize_obj, "efl.dragable.slider"),
button_x, button_y);
}
else if (pd->intvl_flag == 2)
else if (sd->intvl_flag == 2)
{
efl_ui_drag_value_set(efl_part(wd->resize_obj, "efl.dragable2.slider"),
button_x, button_y);
@ -205,7 +231,7 @@ _efl_ui_slider_interval_move_knob(Evas_Object *obj, Efl_Ui_Slider_Interval_Data
EOLIAN static void
_efl_ui_slider_interval_interval_value_set(Eo *obj, Efl_Ui_Slider_Interval_Data *pd, double from, double to)
{
EFL_UI_SLIDER_DATA_GET(obj, sd);
EFL_UI_SLIDER_INTERVAL_DATA_GET(obj, sd);
pd->intvl_from = from;
sd->val = from;
pd->intvl_to = to;
@ -216,7 +242,7 @@ _efl_ui_slider_interval_interval_value_set(Eo *obj, Efl_Ui_Slider_Interval_Data
}
if (pd->intvl_to > sd->val_max) pd->intvl_to = sd->val_max;
efl_ui_slider_val_set(obj);
_val_set(obj);
}
EOLIAN static void
@ -226,15 +252,338 @@ _efl_ui_slider_interval_interval_value_get(const Eo *obj EINA_UNUSED, Efl_Ui_Sli
if (to) *to = fmax(pd->intvl_from, pd->intvl_to);
}
static const char *
_theme_group_modify_pos_get(const char *cur_group, const char *search, size_t len)
{
const char *pos = NULL;
const char *temp_str = NULL;
temp_str = cur_group + len - strlen(search);
if (temp_str >= cur_group)
{
if (!strcmp(temp_str, search))
pos = temp_str;
}
return pos;
}
static char *
_efl_ui_slider_interval_theme_group_get(Evas_Object *obj, Efl_Ui_Slider_Interval_Data *sd)
{
const char *pos = NULL;
const char *cur_group = elm_widget_theme_element_get(obj);
Eina_Strbuf *new_group = eina_strbuf_new();
size_t len = 0;
if (cur_group)
{
len = strlen(cur_group);
pos = _theme_group_modify_pos_get(cur_group, "horizontal", len);
if (!pos)
pos = _theme_group_modify_pos_get(cur_group, "vertical", len);
// TODO: change separator when it is decided.
// can skip when prev_group == cur_group
if (!pos)
{
eina_strbuf_append(new_group, cur_group);
eina_strbuf_append(new_group, "/");
}
else
{
eina_strbuf_append_length(new_group, cur_group, pos - cur_group);
}
}
if (_is_horizontal(sd->dir))
eina_strbuf_append(new_group, "horizontal");
else
eina_strbuf_append(new_group, "vertical");
return eina_strbuf_release(new_group);
}
static void
_slider_update(Evas_Object *obj, Eina_Bool user_event)
{
_val_fetch(obj, user_event);
evas_object_smart_changed(obj);
}
static void
_drag(void *data,
Evas_Object *obj EINA_UNUSED,
const char *emission EINA_UNUSED,
const char *source EINA_UNUSED)
{
_slider_update(data, EINA_TRUE);
}
static void
_drag_start(void *data,
Evas_Object *obj EINA_UNUSED,
const char *emission EINA_UNUSED,
const char *source EINA_UNUSED)
{
if (!efl_ui_focus_object_focus_get(data))
elm_object_focus_set(data, EINA_TRUE);
_slider_update(data, EINA_TRUE);
efl_event_callback_call(data, EFL_UI_SLIDER_INTERVAL_EVENT_SLIDER_DRAG_START, NULL);
elm_widget_scroll_freeze_push(data);
}
static void
_drag_stop(void *data,
Evas_Object *obj EINA_UNUSED,
const char *emission EINA_UNUSED,
const char *source EINA_UNUSED)
{
_slider_update(data, EINA_TRUE);
efl_event_callback_call(data, EFL_UI_SLIDER_INTERVAL_EVENT_SLIDER_DRAG_STOP, NULL);
elm_widget_scroll_freeze_pop(data);
}
static void
_drag_step(void *data,
Evas_Object *obj EINA_UNUSED,
const char *emission EINA_UNUSED,
const char *source EINA_UNUSED)
{
_slider_update(data, EINA_TRUE);
}
static void
_spacer_down_cb(void *data,
Evas *e EINA_UNUSED,
Evas_Object *obj EINA_UNUSED,
void *event_info)
{
EFL_UI_SLIDER_INTERVAL_DATA_GET(data, sd);
Evas_Event_Mouse_Down *ev = event_info;
Eina_Rect sr;
double button_x = 0.0, button_y = 0.0;
sd->spacer_down = EINA_TRUE;
sr = efl_gfx_entity_geometry_get(sd->spacer);
sd->downx = ev->canvas.x - sr.x;
sd->downy = ev->canvas.y - sr.y;
if (_is_horizontal(sd->dir))
{
button_x = ((double)ev->canvas.x - (double)sr.x) / (double)sr.w;
if (button_x > 1) button_x = 1;
if (button_x < 0) button_x = 0;
}
else
{
button_y = ((double)ev->canvas.y - (double)sr.y) / (double)sr.h;
if (button_y > 1) button_y = 1;
if (button_y < 0) button_y = 0;
}
_down_knob(data, button_x, button_y);
if (!efl_ui_focus_object_focus_get(data))
elm_object_focus_set(data, EINA_TRUE);
_slider_update(data, EINA_TRUE);
efl_event_callback_call(data, EFL_UI_SLIDER_INTERVAL_EVENT_SLIDER_DRAG_START, NULL);
}
static void
_spacer_move_cb(void *data,
Evas *e EINA_UNUSED,
Evas_Object *obj EINA_UNUSED,
void *event_info)
{
EFL_UI_SLIDER_INTERVAL_DATA_GET(data, sd);
Eina_Rect sr;
double button_x = 0.0, button_y = 0.0;
Evas_Event_Mouse_Move *ev = event_info;
if (sd->spacer_down)
{
Evas_Coord d = 0;
sr = efl_gfx_entity_geometry_get(sd->spacer);
if (_is_horizontal(sd->dir))
d = abs(ev->cur.canvas.x - sr.x - sd->downx);
else d = abs(ev->cur.canvas.y - sr.y - sd->downy);
if (d > (_elm_config->thumbscroll_threshold - 1))
{
if (!sd->frozen)
{
elm_widget_scroll_freeze_push(data);
sd->frozen = EINA_TRUE;
}
ev->event_flags &= ~EVAS_EVENT_FLAG_ON_HOLD;
}
if (ev->event_flags & EVAS_EVENT_FLAG_ON_HOLD)
{
if (sd->spacer_down) sd->spacer_down = EINA_FALSE;
_slider_update(data, EINA_TRUE);
efl_event_callback_call
(data, EFL_UI_SLIDER_INTERVAL_EVENT_SLIDER_DRAG_STOP, NULL);
if (sd->frozen)
{
elm_widget_scroll_freeze_pop(data);
sd->frozen = EINA_FALSE;
}
return;
}
if (_is_horizontal(sd->dir))
{
button_x = ((double)ev->cur.canvas.x - (double)sr.x) / (double)sr.w;
if (button_x > 1) button_x = 1;
if (button_x < 0) button_x = 0;
}
else
{
button_y = ((double)ev->cur.canvas.y - (double)sr.y) / (double)sr.h;
if (button_y > 1) button_y = 1;
if (button_y < 0) button_y = 0;
}
_move_knob(data, button_x, button_y);
_slider_update(data, EINA_TRUE);
}
}
static void
_spacer_up_cb(void *data,
Evas *e EINA_UNUSED,
Evas_Object *obj EINA_UNUSED,
void *event_info EINA_UNUSED)
{
EFL_UI_SLIDER_INTERVAL_DATA_GET(data, sd);
if (!sd->spacer_down) return;
if (sd->spacer_down) sd->spacer_down = EINA_FALSE;
_slider_update(data, EINA_TRUE);
efl_event_callback_call(data, EFL_UI_SLIDER_INTERVAL_EVENT_SLIDER_DRAG_STOP, NULL);
if (sd->frozen)
{
elm_widget_scroll_freeze_pop(data);
sd->frozen = EINA_FALSE;
}
}
static void
_mouse_in_cb(void *data EINA_UNUSED,
Evas *e EINA_UNUSED,
Evas_Object *obj,
void *event_info EINA_UNUSED)
{
efl_ui_widget_scroll_hold_push(obj);
}
static void
_mouse_out_cb(void *data EINA_UNUSED,
Evas *e EINA_UNUSED,
Evas_Object *obj,
void *event_info EINA_UNUSED)
{
efl_ui_widget_scroll_hold_pop(obj);
}
static char *
_access_info_cb(void *data EINA_UNUSED, Evas_Object *obj)
{
const char *txt = elm_widget_access_info_get(obj);
if (!txt) txt = elm_layout_text_get(obj, NULL);
if (txt) return strdup(txt);
return NULL;
}
static char *
_access_state_cb(void *data EINA_UNUSED, Evas_Object *obj)
{
char *ret;
Eina_Strbuf *buf = eina_strbuf_new();
if (elm_widget_disabled_get(obj))
eina_strbuf_append(buf, " state: disabled");
if (eina_strbuf_length_get(buf))
{
ret = eina_strbuf_string_steal(buf);
eina_strbuf_free(buf);
return ret;
}
eina_strbuf_free(buf);
return NULL;
}
EOLIAN static Efl_Object *
_efl_ui_slider_interval_efl_object_constructor(Eo *obj, Efl_Ui_Slider_Interval_Data *pd EINA_UNUSED)
_efl_ui_slider_interval_efl_object_constructor(Eo *obj, Efl_Ui_Slider_Interval_Data *priv)
{
ELM_WIDGET_DATA_GET_OR_RETURN(obj, wd, NULL);
char *group;
if (!elm_widget_theme_klass_get(obj))
elm_widget_theme_klass_set(obj, "slider_interval");
obj = efl_constructor(efl_super(obj, MY_CLASS));
efl_access_object_role_set(obj, EFL_ACCESS_ROLE_SLIDER);
if (!elm_widget_theme_klass_get(obj))
elm_widget_theme_klass_set(obj, "slider");
group = _efl_ui_slider_interval_theme_group_get(obj, priv);
if (elm_widget_theme_object_set(obj, wd->resize_obj,
elm_widget_theme_klass_get(obj),
group,
elm_widget_theme_style_get(obj)) == EFL_UI_THEME_APPLY_ERROR_GENERIC)
CRI("Failed to set layout!");
free(group);
priv->dir = EFL_UI_LAYOUT_ORIENTATION_HORIZONTAL;
priv->val_max = 1.0;
priv->step = SLIDER_STEP;
efl_layout_signal_callback_add(obj, "drag", "*", obj, _drag, NULL);
efl_layout_signal_callback_add(obj, "drag,start", "*", obj, _drag_start, NULL);
efl_layout_signal_callback_add(obj, "drag,stop", "*", obj, _drag_stop, NULL);
efl_layout_signal_callback_add(obj, "drag,step", "*", obj, _drag_step, NULL);
efl_layout_signal_callback_add(obj, "drag,page", "*", obj, _drag_stop, NULL);
priv->spacer = efl_add(EFL_CANVAS_RECTANGLE_CLASS, obj,
efl_gfx_color_set(efl_added, 0, 0, 0, 0));
efl_content_set(efl_part(obj, "efl.bar"), priv->spacer);
evas_object_event_callback_add
(priv->spacer, EVAS_CALLBACK_MOUSE_DOWN, _spacer_down_cb, obj);
evas_object_event_callback_add
(priv->spacer, EVAS_CALLBACK_MOUSE_MOVE, _spacer_move_cb, obj);
evas_object_event_callback_add
(priv->spacer, EVAS_CALLBACK_MOUSE_UP, _spacer_up_cb, obj);
evas_object_event_callback_add
(obj, EVAS_CALLBACK_MOUSE_IN, _mouse_in_cb, obj);
evas_object_event_callback_add
(obj, EVAS_CALLBACK_MOUSE_OUT, _mouse_out_cb, obj);
efl_ui_widget_focus_allow_set(obj, EINA_TRUE);
_elm_access_object_register(obj, wd->resize_obj);
_elm_access_text_set
(_elm_access_info_get(obj), ELM_ACCESS_TYPE, E_("slider"));
_elm_access_callback_set
(_elm_access_info_get(obj), ELM_ACCESS_INFO, _access_info_cb, NULL);
_elm_access_callback_set
(_elm_access_info_get(obj), ELM_ACCESS_STATE, _access_state_cb, NULL);
evas_object_smart_changed(obj);
return obj;
}
@ -247,10 +596,332 @@ _efl_ui_slider_interval_efl_object_destructor(Eo *obj,
efl_destructor(efl_super(obj, MY_CLASS));
}
#define EFL_UI_SLIDER_INTERVAL_EXTRA_OPS \
EFL_UI_SLIDER_VAL_FETCH_OPS(efl_ui_slider_interval), \
EFL_UI_SLIDER_VAL_SET_OPS(efl_ui_slider_interval), \
EFL_UI_SLIDER_DOWN_KNOB_OPS(efl_ui_slider_interval), \
EFL_UI_SLIDER_MOVE_KNOB_OPS(efl_ui_slider_interval), \
EOLIAN static Eina_Error
_efl_ui_slider_interval_efl_ui_widget_theme_apply(Eo *obj, Efl_Ui_Slider_Interval_Data *sd)
{
Eina_Error int_ret = EFL_UI_THEME_APPLY_ERROR_GENERIC;
ELM_WIDGET_DATA_GET_OR_RETURN(obj, wd, EFL_UI_THEME_APPLY_ERROR_GENERIC);
char *group;
group = _efl_ui_slider_interval_theme_group_get(obj, sd);
if (group)
{
elm_widget_theme_element_set(obj, group);
free(group);
}
int_ret = efl_ui_widget_theme_apply(efl_super(obj, MY_CLASS));
if (int_ret == EFL_UI_THEME_APPLY_ERROR_GENERIC) return int_ret;
if (efl_ui_layout_orientation_is_inverted(sd->dir))
efl_layout_signal_emit(obj, "efl,state,inverted,on", "efl");
else
efl_layout_signal_emit(obj, "efl,state,inverted,off", "efl");
_val_set(obj);
efl_layout_signal_process(wd->resize_obj, EINA_FALSE);
evas_object_smart_changed(obj);
return int_ret;
}
static void
_drag_up(Evas_Object *obj)
{
double step;
double relative_step;
EFL_UI_SLIDER_INTERVAL_DATA_GET(obj, sd);
ELM_WIDGET_DATA_GET_OR_RETURN(obj, wd);
step = sd->step;
if (efl_ui_layout_orientation_is_inverted(sd->dir)) step *= -1.0;
relative_step = step/(sd->val_max - sd->val_min);
efl_ui_drag_step_move(efl_part(wd->resize_obj, "efl.dragable.slider"),
relative_step, relative_step);
_slider_update(obj, EINA_TRUE);
}
static void
_drag_down(Evas_Object *obj)
{
double step;
double relative_step;
EFL_UI_SLIDER_INTERVAL_DATA_GET(obj, sd);
ELM_WIDGET_DATA_GET_OR_RETURN(obj, wd);
step = -sd->step;
if (efl_ui_layout_orientation_is_inverted(sd->dir)) step *= -1.0;
relative_step = step/(sd->val_max - sd->val_min);
efl_ui_drag_step_move(efl_part(wd->resize_obj, "efl.dragable.slider"),
relative_step, relative_step);
_slider_update(obj, EINA_TRUE);
}
static Eina_Bool
_key_action_drag(Evas_Object *obj, const char *params)
{
EFL_UI_SLIDER_INTERVAL_DATA_GET(obj, sd);
const char *dir = params;
double old_value, new_value;
old_value = efl_ui_range_value_get(obj);
if (!strcmp(dir, "left"))
{
if (!_is_horizontal(sd->dir))
return EINA_FALSE;
if (!efl_ui_layout_orientation_is_inverted(sd->dir))
_drag_down(obj);
else _drag_up(obj);
}
else if (!strcmp(dir, "right"))
{
if (!_is_horizontal(sd->dir))
return EINA_FALSE;
if (!efl_ui_layout_orientation_is_inverted(sd->dir))
_drag_up(obj);
else _drag_down(obj);
}
else if (!strcmp(dir, "up"))
{
if (_is_horizontal(sd->dir))
return EINA_FALSE;
if (efl_ui_layout_orientation_is_inverted(sd->dir))
_drag_up(obj);
else _drag_down(obj);
}
else if (!strcmp(dir, "down"))
{
if (_is_horizontal(sd->dir))
return EINA_FALSE;
if (efl_ui_layout_orientation_is_inverted(sd->dir))
_drag_down(obj);
else _drag_up(obj);
}
else return EINA_FALSE;
new_value = efl_ui_range_value_get(obj);
return !EINA_DBL_EQ(new_value, old_value);
}
EOLIAN static Eina_Bool
_efl_ui_slider_interval_efl_ui_widget_on_access_activate(Eo *obj, Efl_Ui_Slider_Interval_Data *sd, Efl_Ui_Activate act)
{
if (elm_widget_disabled_get(obj)) return EINA_FALSE;
if (act == EFL_UI_ACTIVATE_DEFAULT) return EINA_FALSE;
if ((act == EFL_UI_ACTIVATE_UP) ||
(act == EFL_UI_ACTIVATE_RIGHT))
{
if (!efl_ui_layout_orientation_is_inverted(sd->dir))
_drag_up(obj);
else _drag_down(obj);
}
else if ((act == EFL_UI_ACTIVATE_DOWN) ||
(act == EFL_UI_ACTIVATE_LEFT))
{
if (!efl_ui_layout_orientation_is_inverted(sd->dir))
_drag_down(obj);
else _drag_up(obj);
}
_slider_update(obj, EINA_TRUE);
return EINA_TRUE;
}
// _slider_efl_ui_widget_widget_input_event_handler
ELM_WIDGET_KEY_DOWN_DEFAULT_IMPLEMENT(slider, Efl_Ui_Slider_Interval_Data)
EOLIAN static Eina_Bool
_efl_ui_slider_interval_efl_ui_widget_widget_input_event_handler(Eo *obj, Efl_Ui_Slider_Interval_Data *sd, const Efl_Event *eo_event, Evas_Object *src)
{
Eo *ev = eo_event->info;
if (eo_event->desc == EFL_EVENT_KEY_DOWN)
{
if (!_slider_efl_ui_widget_widget_input_event_handler(obj, sd, eo_event, src))
return EINA_FALSE;
}
else if (eo_event->desc == EFL_EVENT_KEY_UP)
{
return EINA_FALSE;
}
else if (eo_event->desc == EFL_EVENT_POINTER_WHEEL)
{
if (efl_input_processed_get(ev)) return EINA_FALSE;
if (efl_input_pointer_wheel_delta_get(ev) < 0)
{
if (_is_horizontal(sd->dir))
_drag_up(obj);
else
_drag_down(obj);
}
else
{
if (_is_horizontal(sd->dir))
_drag_down(obj);
else
_drag_up(obj);
}
efl_input_processed_set(ev, EINA_TRUE);
}
else return EINA_FALSE;
_slider_update(obj, EINA_TRUE);
return EINA_TRUE;
}
EOLIAN static void
_efl_ui_slider_interval_efl_ui_range_display_range_limits_set(Eo *obj, Efl_Ui_Slider_Interval_Data *sd, double min, double max)
{
if (max < min)
{
ERR("Wrong params. min(%lf) is greater than max(%lf).", min, max);
return;
}
if (EINA_DBL_EQ(max, min))
{
ERR("min and max must have a different value");
return;
}
if ((EINA_DBL_EQ(sd->val_min, min)) && (EINA_DBL_EQ(sd->val_max, max))) return;
sd->val_min = min;
sd->val_max = max;
if (sd->val < sd->val_min) sd->val = sd->val_min;
if (sd->val > sd->val_max) sd->val = sd->val_max;
_val_set(obj);
}
EOLIAN static void
_efl_ui_slider_interval_efl_ui_range_display_range_limits_get(const Eo *obj EINA_UNUSED, Efl_Ui_Slider_Interval_Data *sd, double *min, double *max)
{
if (min) *min = sd->val_min;
if (max) *max = sd->val_max;
}
EOLIAN static void
_efl_ui_slider_interval_efl_ui_range_display_range_value_set(Eo *obj, Efl_Ui_Slider_Interval_Data *sd, double val)
{
if (val < sd->val_min)
{
ERR("Error, value is less than minimum");
return;
}
if (val > sd->val_max)
{
ERR("Error, value is greater than maximum");
return;
}
if (EINA_DBL_EQ(val, sd->val)) return;
sd->val = val;
_emit_events(obj, sd);
_val_set(obj);
}
EOLIAN static double
_efl_ui_slider_interval_efl_ui_range_display_range_value_get(const Eo *obj EINA_UNUSED, Efl_Ui_Slider_Interval_Data *sd)
{
return sd->val;
}
EOLIAN static double
_efl_ui_slider_interval_efl_ui_range_interactive_range_step_get(const Eo *obj EINA_UNUSED, Efl_Ui_Slider_Interval_Data *sd)
{
return sd->step;
}
EOLIAN static void
_efl_ui_slider_interval_efl_ui_range_interactive_range_step_set(Eo *obj EINA_UNUSED, Efl_Ui_Slider_Interval_Data *sd, double step)
{
if (step <= 0)
{
ERR("Wrong param. The step(%lf) should be greater than 0.0", step);
return;
}
if (sd->step == step) return;
sd->step = step;
}
EOLIAN static void
_efl_ui_slider_interval_efl_ui_layout_orientable_orientation_set(Eo *obj, Efl_Ui_Slider_Interval_Data *sd, Efl_Ui_Layout_Orientation dir)
{
sd->dir = dir;
efl_ui_widget_theme_apply(obj);
}
EOLIAN static Efl_Ui_Layout_Orientation
_efl_ui_slider_interval_efl_ui_layout_orientable_orientation_get(const Eo *obj EINA_UNUSED, Efl_Ui_Slider_Interval_Data *sd)
{
return sd->dir;
}
// A11Y Accessibility
EOLIAN static void
_efl_ui_slider_interval_efl_access_value_value_and_text_get(const Eo *obj EINA_UNUSED, Efl_Ui_Slider_Interval_Data *sd, double *value, const char **text)
{
if (value) *value = sd->val;
if (text) *text = NULL;
}
EOLIAN static Eina_Bool
_efl_ui_slider_interval_efl_access_value_value_and_text_set(Eo *obj, Efl_Ui_Slider_Interval_Data *sd, double value, const char *text EINA_UNUSED)
{
double oldval = sd->val;
if (value < sd->val_min) value = sd->val_min;
if (value > sd->val_max) value = sd->val_max;
efl_event_callback_call(obj, EFL_UI_SLIDER_INTERVAL_EVENT_SLIDER_DRAG_START, NULL);
sd->val = value;
_val_set(obj);
sd->val = oldval;
_slider_update(obj, EINA_TRUE);
efl_event_callback_call(obj, EFL_UI_SLIDER_INTERVAL_EVENT_SLIDER_DRAG_STOP, NULL);
return EINA_TRUE;
}
EOLIAN static void
_efl_ui_slider_interval_efl_access_value_range_get(const Eo *obj EINA_UNUSED, Efl_Ui_Slider_Interval_Data *sd, double *lower, double *upper, const char **descr)
{
if (lower) *lower = sd->val_min;
if (upper) *upper = sd->val_max;
if (descr) *descr = NULL;
}
EOLIAN static double
_efl_ui_slider_interval_efl_access_value_increment_get(const Eo *obj EINA_UNUSED, Efl_Ui_Slider_Interval_Data *sd)
{
return sd->step;
}
EOLIAN const Efl_Access_Action_Data *
_efl_ui_slider_interval_efl_access_widget_action_elm_actions_get(const Eo *obj EINA_UNUSED, Efl_Ui_Slider_Interval_Data *pd EINA_UNUSED)
{
static Efl_Access_Action_Data atspi_actions[] = {
{ "drag,left", "drag", "left", _key_action_drag},
{ "drag,right", "drag", "right", _key_action_drag},
{ "drag,up", "drag", "up", _key_action_drag},
{ "drag,down", "drag", "down", _key_action_drag},
{ NULL, NULL, NULL, NULL}
};
return &atspi_actions[0];
}
// A11Y Accessibility - END
#include "efl_ui_slider_interval.eo.c"

24
src/lib/elementary/efl_ui_slider_interval.eo
View File

@ -1,4 +1,5 @@
class @beta Efl.Ui.Slider_Interval extends Efl.Ui.Slider
class @beta Efl.Ui.Slider_Interval extends Efl.Ui.Layout_Base implements Efl.Ui.Range_Interactive,
Efl.Ui.Layout_Orientable, Efl.Access.Value, Efl.Access.Widget.Action
{
[[An interval slider.
@ -19,7 +20,24 @@ class @beta Efl.Ui.Slider_Interval extends Efl.Ui.Slider
}
}
implements {
Efl.Object.constructor;
Efl.Object.destructor;
Efl.Object.constructor;
Efl.Object.destructor;
Efl.Ui.Widget.theme_apply;
Efl.Ui.Widget.on_access_activate;
Efl.Ui.Widget.widget_input_event_handler;
Efl.Ui.Range_Display.range_value { get; set; }
Efl.Ui.Range_Display.range_limits {get; set; }
Efl.Ui.Range_Interactive.range_step { get; set; }
Efl.Ui.Layout_Orientable.orientation { get; set; }
Efl.Access.Value.value_and_text { get; set; }
Efl.Access.Value.range { get; }
Efl.Access.Value.increment { get; }
Efl.Access.Widget.Action.elm_actions { get; }
}
events {
slider,drag,start: void; [[Called when a slider drag operation has started. This means a $press event
has been received on the slider thumb but not the $unpress.]]
slider,drag,stop: void; [[Called when a slider drag operation has finished. This means an $unpress event
has been received on the slider thumb.]]
}
}

15
src/lib/elementary/efl_ui_slider_interval_private.h
View File

@ -5,9 +5,18 @@
typedef struct _Efl_Ui_Slider_Interval_Data Efl_Ui_Slider_Interval_Data;
struct _Efl_Ui_Slider_Interval_Data
{
Ecore_Timer *delay;
double intvl_from, intvl_to;
int intvl_flag;
Evas_Object *spacer;
Ecore_Timer *delay;
double intvl_from, intvl_to;
double val, val_min, val_max, step;
int intvl_flag;
Evas_Coord downx, downy;
Efl_Ui_Layout_Orientation dir;
Eina_Bool spacer_down : 1;
Eina_Bool frozen : 1;
};
/**

4
src/lib/elementary/efl_ui_spin_button.c
View File

@ -722,13 +722,13 @@ _efl_ui_spin_button_efl_ui_range_display_range_value_set(Eo *obj, Efl_Ui_Spin_Bu
}
EOLIAN static void
_efl_ui_spin_button_editable_set(Eo *obj EINA_UNUSED, Efl_Ui_Spin_Button_Data *sd, Eina_Bool editable)
_efl_ui_spin_button_direct_text_input_set(Eo *obj EINA_UNUSED, Efl_Ui_Spin_Button_Data *sd, Eina_Bool editable)
{
sd->editable = editable;
}
EOLIAN static Eina_Bool
_efl_ui_spin_button_editable_get(const Eo *obj EINA_UNUSED, Efl_Ui_Spin_Button_Data *sd)
_efl_ui_spin_button_direct_text_input_get(const Eo *obj EINA_UNUSED, Efl_Ui_Spin_Button_Data *sd)
{
return sd->editable;
}

4
src/lib/elementary/efl_ui_spin_button.eo
View File

@ -40,7 +40,7 @@ class @beta Efl.Ui.Spin_Button extends Efl.Ui.Spin implements Efl.Ui.Focus.Compo
circulate: bool(false); [[$true to enable circulate or $false to disable it.]]
}
}
@property editable {
@property direct_text_input {
[[Control whether the spin can be directly edited by the user.
Spin objects can have editing disabled, in which case they can only
@ -55,7 +55,7 @@ class @beta Efl.Ui.Spin_Button extends Efl.Ui.Spin implements Efl.Ui.Focus.Compo
get {
}
values {
editable: bool(false); [[$true to allow users to edit it or $false to don't allow users to edit it directly.]]
direct_text_input: bool(false); [[$true to allow users to edit it or $false to don't allow users to edit it directly.]]
}
}
}

4
src/lib/elementary/efl_ui_spotlight_manager_stack.c
View File

@ -62,9 +62,11 @@ static void
_running_cb(void *data, const Efl_Event *ev EINA_UNUSED)
{
Efl_Ui_Spotlight_Manager_Stack_Data *pd = efl_data_scope_safe_get(data, MY_CLASS);
double absolut_position;
EINA_SAFETY_ON_NULL_RETURN(pd);
//calculate absolut position, multiply pos with 2.0 because duration is only 0.5)
double absolut_position = pd->from + (pd->to - pd->from)*(efl_player_pos_get(pd->show)*2.0);
absolut_position = pd->from + (pd->to - pd->from)*(efl_player_pos_get(pd->show)*2.0);
efl_event_callback_call(data, EFL_UI_SPOTLIGHT_MANAGER_EVENT_POS_UPDATE, &absolut_position);
}

96
src/lib/elementary/efl_ui_table.c
View File

@ -244,6 +244,10 @@ _efl_ui_table_efl_object_invalidate(Eo *obj, Efl_Ui_Table_Data *pd)
EINA_INLIST_FREE(EINA_INLIST_GET(pd->items), gi)
{
efl_event_callback_array_del(gi->object, efl_ui_table_callbacks(), obj);
pd->items = (Table_Item *)
eina_inlist_remove(EINA_INLIST_GET(pd->items), EINA_INLIST_GET(gi));
free(gi);
}
}
@ -379,9 +383,9 @@ _efl_ui_table_efl_pack_table_pack_table(Eo *obj, Efl_Ui_Table_Data *pd,
}
EOLIAN static Eina_Bool
_efl_ui_table_efl_pack_table_table_position_get(const Eo *obj, Efl_Ui_Table_Data *pd, Evas_Object *subobj, int *col, int *row, int *colspan, int *rowspan)
_efl_ui_table_efl_pack_table_table_cell_column_get(const Eo *obj, Efl_Ui_Table_Data *pd, Evas_Object *subobj, int *col, int *colspan)
{
int c = -1, r = -1, cs = 0, rs = 0;
int c = -1, cs = 0;
Table_Item *gi;
Eina_Bool ret = EINA_FALSE;
@ -389,19 +393,101 @@ _efl_ui_table_efl_pack_table_table_position_get(const Eo *obj, Efl_Ui_Table_Data
if (gi)
{
c = gi->col;
r = gi->row;
cs = gi->col_span;
rs = gi->row_span;
ret = EINA_TRUE;
}
if (col) *col = c;
if (row) *row = r;
if (colspan) *colspan = cs;
return ret;
}
EOLIAN static void
_efl_ui_table_efl_pack_table_table_cell_column_set(Eo *obj, Efl_Ui_Table_Data *pd, Evas_Object *subobj, int col, int colspan)
{
Table_Item *gi;
gi = _efl_ui_table_item_date_get((Eo *)obj, pd, subobj);
if (!gi)
return;
if (col < 0) col = 0;
if (colspan < 1) colspan = 1;
if (((int64_t) col + (int64_t) colspan) > (int64_t) INT_MAX)
colspan = INT_MAX - col;
if (pd->req_cols && ((col + colspan) > pd->req_cols))
{
ERR("table requested size exceeded! packing in extra cell at "
"%d+%d (table cols: %d)", col, colspan, pd->req_cols);
}
gi->col = col;
gi->col_span = colspan;
if (gi->col > pd->last_col)
pd->linear_recalc = EINA_TRUE;
if (pd->cols < gi->col + gi->col_span)
pd->cols = gi->col + gi->col_span;
efl_pack_layout_request(obj);
}
EOLIAN static Eina_Bool
_efl_ui_table_efl_pack_table_table_cell_row_get(const Eo *obj, Efl_Ui_Table_Data *pd, Evas_Object *subobj, int *row, int *rowspan)
{
int r = -1, rs = 0;
Table_Item *gi;
Eina_Bool ret = EINA_FALSE;
gi = _efl_ui_table_item_date_get((Eo *)obj, pd, subobj);
if (gi)
{
r = gi->row;
rs = gi->row_span;
ret = EINA_TRUE;
}
if (row) *row = r;
if (rowspan) *rowspan = rs;
return ret;
}
EOLIAN static void
_efl_ui_table_efl_pack_table_table_cell_row_set(Eo *obj, Efl_Ui_Table_Data *pd, Evas_Object *subobj, int row, int rowspan)
{
Table_Item *gi;
gi = _efl_ui_table_item_date_get((Eo *)obj, pd, subobj);
if (!gi)
return;
if (row < 0) row = 0;
if (rowspan < 1) rowspan = 1;
if (((int64_t) row + (int64_t) rowspan) > (int64_t) INT_MAX)
rowspan = INT_MAX - row;
if (pd->req_rows && ((row + rowspan) > pd->req_rows))
{
ERR("table requested size exceeded! packing in extra cell at "
"%d+%d (table rows: %d)", row, rowspan, pd->req_rows);
}
gi->row = row;
gi->row_span = rowspan;
if (gi->row > pd->last_row)
pd->linear_recalc = EINA_TRUE;
if (pd->rows < gi->row + gi->row_span)
pd->rows = gi->row + gi->row_span;
efl_pack_layout_request(obj);
}
EOLIAN static Efl_Gfx_Entity *
_efl_ui_table_efl_pack_table_table_content_get(Eo *obj EINA_UNUSED, Efl_Ui_Table_Data *pd, int col, int row)
{

3
src/lib/elementary/efl_ui_table.eo
View File

@ -47,7 +47,8 @@ class Efl.Ui.Table extends Efl.Ui.Widget implements Efl.Pack_Table, Efl.Pack_Lay
Efl.Pack_Table.pack_table;
Efl.Pack_Table.table_content_get;
Efl.Pack_Table.table_contents_get;
Efl.Pack_Table.table_position { get; }
Efl.Pack_Table.table_cell_column { get; set; }
Efl.Pack_Table.table_cell_row { get; set; }
Efl.Pack_Table.table_size { get; set; }
Efl.Pack_Table.table_columns { get; set; }
Efl.Pack_Table.table_rows { get; set; }

274
src/lib/elementary/efl_ui_text_alert_popup.c
View File

@ -1,274 +0,0 @@
#ifdef HAVE_CONFIG_H
# include "elementary_config.h"
#endif
#define EFL_PART_PROTECTED
#include <Elementary.h>
#include "elm_priv.h"
#include "efl_ui_popup_private.h"
#include "efl_ui_text_alert_popup_private.h"
#include "efl_ui_text_alert_popup_part.eo.h"
#include "elm_part_helper.h"
#define MY_CLASS EFL_UI_TEXT_ALERT_POPUP_CLASS
#define MY_CLASS_NAME "Efl.Ui.Text_Alert_Popup"
//static const char PART_NAME_TEXT[] = "text";
static void
_scroller_sizing_eval(Eo *obj, Efl_Ui_Text_Alert_Popup_Data *pd, Eina_Size2D obj_min, Eina_Size2D text_min)
{
Eina_Size2D max_size, min_size;
max_size = efl_gfx_hint_size_max_get(obj);
if (max_size.w != -1)
max_size.w = (obj_min.w > max_size.w) ? obj_min.w : max_size.w;
if (max_size.h != -1)
max_size.h = (obj_min.h > max_size.h) ? obj_min.h : max_size.h;
min_size = efl_gfx_hint_size_min_get(obj);
Eina_Size2D size;
size.w = (obj_min.w > min_size.w) ? obj_min.w : min_size.w;
size.h = (obj_min.h > min_size.h) ? obj_min.h : min_size.h;
text_min.w = (obj_min.w > text_min.w) ? obj_min.w : text_min.w;
text_min.h = (obj_min.h > text_min.h) ? obj_min.h : text_min.h;
Eina_Size2D new_min = obj_min;
if ((max_size.w == -1) && (max_size.h == -1))
{
efl_ui_scrollable_match_content_set(pd->scroller, EINA_FALSE, EINA_FALSE);
efl_gfx_entity_size_set(obj, size);
}
else if ((max_size.w == -1) && (max_size.h != -1))
{
if (max_size.h < text_min.h)
{
efl_ui_scrollable_match_content_set(pd->scroller, EINA_FALSE, EINA_FALSE);
size = EINA_SIZE2D(size.w, max_size.h);
}
else
{
new_min.h = text_min.h;
efl_ui_scrollable_match_content_set(pd->scroller, EINA_FALSE, EINA_TRUE);
size = EINA_SIZE2D(size.w, text_min.h);
}
}
else if ((max_size.w != -1) && (max_size.h == -1))
{
if (max_size.w < text_min.w)
{
efl_ui_scrollable_match_content_set(pd->scroller, EINA_FALSE, EINA_FALSE);
size = EINA_SIZE2D(max_size.w, size.h);
}
else
{
new_min.w = text_min.w;
efl_ui_scrollable_match_content_set(pd->scroller, EINA_TRUE, EINA_FALSE);
size = EINA_SIZE2D(text_min.w, size.h);
}
}
else if ((max_size.w != -1) && (max_size.h != -1))
{
Eina_Size2D new_size;
Eina_Bool min_limit_w = EINA_FALSE;
Eina_Bool min_limit_h = EINA_FALSE;
if (max_size.w < text_min.w)
{
new_size.w = max_size.w;
}
else
{
min_limit_w = EINA_TRUE;
new_min.w = text_min.w;
new_size.w = text_min.w;
}
if (max_size.h < text_min.h)
{
new_size.h = max_size.h;
}
else
{
min_limit_h = EINA_TRUE;
new_min.h = text_min.h;
new_size.h = text_min.h;
}
efl_ui_scrollable_match_content_set(pd->scroller, min_limit_w, min_limit_h);
size = new_size;
}
efl_gfx_entity_size_set(obj, size);
efl_canvas_group_calculate(pd->scroller);
efl_gfx_hint_size_restricted_min_set(obj, new_min);
}
static void
_sizing_eval(Eo *obj, Efl_Ui_Text_Alert_Popup_Data *pd)
{
ELM_WIDGET_DATA_GET_OR_RETURN(obj, wd);
Evas_Coord obj_minw = -1, obj_minh = -1;
Evas_Coord text_minw = -1, text_minh = -1;
Eina_Size2D text_min;
//Calculate popup's min size including scroller's min size
{
elm_label_line_wrap_set(pd->message, ELM_WRAP_NONE);
efl_canvas_group_calculate(pd->message);
text_min = efl_gfx_hint_size_combined_min_get(pd->message);
elm_label_line_wrap_set(pd->message, ELM_WRAP_MIXED);
efl_canvas_group_calculate(pd->message);
efl_ui_scrollable_match_content_set(pd->scroller, EINA_FALSE, EINA_TRUE);
efl_canvas_group_calculate(pd->scroller);
elm_coords_finger_size_adjust(1, &text_minw, 1, &text_minh);
edje_object_size_min_restricted_calc
(wd->resize_obj, &text_minw, &text_minh, text_minw, text_minh);
}
//Calculate popup's min size except scroller's min size
{
efl_ui_scrollable_match_content_set(pd->scroller, EINA_FALSE, EINA_FALSE);
efl_canvas_group_calculate(pd->scroller);
elm_coords_finger_size_adjust(1, &obj_minw, 1, &obj_minh);
edje_object_size_min_restricted_calc
(wd->resize_obj, &obj_minw, &obj_minh, obj_minw, obj_minh);
}
text_min.h = text_minh;
_scroller_sizing_eval(obj, pd, EINA_SIZE2D(obj_minw, obj_minh), text_min);
}
EOLIAN static void
_efl_ui_text_alert_popup_efl_canvas_group_group_calculate(Eo *obj, Efl_Ui_Text_Alert_Popup_Data *pd)
{
EFL_UI_POPUP_DATA_GET_OR_RETURN(obj, ppd);
ppd->in_calc = EINA_TRUE;
_sizing_eval(obj, pd);
efl_canvas_group_need_recalculate_set(pd->scroller, EINA_FALSE);
efl_canvas_group_need_recalculate_set(obj, EINA_FALSE);
efl_canvas_group_calculate(efl_super(obj, MY_CLASS));
ppd->in_calc = EINA_FALSE;
}
static Eina_Bool
_efl_ui_text_alert_popup_content_set(Eo *obj, Efl_Ui_Text_Alert_Popup_Data *pd EINA_UNUSED, const char *part, Eo *content)
{
return efl_content_set(efl_part(efl_super(obj, MY_CLASS), part), content);
}
Eo *
_efl_ui_text_alert_popup_content_get(Eo *obj, Efl_Ui_Text_Alert_Popup_Data *pd EINA_UNUSED, const char *part)
{
return efl_content_get(efl_part(efl_super(obj, MY_CLASS), part));
}
static Eo *
_efl_ui_text_alert_popup_content_unset(Eo *obj, Efl_Ui_Text_Alert_Popup_Data *pd EINA_UNUSED, const char *part)
{
return efl_content_unset(efl_part(efl_super(obj, MY_CLASS), part));
}
static Eina_Bool
_efl_ui_text_alert_popup_text_set(Eo *obj, Efl_Ui_Text_Alert_Popup_Data *pd, const char *part, const char *label)
{
if (part && !strcmp(part, "efl.text"))
{
if (!pd->message)
{
// TODO: Change internal component to Efl.Ui.Widget
pd->message = elm_label_add(obj);
//elm_widget_element_update(obj, pd->message, PART_NAME_TEXT);
efl_gfx_hint_weight_set(pd->message, EVAS_HINT_EXPAND,
EVAS_HINT_EXPAND);
efl_content_set(pd->scroller, pd->message);
}
elm_object_text_set(pd->message, label);
efl_canvas_group_change(obj);
}
else
efl_text_set(efl_part(efl_super(obj, MY_CLASS), part), label);
return EINA_TRUE;
}
const char *
_efl_ui_text_alert_popup_text_get(const Eo *obj EINA_UNUSED, Efl_Ui_Text_Alert_Popup_Data *pd, const char *part)
{
if (part && !strcmp(part, "efl.text"))
{
if (pd->message)
return elm_object_text_get(pd->message);
return NULL;
}
return efl_text_get(efl_part(efl_super(obj, MY_CLASS), part));
}
EOLIAN static void
_efl_ui_text_alert_popup_efl_text_text_set(Eo *obj, Efl_Ui_Text_Alert_Popup_Data *pd, const char *label)
{
_efl_ui_text_alert_popup_text_set(obj, pd, "efl.text", label);
}
EOLIAN static const char*
_efl_ui_text_alert_popup_efl_text_text_get(const Eo *obj, Efl_Ui_Text_Alert_Popup_Data *pd)
{
return _efl_ui_text_alert_popup_text_get(obj, pd, "efl.text");
}
EOLIAN static Eo *
_efl_ui_text_alert_popup_efl_object_constructor(Eo *obj,
Efl_Ui_Text_Alert_Popup_Data *pd)
{
ELM_WIDGET_DATA_GET_OR_RETURN(obj, wd, NULL);
if (!elm_widget_theme_klass_get(obj))
elm_widget_theme_klass_set(obj, "text_alert_popup");
obj = efl_constructor(efl_super(obj, MY_CLASS));
efl_canvas_object_type_set(obj, MY_CLASS_NAME);
pd->scroller = efl_add(EFL_UI_SCROLLER_CLASS, obj,
efl_ui_widget_style_set(efl_added, "popup/no_inset_shadow"),
efl_ui_scrollbar_bar_mode_set(efl_added, EFL_UI_SCROLLBAR_MODE_OFF, EFL_UI_SCROLLBAR_MODE_AUTO));
efl_content_set(efl_part(efl_super(obj, MY_CLASS), "efl.content"),
pd->scroller);
return obj;
}
/* Efl.Part begin */
static Eina_Bool
_part_is_efl_ui_text_alert_popup_part(const Eo *obj EINA_UNUSED, const char *part)
{
//Use Efl.Ui.Widget's "background" and "shadow" parts
if (eina_streq(part, "background") || eina_streq(part, "shadow"))
return EINA_FALSE;
return EINA_TRUE;
}
ELM_PART_OVERRIDE_PARTIAL(efl_ui_text_alert_popup, EFL_UI_TEXT_ALERT_POPUP, Efl_Ui_Text_Alert_Popup_Data, _part_is_efl_ui_text_alert_popup_part)
ELM_PART_OVERRIDE_CONTENT_SET(efl_ui_text_alert_popup, EFL_UI_TEXT_ALERT_POPUP, Efl_Ui_Text_Alert_Popup_Data)
ELM_PART_OVERRIDE_CONTENT_GET(efl_ui_text_alert_popup, EFL_UI_TEXT_ALERT_POPUP, Efl_Ui_Text_Alert_Popup_Data)
ELM_PART_OVERRIDE_CONTENT_UNSET(efl_ui_text_alert_popup, EFL_UI_TEXT_ALERT_POPUP, Efl_Ui_Text_Alert_Popup_Data)
ELM_PART_OVERRIDE_TEXT_SET(efl_ui_text_alert_popup, EFL_UI_TEXT_ALERT_POPUP, Efl_Ui_Text_Alert_Popup_Data)
ELM_PART_OVERRIDE_TEXT_GET(efl_ui_text_alert_popup, EFL_UI_TEXT_ALERT_POPUP, Efl_Ui_Text_Alert_Popup_Data)
#include "efl_ui_text_alert_popup_part.eo.c"
/* Efl.Part end */
#include "efl_ui_text_alert_popup.eo.c"

12
src/lib/elementary/efl_ui_text_alert_popup.eo
View File

@ -1,12 +0,0 @@
import eina_types;
class @beta Efl.Ui.Text_Alert_Popup extends Efl.Ui.Alert_Popup implements Efl.Text
{
[[EFL UI Text Alert Popup class]]
implements {
Efl.Object.constructor;
Efl.Canvas.Group.group_calculate;
Efl.Text.text { get; set; }
Efl.Part.part_get;
}
}

10
src/lib/elementary/efl_ui_text_alert_popup_part.eo
View File

@ -1,10 +0,0 @@
class @beta Efl.Ui.Text_Alert_Popup_Part extends Efl.Ui.Layout_Part implements Efl.Content, Efl.Text
{
[[Efl UI Text Alert Popup internal part class]]
data: null;
implements {
Efl.Content.content { get; set; }
Efl.Content.content_unset;
Efl.Text.text { get; set; }
}
}

13
src/lib/elementary/efl_ui_text_alert_popup_private.h
View File

@ -1,13 +0,0 @@
#ifndef EFL_UI_TEXT_ALERT_POPUP_H
#define EFL_UI_TEXT_ALERT_POPUP_H
#include "Elementary.h"
typedef struct _Efl_Ui_Text_Alert_Popup_Data Efl_Ui_Text_Alert_Popup_Data;
struct _Efl_Ui_Text_Alert_Popup_Data
{
Eo *scroller;
Eo *message;
};
#endif

4
src/lib/elementary/efl_ui_timepicker.c
View File

@ -124,14 +124,14 @@ _fields_init(Eo *obj)
pd->hour = efl_add(EFL_UI_SPIN_BUTTON_CLASS, obj,
efl_ui_range_limits_set(efl_added, 1, 12),
efl_ui_spin_button_wraparound_set(efl_added, EINA_TRUE),
efl_ui_spin_button_editable_set(efl_added, EINA_TRUE),
efl_ui_spin_button_direct_text_input_set(efl_added, EINA_TRUE),
efl_ui_layout_orientation_set(efl_added, EFL_UI_LAYOUT_ORIENTATION_VERTICAL),
efl_event_callback_add(efl_added, EFL_UI_RANGE_EVENT_CHANGED,_field_changed_cb, obj));
pd->min = efl_add(EFL_UI_SPIN_BUTTON_CLASS, obj,
efl_ui_range_limits_set(efl_added, 0, 59),
efl_ui_spin_button_wraparound_set(efl_added, EINA_TRUE),
efl_ui_spin_button_editable_set(efl_added, EINA_TRUE),
efl_ui_spin_button_direct_text_input_set(efl_added, EINA_TRUE),
efl_ui_layout_orientation_set(efl_added, EFL_UI_LAYOUT_ORIENTATION_VERTICAL),
efl_event_callback_add(efl_added, EFL_UI_RANGE_EVENT_CHANGED,_field_changed_cb, obj));

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

@ -2282,7 +2282,7 @@ _efl_ui_widget_scroll_freeze_pop(Eo *obj, Elm_Widget_Smart_Data *sd)
{
if (elm_widget_is(child) && _elm_scrollable_is(child))
{
if (elm_widget_is_legacy(obj))
if (elm_widget_is_legacy(child))
elm_interface_scrollable_freeze_set(child, EINA_FALSE);
else
efl_ui_scrollable_scroll_freeze_set(child, EINA_FALSE);

3
src/lib/elementary/efl_ui_widget_image.h
View File

@ -58,8 +58,6 @@ struct _Efl_Ui_Image_Data
double frame_duration;
double align_x, align_y;
Evas_Coord img_x, img_y, img_w, img_h;
Eina_Size2D load_size;
int frame_count;
int cur_frame;
@ -104,6 +102,7 @@ struct _Efl_Ui_Image_Data
Eina_Bool scale_down : 1;
Eina_Bool legacy_align : 1;
Eina_Bool property_watch : 1;
Eina_Bool in_calc : 1;
};
/**

241
src/lib/elementary/efl_ui_widget_scrollable_content.c Normal file
View File

@ -0,0 +1,241 @@
#ifdef HAVE_CONFIG_H
# include "elementary_config.h"
#endif
#define EFL_UI_WIDGET_SCROLLABLE_CONTENT_PROTECTED
#include "elm_priv.h"
#define MY_CLASS EFL_UI_WIDGET_SCROLLABLE_CONTENT_MIXIN
#define MY_CLASS_NAME "Efl_Ui_Widget_Scrollable_Content"
typedef struct Efl_Ui_Widget_Scrollable_Content_Data
{
Eo *scroller;
Eo *label;
Eina_Bool did_group_calc : 1;
} Efl_Ui_Widget_Scrollable_Content_Data;
static void
_scroller_sizing_eval(Eo *obj, Efl_Ui_Widget_Scrollable_Content_Data *pd,
Eina_Size2D obj_min, Eina_Size2D scr_min)
{
Eina_Size2D max_size, min_size, size;
max_size = efl_gfx_hint_size_max_get(obj);
if (max_size.w != -1)
max_size.w = (obj_min.w > max_size.w) ? obj_min.w : max_size.w;
if (max_size.h != -1)
max_size.h = (obj_min.h > max_size.h) ? obj_min.h : max_size.h;
min_size = efl_gfx_hint_size_min_get(obj);
size.w = (obj_min.w > min_size.w) ? obj_min.w : min_size.w;
size.h = (obj_min.h > min_size.h) ? obj_min.h : min_size.h;
if (pd->label)
{
scr_min.w = (obj_min.w > scr_min.w) ? obj_min.w : scr_min.w;
scr_min.h = (obj_min.h > scr_min.h) ? obj_min.h : scr_min.h;
}
Eina_Size2D new_min = obj_min;
if ((max_size.w == -1) && (max_size.h == -1))
{
efl_ui_scrollable_match_content_set(pd->scroller, EINA_FALSE, EINA_FALSE);
}
else if ((max_size.w == -1) && (max_size.h != -1))
{
if (max_size.h < scr_min.h)
{
efl_ui_scrollable_match_content_set(pd->scroller, EINA_FALSE, EINA_FALSE);
size = EINA_SIZE2D(size.w, max_size.h);
}
else
{
new_min.h = scr_min.h;
efl_ui_scrollable_match_content_set(pd->scroller, EINA_FALSE, EINA_TRUE);
size = EINA_SIZE2D(size.w, scr_min.h);
}
}
else if ((max_size.w != -1) && (max_size.h == -1))
{
if (max_size.w < scr_min.w)
{
efl_ui_scrollable_match_content_set(pd->scroller, EINA_FALSE, EINA_FALSE);
size = EINA_SIZE2D(max_size.w, size.h);
}
else
{
new_min.w = scr_min.w;
efl_ui_scrollable_match_content_set(pd->scroller, EINA_TRUE, EINA_FALSE);
size = EINA_SIZE2D(scr_min.w, size.h);
}
}
else if ((max_size.w != -1) && (max_size.h != -1))
{
Eina_Bool min_limit_w = EINA_FALSE;
Eina_Bool min_limit_h = EINA_FALSE;
if (max_size.w < scr_min.w)
{
size.w = max_size.w;
}
else
{
min_limit_w = EINA_TRUE;
new_min.w = scr_min.w;
size.w = scr_min.w;
}
if (max_size.h < scr_min.h)
{
size.h = max_size.h;
}
else
{
min_limit_h = EINA_TRUE;
new_min.h = scr_min.h;
size.h = scr_min.h;
}
efl_ui_scrollable_match_content_set(pd->scroller, min_limit_w, min_limit_h);
}
/* this event must come before the scroller recalc in order to ensure the scroller has the correct viewport size */
efl_event_callback_call(obj, EFL_UI_WIDGET_SCROLLABLE_CONTENT_EVENT_OPTIMAL_SIZE_CALC, &size);
efl_canvas_group_calculate(pd->scroller);
efl_gfx_hint_size_restricted_min_set(obj, new_min);
}
static void
_sizing_eval(Eo *obj, Efl_Ui_Widget_Scrollable_Content_Data *pd)
{
ELM_WIDGET_DATA_GET_OR_RETURN(obj, wd);
Evas_Coord obj_minw = -1, obj_minh = -1;
Evas_Coord scr_minw = -1, scr_minh = -1;
Eina_Size2D text_min;
//Calculate popup's min size including scroller's min size
{
if (pd->label)
{
elm_label_line_wrap_set(pd->label, ELM_WRAP_NONE);
efl_canvas_group_calculate(pd->label);
text_min = efl_gfx_hint_size_combined_min_get(pd->label);
elm_label_line_wrap_set(pd->label, ELM_WRAP_MIXED);
efl_canvas_group_calculate(pd->label);
}
efl_ui_scrollable_match_content_set(pd->scroller, !pd->label, EINA_TRUE);
efl_canvas_group_calculate(pd->scroller);
elm_coords_finger_size_adjust(1, &scr_minw, 1, &scr_minh);
edje_object_size_min_restricted_calc
(wd->resize_obj, &scr_minw, &scr_minh, scr_minw, scr_minh);
}
//Calculate popup's min size except scroller's min size
{
efl_ui_scrollable_match_content_set(pd->scroller, EINA_FALSE, EINA_FALSE);
efl_canvas_group_calculate(pd->scroller);
elm_coords_finger_size_adjust(1, &obj_minw, 1, &obj_minh);
edje_object_size_min_restricted_calc
(wd->resize_obj, &obj_minw, &obj_minh, obj_minw, obj_minh);
}
if (pd->label)
scr_minw = text_min.w;
_scroller_sizing_eval(obj, pd, EINA_SIZE2D(obj_minw, obj_minh), EINA_SIZE2D(scr_minw, scr_minh));
}
EOLIAN static void
_efl_ui_widget_scrollable_content_efl_canvas_group_group_calculate(Eo *obj, Efl_Ui_Widget_Scrollable_Content_Data *pd)
{
pd->did_group_calc = EINA_FALSE;
if (!pd->scroller)
{
efl_canvas_group_calculate(efl_super(obj, MY_CLASS));
return;
}
pd->did_group_calc = EINA_TRUE;
_sizing_eval(obj, pd);
efl_canvas_group_need_recalculate_set(pd->scroller, EINA_FALSE);
efl_canvas_group_need_recalculate_set(obj, EINA_FALSE);
}
static void
_scroller_setup(Eo *obj, Efl_Ui_Widget_Scrollable_Content_Data *pd)
{
pd->scroller = efl_add(EFL_UI_SCROLLER_CLASS, obj,
efl_ui_widget_style_set(efl_added, "popup/no_inset_shadow")
);
efl_wref_add(pd->scroller, &pd->scroller);
efl_content_set(obj, pd->scroller);
}
static void
_label_setup(Eo *obj EINA_UNUSED, Efl_Ui_Widget_Scrollable_Content_Data *pd)
{
// TODO: Change internal component to Efl.Ui.Widget
pd->label = elm_label_add(pd->scroller);
//elm_widget_element_update(obj, pd->label, PART_NAME_TEXT);
efl_gfx_hint_weight_set(pd->label, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
efl_wref_add(pd->label, &pd->label);
efl_content_set(pd->scroller, pd->label);
}
EOLIAN static Eina_Bool
_efl_ui_widget_scrollable_content_scrollable_content_did_group_calc_get(const Eo *obj EINA_UNUSED, Efl_Ui_Widget_Scrollable_Content_Data *pd)
{
return pd->did_group_calc;
}
EOLIAN static Eina_Bool
_efl_ui_widget_scrollable_content_scrollable_content_set(Eo *obj, Efl_Ui_Widget_Scrollable_Content_Data *pd, Eo *content)
{
Eina_Bool ret;
if (!pd->scroller)
_scroller_setup(obj, pd);
ret = efl_content_set(pd->scroller, content);
if (ret) efl_canvas_group_change(obj);
return ret;
}
EOLIAN static Eo *
_efl_ui_widget_scrollable_content_scrollable_content_get(const Eo *obj EINA_UNUSED, Efl_Ui_Widget_Scrollable_Content_Data *pd)
{
return efl_content_get(pd->scroller);
}
EOLIAN static void
_efl_ui_widget_scrollable_content_scrollable_text_set(Eo *obj, Efl_Ui_Widget_Scrollable_Content_Data *pd, const char *text)
{
if (!pd->scroller)
_scroller_setup(obj, pd);
if (!pd->label)
_label_setup(obj, pd);
elm_object_text_set(pd->label, text);
//efl_text_set(pd->label, text);
efl_canvas_group_change(obj);
}
EOLIAN static const char *
_efl_ui_widget_scrollable_content_scrollable_text_get(const Eo *obj EINA_UNUSED, Efl_Ui_Widget_Scrollable_Content_Data *pd)
{
return elm_object_text_get(pd->label);
//return efl_text_get(pd->label);
}
EOLIAN static void
_efl_ui_widget_scrollable_content_efl_object_destructor(Eo *obj, Efl_Ui_Widget_Scrollable_Content_Data *pd)
{
if (pd->scroller) efl_wref_del(pd->scroller, &pd->scroller);
efl_destructor(efl_super(obj, MY_CLASS));
}
#define EFL_UI_WIDGET_SCROLLABLE_CONTENT_EXTRA_OPS \
EFL_CANVAS_GROUP_CALC_OPS(efl_ui_widget_scrollable_content)
#include "efl_ui_widget_scrollable_content.eo.c"

76
src/lib/elementary/efl_ui_widget_scrollable_content.eo Normal file
View File

@ -0,0 +1,76 @@
import eina_types;
mixin @beta Efl.Ui.Widget_Scrollable_Content requires Efl.Object
{
[[Efl widget scrollable content mixin
This can be used to provide scrollable contents and text for widgets.
Widgets can set the "__efl_scrollable_content_scroller_style" key data during
their constructor to apply a style to the internal scroller widget.
]]
c_prefix: efl_ui_widget;
event_prefix: efl_ui_widget_scrollable_content;
data: Efl_Ui_Widget_Scrollable_Content_Data;
methods {
@property scrollable_content_did_group_calc @protected @beta {
[[Widgets can call this function during their @Efl.Canvas.Group.group_calculate
implementation after the super call to determine whether the internal scroller
has performed sizing calculations.
The optimal_size,calc event will have been emitted during the super call if
this method returns $true.
In the case that this returns $true, it's likely that the widget should be completing
its internal sizing calculations from the optimal_size,calc callback using
`efl_canvas_group_calculate(efl_super(ev->object, EFL_UI_WIDGET_SCROLLABLE_CONTENT_MIXIN));`
in order to skip the scrollable sizing calc.
]]
get {}
values {
did_group_calc: bool; [[Whether the internal scroller has done sizing calcs.]]
}
}
@property scrollable_content {
[[This is the content which will be placed in the internal scroller.
]]
set {
return: bool; [[True on success]]
}
get {}
values {
content: Efl.Canvas.Object; [[The content object.]]
}
}
@property scrollable_text {
set {
[[Sets the text string to be displayed by the given text object.
The text will be scrollable depending on its size relative to the
object's geometry.
See also @.scrollable_text.get.
]]
}
get {
[[Retrieves the text string currently being displayed by the given
text object.
Do not free() the return value.
See also @.scrollable_text.set.
]]
}
values {
text: string; [[Text string to display on it.]]
}
}
}
events {
optimal_size,calc: Eina.Size2D; [[The optimal size for the widget based on scrollable content.]]
}
implements {
Efl.Object.destructor;
}
}

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

@ -7723,7 +7723,7 @@ _efl_ui_win_part_file_load(Eo *obj, Efl_Ui_Win_Data *sd, Eo *part_obj, const cha
if (file)
{
bg = efl_add(EFL_UI_IMAGE_CLASS, obj);
efl_gfx_image_scale_type_set(bg, EFL_GFX_IMAGE_SCALE_TYPE_FIT_OUTSIDE);
efl_gfx_image_scale_type_set(bg, EFL_GFX_IMAGE_SCALE_TYPE_EXPAND);
ok = efl_file_simple_load(bg, file, key);
if (!ok) ELM_SAFE_DEL(bg);
_elm_win_bg_set(sd, bg);

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

@ -532,7 +532,7 @@ _elm_ctxpopup_efl_ui_widget_widget_sub_object_add(Eo *obj, Elm_Ctxpopup_Data *_p
}
EOLIAN static void
_elm_ctxpopup_efl_canvas_group_calculate(Eo *obj, Elm_Ctxpopup_Data *sd)
_elm_ctxpopup_efl_canvas_group_group_calculate(Eo *obj, Elm_Ctxpopup_Data *sd)
{
Eina_Rectangle rect = { 0, 0, 1, 1 };
Evas_Coord_Point list_size = { 0, 0 }, parent_size = {0, 0};

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

@ -908,7 +908,7 @@ _elm_naviframe_item_elm_widget_item_signal_emit(Eo *eo_it EINA_UNUSED,
}
EOLIAN static void
_elm_naviframe_efl_canvas_group_calculate(Eo *obj, Elm_Naviframe_Data *sd)
_elm_naviframe_efl_canvas_group_group_calculate(Eo *obj, Elm_Naviframe_Data *sd)
{
Evas_Coord minw = 0, minh = 0;
Elm_Naviframe_Item_Data *it, *top;

Some files were not shown because too many files have changed in this diff Show More