Merge branch 'master' into devs/hermet/lottie

data/elementary/themes/edc/efl/check.edc

@@ -256,10 +256,7 @@ group { "efl/check";
       }
    }
    programs {
-      program {
-         signal: "mouse,clicked,1"; source: "event";
-         action: SIGNAL_EMIT "efl,action,check,toggle" "efl";
-      }
+      EFL_UI_CLICKABLE_PART_BIND(event)
       program {
          signal: "efl,state,check,on"; source: "efl";
          action:  STATE_SET "selected" 0.0;
@@ -774,10 +771,7 @@ group { "efl/check:toggle";
       }
    }
    programs {
-      program {
-         signal: "mouse,clicked,1"; source: "event";
-         action: SIGNAL_EMIT "efl,action,check,toggle" "efl";
-      }
+      EFL_UI_CLICKABLE_PART_BIND(event)
       program {
          signal: "efl,state,check,on"; source: "efl";
          script {

data/elementary/themes/edc/efl/radio.edc

@@ -222,10 +222,7 @@ group { "efl/radio";
       }
    }
    programs {
-      program {
-         signal: "mouse,clicked,1"; source: "event";
-         action: SIGNAL_EMIT "efl,action,radio,toggle" "efl";
-      }
+      EFL_UI_CLICKABLE_PART_BIND(event)
       program {
          signal: "efl,state,radio,on"; source: "efl";
          action:  STATE_SET "selected" 0.0;

doc/docfx/README

@@ -25,4 +25,22 @@ repository and adapt them to the DocFX syntax.
 Finally, run the `gendoc.sh` script (also from this folder) to produce the HTML
 files. First run can take a long time (from 10' to 1h), subsequent runs use
 cached results and take about 5 minutes.
+The result can be found in the _site folder.
 
+DEPLOYMENT
+----------
+
+This is the manual deployment process currently in use. It could certainly
+be improved and automated.
+The HTML files produced by DocFX are currently hosted using GitHub pages.
+The Enlightenment site's content is hosted in the www-content repository:
+https://git.enlightenment.org/website/www-content.git/
+This repo is mirrored at GitHub:
+https://github.com/Enlightenment/www-content
+The GitHub mirror has a branch called "gh-pages" which has a "gh-pages"
+folder at the root.
+
+Whenever new documentation is generated, just copy the _site folder from
+/doc/docfx in the EFL repo to /gh-pages/api/csharp in the www-content repo
+(gh-pages branch!) and push to the GitHub mirror.
+Changes should be visible almost instantly, since they are static pages.

src/bin/elementary/meson.build

@@ -158,6 +158,7 @@ elementary_test_src = [
   'test_ui_relative_layout.c',
   'test_ui_item_container.c',
   'test_ui_items.c',
+  'test_ui_frame.c',
   'test.h'
 ]
 

src/bin/elementary/test.c

@@ -402,6 +402,7 @@ void test_efl_ui_radio(void *data, Evas_Object *obj, void *event_info);
 void test_efl_ui_collection_list(void *data, Evas_Object *obj, void *event_info );
 void test_efl_ui_collection_grid(void *data, Evas_Object *obj, void *event_info);
 void test_efl_ui_item(void *data, Evas_Object *obj, void *event_info);
+void test_ui_frame(void *data EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event_info EINA_UNUSED);
 
 static void _list_udpate(void);
 
@@ -907,6 +908,7 @@ add_tests:
    ADD_TEST_EO(NULL, "Containers", "Efl.Ui.Collection List", test_efl_ui_collection_list);
    ADD_TEST_EO(NULL, "Containers", "Efl.Ui.Collection Grid", test_efl_ui_collection_grid);
    ADD_TEST_EO(NULL, "Containers", "Items", test_efl_ui_item);
+   ADD_TEST_EO(NULL, "Containers", "Efl.Ui.Frame", test_ui_frame);
 
    //------------------------------//
    ADD_TEST_EO(NULL, "Events", "Event Refeed", test_events);

src/bin/elementary/test_evas_snapshot.c

@@ -173,7 +173,7 @@ test_evas_snapshot(void *data EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *e
            elm_slider_unit_format_set(efl_added, "%.0f px"),
            efl_gfx_hint_weight_set(efl_added, 1.0, 0.0),
            efl_pack_table(table, efl_added, 0, TABLE_SIZE, TABLE_SIZE, 1),
-           efl_event_callback_add(efl_added, EFL_UI_SLIDER_EVENT_CHANGED, _radius_set, win));
+           efl_event_callback_add(efl_added, EFL_UI_RANGE_EVENT_CHANGED, _radius_set, win));
 
    box = efl_add(EFL_UI_BOX_CLASS, win,
                  efl_ui_layout_orientation_set(efl_added, EFL_UI_LAYOUT_ORIENTATION_HORIZONTAL),

src/bin/elementary/test_ui_box.c

@@ -379,7 +379,7 @@ test_ui_box(void *data EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event_in
    elm_slider_horizontal_set(o, 0);
    efl_gfx_hint_align_set(o, 0.5, -1);
    efl_gfx_hint_weight_set(o, 1, 1);
-   efl_event_callback_add(o, EFL_UI_SLIDER_EVENT_CHANGED, user_min_slider_cb, NULL);
+   efl_event_callback_add(o, EFL_UI_RANGE_EVENT_CHANGED, user_min_slider_cb, NULL);
    elm_slider_min_max_set(o, 0, 250);
    elm_slider_inverted_set(o, 1);
    elm_slider_value_set(o, 0);
@@ -406,7 +406,7 @@ test_ui_box(void *data EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event_in
    elm_slider_horizontal_set(o, 0);
    efl_gfx_hint_align_set(o, 0.5, -1);
    efl_gfx_hint_weight_set(o, 1, 1);
-   efl_event_callback_add(o, EFL_UI_SLIDER_EVENT_CHANGED, padding_slider_cb, win);
+   efl_event_callback_add(o, EFL_UI_RANGE_EVENT_CHANGED, padding_slider_cb, win);
    elm_slider_min_max_set(o, 0, 40);
    elm_slider_inverted_set(o, 1);
    elm_slider_value_set(o, 10);
@@ -433,7 +433,7 @@ test_ui_box(void *data EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event_in
    elm_slider_horizontal_set(o, 0);
    efl_gfx_hint_align_set(o, 0.5, -1);
    efl_gfx_hint_weight_set(o, 1, 1);
-   efl_event_callback_add(o, EFL_UI_SLIDER_EVENT_CHANGED, margin_slider_cb, win);
+   efl_event_callback_add(o, EFL_UI_RANGE_EVENT_CHANGED, margin_slider_cb, win);
    elm_slider_min_max_set(o, 0, 40);
    elm_slider_inverted_set(o, 1);
    elm_slider_value_set(o, 10);
@@ -460,7 +460,7 @@ test_ui_box(void *data EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event_in
    elm_slider_horizontal_set(o, 0);
    efl_gfx_hint_align_set(o, 0.5, -1);
    efl_gfx_hint_weight_set(o, 1, 1);
-   efl_event_callback_add(o, EFL_UI_SLIDER_EVENT_CHANGED, alignv_slider_cb, win);
+   efl_event_callback_add(o, EFL_UI_RANGE_EVENT_CHANGED, alignv_slider_cb, win);
    elm_slider_min_max_set(o, -0.1, 1.0);
    elm_slider_step_set(o, 0.1);
    elm_slider_value_set(o, 0.5);
@@ -474,7 +474,7 @@ test_ui_box(void *data EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event_in
    efl_gfx_hint_align_set(o, 0.5, -1);
    efl_gfx_hint_weight_set(o, 1, 0);
    efl_gfx_hint_size_min_set(o, EINA_SIZE2D(100, 0));
-   efl_event_callback_add(o, EFL_UI_SLIDER_EVENT_CHANGED, alignh_slider_cb, win);
+   efl_event_callback_add(o, EFL_UI_RANGE_EVENT_CHANGED, alignh_slider_cb, win);
    elm_slider_min_max_set(o, -0.1, 1.0);
    elm_slider_step_set(o, 0.1);
    elm_slider_value_set(o, 0.5);
@@ -500,7 +500,7 @@ test_ui_box(void *data EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event_in
    elm_slider_horizontal_set(o, 0);
    efl_gfx_hint_align_set(o, 0.5, -1);
    efl_gfx_hint_weight_set(o, 1, 1);
-   efl_event_callback_add(o, EFL_UI_SLIDER_EVENT_CHANGED, alignv_btn_slider_cb, win);
+   efl_event_callback_add(o, EFL_UI_RANGE_EVENT_CHANGED, alignv_btn_slider_cb, win);
    elm_slider_min_max_set(o, 0.0, 1.0);
    elm_slider_step_set(o, 0.1);
    elm_slider_value_set(o, 0.5);
@@ -514,7 +514,7 @@ test_ui_box(void *data EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event_in
    efl_gfx_hint_align_set(o, 0.5, -1);
    efl_gfx_hint_weight_set(o, 1, 0);
    efl_gfx_hint_size_min_set(o, EINA_SIZE2D(100, 0));
-   efl_event_callback_add(o, EFL_UI_SLIDER_EVENT_CHANGED, alignh_btn_slider_cb, win);
+   efl_event_callback_add(o, EFL_UI_RANGE_EVENT_CHANGED, alignh_btn_slider_cb, win);
    elm_slider_min_max_set(o, -0.1, 1.0);
    elm_slider_step_set(o, 0.1);
    elm_slider_value_set(o, 0.5);

src/bin/elementary/test_ui_frame.c

@@ -0,0 +1,55 @@
+#ifdef HAVE_CONFIG_H
+# include "elementary_config.h"
+#endif
+#include <Efl_Ui.h>
+#include <Elementary.h>
+
+static void
+_inc_clicked(void *data, const Efl_Event *ev EINA_UNUSED)
+{
+   efl_ui_frame_collapse_go(data, EINA_TRUE);
+}
+
+void
+test_ui_frame(void *data EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event_info EINA_UNUSED)
+{
+   Eo *win, *bx, *f, *txt;
+
+   win = efl_add_ref(EFL_UI_WIN_CLASS, efl_main_loop_get(),
+                 efl_ui_win_type_set(efl_added, EFL_UI_WIN_TYPE_BASIC),
+                 efl_text_set(efl_added, "Efl.Ui.Frame"),
+                 efl_ui_win_autodel_set(efl_added, EINA_TRUE));
+
+   bx = efl_add(EFL_UI_BOX_CLASS, win,
+                efl_content_set(win, efl_added),
+                efl_ui_layout_orientation_set(efl_added, EFL_UI_LAYOUT_ORIENTATION_VERTICAL));
+
+   f = efl_add(EFL_UI_FRAME_CLASS, win,
+               efl_pack_end(bx, efl_added),
+               efl_ui_frame_autocollapse_set(efl_added, EINA_FALSE));
+   efl_text_set(f, "Test 1");
+
+   txt = efl_add(EFL_UI_TEXT_CLASS, f);
+   efl_text_set(txt, "Not collapseable");
+   efl_content_set(f, txt);
+
+   f = efl_add(EFL_UI_FRAME_CLASS, win,
+               efl_pack_end(bx, efl_added),
+               efl_ui_frame_autocollapse_set(efl_added, EINA_TRUE));
+   efl_text_set(f, "Test2");
+
+   txt = efl_add(EFL_UI_TEXT_CLASS, f);
+   efl_text_set(txt, "Collapseable");
+   efl_content_set(f, txt);
+
+   f = efl_add(EFL_UI_FRAME_CLASS, win,
+               efl_pack_end(bx, efl_added));
+   efl_text_set(f, "Test 3");
+
+   efl_add(EFL_UI_BUTTON_CLASS, bx,
+           efl_text_set(efl_added, "frame collapse externally"),
+           efl_event_callback_add(efl_added, EFL_INPUT_EVENT_CLICKED, _inc_clicked, f),
+           efl_content_set(f, efl_added));
+
+   efl_gfx_entity_size_set(win, EINA_SIZE2D(100, 120));
+}

src/bin/elementary/test_ui_pager.c

@@ -364,7 +364,7 @@ static void page_size_cb(void *data,
                 efl_ui_range_limits_set(efl_added, 100, 200),
                 efl_ui_range_value_set(efl_added, params->w),
                 efl_gfx_hint_size_min_set(efl_added, EINA_SIZE2D(100, 0)),
-                efl_event_callback_add(efl_added, EFL_UI_SLIDER_EVENT_CHANGED,
+                efl_event_callback_add(efl_added, EFL_UI_RANGE_EVENT_CHANGED,
                                        width_slider_cb, params),
                 efl_pack_end(inbox, efl_added));
 
@@ -405,7 +405,7 @@ static void page_size_cb(void *data,
                 efl_ui_range_limits_set(efl_added, 100, 300),
                 efl_ui_range_value_set(efl_added, params->h),
                 efl_gfx_hint_size_min_set(efl_added, EINA_SIZE2D(100, 0)),
-                efl_event_callback_add(efl_added, EFL_UI_SLIDER_EVENT_CHANGED,
+                efl_event_callback_add(efl_added, EFL_UI_RANGE_EVENT_CHANGED,
                                        height_slider_cb, params),
                 efl_pack_end(inbox, efl_added));
 

src/bin/elementary/test_ui_pager_scroll.c

@@ -418,7 +418,7 @@ static void page_size_cb(void *data,
                 efl_ui_range_limits_set(efl_added, 100, 200),
                 efl_ui_range_value_set(efl_added, params->w),
                 efl_gfx_hint_size_min_set(efl_added, EINA_SIZE2D(100, 0)),
-                efl_event_callback_add(efl_added, EFL_UI_SLIDER_EVENT_CHANGED,
+                efl_event_callback_add(efl_added, EFL_UI_RANGE_EVENT_CHANGED,
                                        width_slider_cb, params),
                 efl_pack_end(inbox, efl_added));
 
@@ -459,7 +459,7 @@ static void page_size_cb(void *data,
                 efl_ui_range_limits_set(efl_added, 100, 300),
                 efl_ui_range_value_set(efl_added, params->h),
                 efl_gfx_hint_size_min_set(efl_added, EINA_SIZE2D(100, 0)),
-                efl_event_callback_add(efl_added, EFL_UI_SLIDER_EVENT_CHANGED,
+                efl_event_callback_add(efl_added, EFL_UI_RANGE_EVENT_CHANGED,
                                        height_slider_cb, params),
                 efl_pack_end(inbox, efl_added));
 
@@ -503,7 +503,7 @@ static void padding_cb(void *data,
            efl_ui_range_limits_set(efl_added, 0, 50),
            efl_ui_range_value_set(efl_added, params->padding),
            efl_gfx_hint_size_min_set(efl_added, EINA_SIZE2D(100, 0)),
-           efl_event_callback_add(efl_added, EFL_UI_SLIDER_EVENT_CHANGED,
+           efl_event_callback_add(efl_added, EFL_UI_RANGE_EVENT_CHANGED,
                                   padding_slider_cb, params),
            efl_pack_end(box, efl_added));
 }
@@ -534,7 +534,7 @@ static void side_page_num_cb(void *data,
            efl_ui_layout_orientation_set(efl_added, EFL_UI_LAYOUT_ORIENTATION_VERTICAL),
            efl_gfx_hint_weight_set(efl_added, 1, 1),
            efl_gfx_hint_align_set(efl_added, -1, -1),
-           efl_event_callback_add(efl_added, EFL_UI_SLIDER_EVENT_CHANGED,
+           efl_event_callback_add(efl_added, EFL_UI_RANGE_EVENT_CHANGED,
                                   side_page_num_slider_cb, params),
            efl_pack_end(box, efl_added));
 }

src/bin/elementary/test_ui_relative_layout.c

@@ -175,7 +175,7 @@ _setter_add(Eo *vbox, Eo *btn, Options option)
            efl_ui_range_step_set(efl_added, 0.1),
            efl_ui_range_value_set(efl_added, relative),
            efl_key_wref_set(efl_added, "btn", btn),
-           efl_event_callback_add(efl_added, EFL_UI_SLIDER_EVENT_CHANGED, _slider_changed_relative_cb, (void *)option),
+           efl_event_callback_add(efl_added, EFL_UI_RANGE_EVENT_CHANGED, _slider_changed_relative_cb, (void *)option),
            efl_pack(hbox, efl_added));
 }
 
@@ -246,7 +246,7 @@ _button_frame_add(Eo *box, Eo *btn)
            efl_ui_range_step_set(efl_added, 0.1),
            efl_ui_range_value_set(efl_added, align_x),
            efl_key_wref_set(efl_added, "btn", btn),
-           efl_event_callback_add(efl_added, EFL_UI_SLIDER_EVENT_CHANGED, _slider_changed_align_cb, (void *)'x'),
+           efl_event_callback_add(efl_added, EFL_UI_RANGE_EVENT_CHANGED, _slider_changed_align_cb, (void *)'x'),
            efl_pack(hbox, efl_added));
 
    hbox = efl_add(EFL_UI_BOX_CLASS, vbox,
@@ -266,7 +266,7 @@ _button_frame_add(Eo *box, Eo *btn)
            efl_ui_range_step_set(efl_added, 0.1),
            efl_ui_range_value_set(efl_added, align_y),
            efl_key_wref_set(efl_added, "btn", btn),
-           efl_event_callback_add(efl_added, EFL_UI_SLIDER_EVENT_CHANGED, _slider_changed_align_cb, (void *)'y'),
+           efl_event_callback_add(efl_added, EFL_UI_RANGE_EVENT_CHANGED, _slider_changed_align_cb, (void *)'y'),
            efl_pack(hbox, efl_added));
 }
 

src/bin/elementary/test_ui_slider.c

@@ -115,6 +115,6 @@ test_ui_slider(void *data EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event
            efl_gfx_hint_size_min_set(efl_added, EINA_SIZE2D(260, 0)),
            efl_ui_range_limits_set(efl_added, 0, 150),
            efl_ui_range_step_set(efl_added, 9),
-           efl_event_callback_add(efl_added, EFL_UI_SLIDER_EVENT_CHANGED, _slider_changed_cb, NULL),
+           efl_event_callback_add(efl_added, EFL_UI_RANGE_EVENT_CHANGED, _slider_changed_cb, NULL),
            efl_pack(bx, efl_added));
 }

src/bin/elementary/test_ui_slider_interval.c

@@ -112,6 +112,6 @@ test_slider_interval(void *data EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void
            efl_ui_range_limits_set(efl_added, 0, 600),
            efl_ui_slider_interval_value_set(efl_added, 100, 500),
            efl_ui_range_step_set(efl_added, step),
-           efl_event_callback_add(efl_added, EFL_UI_SLIDER_EVENT_CHANGED, _intv_slider_changed_cb, NULL),
+           efl_event_callback_add(efl_added, EFL_UI_RANGE_EVENT_CHANGED, _intv_slider_changed_cb, NULL),
            efl_pack(bx, efl_added));
 }

src/bin/elementary/test_ui_spin.c

@@ -51,9 +51,9 @@ test_ui_spin(void *data EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event_i
                 efl_ui_range_value_set(efl_added, 6),
                 efl_ui_range_step_set(efl_added, 2),
                 efl_ui_format_string_set(efl_added, "test %d", EFL_UI_FORMAT_STRING_TYPE_SIMPLE),
-                efl_event_callback_add(efl_added, EFL_UI_SPIN_EVENT_CHANGED,_spin_changed_cb, NULL),
-                efl_event_callback_add(efl_added, EFL_UI_SPIN_EVENT_MIN_REACHED,_spin_min_reached_cb, NULL),
-                efl_event_callback_add(efl_added, EFL_UI_SPIN_EVENT_MAX_REACHED,_spin_max_reached_cb, NULL),
+                efl_event_callback_add(efl_added, EFL_UI_RANGE_EVENT_CHANGED,_spin_changed_cb, NULL),
+                efl_event_callback_add(efl_added, EFL_UI_RANGE_EVENT_MIN_REACHED,_spin_min_reached_cb, NULL),
+                efl_event_callback_add(efl_added, EFL_UI_RANGE_EVENT_MAX_REACHED,_spin_max_reached_cb, NULL),
                 efl_pack(bx, efl_added));
 
    efl_add(EFL_UI_BUTTON_CLASS, bx,

src/bin/elementary/test_ui_spin_button.c

@@ -41,10 +41,10 @@ test_ui_spin_button(void *data EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *
            efl_ui_range_limits_set(efl_added, 0, 10),
            efl_ui_range_value_set(efl_added, 6),
            efl_ui_range_step_set(efl_added, 2),
-           efl_ui_spin_button_circulate_set(efl_added, EINA_TRUE),
+           efl_ui_spin_button_wraparound_set(efl_added, EINA_TRUE),
            efl_ui_spin_button_editable_set(efl_added, EINA_TRUE),
-           efl_event_callback_add(efl_added, EFL_UI_SPIN_BUTTON_EVENT_DELAY_CHANGED,_spin_delay_changed_cb, NULL),
-           efl_event_callback_add(efl_added, EFL_UI_SPIN_EVENT_CHANGED, _spin_changed_cb, NULL),
+           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));
 
    efl_add(EFL_UI_SPIN_BUTTON_CLASS, bx,

src/bin/elementary/test_ui_spotlight.c

@@ -140,6 +140,57 @@ next_btn_cb(void *data, const Efl_Event *ev EINA_UNUSED)
      efl_ui_spotlight_active_index_set(spotlight, active_index + 1);
 }
 
+static Eina_Value
+future_then_cb(void *data EINA_UNUSED, const Eina_Value value, const Eina_Future *dead_future EINA_UNUSED)
+{
+   /* If efl_ui_spotlight_pop is called with EINA_FALSE, then the content is not
+    * deleted and the value contains the content. */
+   Eo *content = eina_value_object_get(&value);
+   if (content)
+     efl_gfx_entity_visible_set(content, EINA_FALSE);
+
+   return EINA_VALUE_EMPTY;
+}
+
+static void
+pop_btn_cb(void *data, const Efl_Event *ev EINA_UNUSED)
+{
+   Eo *spotlight = data;
+
+   if (efl_content_count(spotlight) == 0) return;
+
+   Eina_Future *future = efl_ui_spotlight_pop(spotlight, EINA_TRUE);
+   eina_future_then(future, future_then_cb, NULL);
+}
+
+static void
+push_btn_cb(void *data, const Efl_Event *ev EINA_UNUSED)
+{
+   Eo *spotlight = data;
+   Eo *view;
+   int count = efl_content_count(spotlight);
+
+   switch (count % 3)
+     {
+        case 0:
+          view = view_add(BUTTON, spotlight);
+          break;
+
+        case 1:
+          view = view_add(LIST, spotlight);
+          break;
+
+        case 2:
+          view = view_add(LAYOUT, spotlight);
+          break;
+
+        default:
+          view = view_add(LAYOUT, spotlight);
+          break;
+     }
+   efl_ui_spotlight_push(spotlight, view);
+}
+
 static void
 back_btn_cb(void *data, const Efl_Event *ev EINA_UNUSED)
 {
@@ -397,7 +448,7 @@ spotlight_size(void *data,
                 efl_ui_range_limits_set(efl_added, 100, 200),
                 efl_ui_range_value_set(efl_added, params->w),
                 efl_gfx_hint_size_min_set(efl_added, EINA_SIZE2D(100, 0)),
-                efl_event_callback_add(efl_added, EFL_UI_SLIDER_EVENT_CHANGED,
+                efl_event_callback_add(efl_added, EFL_UI_RANGE_EVENT_CHANGED,
                                        width_slider_cb, params),
                 efl_pack_end(inbox, efl_added));
 
@@ -438,7 +489,7 @@ spotlight_size(void *data,
                 efl_ui_range_limits_set(efl_added, 100, 300),
                 efl_ui_range_value_set(efl_added, params->h),
                 efl_gfx_hint_size_min_set(efl_added, EINA_SIZE2D(100, 0)),
-                efl_event_callback_add(efl_added, EFL_UI_SLIDER_EVENT_CHANGED,
+                efl_event_callback_add(efl_added, EFL_UI_RANGE_EVENT_CHANGED,
                                        height_slider_cb, params),
                 efl_pack_end(inbox, efl_added));
 
@@ -494,6 +545,40 @@ view_animation_cb(void *data,
    efl_gfx_entity_visible_set(ck, 1);
 }
 
+static void
+_scroll_block_check_cb(void *data, const Efl_Event *ev)
+{
+   Params *params = data;
+
+   efl_ui_spotlight_manager_scroll_block_set(efl_ui_spotlight_manager_get(params->spotlight), efl_ui_check_selected_get(ev->object));
+}
+
+static void
+scroll_block_cb(void *data,
+                Evas_Object *obj EINA_UNUSED,
+                void *event_info EINA_UNUSED)
+{
+   Params *params = data;
+   Evas_Object *navi = params->navi;
+   Eo *btn, *box, *ck;
+
+   btn = efl_add(EFL_UI_BUTTON_CLASS, navi,
+                 efl_text_set(efl_added, "Back"),
+                 efl_event_callback_add(efl_added, EFL_INPUT_EVENT_CLICKED,
+                                        back_btn_cb, navi));
+
+   box = efl_add(EFL_UI_BOX_CLASS, navi,
+                 elm_naviframe_item_push(navi, "Scroll Block", btn, NULL,
+                                         efl_added, NULL));
+
+   ck = efl_add(EFL_UI_CHECK_CLASS, box);
+   efl_event_callback_add(ck, EFL_UI_CHECK_EVENT_SELECTED_CHANGED, _scroll_block_check_cb, params);
+   efl_ui_check_selected_set(ck, efl_ui_spotlight_manager_scroll_block_get(efl_ui_spotlight_manager_get(params->spotlight)));
+   efl_text_set(ck, "Scroll Block");
+   efl_pack_end(box, ck);
+   efl_gfx_entity_visible_set(ck, 1);
+}
+
 static void
 pack_cb(void *data,
         Evas_Object *obj EINA_UNUSED,
@@ -808,15 +893,15 @@ test_ui_spotlight_stack(void *data EINA_UNUSED,
    efl_ui_spotlight_manager_set(spotlight, efl_new(EFL_UI_SPOTLIGHT_MANAGER_STACK_CLASS));
 
    efl_add(EFL_UI_BUTTON_CLASS, layout,
-           efl_text_set(efl_added, "Prev"),
+           efl_text_set(efl_added, "Pop"),
            efl_event_callback_add(efl_added,
-                                  EFL_INPUT_EVENT_CLICKED, prev_btn_cb, spotlight),
+                                  EFL_INPUT_EVENT_CLICKED, pop_btn_cb, spotlight),
            efl_content_set(efl_part(layout, "prev_btn"), efl_added));
 
    efl_add(EFL_UI_BUTTON_CLASS, layout,
-           efl_text_set(efl_added, "Next"),
+           efl_text_set(efl_added, "Push"),
            efl_event_callback_add(efl_added,
-                                  EFL_INPUT_EVENT_CLICKED, next_btn_cb, spotlight),
+                                  EFL_INPUT_EVENT_CLICKED, push_btn_cb, spotlight),
            efl_content_set(efl_part(layout, "next_btn"), efl_added));
 
    params = calloc(1, sizeof(Params));
@@ -835,6 +920,7 @@ test_ui_spotlight_stack(void *data EINA_UNUSED,
    elm_list_item_append(list, "Active Index", NULL, NULL, active_index_cb, params);
    elm_list_item_append(list, "Indicator", NULL, NULL, indicator_cb, params);
    elm_list_item_append(list, "Animation", NULL, NULL, view_animation_cb, params);
+   elm_list_item_append(list, "Scroll Block", NULL, NULL, scroll_block_cb, params);
    elm_list_go(list);
 
    efl_event_callback_add(list, EFL_EVENT_DEL, list_del_cb, params);
@@ -1036,6 +1122,7 @@ test_ui_spotlight_scroll(void *data EINA_UNUSED,
    elm_list_item_append(list, "Active Index", NULL, NULL, active_index_cb, params);
    elm_list_item_append(list, "Indicator", NULL, NULL, indicator_cb, params);
    elm_list_item_append(list, "Animation", NULL, NULL, view_animation_cb, params);
+   elm_list_item_append(list, "Scroll Block", NULL, NULL, scroll_block_cb, params);
    elm_list_go(list);
 
    efl_event_callback_add(list, EFL_EVENT_DEL, list_del_cb, params);

src/bin/elementary/test_ui_table.c

@@ -304,7 +304,7 @@ test_ui_table(void *data EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event_
    elm_slider_horizontal_set(o, 0);
    efl_gfx_hint_align_set(o, 0.5, -1);
    efl_gfx_hint_weight_set(o, 1, 1);
-   efl_event_callback_add(o, EFL_UI_SLIDER_EVENT_CHANGED, user_min_slider_cb, NULL);
+   efl_event_callback_add(o, EFL_UI_RANGE_EVENT_CHANGED, user_min_slider_cb, NULL);
    elm_slider_min_max_set(o, 0, 250);
    elm_slider_inverted_set(o, 1);
    elm_slider_value_set(o, 0);
@@ -331,7 +331,7 @@ test_ui_table(void *data EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event_
    elm_slider_horizontal_set(o, 0);
    efl_gfx_hint_align_set(o, 0.5, -1);
    efl_gfx_hint_weight_set(o, 1, 1);
-   efl_event_callback_add(o, EFL_UI_SLIDER_EVENT_CHANGED, padding_slider_cb, table);
+   efl_event_callback_add(o, EFL_UI_RANGE_EVENT_CHANGED, padding_slider_cb, table);
    elm_slider_min_max_set(o, 0, 40);
    elm_slider_inverted_set(o, 1);
    elm_slider_value_set(o, 0);
@@ -357,7 +357,7 @@ test_ui_table(void *data EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event_
    elm_slider_horizontal_set(o, 0);
    efl_gfx_hint_align_set(o, 0.5, -1);
    efl_gfx_hint_weight_set(o, 1, 1);
-   efl_event_callback_add(o, EFL_UI_SLIDER_EVENT_CHANGED, margin_slider_cb, table);
+   efl_event_callback_add(o, EFL_UI_RANGE_EVENT_CHANGED, margin_slider_cb, table);
    elm_slider_min_max_set(o, 0, 40);
    elm_slider_inverted_set(o, 1);
    elm_slider_value_set(o, 0);
@@ -384,7 +384,7 @@ test_ui_table(void *data EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event_
    elm_slider_horizontal_set(o, 0);
    efl_gfx_hint_align_set(o, 0.5, -1);
    efl_gfx_hint_weight_set(o, 1, 1);
-   efl_event_callback_add(o, EFL_UI_SLIDER_EVENT_CHANGED, btnmargins_slider_cb, table);
+   efl_event_callback_add(o, EFL_UI_RANGE_EVENT_CHANGED, btnmargins_slider_cb, table);
    elm_slider_min_max_set(o, 0, 40);
    elm_slider_inverted_set(o, 1);
    elm_slider_value_set(o, 0);
@@ -411,7 +411,7 @@ test_ui_table(void *data EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event_
    elm_slider_horizontal_set(o, 0);
    efl_gfx_hint_align_set(o, 0.5, -1);
    efl_gfx_hint_weight_set(o, 1, 1);
-   efl_event_callback_add(o, EFL_UI_SLIDER_EVENT_CHANGED, alignv_slider_cb, NULL);
+   efl_event_callback_add(o, EFL_UI_RANGE_EVENT_CHANGED, alignv_slider_cb, NULL);
    elm_slider_min_max_set(o, 0, 1);
    elm_slider_value_set(o, 0.3);
    efl_pack(bx, o);
@@ -423,7 +423,7 @@ test_ui_table(void *data EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event_
    elm_slider_horizontal_set(o, 1);
    efl_gfx_hint_align_set(o, -1, -1);
    efl_gfx_hint_weight_set(o, 1, 0);
-   efl_event_callback_add(o, EFL_UI_SLIDER_EVENT_CHANGED, alignh_slider_cb, NULL);
+   efl_event_callback_add(o, EFL_UI_RANGE_EVENT_CHANGED, alignh_slider_cb, NULL);
    elm_slider_min_max_set(o, 0, 1);
    elm_slider_value_set(o, 0.3);
    efl_pack(bx, o);

src/bin/elementary/test_ui_textpath.c

@@ -152,7 +152,7 @@ test_ui_textpath(void *data EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *eve
    efl_gfx_hint_align_set(sld, 0.5, EVAS_HINT_FILL);
    efl_gfx_hint_weight_set(sld, EFL_GFX_HINT_EXPAND, EFL_GFX_HINT_EXPAND);
    efl_gfx_hint_size_min_set(sld, EINA_SIZE2D(150, 0));
-   efl_event_callback_add(sld, EFL_UI_SLIDER_EVENT_CHANGED, _angle_changed_cb, txtpath);
+   efl_event_callback_add(sld, EFL_UI_RANGE_EVENT_CHANGED, _angle_changed_cb, txtpath);
    elm_box_pack_end(hbox, sld);
    efl_gfx_entity_visible_set(sld, EINA_TRUE);
    angle_sld = sld;
@@ -164,7 +164,7 @@ test_ui_textpath(void *data EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *eve
    efl_gfx_hint_align_set(sld, 0.5, EVAS_HINT_FILL);
    efl_gfx_hint_weight_set(sld, EFL_GFX_HINT_EXPAND, EFL_GFX_HINT_EXPAND);
    efl_gfx_hint_size_min_set(sld, EINA_SIZE2D(150, 0));
-   efl_event_callback_add(sld, EFL_UI_SLIDER_EVENT_CHANGED, _slice_no_changed_cb, txtpath);
+   efl_event_callback_add(sld, EFL_UI_RANGE_EVENT_CHANGED, _slice_no_changed_cb, txtpath);
    elm_box_pack_end(hbox, sld);
    efl_gfx_entity_visible_set(sld, EINA_TRUE);
    slice_sld = sld;

src/bin/eolian_cxx/eolian_cxx.cc

@@ -305,7 +305,26 @@ run(options_type const& opts)
          }
        else
          {
-           std::abort();
+           if (!types_generate(base, opts, cpp_types_header))
+             {
+               EINA_CXX_DOM_LOG_ERR(eolian_cxx::domain)
+                 << "Error generating: " << ::eolian_class_short_name_get(klass)
+                 << std::endl;
+               assert(false && "error generating class");
+             }
+           else
+             {
+               std::ofstream header_decl;
+               header_decl.open(opts.out_file);
+               if (!header_decl.good())
+               {
+                 EINA_CXX_DOM_LOG_ERR(eolian_cxx::domain)
+                   << "Can't open output file: " << opts.out_file << std::endl;
+                 assert(false && "error opening file");
+               }
+               std::copy (cpp_types_header.begin(), cpp_types_header.end()
+                          , std::ostream_iterator<char>(header_decl));
+             }
          }
      }
    else
@@ -336,6 +355,10 @@ run(options_type const& opts)
                headers.insert(filename + std::string(".hh"));
                eo_files.insert(filename);
              }
+           else
+           {
+             headers.insert (base + std::string(".hh"));
+           }
          }
 
        using efl::eolian::grammar::header_include_directive;

src/bin/eolian_mono/eolian/mono/documentation.hh

@@ -567,6 +567,26 @@ documentation_generator as_generator(documentation_terminal)
     return documentation_generator(0);
 }
 
+/// Escape a single string, HTML-escaping and converting the syntax
+struct documentation_string_generator
+{
+  template<typename OutputIterator, typename Context>
+  bool generate(OutputIterator sink, std::string const& text, Context const& context) const
+  {
+      std::string escaped;
+      if (!as_generator(html_escaped_string).generate(std::back_inserter(escaped), text, context))
+        return false;
+
+      auto options = context_find_tag<options_context>(context);
+      auto state = context_find_tag<eolian_state_context>(context).state;
+      if (!as_generator(string).generate(sink, documentation_generator::syntax_conversion(escaped, state, options.want_beta), context))
+        return false;
+
+      return true;
+  }
+
+} const documentation_string {};
+
 } // namespace eolian_mono
 
 
@@ -577,6 +597,11 @@ struct is_eager_generator<::eolian_mono::documentation_generator> : std::true_ty
 template<>
 struct is_generator<::eolian_mono::documentation_generator> : std::true_type {};
 
+template<>
+struct is_eager_generator<::eolian_mono::documentation_string_generator> : std::true_type {};
+template<>
+struct is_generator<::eolian_mono::documentation_string_generator> : std::true_type {};
+
 template<>
 struct is_generator<::eolian_mono::documentation_terminal> : std::true_type {};
 
@@ -585,6 +610,8 @@ template<>
 struct attributes_needed<struct ::eolian_mono::documentation_generator> : std::integral_constant<int, 1> {};
 template<>
 struct attributes_needed<struct ::eolian_mono::documentation_terminal> : std::integral_constant<int, 1> {};
+template<>
+struct attributes_needed<struct ::eolian_mono::documentation_string_generator> : std::integral_constant<int, 1> {};
 }
 } } }
 

src/bin/eolian_mono/eolian/mono/events.hh

@@ -247,12 +247,12 @@ struct event_argument_wrapper_generator
 
       std::string evt_name = name_helpers::managed_event_name(evt.name);
 
-      return as_generator("///<summary>Event argument wrapper for event <see cref=\""
+      return as_generator("/// <summary>Event argument wrapper for event <see cref=\""
                           << join_namespaces(evt.klass.namespaces, '.', managed_namespace)
                           << klass_interface_name(evt.klass) << "." << evt_name << "\"/>.</summary>\n"
                           << "[Efl.Eo.BindingEntity]\n"
                           << "public class " << name_helpers::managed_event_args_short_name(evt) << " : EventArgs {\n"
-                          << scope_tab << "///<summary>Actual event payload.</summary>\n"
+                          << scope_tab << "/// <summary>Actual event payload.</summary>\n"
                           << scope_tab << "public " << type << " arg { get; set; }\n"
                           << "}\n"
                  ).generate(sink, *etype, context);
@@ -404,7 +404,7 @@ struct event_definition_generator
       auto library_name = context_find_tag<library_context>(context).actual_library_name(klass.filename);
       std::string upper_c_name = utils::to_uppercase(evt.c_name);
       if (!as_generator(
-            scope_tab << "///<summary>Method to raise event "<< event_name << ".</summary>\n"
+            scope_tab << "/// <summary>Method to raise event "<< event_name << ".</summary>\n"
             << scope_tab << "public void On" << event_name << "(" << event_args_type << " e)\n"
             << scope_tab << "{\n"
             << scope_tab << scope_tab << "var key = \"_" << upper_c_name << "\";\n"

src/bin/eolian_mono/eolian/mono/klass.hh

@@ -459,7 +459,7 @@ struct klass
      auto inherit_name = name_helpers::klass_concrete_name(cls);
 
      if(!as_generator(
-                scope_tab << "///<summary>Pointer to the native class description.</summary>\n"
+                scope_tab << "/// <summary>Pointer to the native class description.</summary>\n"
                 << scope_tab << "public override System.IntPtr NativeClass\n"
                 << scope_tab << "{\n"
                 << scope_tab << scope_tab << "get\n"

src/bin/eolian_mono/eolian/mono/struct_definition.hh

@@ -274,7 +274,7 @@ struct struct_internal_definition_generator
      if (!as_generator
          (
           indent << "#pragma warning disable CS1591\n\n"
-          << indent << "///<summary>Internal wrapper for struct " << string << ".</summary>\n"
+          << indent << "/// <summary>Internal wrapper for struct " << string << ".</summary>\n"
           << indent << "[StructLayout(LayoutKind.Sequential)]\n"
           << indent << "public struct " << string << "\n"
           << indent << "{\n"
@@ -295,7 +295,7 @@ struct struct_internal_definition_generator
                               || regular->base_type == "stringshare"
                               || regular->base_type == "any_value_ptr")))
             {
-               if (!as_generator(indent << scope_tab << "///<summary>Internal wrapper for field " << field_name << "</summary>\n"
+               if (!as_generator(indent << scope_tab << "/// <summary>Internal wrapper for field " << field_name << "</summary>\n"
                                  << indent << scope_tab << "public System.IntPtr " << field_name << ";\n")
                    .generate(sink, nullptr, context))
                  return false;
@@ -303,7 +303,7 @@ struct struct_internal_definition_generator
           else if (regular && !(regular->base_qualifier & efl::eolian::grammar::attributes::qualifier_info::is_ref)
                    && regular->base_type == "bool")
             {
-               if (!as_generator(indent << scope_tab << "///<summary>Internal wrapper for field " << field_name << "</summary>\n"
+               if (!as_generator(indent << scope_tab << "/// <summary>Internal wrapper for field " << field_name << "</summary>\n"
                                  << indent << scope_tab << "public System.Byte " << field_name << ";\n")
                    .generate(sink, nullptr, context))
                  return false;
@@ -311,7 +311,7 @@ struct struct_internal_definition_generator
           else if (regular && !(regular->base_qualifier & efl::eolian::grammar::attributes::qualifier_info::is_ref)
                    && regular->base_type == "char")
             {
-               if (!as_generator(indent << scope_tab << "///<summary>Internal wrapper for field " << field_name << "</summary>\n"
+               if (!as_generator(indent << scope_tab << "/// <summary>Internal wrapper for field " << field_name << "</summary>\n"
                                  << indent << scope_tab << "public System.Byte " << field_name << ";\n")
                    .generate(sink, nullptr, context))
                  return false;
@@ -337,7 +337,7 @@ struct struct_internal_definition_generator
 
      // to internal
      if (!as_generator(
-           indent << scope_tab << "///<summary>Implicit conversion to the internal/marshalling representation.</summary>\n"
+           indent << scope_tab << "/// <summary>Implicit conversion to the internal/marshalling representation.</summary>\n"
            << indent << scope_tab << "public static implicit operator " << string << "(" << string << " _external_struct)\n"
            << indent << scope_tab << "{\n"
            << indent << scope_tab << scope_tab << "var _internal_struct = new " << string << "();\n"
@@ -356,7 +356,7 @@ struct struct_internal_definition_generator
 
      // to managed
      if (!as_generator(
-           indent << scope_tab << "///<summary>Implicit conversion to the managed representation.</summary>\n"
+           indent << scope_tab << "/// <summary>Implicit conversion to the managed representation.</summary>\n"
            << indent << scope_tab << "public static implicit operator " << string << "(" << string << " _internal_struct)\n"
            << indent << scope_tab << "{\n"
            << indent << scope_tab << scope_tab << "var _external_struct = new " << string << "();\n"
@@ -406,14 +406,16 @@ struct struct_definition_generator
      // iterate struct fields
      for (auto const& field : struct_.fields)
        {
-          auto field_name = field.name;
-          field_name[0] = std::toupper(field_name[0]); // Hack to allow 'static' as a field name
-          if (!as_generator
-              (
-               documentation(indent.n + 1)
-               << indent << scope_tab << "public " << type << " " << string << ";\n"
-              )
-              .generate(sink, std::make_tuple(field, field.type, name_helpers::to_field_name(field.name)), context))
+          if (!as_generator(documentation(indent.n + 1)).generate(sink, field, context))
+            return false;
+
+          if (!field.type.doc_summary.empty())
+            {
+               if (!as_generator(indent << scope_tab << "/// <value>" << field.type.doc_summary << "</value>\n").generate(sink, attributes::unused, context))
+                 return false;
+            }
+
+          if (!as_generator(indent << scope_tab << "public " << type << " " << name_helpers::to_field_name(field.name) << ";\n").generate(sink, field.type, context))
             return false;
        }
 
@@ -425,7 +427,7 @@ struct struct_definition_generator
      // those 'mini-amd64.c condition fields not met' crashes.
      if (struct_.fields.size() == 0)
        {
-           if (!as_generator(indent << scope_tab << "///<summary>Placeholder field</summary>\n"
+           if (!as_generator(indent << scope_tab << "/// <summary>Placeholder field</summary>\n"
                              << indent << scope_tab << "public IntPtr field;\n").generate(sink, nullptr, context))
              return false;
        }
@@ -433,20 +435,21 @@ struct struct_definition_generator
        {
           // Constructor with default parameters for easy struct initialization
           if(!as_generator(
-                      indent << scope_tab << "///<summary>Constructor for " << string << ".</summary>\n"
+                      indent << scope_tab << "/// <summary>Constructor for " << string << ".</summary>\n"
+                      << *(indent << scope_tab << field_argument_docs << ";\n")
                       << indent << scope_tab << "public " << string << "(\n"
                       << ((indent << scope_tab << scope_tab << field_argument_default) % ",\n")
                       << indent << scope_tab << ")\n"
                       << indent << scope_tab << "{\n"
                       << *(indent << scope_tab << scope_tab << field_argument_assignment << ";\n")
                       << indent << scope_tab << "}\n\n")
-             .generate(sink, std::make_tuple(struct_name, struct_name, struct_.fields, struct_.fields), context))
+             .generate(sink, std::make_tuple(struct_name, struct_.fields, struct_name, struct_.fields, struct_.fields), context))
               return false;
        }
 
      if(!as_generator(
-            indent << scope_tab << "///<summary>Implicit conversion to the managed representation from a native pointer.</summary>\n"
-            << indent << scope_tab << "///<param name=\"ptr\">Native pointer to be converted.</param>\n"
+            indent << scope_tab << "/// <summary>Implicit conversion to the managed representation from a native pointer.</summary>\n"
+            << indent << scope_tab << "/// <param name=\"ptr\">Native pointer to be converted.</param>\n"
             << indent << scope_tab << "public static implicit operator " << struct_name << "(IntPtr ptr)\n"
             << indent << scope_tab << "{\n"
             << indent << scope_tab << scope_tab << "var tmp = (" << struct_name << ".NativeStruct)Marshal.PtrToStructure(ptr, typeof(" << struct_name << ".NativeStruct));\n"

src/bin/eolian_mono/eolian/mono/struct_fields.hh

@@ -37,6 +37,18 @@ struct field_argument_assignment_generator
    }
 } const field_argument_assignment {};
 
+struct field_argument_docs_generator
+{
+   template<typename OutputIterator, typename Context>
+   bool generate(OutputIterator sink, attributes::struct_field_def const& field, Context const& context) const
+   {
+       if (!as_generator("/// <param name=\"" << string << "\">" << documentation_string << "</param>")
+               .generate(sink, std::make_tuple(name_helpers::to_field_name(field.name), field.documentation.summary), context))
+           return false;
+       return true;
+   }
+} const field_argument_docs {};
+
 }
 
 namespace efl { namespace eolian { namespace grammar {
@@ -51,6 +63,11 @@ struct is_eager_generator< ::eolian_mono::field_argument_assignment_generator> :
 template<>
 struct is_generator< ::eolian_mono::field_argument_assignment_generator> : std::true_type {};
 
+template<>
+struct is_eager_generator< ::eolian_mono::field_argument_docs_generator> : std::true_type {};
+template<>
+struct is_generator< ::eolian_mono::field_argument_docs_generator> : std::true_type {};
+
 namespace type_traits {
 
 template <>
@@ -59,6 +76,9 @@ struct attributes_needed< ::eolian_mono::field_argument_default_generator> : std
 template <>
 struct attributes_needed< ::eolian_mono::field_argument_assignment_generator> : std::integral_constant<int, 1> {};
 
+template <>
+struct attributes_needed< ::eolian_mono::field_argument_docs_generator> : std::integral_constant<int, 1> {};
+
 }
 
 } } }

src/bindings/cxx/meson.build

@@ -38,6 +38,24 @@ foreach lib : cxx_sublibs
   eo_file_subdirs = get_variable(package_name + '_eo_subdirs')
   #generate files for each .eo files
   foreach eo_file_subdir : eo_file_subdirs
+    if eo_file_subdir != ''
+      cxx_pub_eot_files = get_variable(package_name + '_' + eo_file_subdir +'_eot_files')
+    else
+      cxx_pub_eot_files = get_variable(package_name +'_eot_files')
+    endif
+    subdir_file_location = join_paths(file_location, eo_file_subdir)
+    foreach cxx_gen_file : cxx_pub_eot_files
+      cxx_generator_target += custom_target('eolian_cxx_gen_'+cxx_gen_file.underscorify()+'',
+        input : join_paths(subdir_file_location, cxx_gen_file),
+        output : [cxx_gen_file + '.hh'],
+        install : true,
+        install_dir : join_paths(dir_include, package_version_name, eo_file_subdir),
+        command : [eolian_cxx_gen, '-I', meson.current_source_dir(), eolian_include_directories,
+                                   '-o', join_paths(meson.current_build_dir(), cxx_gen_file + '.hh'),
+                                   '@INPUT@'])
+      eo_file_list += files(join_paths(subdir_file_location, cxx_gen_file))
+    endforeach
+
     if eo_file_subdir != ''
       cxx_pub_eo_files = get_variable(package_name + '_' + eo_file_subdir +'_eo_files')
     else

src/bindings/luajit/eolian.lua

@@ -169,8 +169,7 @@ ffi.cdef [[
         EOLIAN_TYPE_BUILTIN_STRINGSHARE,
         EOLIAN_TYPE_BUILTIN_STRBUF,
 
-        EOLIAN_TYPE_BUILTIN_VOID_PTR,
-        EOLIAN_TYPE_BUILTIN_FREE_CB
+        EOLIAN_TYPE_BUILTIN_VOID_PTR
     } Eolian_Type_Builtin_Type;
 
     typedef enum {
@@ -973,8 +972,7 @@ M.type_builtin_type = {
    STRINGSHARE   = 46,
    STRBUF        = 47,
 
-   VOID_PTR      = 48,
-   FREE_CB       = 49
+   VOID_PTR      = 48
 }
 
 M.typedecl_type = {

src/examples/elementary/genlist_example_01.c

@@ -11,7 +11,7 @@ static char *
 _item_label_get(void *data, Evas_Object *obj EINA_UNUSED, const char *part EINA_UNUSED)
 {
    char buf[256];
-   snprintf(buf, sizeof(buf), "Item # %i", (int)(long)data);
+   snprintf(buf, sizeof(buf), "Item # %i", (int)(uintptr_t)data);
    return strdup(buf);
 }
 
@@ -39,7 +39,7 @@ elm_main(int argc EINA_UNUSED, char **argv EINA_UNUSED)
 {
    Evas_Object *win;
    Evas_Object *list;
-   int i;
+   unsigned int i;
 
    win = elm_win_util_standard_add("genlist", "Genlist");
    elm_policy_set(ELM_POLICY_QUIT, ELM_POLICY_QUIT_LAST_WINDOW_CLOSED);
@@ -60,7 +60,7 @@ elm_main(int argc EINA_UNUSED, char **argv EINA_UNUSED)
    for (i = 0; i < N_ITEMS; i++)
      {
         elm_genlist_item_append(list, _itc,
-                                (void *)(long)i, NULL,
+                                (void *)(uintptr_t)i, NULL,
                                 ELM_GENLIST_ITEM_NONE,
                                 _item_sel_cb, NULL);
      }

src/examples/elementary/genlist_example_02.c

@@ -13,7 +13,7 @@ _item_label_get(void *data, Evas_Object *obj EINA_UNUSED, const char *part EINA_
 {
    time_t t = (time_t)ecore_time_unix_get();
    char buf[256];
-   int i = (int)(long)data;
+   int i = (int)(uintptr_t)data;
    if (i % 2)
      {
         int n;
@@ -90,7 +90,7 @@ elm_main(int argc EINA_UNUSED, char **argv EINA_UNUSED)
 {
    Evas_Object *win, *box, *hbox;
    Evas_Object *list, *btn;
-   int i;
+   unsigned int i;
 
    win = elm_win_util_standard_add("genlist", "Genlist - simple");
    elm_policy_set(ELM_POLICY_QUIT, ELM_POLICY_QUIT_LAST_WINDOW_CLOSED);
@@ -151,7 +151,7 @@ elm_main(int argc EINA_UNUSED, char **argv EINA_UNUSED)
    for (i = 0; i < N_ITEMS; i++)
      {
         elm_genlist_item_append(list, _itc,
-                                (void *)(long)i, NULL,
+                                (void *)(uintptr_t)i, NULL,
                                 ELM_GENLIST_ITEM_NONE,
                                 _item_sel_cb, NULL);
      }

src/examples/elementary/genlist_example_03.c

@@ -12,7 +12,7 @@ _item_label_get(void *data, Evas_Object *obj EINA_UNUSED, const char *part)
 {
    time_t t = (time_t)ecore_time_unix_get();
    char buf[256];
-   int i = (int)(long)data;
+   int i = (int)(uintptr_t)data;
 
    if (!strcmp(part, "elm.text"))
      snprintf(buf, sizeof(buf), "Item # %i", i);
@@ -60,12 +60,12 @@ _genlist_add(Evas_Object *box)
 static void
 _genlist_fill(Evas_Object *list)
 {
-   int i;
+   unsigned int i;
 
    for (i = 0; i < N_ITEMS; i++)
      {
         elm_genlist_item_append(list, _itc,
-                                (void *)(long)i, NULL,
+                                (void *)(uintptr_t)i, NULL,
                                 ELM_GENLIST_ITEM_NONE,
                                 _item_sel_cb, NULL);
      }

src/examples/elementary/genlist_example_04.c

@@ -14,7 +14,7 @@ _item_label_get(void *data, Evas_Object *obj EINA_UNUSED, const char *part)
 {
    time_t t = (time_t)ecore_time_unix_get();
    char buf[256];
-   int i = (int)(long)data;
+   int i = (int)(uintptr_t)data;
 
    if (!strcmp(part, "elm.text"))
      snprintf(buf, sizeof(buf), "Item # %i", i);
@@ -52,7 +52,7 @@ static char *
 _group_label_get(void *data, Evas_Object *obj EINA_UNUSED, const char *part EINA_UNUSED)
 {
    char buf[256];
-   int i = (int)(long)data;
+   int i = (int)(uintptr_t)data;
 
    snprintf(buf, sizeof(buf), "Group %d (item #%d)", i / 7, i);
 
@@ -77,7 +77,7 @@ _append_cb(void *data, Evas_Object *o EINA_UNUSED, void *event_info EINA_UNUSED)
    Evas_Object *list = data;
 
    elm_genlist_item_append(list, _itc,
-                           (void *)(long)nitems++, NULL,
+                           (void *)(uintptr_t)nitems++, NULL,
                            ELM_GENLIST_ITEM_NONE,
                            _item_sel_cb, NULL);
 
@@ -89,7 +89,7 @@ _prepend_cb(void *data, Evas_Object *o EINA_UNUSED, void *event_info EINA_UNUSED
    Evas_Object *list = data;
 
    elm_genlist_item_prepend(list, _itc,
-                            (void *)(long)nitems++, NULL,
+                            (void *)(uintptr_t)nitems++, NULL,
                             ELM_GENLIST_ITEM_NONE,
                             _item_sel_cb, NULL);
 
@@ -104,7 +104,7 @@ _insert_before_cb(void *data, Evas_Object *o EINA_UNUSED, void *event_info EINA_
    if (!glit) return;
 
    elm_genlist_item_insert_before(list, _itc,
-                                  (void *)(long)nitems++, NULL,
+                                  (void *)(uintptr_t)nitems++, NULL,
                                   glit, ELM_GENLIST_ITEM_NONE,
                                   _item_sel_cb, NULL);
 
@@ -119,7 +119,7 @@ _insert_after_cb(void *data, Evas_Object *o EINA_UNUSED, void *event_info EINA_U
    if (!glit) return;
 
    elm_genlist_item_insert_after(list, _itc,
-                                 (void *)(long)nitems++, NULL,
+                                 (void *)(uintptr_t)nitems++, NULL,
                                  glit, ELM_GENLIST_ITEM_NONE,
                                  _item_sel_cb, NULL);
 
@@ -305,7 +305,7 @@ elm_main(int argc EINA_UNUSED, char **argv EINA_UNUSED)
         if (i % 7 == 0)
           {
              glg = gli = elm_genlist_item_append(list, _itc_group,
-                                                 (void *)(long)nitems++, NULL,
+                                                 (void *)(uintptr_t)nitems++, NULL,
                                                  ELM_GENLIST_ITEM_GROUP,
                                                  _item_sel_cb, NULL);
              elm_genlist_item_select_mode_set(gli, ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
@@ -313,7 +313,7 @@ elm_main(int argc EINA_UNUSED, char **argv EINA_UNUSED)
         else
           {
              gli = elm_genlist_item_append(list, _itc,
-                                           (void *)(long)nitems++, glg,
+                                           (void *)(uintptr_t)nitems++, glg,
                                            ELM_GENLIST_ITEM_NONE,
                                            _item_sel_cb, NULL);
           }

src/examples/elementary/slider_cxx_example.cc

@@ -68,15 +68,15 @@ efl_main(void *data EINA_UNUSED, const Efl_Event *ev EINA_UNUSED)
    sl7.hint_fill_set(true, false);
    bx.pack_end(sl7);
 
-   auto changed = std::bind ( [] (efl::ui::Slider obj)
+   auto changed = std::bind ( [] (efl::ui::Range_Display obj)
    { std::cout << "Changed to " << obj.range_value_get() << std::endl; }
          , std::placeholders::_1);
 
-   auto steady =  std::bind ( [] (efl::ui::Slider obj)
+   auto steady =  std::bind ( [] (efl::ui::Range_Interactive obj)
    { std::cout << "Steady to " << obj.range_value_get() << std::endl; }
          , std::placeholders::_1);
 
-   sl7.changed_event_cb_add(changed);
-   sl7.steady_event_cb_add(steady);
+   efl::eo::downcast<efl::ui::Range_Display>(sl7).changed_event_cb_add(changed);
+   efl::eo::downcast<efl::ui::Range_Interactive>(sl7).steady_event_cb_add(steady);
 }
 EFL_MAIN()

src/examples/elementary/spinner_cxx_example.cc

@@ -1,19 +1,20 @@
 // g++ -g `pkg-config --cflags --libs elementary-cxx efl-cxx eina-cxx eo-cxx ecore-cxx evas-cxx edje-cxx` spinner_cxx_example.cc -o spinner_cxx_example
 
-#define ELM_WIDGET_PROTECTED
-
+#define EFL_CXXPERIMENTAL
+#ifndef EFL_BETA_API_SUPPORT
+#define EFL_BETA_API_SUPPORT
+#endif
 #include <Efl_Ui.hh>
 #include <iostream>
 
-#warning FIXME: This example requires proper EO API usage (not legacy spinner)
-
+using namespace std::placeholders;
 using efl::eo::instantiate;
 
+static efl::ui::Win win;
+
 static void
 efl_main(void *data EINA_UNUSED, const Efl_Event *ev EINA_UNUSED)
 {
-#if 0
-
    efl::ui::Win win(instantiate);
    win.text_set("Spinner Example");
    win.autohide_set(true);
@@ -22,67 +23,73 @@ efl_main(void *data EINA_UNUSED, const Efl_Event *ev EINA_UNUSED)
    efl::ui::Box bx(instantiate, win);
    win.content_set(bx);
 
-   elm::Spinner sp(instantiate, win);
+   efl::ui::Spin_Button sp(instantiate, win);
    sp.hint_fill_set(true, false);
+   sp.range_step_set(1.0);
+   sp.range_limits_set(0.0, 10.0);
+   sp.wraparound_set(true);
    bx.pack_end(sp);
 
-   elm::Spinner sp2(instantiate, win);
-   sp2.label_format_set("Percentage %%%1.2f something");
+   efl::ui::Spin_Button sp2(instantiate, win);
+   sp2.format_string_set("Percentage %%%1.2f something", EFL_UI_FORMAT_STRING_TYPE_SIMPLE);
    sp2.hint_fill_set(true, false);
    bx.pack_end(sp2);
 
-   elm::Spinner sp3(instantiate, win);
-   sp3.label_format_set("%1.1f units");
-   sp3.step_set(1.5);
-   sp3.wrap_set(true);
-   sp3.min_max_set(-50.0, 250.0);
+   efl::ui::Spin_Button sp3(instantiate, win);
+   sp3.format_string_set("%1.1f units", EFL_UI_FORMAT_STRING_TYPE_SIMPLE);
+   sp3.range_step_set(1.5);
+   sp3.range_limits_set(-50.0, 250.0);
    sp3.hint_fill_set(true, false);
    bx.pack_end(sp3);
 
-   elm::Spinner sp4(instantiate, win);
-   sp4.style_set("vertical");
-   sp4.interval_set(0.2);
+   efl::ui::Spin_Button sp4(instantiate, win);
+   //FIXME setting the style is propetected...
+   //sp4.style_set("vertical");
+   sp4.range_step_set(0.2);
    sp4.hint_fill_set(true, false);
    bx.pack_end(sp4);
 
-   elm::Spinner sp5(instantiate, win);
+   efl::ui::Spin_Button sp5(instantiate, win);
    sp5.editable_set(false);
    sp5.hint_fill_set(true, false);
    bx.pack_end(sp5);
 
-   elm::Spinner sp6(instantiate, win);
+   Efl_Ui_Format_Value values[] = {
+     {1, "January"},
+     {2, "February"},
+     {3, "March"},
+     {4, "April"},
+     {5, "May"},
+     {6, "June"},
+     {7, "July"},
+     {8, "August"},
+     {9, "September"},
+     {10, "October"},
+     {11, "November"},
+     {12, "December"}
+   };
+   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.min_max_set(1, 12);
-   sp6.special_value_add(1, "January");
-   sp6.special_value_add(2, "February");
-   sp6.special_value_add(3, "March");
-   sp6.special_value_add(4, "April");
-   sp6.special_value_add(5, "May");
-   sp6.special_value_add(6, "June");
-   sp6.special_value_add(7, "July");
-   sp6.special_value_add(8, "August");
-   sp6.special_value_add(9, "September");
-   sp6.special_value_add(10, "October");
-   sp6.special_value_add(11, "November");
-   sp6.special_value_add(12, "December");
+   sp6.range_limits_set(1, 12);
+   //sp6.format_values_set(values_acc);
    sp6.hint_fill_set(true, false);
    bx.pack_end(sp6);
 
-   elm::Spinner sp7(instantiate, win);
+   efl::ui::Spin_Button sp7(instantiate, win);
    sp7.hint_fill_set(true, false);
    bx.pack_end(sp7);
    sp7.editable_set(true);
 
-   auto changed = std::bind([] (elm::Spinner &spinner)
-   { std::cout << "Value changed to " << spinner.value_get() << std::endl; },
-         std::placeholders::_1);
-   efl::eolian::event_add(elm::Spinner::changed_event, sp7, changed);
+   auto changed = std::bind ( [] (efl::ui::Range_Display obj)
+   { std::cout << "Changed to " << obj.range_value_get() << std::endl; }
+         , std::placeholders::_1);
+   efl::eo::downcast<efl::ui::Range_Display>(sp7).changed_event_cb_add(changed);
 
-   auto delay = std::bind([] (elm::Spinner &spinner)
-   { std::cout << "Value changed to " << spinner.value_get() << "" << std::endl; },
-         std::placeholders::_1);
-   efl::eolian::event_add(elm::Spinner::delay_changed_event, sp7, delay);
+   auto steady =  std::bind ( [] (efl::ui::Range_Interactive obj)
+   { std::cout << "Steady to " << obj.range_value_get() << std::endl; }
+         , std::placeholders::_1);
+   efl::eo::downcast<efl::ui::Range_Interactive>(sp7).steady_event_cb_add(steady);
 
-#endif
 }
 EFL_MAIN()

src/lib/ecore/efl_composite_model.eo

@@ -2,20 +2,21 @@ class @beta Efl.Composite_Model extends Efl.Loop_Model implements Efl.Ui.View
 {
    [[Efl model for all composite class which provide a unified API to set source of data.
 
-   This class also provide an @Efl.Model.property "$child.index" that match the value of @.index.]]
+   This class also provide an @Efl.Model.property "child.index" that match the value of @.index.]]
    methods {
       @property index {
-         [[Position of this object in the parent model.]]
+         [[Position of this object in the parent model.
+
+           It can only be set before the object is finalized but after the Model it composes is set
+           (and only if that Model does not provide an index already).
+           It can only be retrieved after the object has been finalized.
+         ]]
          set {
-            [[Set the index. It can only be set before the object is finalized,
-            but after the Model it compose is set and only if that Model does
-            not provide an index already.]]
          }
          get {
-            [[Get the index. It will only work after the object has been finalized.]]
          }
          values {
-            index: uint; [[Index of the object in the parent model. The index is uniq and start from zero.]]
+            index: uint; [[Index of the object in the parent model. The index is unique and starts from zero.]]
          }
       }
    }

src/lib/ecore_wl2/ecore_wl2.c

@@ -231,7 +231,7 @@ ecore_wl2_shutdown(void)
 {
    if (_ecore_wl2_init_count < 1)
      {
-        ERR("Ecore_Wl2 shutdown called without Ecore_Wl2 Init");
+        EINA_LOG_ERR("Ecore_Wl2 shutdown called without Ecore_Wl2 Init");
         return 0;
      }
 

src/lib/edje/edje_calc.c

@@ -3018,9 +3018,7 @@ _edje_part_recalc_single(Edje *ed,
    params->req.x = TO_INT(params->eval.x);
    params->req.y = TO_INT(params->eval.y);
    params->req.w = TO_INT(params->eval.w);
-   if (params->req.w < 0) params->req.w = 0;
    params->req.h = TO_INT(params->eval.h);
-   if (params->req.h < 0) params->req.h = 0;
 
    /* adjust for min size */
    _edje_part_recalc_single_min(desc, params, minw, minh, apref);

src/lib/efl/interfaces/efl_gfx_types.eot

@@ -161,8 +161,8 @@ enum Efl.Gfx.Change_Flag
 struct Efl.Gfx.Event.Render_Post
 {
    [[Data sent along a "render,post" event, after a frame has been rendered.]]
-   updated_area: list<ptr(Eina.Rect)>; [[A list of rectangles that were
-                                         updated in the canvas.]]
+   updated_area: list<Eina.Rect>; [[A list of rectangles that were
+                                    updated in the canvas.]]
 }
 
 enum Efl.Gfx.Hint_Aspect

src/lib/efl/interfaces/efl_text_font.eo

@@ -63,6 +63,9 @@ interface @beta Efl.Text_Font {
               to get an idea). Alternatively, youe can use the full path to a font
               file.
 
+              To skip changing font family pass null as font family.
+              To skip changing font size pass 0 as font size.
+
               See also @.font.get, @.font_source.get.
             ]]
          }

src/lib/efl/interfaces/efl_ui_range_display.eo

@@ -48,4 +48,9 @@ interface @beta Efl.Ui.Range_Display
          }
       }
    }
+   events {
+      changed: void; [[Emitted when the $range_value is getting changed]]
+      min,reached: void; [[Emitted when the $range_value has reached the minimum of $range_limits]]
+      max,reached: void; [[Emitted when the $range_value has reached the maximum of $range_limits]]
+   }
 }

src/lib/efl/interfaces/efl_ui_range_interactive.eo

@@ -23,4 +23,11 @@ interface @beta Efl.Ui.Range_Interactive extends Efl.Ui.Range_Display
          }
       }
    }
+   events {
+      steady: void; [[Called when the widget's value has changed and has remained unchanged for 0.2s.
+                   This allows filtering out unwanted "noise" from the widget if you are only
+                   interested in its final position.
+                   Use this event instead of @[Efl.Ui.Range_Display.changed] if you are going to perform a costly operation
+                   on its handler. ]]
+   }
 }

src/lib/elementary/efl_ui_box_flow.c

@@ -193,6 +193,7 @@ _efl_ui_box_flow_efl_pack_layout_layout_update(Eo *obj, Efl_Ui_Box_Flow_Data *pd
 
         cross_min_sum += row->cross_space;
         cross_weight_sum += row->cross_weight;
+        item_last += row->item_count;
 
         if (bd->homogeneous)
           continue;
@@ -205,7 +206,6 @@ _efl_ui_box_flow_efl_pack_layout_layout_update(Eo *obj, Efl_Ui_Box_Flow_Data *pd
              calc_size = box_size;
              inlist = NULL;
 
-             item_last += row->item_count;
              for (; i < item_last; i++)
                {
                   double denom;
@@ -246,6 +246,7 @@ _efl_ui_box_flow_efl_pack_layout_layout_update(Eo *obj, Efl_Ui_Box_Flow_Data *pd
         else if (EINA_DBL_EQ(row->weight_sum, 0))
           {
              row->cur_pos += (box_size - row->min_sum) * box_calc[axis].align;
+             i += row->item_count;
           }
      }
 

src/lib/elementary/efl_ui_check.c

@@ -253,6 +253,12 @@ _on_check_toggle(void *data,
    _activate(data);
 }
 
+static void
+_clicked_cb(void *data, const Efl_Event *ev EINA_UNUSED)
+{
+   _activate(data);
+}
+
 EOLIAN static Eina_Bool
 _efl_ui_check_selected_get(const Eo *obj EINA_UNUSED, Efl_Ui_Check_Data *pd EINA_UNUSED)
 {
@@ -304,7 +310,7 @@ _efl_ui_check_efl_object_constructor(Eo *obj, Efl_Ui_Check_Data *pd EINA_UNUSED)
    evas_object_smart_callbacks_descriptions_set(obj, _smart_callbacks);
 
    ELM_WIDGET_DATA_GET_OR_RETURN(obj, wd, NULL);
-
+   efl_ui_clickable_util_bind_to_theme(wd->resize_obj, obj);
    if (elm_widget_is_legacy(obj))
      {
         efl_layout_signal_callback_add
@@ -320,8 +326,7 @@ _efl_ui_check_efl_object_constructor(Eo *obj, Efl_Ui_Check_Data *pd EINA_UNUSED)
           (wd->resize_obj, "efl,action,check,on", "*", obj, _on_check_on, NULL);
         efl_layout_signal_callback_add
           (wd->resize_obj, "efl,action,check,off", "*", obj, _on_check_off, NULL);
-        efl_layout_signal_callback_add
-          (wd->resize_obj, "efl,action,check,toggle", "*", obj, _on_check_toggle, NULL);
+        efl_event_callback_add(obj, EFL_INPUT_EVENT_CLICKED, _clicked_cb, obj);
      }
 
    efl_access_object_role_set(obj, EFL_ACCESS_ROLE_CHECK_BOX);

src/lib/elementary/efl_ui_check.eo

@@ -1,4 +1,4 @@
-class @beta Efl.Ui.Check extends Efl.Ui.Layout_Base implements Efl.Access.Widget.Action, Efl.Text, Efl.Content
+class @beta Efl.Ui.Check extends Efl.Ui.Layout_Base implements Efl.Access.Widget.Action, Efl.Text, Efl.Content, Efl.Input.Clickable
 {
    [[Check widget
 

src/lib/elementary/efl_ui_clickable_util.c

@@ -68,7 +68,6 @@ _press_cb(void *data, const Efl_Event *ev)
    if (!efl_input_processed_get(pointer))
      {
         efl_input_clickable_press(data, 1);
-        efl_input_processed_set(pointer, EINA_TRUE);
      }
 }
 
@@ -89,13 +88,11 @@ _unpress_cb(void *data, const Efl_Event *ev EINA_UNUSED)
         if (efl_canvas_object_pointer_mode_get(data) == EFL_INPUT_OBJECT_POINTER_MODE_AUTO_GRAB)
           {
              efl_input_clickable_unpress(data, 1);
-             efl_input_processed_set(pointer, EINA_TRUE);
           }
      }
    else
      {
         efl_input_clickable_unpress(data, 1);
-        efl_input_processed_set(pointer, EINA_TRUE);
      }
 }
 

src/lib/elementary/efl_ui_collection.c

@@ -13,21 +13,20 @@
 #include "elm_priv.h"
 
 typedef struct {
-   Eina_Accessor acc;
    unsigned int last_index;
    const Eina_List *current;
    Eina_List **items;
 } Fast_Accessor;
 
-static Eina_Bool
-_fast_accessor_get_at(Fast_Accessor *accessor, unsigned int idx, void **data)
+static const Eina_List*
+_fast_accessor_get_at(Fast_Accessor *accessor, unsigned int idx)
 {
    const Eina_List *over;
    unsigned int middle;
    unsigned int i;
 
    if (idx >= eina_list_count(*accessor->items))
-     return EINA_FALSE;
+     return NULL;
 
    if (accessor->last_index == idx)
      over = accessor->current;
@@ -70,33 +69,12 @@ _fast_accessor_get_at(Fast_Accessor *accessor, unsigned int idx, void **data)
      }
 
    if (!over)
-     return EINA_FALSE;
+     return NULL;
 
    accessor->last_index = idx;
    accessor->current = over;
 
-   *data = eina_list_data_get(over);
-   return EINA_TRUE;
-}
-
-
-static Eina_Accessor*
-_fast_accessor_clone(Fast_Accessor *accessor)
-{
-   return eina_list_accessor_new(*accessor->items);
-}
-
-static Eina_List *
-_fast_accessor_get_container(Fast_Accessor *accessor EINA_UNUSED)
-{
-   ERR("Not allowed to get a container!");
-   return NULL;
-}
-
-static void
-_fast_accessor_free(Fast_Accessor *accessor EINA_UNUSED)
-{
-   ERR("Freeing this accessor is not supported");
+   return over;
 }
 
 static void
@@ -105,12 +83,6 @@ _fast_accessor_init(Fast_Accessor *accessor, Eina_List **items)
    //this is the accessor for accessing the items
    //we have to workarround here the problem that
    //no accessor can be created for a not yet created list.
-   accessor->acc.version = EINA_ACCESSOR_VERSION;
-   accessor->acc.get_at = FUNC_ACCESSOR_GET_AT(_fast_accessor_get_at);
-   accessor->acc.clone = FUNC_ACCESSOR_CLONE(_fast_accessor_clone);
-   accessor->acc.get_container = FUNC_ACCESSOR_GET_CONTAINER(_fast_accessor_get_container);
-   accessor->acc.free = FUNC_ACCESSOR_FREE(_fast_accessor_free);
-   EINA_MAGIC_SET(&accessor->acc, EINA_MAGIC_ACCESSOR);
    accessor->items = items;
 }
 
@@ -242,7 +214,7 @@ static void
 _item_scroll_internal(Eo *obj EINA_UNUSED,
                       Efl_Ui_Collection_Data *pd,
                       Efl_Ui_Item *item,
-                      double align,
+                      double align EINA_UNUSED,
                       Eina_Bool anim)
 {
    Eina_Rect ipos, view;
@@ -285,22 +257,53 @@ _efl_ui_collection_selected_items_get(Eo *obj EINA_UNUSED, Efl_Ui_Collection_Dat
    return eina_list_iterator_new(pd->selected);
 }
 
-static Eina_Bool
-_size_accessor_get_at(Fast_Accessor *accessor, unsigned int idx, void **data)
+static int
+_size_accessor_get_at(void *data, int start_id, Eina_Rw_Slice memory)
 {
-   Eina_Bool res = EINA_FALSE;
-   Efl_Gfx_Entity *geom;
-   Eina_Size2D *size = (void*)data;
+   Fast_Accessor *accessor = data;
+   size_t i;
+   const Eina_List *lst = _fast_accessor_get_at(accessor, start_id);
 
-   res = _fast_accessor_get_at(accessor, idx,(void*) &geom);
+   EINA_SAFETY_ON_NULL_RETURN_VAL(lst, -1);
 
-   if (!res) return EINA_FALSE;
+   for (i = 0; i < memory.len; ++i)
+     {
+         Efl_Gfx_Entity *geom = eina_list_data_get(lst);
+         Eina_Size2D size = efl_gfx_hint_size_min_get(geom);
 
-   *size = efl_gfx_hint_size_min_get(geom);
+         ((Eina_Size2D*)memory.mem)[i] = size;
+         lst = eina_list_next(lst);
+         if (!lst)
+           {
+              i++;
+              break;
+           }
+     }
 
-   return res;
+   return i;
 }
 
+static int
+_obj_accessor_get_at(void *data, int start_id, Eina_Rw_Slice memory)
+{
+   Fast_Accessor *accessor = data;
+   size_t i;
+   const Eina_List *lst = _fast_accessor_get_at(accessor, start_id);
+
+   for (i = 0; i < memory.len; ++i)
+     {
+         Efl_Gfx_Entity *geom = eina_list_data_get(lst);
+
+         ((Efl_Gfx_Entity**)memory.mem)[i] = geom;
+         lst = eina_list_next(lst);
+         if (!lst)
+           {
+              i++;
+              break;
+           }
+     }
+   return i;
+}
 
 EOLIAN static Efl_Object*
 _efl_ui_collection_efl_object_constructor(Eo *obj, Efl_Ui_Collection_Data *pd EINA_UNUSED)
@@ -311,7 +314,6 @@ _efl_ui_collection_efl_object_constructor(Eo *obj, Efl_Ui_Collection_Data *pd EI
 
    _fast_accessor_init(&pd->obj_accessor, &pd->items);
    _fast_accessor_init(&pd->size_accessor, &pd->items);
-   pd->size_accessor.acc.get_at = FUNC_ACCESSOR_GET_AT(_size_accessor_get_at);
 
    if (!elm_widget_theme_klass_get(obj))
      elm_widget_theme_klass_set(obj, "item_container");
@@ -759,7 +761,7 @@ _efl_ui_collection_position_manager_set(Eo *obj, Efl_Ui_Collection_Data *pd, Efl
    if (pd->pos_man)
      {
         efl_event_callback_array_del(pd->pos_man, pos_manager_cbs(), obj);
-        efl_ui_position_manager_entity_data_access_set(pd->pos_man, NULL, NULL, 0);
+        efl_ui_position_manager_entity_data_access_set(pd->pos_man, NULL, NULL, NULL, NULL, NULL, NULL, 0);
         efl_del(pd->pos_man);
      }
    pd->pos_man = layouter;
@@ -767,7 +769,11 @@ _efl_ui_collection_position_manager_set(Eo *obj, Efl_Ui_Collection_Data *pd, Efl
      {
         efl_parent_set(pd->pos_man, obj);
         efl_event_callback_array_add(pd->pos_man, pos_manager_cbs(), obj);
-        efl_ui_position_manager_entity_data_access_set(pd->pos_man, &pd->obj_accessor.acc, &pd->size_accessor.acc, eina_list_count(pd->items));
+        //efl_ui_position_manager_entity_data_access_set(pd->pos_man, &pd->obj_accessor.acc, &pd->size_accessor.acc, eina_list_count(pd->items));
+        efl_ui_position_manager_entity_data_access_set(pd->pos_man,
+          &pd->obj_accessor, _obj_accessor_get_at, NULL,
+          &pd->size_accessor, _size_accessor_get_at, NULL,
+          eina_list_count(pd->items));
         efl_ui_position_manager_entity_viewport_set(pd->pos_man, efl_ui_scrollable_viewport_geometry_get(obj));
         efl_ui_layout_orientation_set(pd->pos_man, pd->dir);
      }

src/lib/elementary/efl_ui_datepicker.c

@@ -161,24 +161,24 @@ _fields_init(Eo *obj)
    //Field create.
    pd->year = efl_add(EFL_UI_SPIN_BUTTON_CLASS, obj,
                       efl_ui_range_limits_set(efl_added, 1900, 2037),
-                      efl_ui_spin_button_circulate_set(efl_added, EINA_TRUE),
+                      efl_ui_spin_button_wraparound_set(efl_added, EINA_TRUE),
                       efl_ui_spin_button_editable_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_SPIN_EVENT_CHANGED,_field_changed_cb, obj));
+                      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_circulate_set(efl_added, EINA_TRUE),
+                       efl_ui_spin_button_wraparound_set(efl_added, EINA_TRUE),
                        efl_ui_spin_button_editable_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_SPIN_EVENT_CHANGED,_field_changed_cb, obj));
+                       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_circulate_set(efl_added, EINA_TRUE),
+                     efl_ui_spin_button_wraparound_set(efl_added, EINA_TRUE),
                      efl_ui_spin_button_editable_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_SPIN_EVENT_CHANGED,_field_changed_cb, obj));
+                     efl_event_callback_add(efl_added, EFL_UI_RANGE_EVENT_CHANGED,_field_changed_cb, obj));
 
    DATE_GET();
    //Using system config?

src/lib/elementary/efl_ui_item_private.h

@@ -10,7 +10,6 @@ typedef struct _Efl_Ui_Item_Data
 
    // Boolean Data
    Eina_Bool  selected : 1; /* State for item selected */
-   Eina_Bool  needs_size_calc : 1; /* Flag for Size calculation */
 } Efl_Ui_Item_Data;
 
 

src/lib/elementary/efl_ui_pan.eo

@@ -1,39 +1,55 @@
 class @beta Efl.Ui.Pan extends Efl.Canvas.Group implements Efl.Content
 {
-   [[Elementary pan class]]
+   [[Pan widget class.
+
+     This widget positions its contents (set using @Efl.Content.content) relative to the widget itself.
+     This is particularly useful for large content which does not fit inside its container. In this case
+     only a portion is shown.
+
+     The position of this "window" into the content can be changed using @Efl.Ui.Pan.pan_position.
+     This widget does not provide means for a user to change the content's position (like scroll bars).
+     This widget is meant to be used internally by other clases like @Efl.Ui.Scroll.Manager.
+   ]]
    methods {
       @property pan_position {
-    [[Position]]
-         set {
-         }
-         get {
-         }
+         [[Position of the content inside the Pan widget.
+
+           Setting the position to @Efl.Ui.Pan.pan_position_min makes the upper left corner of the content visible.
+           Setting the position to @Efl.Ui.Pan.pan_position_max makes the lower right corner of the content visible.
+           Values outside this range are valid and make the background show.
+         ]]
          values {
-            position: Eina.Position2D;
+            position: Eina.Position2D;  [[Content position.]]
          }
       }
       @property content_size {
-    [[Content size]]
+         [[Size of the content currently set through @Efl.Content.content.
+           This is a convenience proxy.
+         ]]
          get {
          }
          values {
-       size: Eina.Size2D;
+            size: Eina.Size2D; [[The size of the content.]]
          }
       }
       @property pan_position_min {
-    [[The minimal position to scroll]]
+         [[Position you can set to @Efl.Ui.Pan.pan_position so that the content's upper left corner is visible.
+           Always (0, 0).
+         ]]
          get {
          }
          values {
-       pos: Eina.Position2D;
+            pos: Eina.Position2D; [[Content's upper left corner position.]]
          }
       }
       @property pan_position_max {
-    [[The maximal position to scroll]]
+         [[Position you can set to @Efl.Ui.Pan.pan_position so that the content's lower right corner is visible.
+           It depends both on the content's size and this widget's size.
+         ]]
          get {
          }
          values {
-       pos: Eina.Position2D;
+            pos: Eina.Position2D; [[Content's lower right corner position.]]
          }
       }
    }
@@ -48,8 +64,8 @@ class @beta Efl.Ui.Pan extends Efl.Canvas.Group implements Efl.Content
       Efl.Canvas.Group.group_calculate;
    }
    events {
-      pan,content,changed: void; [[Called when pan content changed]]
-      pan,viewport,changed: void; [[Called when pan viewport changed]]
-      pan,position,changed: void; [[Called when pan position changed]]
+      pan,content,changed: void; [[The content has changed.]]
+      pan,viewport,changed: void; [[This widget's position or size has changed.]]
+      pan,position,changed: void; [[The content's position has changed.]]
    }
 }

src/lib/elementary/efl_ui_position_manager_common.h

@@ -0,0 +1,48 @@
+#ifndef EFL_UI_POSITION_MANAGER_COMMON_H
+#define EFL_UI_POSITION_MANAGER_COMMON_H 1
+
+#include <Eina.h>
+#include <Efl_Ui.h>
+#include "efl_ui_position_manager_entity.eo.h"
+
+typedef struct {
+   void *data;
+   Efl_Ui_Position_Manager_Batch_Access_Entity access; //this can also be the size accessor, but that does not matter here
+   Eina_Free_Cb free_cb;
+} Api_Callback;
+
+static inline int
+_fill_buffer(Api_Callback *cb , int start_id, int len, void *data)
+{
+   Eina_Rw_Slice slice;
+   slice.mem = data;
+   slice.len = len;
+
+   return cb->access(cb->data, start_id, slice);
+}
+
+static inline void
+vis_change_segment(Api_Callback *cb, int a, int b, Eina_Bool flag)
+{
+   const int len = 50;
+   Efl_Gfx_Entity *data[len];
+
+   if (a == b) return;
+
+   for (int i = MIN(a, b); i < MAX(a, b); ++i)
+     {
+        Efl_Gfx_Entity *ent = NULL;
+        int buffer_id = (i-MIN(a,b)) % len;
+
+        if (buffer_id == 0)
+          {
+             EINA_SAFETY_ON_FALSE_RETURN(_fill_buffer(cb, MIN(a,b), len, data) >= 0);
+          }
+        ent = data[i - MIN(a,b)];
+        if (ent && !efl_ui_focus_object_focus_get(ent))
+          {
+             efl_gfx_entity_visible_set(ent, flag);
+          }
+     }
+}
+#endif

src/lib/elementary/efl_ui_position_manager_entity.eo

@@ -1,4 +1,28 @@
 
+function Efl.Ui.Position_Manager.Batch_Access_Entity {
+   [[ Function callback for getting a batch of items]]
+   params {
+      start_id : int; [[The id of the first item to fetch]]
+      memory : rw_slice<Efl.Gfx.Entity>; [[The slice to fill the information in, the full slice will be filled if there are enough items]]
+   }
+   return: int; [[The number of filled elements in the slice]]
+};
+
+function Efl.Ui.Position_Manager.Batch_Access_Size {
+   [[ Function callback for getting sizes of a batch of items]]
+   params {
+      start_id : int; [[The id of the first item to fetch]]
+      memory : rw_slice<Efl.Gfx.Entity>; [[The slice to fill the information in, the full slice will be filled if there are enough items]]
+   }
+   return: int; [[The number of filled elements in the slice]]
+};
+
+struct Efl.Ui.Position_Manager.Range_Update {
+   [[A struct containing the the updated range of visible items in this position manger]]
+   start_id : uint; [[The first item that is visible]]
+   end_id : uint; [[The last item that is visible]]
+}
+
 interface @beta Efl.Ui.Position_Manager.Entity extends Efl.Ui.Layout_Orientable
 {
    [[
@@ -15,14 +39,16 @@ interface @beta Efl.Ui.Position_Manager.Entity extends Efl.Ui.Layout_Orientable
 
           $size_access gives access to the 2D sizes for the items to manage. All sizes will always be valid, and might change over time (indicated through the @.item_size_changed method).
           The whole range might need to be traversed in order to calculate the position of all items in some arrangements.
+
+          You can access a batch of objects or sizes by calling the here passed function callbacks. Further details can be found at the function definitions.
          ]]
          set {
 
          }
          values {
-           obj_access : accessor<Efl.Gfx.Entity>; [[The accessor for canvas obejcts, even if the id is valid, the returned object may be NULL]]
-           size_access : accessor<Eina.Size2D>; [[Accessor for the size, returned values are always valid, but might be changed / updated]]
-           size : int; [[valid size for accessors, 0 <= i < size]]
+           obj_access : Efl.Ui.Position_Manager.Batch_Access_Entity; [[Function callback for canvas objects, even if the start_id is valid, the returned objects may be NULL]]
+           size_access : Efl.Ui.Position_Manager.Batch_Access_Size; [[Function callback for the size, returned values are always valid, but might be changed / updated]]
+           size : int; [[valid size for start_id, 0 <= i < size]]
          }
       }
       @property viewport {
@@ -92,5 +118,6 @@ interface @beta Efl.Ui.Position_Manager.Entity extends Efl.Ui.Layout_Orientable
    events {
      content_size,changed : Eina.Size2D; [[Emitted when the aggregate size of all items has changed. This can be used to resize an enclosing Pan object.]]
      content_min_size,changed : Eina.Size2D; [[Emitted when the minimum size of all items has changed. The minimum size is the size, that this position_manager needs at *least* to display a single item.]]
+     visible_range,changed : Efl.Ui.Position_Manager.Range_Update;
    }
 }

src/lib/elementary/efl_ui_position_manager_grid.c

@@ -6,13 +6,14 @@
 #include <Elementary.h>
 #include "elm_widget.h"
 #include "elm_priv.h"
+#include "efl_ui_position_manager_common.h"
 
 #define MY_CLASS      EFL_UI_POSITION_MANAGER_GRID_CLASS
 #define MY_DATA_GET(obj, pd) \
   Efl_Ui_Position_Manager_Grid_Data *pd = efl_data_scope_get(obj, MY_CLASS);
 
 typedef struct {
-   Eina_Accessor *content_acc, *size_acc;
+   Api_Callback min_size, object;
    unsigned int size;
    Eina_Rect viewport;
    Eina_Vector2 scroll_position;
@@ -29,27 +30,15 @@ typedef struct {
    } current_display_table;
 } Efl_Ui_Position_Manager_Grid_Data;
 
-static inline void
-vis_change_segment(Efl_Ui_Position_Manager_Grid_Data *pd, int a, int b, Eina_Bool flag)
-{
-   for (int i = MIN(a, b); i < MAX(a, b); ++i)
-     {
-        Efl_Gfx_Entity *ent;
-
-        EINA_SAFETY_ON_FALSE_RETURN(eina_accessor_data_get(pd->content_acc, i, (void**) &ent));
-        if (ent && !efl_ui_focus_object_focus_get(ent))
-          {
-             efl_gfx_entity_visible_set(ent, flag);
-          }
-     }
-}
-
 static void
 _reposition_content(Eo *obj EINA_UNUSED, Efl_Ui_Position_Manager_Grid_Data *pd)
 {
    Eina_Size2D space_size;
    int relevant_space_size, relevant_viewport;
    unsigned int start_id, end_id, step;
+   const int len = 100;
+   Efl_Gfx_Entity *obj_buffer[len];
+   Efl_Ui_Position_Manager_Range_Update ev;
 
    if (!pd->size) return;
    if (pd->max_min_size.w <= 0 || pd->max_min_size.h <= 0) return;
@@ -83,22 +72,28 @@ _reposition_content(Eo *obj EINA_UNUSED, Efl_Ui_Position_Manager_Grid_Data *pd)
      {
         //it is important to first make the segment visible here, and then hide the rest
         //otherwise we get a state where item_container has 0 subchildren, which triggers a lot of focus logic.
-        vis_change_segment(pd, start_id, end_id, EINA_TRUE);
-        vis_change_segment(pd, pd->prev_run.start_id, pd->prev_run.end_id, EINA_FALSE);
+        vis_change_segment(&pd->object, start_id, end_id, EINA_TRUE);
+        vis_change_segment(&pd->object, pd->prev_run.start_id, pd->prev_run.end_id, EINA_FALSE);
      }
    else
      {
-        vis_change_segment(pd, pd->prev_run.start_id, start_id, (pd->prev_run.start_id > start_id));
-        vis_change_segment(pd, pd->prev_run.end_id, end_id, (pd->prev_run.end_id < end_id));
+        vis_change_segment(&pd->object, pd->prev_run.start_id, start_id, (pd->prev_run.start_id > start_id));
+        vis_change_segment(&pd->object, pd->prev_run.end_id, end_id, (pd->prev_run.end_id < end_id));
      }
 
    for (unsigned int i = start_id; i < end_id; ++i)
      {
         Eina_Rect geom;
         Efl_Gfx_Entity *ent;
+        int buffer_id = (i-start_id) % len;
         geom.size = pd->max_min_size;
         geom.pos = pd->viewport.pos;
 
+        if (buffer_id == 0)
+          {
+             EINA_SAFETY_ON_FALSE_RETURN(_fill_buffer(&pd->object, i, len, obj_buffer) > 0);
+          }
+
         if (pd->dir == EFL_UI_LAYOUT_ORIENTATION_VERTICAL)
           {
              geom.x += pd->max_min_size.w*(i%pd->current_display_table.columns);
@@ -112,12 +107,17 @@ _reposition_content(Eo *obj EINA_UNUSED, Efl_Ui_Position_Manager_Grid_Data *pd)
              geom.x -= (relevant_space_size);
           }
 
-        EINA_SAFETY_ON_FALSE_RETURN(eina_accessor_data_get(pd->content_acc, i, (void**) &ent));
+        ent = ((Efl_Gfx_Entity**)obj_buffer)[buffer_id];
+
         //printf(">%d (%d, %d, %d, %d) %p\n", i, geom.x, geom.y, geom.w, geom.h, ent);
         efl_gfx_entity_geometry_set(ent, geom);
      }
-   pd->prev_run.start_id = start_id;
-   pd->prev_run.end_id = end_id;
+   if (pd->prev_run.start_id != start_id || pd->prev_run.end_id != end_id)
+     {
+        ev.start_id = pd->prev_run.start_id = start_id;
+        ev.end_id = pd->prev_run.end_id = end_id;
+        efl_event_callback_call(obj, EFL_UI_POSITION_MANAGER_ENTITY_EVENT_VISIBLE_RANGE_CHANGED, &ev);
+     }
 }
 
 static inline void
@@ -170,13 +170,10 @@ _flush_abs_size(Eo *obj, Efl_Ui_Position_Manager_Grid_Data *pd)
 }
 
 static inline void
-_update_min_size(Eo *obj EINA_UNUSED, Efl_Ui_Position_Manager_Grid_Data *pd, int added_index)
+_update_min_size(Eo *obj EINA_UNUSED, Efl_Ui_Position_Manager_Grid_Data *pd, int added_index EINA_UNUSED, Eina_Size2D min_size)
 {
-   Eina_Size2D elemsize;
-
-   EINA_SAFETY_ON_FALSE_RETURN(eina_accessor_data_get(pd->size_acc, added_index, (void*)&elemsize));
-   pd->max_min_size.w = MAX(pd->max_min_size.w, elemsize.w);
-   pd->max_min_size.h = MAX(pd->max_min_size.h, elemsize.h);
+   pd->max_min_size.w = MAX(pd->max_min_size.w, min_size.w);
+   pd->max_min_size.h = MAX(pd->max_min_size.h, min_size.h);
 }
 
 static inline void
@@ -197,10 +194,14 @@ _flush_min_size(Eo *obj, Efl_Ui_Position_Manager_Grid_Data *pd)
 }
 
 EOLIAN static void
-_efl_ui_position_manager_grid_efl_ui_position_manager_entity_data_access_set(Eo *obj EINA_UNUSED, Efl_Ui_Position_Manager_Grid_Data *pd, Eina_Accessor *obj_access, Eina_Accessor *size_access, int size)
+_efl_ui_position_manager_grid_efl_ui_position_manager_entity_data_access_set(Eo *obj EINA_UNUSED, Efl_Ui_Position_Manager_Grid_Data *pd, void *obj_access_data, Efl_Ui_Position_Manager_Batch_Access_Entity obj_access, Eina_Free_Cb obj_access_free_cb, void *size_access_data, Efl_Ui_Position_Manager_Batch_Access_Size size_access, Eina_Free_Cb size_access_free_cb, int size)
 {
-   pd->size_acc = size_access;
-   pd->content_acc = obj_access;
+   pd->object.data = obj_access_data;
+   pd->object.access = obj_access;
+   pd->object.free_cb = obj_access_free_cb;
+   pd->min_size.data = size_access_data;
+   pd->min_size.access = size_access;
+   pd->min_size.free_cb = size_access_free_cb;
    pd->size = size;
 }
 
@@ -223,10 +224,12 @@ _efl_ui_position_manager_grid_efl_ui_position_manager_entity_scroll_position_set
 EOLIAN static void
 _efl_ui_position_manager_grid_efl_ui_position_manager_entity_item_added(Eo *obj, Efl_Ui_Position_Manager_Grid_Data *pd, int added_index, Efl_Gfx_Entity *subobj EINA_UNUSED)
 {
+   Eina_Size2D size[1];
    pd->size ++;
 
    efl_gfx_entity_visible_set(subobj, EINA_FALSE);
-   _update_min_size(obj, pd, added_index);
+   EINA_SAFETY_ON_FALSE_RETURN(_fill_buffer(&pd->min_size, added_index, 1, &size) == 1);
+   _update_min_size(obj, pd, added_index, size[0]);
    _flush_min_size(obj, pd);
    _flush_abs_size(obj, pd);
    _reposition_content(obj, pd); //FIXME we might can skip that
@@ -249,9 +252,17 @@ _efl_ui_position_manager_grid_efl_ui_position_manager_entity_item_removed(Eo *ob
 EOLIAN static void
 _efl_ui_position_manager_grid_efl_ui_position_manager_entity_item_size_changed(Eo *obj, Efl_Ui_Position_Manager_Grid_Data *pd, int start_id, int end_id)
 {
+   const int len = 50;
+   Eina_Size2D data[len];
+
    for (int i = start_id; i <= end_id; ++i)
      {
-        _update_min_size(obj, pd, i);
+        int buffer_id = (i-start_id) % len;
+        if (buffer_id == 0)
+          {
+             EINA_SAFETY_ON_FALSE_RETURN(_fill_buffer(&pd->min_size, start_id, len, data) >= 0);
+          }
+        _update_min_size(obj, pd, i, data[i-start_id]);
      }
 
    _flush_min_size(obj, pd);

src/lib/elementary/efl_ui_position_manager_list.c

@@ -7,13 +7,14 @@
 #include <Elementary.h>
 #include "elm_widget.h"
 #include "elm_priv.h"
+#include "efl_ui_position_manager_common.h"
 
 #define MY_CLASS      EFL_UI_POSITION_MANAGER_LIST_CLASS
 #define MY_DATA_GET(obj, pd) \
   Efl_Ui_Position_Manager_List_Data *pd = efl_data_scope_get(obj, MY_CLASS);
 
 typedef struct {
-   Eina_Accessor *content_acc, *size_acc;
+   Api_Callback min_size, object;
    unsigned int size;
    Eina_Future *rebuild_absolut_size;
    Eina_Rect viewport;
@@ -40,6 +41,9 @@ static void
 cache_require(Eo *obj EINA_UNUSED, Efl_Ui_Position_Manager_List_Data *pd)
 {
    unsigned int i;
+   const int len = 100;
+   Eina_Size2D size_buffer[100];
+
 
    if (pd->size_cache) return;
 
@@ -59,8 +63,14 @@ cache_require(Eo *obj EINA_UNUSED, Efl_Ui_Position_Manager_List_Data *pd)
         Eina_Size2D size;
         int step;
         int min;
+        int buffer_id = i % len;
+
+        if (buffer_id == 0)
+          {
+             EINA_SAFETY_ON_FALSE_RETURN(_fill_buffer(&pd->min_size, i, len, size_buffer) > 0);
+          }
+       size = size_buffer[buffer_id];
 
-        eina_accessor_data_get(pd->size_acc, i, (void**) &size);
         if (pd->dir == EFL_UI_LAYOUT_ORIENTATION_VERTICAL)
           {
              step = size.h;
@@ -122,21 +132,6 @@ recalc_absolut_size(Eo *obj, Efl_Ui_Position_Manager_List_Data *pd)
    efl_event_callback_call(obj, EFL_UI_POSITION_MANAGER_ENTITY_EVENT_CONTENT_MIN_SIZE_CHANGED, &min_size);
 }
 
-static inline void
-vis_change_segment(Efl_Ui_Position_Manager_List_Data *pd, int a, int b, Eina_Bool flag)
-{
-   for (int i = MIN(a, b); i < MAX(a, b); ++i)
-     {
-        Efl_Gfx_Entity *ent = NULL;
-
-        eina_accessor_data_get(pd->content_acc, i, (void**) &ent);
-        if (ent && !efl_ui_focus_object_focus_get(ent))
-          {
-             efl_gfx_entity_visible_set(ent, flag);
-          }
-     }
-}
-
 static void
 position_content(Eo *obj EINA_UNUSED, Efl_Ui_Position_Manager_List_Data *pd)
 {
@@ -144,6 +139,10 @@ position_content(Eo *obj EINA_UNUSED, Efl_Ui_Position_Manager_List_Data *pd)
    Eina_Size2D space_size;
    unsigned int start_id = 0, end_id = 0, i;
    int relevant_space_size, relevant_viewport;
+   const int len = 100;
+   Eina_Size2D size_buffer[len];
+   Efl_Gfx_Entity *obj_buffer[len];
+   Efl_Ui_Position_Manager_Range_Update ev;
 
    if (!pd->size) return;
    if (pd->average_item_size <= 0) return;
@@ -189,13 +188,13 @@ position_content(Eo *obj EINA_UNUSED, Efl_Ui_Position_Manager_List_Data *pd)
      {
         //it is important to first make the segment visible here, and then hide the rest
         //otherwise we get a state where item_container has 0 subchildren, which triggers a lot of focus logic.
-        vis_change_segment(pd, start_id, end_id, EINA_TRUE);
-        vis_change_segment(pd, pd->prev_run.start_id, pd->prev_run.end_id, EINA_FALSE);
+        vis_change_segment(&pd->object, start_id, end_id, EINA_TRUE);
+        vis_change_segment(&pd->object, pd->prev_run.start_id, pd->prev_run.end_id, EINA_FALSE);
      }
    else
      {
-        vis_change_segment(pd, pd->prev_run.start_id, start_id, (pd->prev_run.start_id > start_id));
-        vis_change_segment(pd, pd->prev_run.end_id, end_id, (pd->prev_run.end_id < end_id));
+        vis_change_segment(&pd->object, pd->prev_run.start_id, start_id, (pd->prev_run.start_id > start_id));
+        vis_change_segment(&pd->object, pd->prev_run.end_id, end_id, (pd->prev_run.end_id < end_id));
      }
 
    geom = pd->viewport;
@@ -209,9 +208,20 @@ position_content(Eo *obj EINA_UNUSED, Efl_Ui_Position_Manager_List_Data *pd)
      {
         Eina_Size2D size;
         Efl_Gfx_Entity *ent = NULL;
+        int buffer_id = (i-start_id) % len;
 
-        EINA_SAFETY_ON_FALSE_RETURN(eina_accessor_data_get(pd->size_acc, i, (void**) &size));
-        EINA_SAFETY_ON_FALSE_RETURN(eina_accessor_data_get(pd->content_acc, i, (void**) &ent));
+        if (buffer_id == 0)
+          {
+             int res1, res2;
+
+             res1 = _fill_buffer(&pd->object, i, len, obj_buffer);
+             res2 = _fill_buffer(&pd->min_size, i, len, size_buffer);
+             EINA_SAFETY_ON_FALSE_RETURN(res1 == res2);
+             EINA_SAFETY_ON_FALSE_RETURN(res2 > 0);
+          }
+
+        size = size_buffer[buffer_id];
+        ent = obj_buffer[buffer_id];
 
         if (pd->dir == EFL_UI_LAYOUT_ORIENTATION_VERTICAL)
           geom.h = size.h;
@@ -224,8 +234,13 @@ position_content(Eo *obj EINA_UNUSED, Efl_Ui_Position_Manager_List_Data *pd)
         else
           geom.x += size.w;
      }
-   pd->prev_run.start_id = start_id;
-   pd->prev_run.end_id = end_id;
+   if (pd->prev_run.start_id != start_id || pd->prev_run.end_id != end_id)
+     {
+        ev.start_id = pd->prev_run.start_id = start_id;
+        ev.end_id = pd->prev_run.end_id = end_id;
+        efl_event_callback_call(obj, EFL_UI_POSITION_MANAGER_ENTITY_EVENT_VISIBLE_RANGE_CHANGED, &ev);
+     }
+
 }
 
 static Eina_Value
@@ -253,11 +268,15 @@ schedule_recalc_absolut_size(Eo *obj, Efl_Ui_Position_Manager_List_Data *pd)
 }
 
 EOLIAN static void
-_efl_ui_position_manager_list_efl_ui_position_manager_entity_data_access_set(Eo *obj EINA_UNUSED, Efl_Ui_Position_Manager_List_Data *pd, Eina_Accessor *content_access, Eina_Accessor *size_access, int size)
+_efl_ui_position_manager_list_efl_ui_position_manager_entity_data_access_set(Eo *obj, Efl_Ui_Position_Manager_List_Data *pd, void *obj_access_data, Efl_Ui_Position_Manager_Batch_Access_Entity obj_access, Eina_Free_Cb obj_access_free_cb, void *size_access_data, Efl_Ui_Position_Manager_Batch_Access_Size size_access, Eina_Free_Cb size_access_free_cb, int size)
 {
    cache_invalidate(obj, pd);
-   pd->content_acc = content_access;
-   pd->size_acc = size_access;
+   pd->object.data = obj_access_data;
+   pd->object.access = obj_access;
+   pd->object.free_cb = obj_access_free_cb;
+   pd->min_size.data = size_access_data;
+   pd->min_size.access = size_access;
+   pd->min_size.free_cb = size_access_free_cb;
    pd->size = size;
 }
 
@@ -314,6 +333,7 @@ _efl_ui_position_manager_list_efl_ui_position_manager_entity_position_single_ite
    Eina_Size2D space_size;
    int relevant_space_size;
    Eina_Size2D size;
+   Eina_Size2D size_buffer[1];
 
    if (!pd->size) return EINA_RECT(0,0,0,0);
 
@@ -333,7 +353,9 @@ _efl_ui_position_manager_list_efl_ui_position_manager_entity_position_single_ite
 
    geom = pd->viewport;
 
-   eina_accessor_data_get(pd->size_acc, idx, (void**)&size);
+   EINA_SAFETY_ON_FALSE_RETURN_VAL(_fill_buffer(&pd->min_size, idx, 1, size_buffer) == 1, EINA_RECT_EMPTY());
+
+   size = size_buffer[0];
 
    if (pd->dir == EFL_UI_LAYOUT_ORIENTATION_VERTICAL)
      {
@@ -360,7 +382,7 @@ _efl_ui_position_manager_list_efl_ui_layout_orientable_orientation_set(Eo *obj E
 {
    pd->dir = dir;
    //in order to reset the state of the visible items, just hide everything and set the old segment accordingly
-   vis_change_segment(pd, pd->prev_run.start_id, pd->prev_run.end_id, EINA_FALSE);
+   vis_change_segment(&pd->object, pd->prev_run.start_id, pd->prev_run.end_id, EINA_FALSE);
    pd->prev_run.start_id = 0;
    pd->prev_run.end_id = 0;
 

src/lib/elementary/efl_ui_progressbar.c

@@ -558,8 +558,17 @@ _progressbar_part_value_set(Eo *obj, Efl_Ui_Progressbar_Data *sd, const char *pa
 
    _val_set(obj);
    _units_set(obj);
-   efl_event_callback_legacy_call
-     (obj, EFL_UI_PROGRESSBAR_EVENT_CHANGED, NULL);
+   if (elm_widget_is_legacy(obj))
+     efl_event_callback_legacy_call
+       (obj, EFL_UI_RANGE_EVENT_CHANGED, NULL);
+   else
+     {
+        efl_event_callback_call(obj, EFL_UI_RANGE_EVENT_CHANGED, NULL);
+        if (sd->val == min)
+          efl_event_callback_call(obj, EFL_UI_RANGE_EVENT_MIN_REACHED, NULL);
+        if (sd->val == max)
+          efl_event_callback_call(obj, EFL_UI_RANGE_EVENT_MAX_REACHED, NULL);
+     }
 }
 
 static double

src/lib/elementary/efl_ui_progressbar.eo

@@ -67,7 +67,4 @@ class @beta Efl.Ui.Progressbar extends Efl.Ui.Layout_Base implements Efl.Ui.Rang
       Efl.Content.content_unset;
       Efl.Ui.L10n.l10n_text { get; set; }
    }
-   events {
-      changed: void; [[Called when progressbar changed]]
-   }
 }

src/lib/elementary/efl_ui_slider.c

@@ -34,7 +34,7 @@ _delay_change(void *data)
    EFL_UI_SLIDER_DATA_GET(data, sd);
 
    sd->delay = NULL;
-   efl_event_callback_call(data, EFL_UI_SLIDER_EVENT_STEADY, NULL);
+   efl_event_callback_call(data, EFL_UI_RANGE_EVENT_STEADY, NULL);
 
    if (_elm_config->atspi_mode)
      efl_access_value_changed_signal_emit(data);
@@ -48,6 +48,16 @@ _is_horizontal(Efl_Ui_Layout_Orientation dir)
    return efl_ui_layout_orientation_is_horizontal(dir, EINA_TRUE);
 }
 
+static void
+_emit_events(Eo *obj, Efl_Ui_Slider_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
 _efl_ui_slider_val_fetch(Evas_Object *obj, Efl_Ui_Slider_Data *sd,  Eina_Bool user_event)
 {
@@ -76,8 +86,8 @@ _efl_ui_slider_val_fetch(Evas_Object *obj, Efl_Ui_Slider_Data *sd,  Eina_Bool us
         sd->val = val;
         if (user_event)
           {
-             efl_event_callback_call(obj, EFL_UI_SLIDER_EVENT_CHANGED, NULL);
-             efl_event_callback_legacy_call(obj, EFL_UI_SLIDER_EVENT_CHANGED, NULL);
+             _emit_events(obj, sd);
+             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);
           }
@@ -765,6 +775,7 @@ _efl_ui_slider_efl_ui_range_display_range_value_set(Eo *obj, Efl_Ui_Slider_Data
    if (sd->val < sd->val_min) sd->val = sd->val_min;
    if (sd->val > sd->val_max) sd->val = sd->val_max;
 
+   _emit_events(obj, sd);
    efl_ui_slider_val_set(obj);
 }
 

src/lib/elementary/efl_ui_slider.eo

@@ -20,12 +20,6 @@ class @beta Efl.Ui.Slider extends Efl.Ui.Layout_Base implements Efl.Ui.Range_Int
       Efl.Access.Widget.Action.elm_actions { get; }
    }
    events {
-      changed: void; [[Called when the slider position has changed.]]
-      steady: void; [[Called when the slider position has changed and has remained unchanged for 0.2s.
-                      This allows filtering out unwanted "noise" from the slider signal if you are only
-                      interested in the final position of the slider.
-                      Use this signal instead of @[Efl.Ui.Slider.changed] if you are going to perform a costly operation
-                      on its handler.]]
       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

src/lib/elementary/efl_ui_slider_interval.c

@@ -22,7 +22,7 @@ _delay_change(void *data)
    EFL_UI_SLIDER_INTERVAL_DATA_GET(data, pd);
 
    pd->delay = NULL;
-   efl_event_callback_call(data, EFL_UI_SLIDER_EVENT_STEADY, NULL);
+   efl_event_callback_call(data, EFL_UI_RANGE_EVENT_STEADY, NULL);
 
    if (_elm_config->atspi_mode)
      efl_access_value_changed_signal_emit(data);
@@ -77,8 +77,8 @@ _efl_ui_slider_interval_val_fetch(Evas_Object *obj, Efl_Ui_Slider_Interval_Data
         pd->intvl_from = val;
         if (user_event)
           {
-             efl_event_callback_call(obj, EFL_UI_SLIDER_EVENT_CHANGED, NULL);
-             efl_event_callback_legacy_call(obj, EFL_UI_SLIDER_EVENT_CHANGED, NULL);
+             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);
           }
@@ -89,8 +89,8 @@ _efl_ui_slider_interval_val_fetch(Evas_Object *obj, Efl_Ui_Slider_Interval_Data
         pd->intvl_to = val2;
         if (user_event)
           {
-             efl_event_callback_call(obj, EFL_UI_SLIDER_EVENT_CHANGED, NULL);
-             efl_event_callback_legacy_call(obj, EFL_UI_SLIDER_EVENT_CHANGED, NULL);
+             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);
           }

src/lib/elementary/efl_ui_spin.c

@@ -29,27 +29,6 @@ _label_write(Evas_Object *obj, Efl_Ui_Spin_Data *sd)
    eina_strbuf_free(strbuf);
 }
 
-EOLIAN static Eina_Bool
-_efl_ui_spin_efl_ui_widget_widget_input_event_handler(Eo *obj, Efl_Ui_Spin_Data *sd, const Efl_Event *eo_event, Evas_Object *src EINA_UNUSED)
-{
-   Eo *ev = eo_event->info;
-
-   if (efl_input_processed_get(ev)) return EINA_FALSE;
-
-   if (eo_event->desc == EFL_EVENT_POINTER_WHEEL)
-     {
-       if (efl_input_pointer_wheel_delta_get(ev) < 0)
-         efl_ui_range_value_set(obj, (efl_ui_range_value_get(obj) + sd->step));
-       else
-         efl_ui_range_value_set(obj, (efl_ui_range_value_get(obj) - sd->step));
-     }
-   else
-     return EINA_FALSE;
-
-   efl_input_processed_set(ev, EINA_TRUE);
-   return EINA_TRUE;
-}
-
 EOLIAN static Eo *
 _efl_ui_spin_efl_object_constructor(Eo *obj, Efl_Ui_Spin_Data *sd)
 {
@@ -156,11 +135,11 @@ _efl_ui_spin_efl_ui_range_display_range_value_set(Eo *obj, Efl_Ui_Spin_Data *sd,
    sd->val = val;
 
    if (EINA_DBL_EQ(sd->val, sd->val_min))
-     efl_event_callback_call(obj, EFL_UI_SPIN_EVENT_MIN_REACHED, NULL);
+     efl_event_callback_call(obj, EFL_UI_RANGE_EVENT_MIN_REACHED, NULL);
    else if (EINA_DBL_EQ(sd->val, sd->val_max))
-     efl_event_callback_call(obj, EFL_UI_SPIN_EVENT_MAX_REACHED, NULL);
+     efl_event_callback_call(obj, EFL_UI_RANGE_EVENT_MAX_REACHED, NULL);
 
-   efl_event_callback_call(obj, EFL_UI_SPIN_EVENT_CHANGED, NULL);
+   efl_event_callback_call(obj, EFL_UI_RANGE_EVENT_CHANGED, NULL);
 
    _label_write(obj, sd);
 }

src/lib/elementary/efl_ui_spin.eo

@@ -9,15 +9,9 @@ class @beta Efl.Ui.Spin extends Efl.Ui.Layout_Base implements Efl.Ui.Range_Inter
    implements {
       Efl.Object.constructor;
       Efl.Object.destructor;
-      Efl.Ui.Widget.widget_input_event_handler;
       Efl.Ui.Range_Display.range_limits { get; set; }
       Efl.Ui.Range_Interactive.range_step { get; set; }
       Efl.Ui.Range_Display.range_value { get; set; }
       Efl.Ui.Format.apply_formatted_value;
    }
-   events {
-      changed: void; [[Called when spin changed]]
-      min,reached: void; [[Called when spin value reached min]]
-      max,reached: void; [[Called when spin value reached max]]
-   }
 }

src/lib/elementary/efl_ui_spin_button.c

@@ -116,7 +116,7 @@ _label_write(Evas_Object *obj)
 static Eina_Value
 _delay_change_timer_cb(Eo *o, void *data EINA_UNUSED, const Eina_Value v)
 {
-   efl_event_callback_call(o, EFL_UI_SPIN_BUTTON_EVENT_DELAY_CHANGED, NULL);
+   efl_event_callback_call(o, EFL_UI_RANGE_EVENT_STEADY, NULL);
 
    return v;
 }
@@ -137,7 +137,7 @@ _value_set(Evas_Object *obj,
    Efl_Ui_Spin_Data *pd = efl_data_scope_get(obj, EFL_UI_SPIN_CLASS);
    Eina_Future *f;
 
-   if (sd->circulate)
+   if (sd->wraparound)
      {
         if (new_val < pd->val_min)
           new_val = pd->val_max;
@@ -732,15 +732,15 @@ _efl_ui_spin_button_editable_get(const Eo *obj EINA_UNUSED, Efl_Ui_Spin_Button_D
 }
 
 EOLIAN static void
-_efl_ui_spin_button_circulate_set(Eo *obj EINA_UNUSED, Efl_Ui_Spin_Button_Data *sd, Eina_Bool circulate)
+_efl_ui_spin_button_wraparound_set(Eo *obj EINA_UNUSED, Efl_Ui_Spin_Button_Data *sd, Eina_Bool wraparound)
 {
-   sd->circulate = circulate;
+   sd->wraparound = wraparound;
 }
 
 EOLIAN static Eina_Bool
-_efl_ui_spin_button_circulate_get(const Eo *obj EINA_UNUSED, Efl_Ui_Spin_Button_Data *sd)
+_efl_ui_spin_button_wraparound_get(const Eo *obj EINA_UNUSED, Efl_Ui_Spin_Button_Data *sd)
 {
-   return sd->circulate;
+   return sd->wraparound;
 }
 
 EOLIAN static const Efl_Access_Action_Data *

src/lib/elementary/efl_ui_spin_button.eo

@@ -8,7 +8,7 @@ class @beta Efl.Ui.Spin_Button extends Efl.Ui.Spin implements Efl.Ui.Focus.Compo
      over them and inputting new ones.
    ]]
    methods {
-      @property circulate {
+      @property wraparound {
          [[Control whether the spin should circulate value when it reaches its minimum or maximum value.
 
            Disabled by default. If disabled, when the user tries to increment the
@@ -73,7 +73,4 @@ class @beta Efl.Ui.Spin_Button extends Efl.Ui.Spin implements Efl.Ui.Focus.Compo
       Efl.Access.Value.increment { get; }
       Efl.Access.Widget.Action.elm_actions { get; }
    }
-   events {
-      delay,changed: void; [[Called when spin delay is changed.]]
-   }
 }

src/lib/elementary/efl_ui_spin_button_private.h

@@ -12,7 +12,7 @@ struct _Efl_Ui_Spin_Button_Data
    Eina_Bool             entry_visible : 1;
    Eina_Bool             entry_reactivate : 1;
    Eina_Bool             editable : 1;
-   Eina_Bool             circulate : 1;
+   Eina_Bool             wraparound : 1;
 };
 
 #endif

src/lib/elementary/efl_ui_spotlight_container.c

@@ -677,16 +677,40 @@ EOLIAN static Eina_Future*
 _efl_ui_spotlight_container_pop(Eo *obj, Efl_Ui_Spotlight_Container_Data *pd, Eina_Bool del)
 {
    Eina_Future *transition_done;
+   Eina_Value v;
    int new_index;
+   int count;
+   Eo *content;
 
-   if (eina_list_count(pd->content_list) < 2)
-     new_index = -1;
+   count = (int)eina_list_count(pd->content_list);
+
+   if (count == 0) return NULL;
+
+   content = efl_pack_content_get(obj, efl_ui_spotlight_active_index_get(obj));
+
+   //pop() unpacks content without transition if there is one content.
+   if (count == 1)
+     {
+        efl_pack_unpack(obj, content);
+        pd->curr.page = -1;
+
+        if (del)
+          {
+             efl_del(content);
+             v = EINA_VALUE_EMPTY;
+          }
+        else
+          {
+             v = eina_value_object_init(content);
+          }
+        return efl_loop_future_resolved(obj, v);
+     }
 
    new_index = efl_ui_spotlight_active_index_get(obj) + 1;
-   if (new_index >= (int)eina_list_count(pd->content_list))
+   if (new_index >= count)
      new_index -= 2;
 
-   pd->transition_done.content = efl_pack_content_get(obj, efl_ui_spotlight_active_index_get(obj));
+   pd->transition_done.content = content;
    pd->transition_done.transition_done = efl_loop_promise_new(obj);
 
    transition_done = eina_future_new(pd->transition_done.transition_done);

src/lib/elementary/efl_ui_spotlight_manager_scroll.c

@@ -22,6 +22,7 @@ typedef struct {
       Eina_Position2D mouse_start;
    } mouse_move;
    Eina_Bool animation;
+   Eina_Bool scroll_block;
 } Efl_Ui_Spotlight_Manager_Scroll_Data;
 
 #define MY_CLASS EFL_UI_SPOTLIGHT_MANAGER_SCROLL_CLASS
@@ -100,6 +101,8 @@ _mouse_down_cb(void *data,
 
    if (efl_content_count(pd->container) == 0) return;
 
+   if (pd->scroll_block) return;
+
    efl_event_callback_del(pd->container, EFL_CANVAS_OBJECT_EVENT_ANIMATOR_TICK, _page_set_animation, obj);
 
    pd->mouse_move.active = EINA_TRUE;
@@ -123,6 +126,7 @@ _mouse_move_cb(void *data,
 
    if (efl_input_event_flags_get(ev) & EFL_INPUT_FLAGS_PROCESSED) return;
    if (!pd->mouse_move.active) return;
+   if (pd->scroll_block) return;
 
    pos = efl_input_pointer_position_get(ev);
    pos_y_diff = pd->mouse_move.mouse_start.x - pos.x;
@@ -149,6 +153,7 @@ _mouse_up_cb(void *data,
 
    if (efl_input_event_flags_get(ev) & EFL_INPUT_FLAGS_PROCESSED) return;
    if (!pd->mouse_move.active) return;
+   if (pd->scroll_block) return;
 
    double absolut_current_position = (double)pd->transition.from + pd->transition.progress;
    int result = round(absolut_current_position);
@@ -332,5 +337,25 @@ _efl_ui_spotlight_manager_scroll_efl_object_invalidate(Eo *obj, Efl_Ui_Spotlight
    efl_invalidate(efl_super(obj, MY_CLASS));
 }
 
+EOLIAN static void
+_efl_ui_spotlight_manager_scroll_scroll_block_set(Eo *obj EINA_UNUSED, Efl_Ui_Spotlight_Manager_Scroll_Data *pd, Eina_Bool scroll_block)
+{
+   if (pd->scroll_block == scroll_block) return;
+
+   pd->scroll_block = scroll_block;
+   if (scroll_block && pd->mouse_move.active)
+     {
+        pd->mouse_move.active = EINA_FALSE;
+        pd->transition.active = EINA_FALSE;
+        pd->transition.progress = 0.0;
+        _apply_box_properties(obj, pd);
+     }
+}
+
+EOLIAN static Eina_Bool
+_efl_ui_spotlight_manager_scroll_scroll_block_get(const Eo *obj EINA_UNUSED, Efl_Ui_Spotlight_Manager_Scroll_Data *pd)
+{
+   return pd->scroll_block;
+}
 
 #include "efl_ui_spotlight_manager_scroll.eo.c"

src/lib/elementary/efl_ui_spotlight_manager_scroll.eo

@@ -1,5 +1,22 @@
 class @beta Efl.Ui.Spotlight.Manager_Scroll extends Efl.Ui.Spotlight.Manager
 {
+   methods {
+      @property scroll_block {
+         [[Blocking of scrolling
+
+           This function will block scrolling movement (by input of a user).
+           You can disable scrolling movement. The default value is $false,
+           where the scrolling movement is allowed.
+         ]]
+         set {
+         }
+         get {
+         }
+         values {
+            scroll_block: bool; [[$true if block scrolling movement, $false otherwise]]
+         }
+      }
+   }
    implements {
       Efl.Ui.Spotlight.Manager.bind;
       Efl.Ui.Spotlight.Manager.content_add;

src/lib/elementary/efl_ui_tags.c

@@ -50,12 +50,12 @@ _shrink_mode_set(Eo *obj,
    if (shrink == EINA_TRUE)
      {
         Evas_Coord w = 0;
-        Evas_Coord box_inner_item_width_padding = 0;
+        double box_inner_item_width_padding = 0;
         Eina_Value val;
 
-        elm_box_padding_get(sd->box, &box_inner_item_width_padding, NULL);
+        efl_gfx_arrangement_content_padding_get(sd->box, &box_inner_item_width_padding, NULL, NULL);
         // unpack all items and entry
-        elm_box_unpack_all(sd->box);
+        efl_pack_unpack_all(sd->box);
         EINA_LIST_FOREACH(sd->layouts, l, layout)
           {
              evas_object_hide(layout);
@@ -65,7 +65,7 @@ _shrink_mode_set(Eo *obj,
 
         if (sd->label && sd->label_packed)
           {
-             elm_box_pack_end(sd->box, sd->label);
+             efl_pack(sd->box, sd->label);
              Eina_Size2D label_min =
                 efl_gfx_hint_size_combined_min_get(sd->label);
              w -= label_min.w;
@@ -79,7 +79,7 @@ _shrink_mode_set(Eo *obj,
           {
              Evas_Coord w_label_count = 0, h = 0;
 
-             elm_box_pack_end(sd->box, layout);
+             efl_pack(sd->box, layout);
              evas_object_show(layout);
 
              Eina_Size2D item_min =
@@ -107,7 +107,7 @@ _shrink_mode_set(Eo *obj,
              if ((w < 0) || (w < w_label_count))
                {
                   Eina_Strbuf *strbuf = eina_strbuf_new();
-                  elm_box_unpack(sd->box, layout);
+                  efl_pack_unpack(sd->box, layout);
                   evas_object_hide(layout);
                   count++;
 
@@ -119,8 +119,8 @@ _shrink_mode_set(Eo *obj,
 
                   edje_object_size_min_calc(sd->end, &w_label_count, &h);
                   elm_coords_finger_size_adjust(1, &w_label_count, 1, &h);
-                  efl_gfx_hint_size_restricted_min_set(sd->end, EINA_SIZE2D(w_label_count, h));
-                  elm_box_pack_end(sd->box, sd->end);
+                  efl_gfx_hint_size_min_set(sd->end, EINA_SIZE2D(w_label_count, h));
+                  efl_pack(sd->box, sd->end);
                   evas_object_show(sd->end);
 
                   break;
@@ -139,7 +139,7 @@ _shrink_mode_set(Eo *obj,
    else
      {
         // unpack all items and entry
-        elm_box_unpack_all(sd->box);
+        efl_pack_unpack_all(sd->box);
         EINA_LIST_FOREACH(sd->layouts, l, layout)
           {
              evas_object_hide(layout);
@@ -148,13 +148,13 @@ _shrink_mode_set(Eo *obj,
 
         // pack buttons only 1line
 
-        if (sd->label && sd->label_packed) elm_box_pack_end(sd->box, sd->label);
+        if (sd->label && sd->label_packed) efl_pack(sd->box, sd->label);
 
         // pack remain btns
         layout = NULL;
         EINA_LIST_FOREACH(sd->layouts, l, layout)
           {
-             elm_box_pack_end(sd->box, layout);
+             efl_pack(sd->box, layout);
              evas_object_show(layout);
           }
 
@@ -338,7 +338,7 @@ _on_item_deleted(void *data,
         if (item == obj)
           {
              sd->layouts = eina_list_remove(sd->layouts, item);
-             elm_box_unpack(sd->box, item);
+             efl_pack_unpack(sd->box, item);
 
              if (sd->selected_it == item)
                sd->selected_it = NULL;
@@ -425,7 +425,7 @@ _item_new(Efl_Ui_Tags_Data *sd,
    if (sd->w_box && min.w > r.w)
      {
         elm_coords_finger_size_adjust(1, &r.w, 1, &min.h);
-        efl_gfx_hint_size_restricted_min_set(layout, EINA_SIZE2D(r.w, min.h));
+        efl_gfx_hint_size_min_set(layout, EINA_SIZE2D(r.w, min.h));
         efl_gfx_entity_size_set(layout, EINA_SIZE2D(r.w, min.h));
      }
 
@@ -440,9 +440,9 @@ _item_new(Efl_Ui_Tags_Data *sd,
    else
      {
         if (sd->editable)
-          elm_box_pack_before(sd->box, layout, sd->entry);
+          efl_pack_before(sd->box, layout, sd->entry);
         else
-          elm_box_pack_end(sd->box, layout);
+          efl_pack(sd->box, layout);
      }
 
    if (!efl_ui_focus_object_focus_get(obj) && sd->view_state == TAGS_VIEW_SHRINK && sd->w_box)
@@ -487,14 +487,14 @@ _box_resize_cb(void *data,
    Eina_Rect r;
    Eina_List *l;
    Eo *layout;
-   int hpad;
+   double hpad;
 
    Efl_Ui_Tags_Data *sd = efl_data_scope_get(data, EFL_UI_TAGS_CLASS);
 
    r = efl_gfx_entity_geometry_get(sd->box);
    if ((r.w <= elm_config_finger_size_get()) || (r.h <= elm_config_finger_size_get())) return;
 
-   elm_box_padding_get(obj, &hpad, NULL);
+   efl_gfx_arrangement_content_padding_get(obj, &hpad, NULL, NULL);
 
    if (sd->h_box < r.h)
      efl_event_callback_call
@@ -514,7 +514,7 @@ _box_resize_cb(void *data,
              if (min.w > r.w - hpad)
                {
                   min.w = r.w - hpad;
-                  efl_gfx_hint_size_restricted_min_set(layout, EINA_SIZE2D(min.w, min.h));
+                  efl_gfx_hint_size_min_set(layout, EINA_SIZE2D(min.w, min.h));
                   efl_gfx_entity_size_set(layout, EINA_SIZE2D(min.w, min.h));
                }
           }
@@ -710,180 +710,35 @@ _label_set(Evas_Object *obj,
    if (!strlen(str))
      {
         sd->label_packed = EINA_FALSE;
-        elm_box_unpack(sd->box, sd->label);
+        efl_pack_unpack(sd->box, sd->label);
         evas_object_hide(sd->label);
      }
    else
      {
         if (sd->label_packed)
-          elm_box_unpack(sd->box, sd->label);
+          efl_pack_unpack(sd->box, sd->label);
         sd->label_packed = EINA_TRUE;
         edje_object_size_min_calc(sd->label, &width, &height);
         evas_object_size_hint_min_set(sd->label, width, height);
-        elm_box_pack_start(sd->box, sd->label);
+        efl_pack_begin(sd->box, sd->label);
         evas_object_show(sd->label);
      }
 
    _view_update(sd);
 }
 
-static Eina_Bool
-_box_min_size_calculate(Evas_Object *box,
-                        Evas_Object_Box_Data *priv,
-                        int *line_height,
-                        void *data EINA_UNUSED)
-{
-   Evas_Coord w, linew = 0, lineh = 0;
-   Eina_Size2D box_min;
-   Eina_Size2D min;
-   int line_num;
-   Eina_List *l;
-   Evas_Object_Box_Option *opt;
-
-   evas_object_geometry_get(box, NULL, NULL, &w, NULL);
-   box_min = efl_gfx_hint_size_combined_min_get(box);
-
-   if (!w) return EINA_FALSE;
-
-   line_num = 1;
-   EINA_LIST_FOREACH(priv->children, l, opt)
-     {
-        min = efl_gfx_hint_size_combined_min_get(opt->obj);
-
-        linew += min.w;
-        if (lineh < min.h) lineh = min.h;
-
-        if (linew > w)
-          {
-             linew = min.w;
-             line_num++;
-          }
-
-        if ((linew != 0) && (l != eina_list_last(priv->children)))
-          linew += priv->pad.h;
-     }
-   box_min.h = lineh * line_num + (line_num - 1) * priv->pad.v;
-
-   efl_gfx_hint_size_restricted_min_set(box, EINA_SIZE2D(box_min.w, box_min.h));
-   *line_height = lineh;
-
-   return EINA_TRUE;
-}
-
-static void
-_box_layout_cb(Evas_Object *o,
-               Evas_Object_Box_Data *priv,
-               void *data)
-{
-   Evas_Coord xx, yy;
-   Eina_Rect r;
-   Evas_Coord linew = 0, lineh = 0;
-   Eina_Size2D min;
-   Evas_Object_Box_Option *opt;
-   const Eina_List *l, *l_next;
-   Evas_Object *obj;
-   double ax, ay;
-   Eina_Bool rtl;
-
-   if (!_box_min_size_calculate(o, priv, &lineh, data)) return;
-
-   r = efl_gfx_entity_geometry_get(o);
-
-   min = efl_gfx_hint_size_combined_min_get(o);
-   efl_gfx_hint_align_get(o, &ax, &ay);
-
-   rtl = efl_ui_mirrored_get(data);
-   if (rtl) ax = 1.0 - ax;
-
-   if (r.w < min.w)
-     {
-        r.x = r.x + ((r.w - min.w) * (1.0 - ax));
-        r.w = min.w;
-     }
-   if (r.h < min.h)
-     {
-        r.y = r.y + ((r.h - min.h) * (1.0 - ay));
-        r.h = min.h;
-     }
-
-   xx = r.x;
-   yy = r.y;
-
-   EINA_LIST_FOREACH_SAFE(priv->children, l, l_next, opt)
-     {
-        Eina_Size2D obj_min;
-        Evas_Coord ww, hh, ow, oh;
-        double wx, wy;
-        Eina_Bool fx, fy;
-
-        obj = opt->obj;
-        evas_object_size_hint_align_get(obj, &ax, &ay);
-        evas_object_size_hint_weight_get(obj, &wx, &wy);
-        efl_gfx_hint_fill_get(obj, &fx, &fy);
-        obj_min = efl_gfx_hint_size_combined_min_get(obj);
-
-        if (EINA_DBL_EQ(ax, -1)) { fx = 1; ax = 0.5; }
-        else if (ax < 0) { ax = 0.0; }
-        if (EINA_DBL_EQ(ay, -1)) { fy = 1; ay = 0.5; }
-        else if (ay < 0) { ay = 0.0; }
-        if (rtl) ax = 1.0 - ax;
-
-        ww = obj_min.w;
-        if (!EINA_DBL_EQ(wx, 0))
-          {
-             if (ww <= r.w - linew) ww = r.w - linew;
-             else ww = r.w;
-          }
-        hh = lineh;
-
-        ow = obj_min.w;
-        if (fx) ow = ww;
-        oh = obj_min.h;
-        if (fy) oh = hh;
-
-        linew += ww;
-        if (linew > r.w && l != priv->children)
-          {
-             xx = r.x;
-             yy += hh;
-             yy += priv->pad.v;
-             linew = ww;
-          }
-
-        evas_object_geometry_set(obj,
-                                 ((!rtl) ? (xx) : (r.x + (r.w - (xx - r.x) - ww)))
-                                 + (Evas_Coord)(((double)(ww - ow)) * ax),
-                                 yy + (Evas_Coord)(((double)(hh - oh)) * ay),
-                                 ow, oh);
-        xx += ww;
-        xx += priv->pad.h;
-
-        if (linew > r.w)
-          {
-             opt = eina_list_data_get(l_next);
-             if (opt && opt->obj && efl_isa(opt->obj, ELM_ENTRY_CLASS))
-               {
-                  xx = r.x;
-                  yy += hh;
-                  yy += priv->pad.v;
-                  linew = 0;
-               }
-          }
-        if ((linew != 0) && (l != eina_list_last(priv->children)))
-          linew += priv->pad.h;
-     }
-}
-
 static void
 _view_init(Evas_Object *obj, Efl_Ui_Tags_Data *sd)
 {
    const char *str;
-   double pad_scale;
    int hpad = 0, vpad = 0;
 
    //FIXME: efl_ui_box doesn't support box_layout customizing.
    //       So i use legacy box here.
-   sd->box = elm_box_add(obj);
+   sd->box = efl_add(EFL_UI_BOX_FLOW_CLASS, obj,
+     efl_ui_layout_orientation_set(efl_added, EFL_UI_LAYOUT_ORIENTATION_HORIZONTAL),
+     efl_gfx_arrangement_content_align_set(efl_added, 0, 0),
+     efl_gfx_hint_align_set(efl_added, 0, 0));
 
    if (!sd->box) return;
 
@@ -891,13 +746,9 @@ _view_init(Evas_Object *obj, Efl_Ui_Tags_Data *sd)
    if (str) hpad = atoi(str);
    str = elm_layout_data_get(obj, "vertical_pad");
    if (str) vpad = atoi(str);
-   pad_scale = efl_gfx_entity_scale_get(obj) * elm_config_scale_get()
-      / edje_object_base_scale_get(elm_layout_edje_get(obj));
-   elm_box_padding_set(sd->box, (hpad * pad_scale), (vpad * pad_scale));
+   efl_gfx_arrangement_content_padding_set(sd->box, hpad, vpad, EINA_TRUE);
 
-   elm_box_layout_set(sd->box, _box_layout_cb, obj, NULL);
-   elm_box_homogeneous_set(sd->box, EINA_FALSE);
-   elm_layout_content_set(obj, "efl.box", sd->box);
+   efl_content_set(efl_part(obj, "efl.box"), sd->box);
 
    sd->label = edje_object_add(evas_object_evas_get(obj));
    if (!sd->label) return;
@@ -911,12 +762,11 @@ _view_init(Evas_Object *obj, Efl_Ui_Tags_Data *sd)
                        efl_text_interactive_editable_set(efl_added, EINA_TRUE),
                        efl_composite_attach(obj, efl_added));
 
-   efl_gfx_hint_size_restricted_min_set(sd->entry, EINA_SIZE2D(MIN_W_ENTRY, 0));
-   evas_object_size_hint_weight_set
-     (sd->entry, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
+   efl_gfx_hint_size_min_set(sd->entry, EINA_SIZE2D(MIN_W_ENTRY, 0));
+   efl_gfx_hint_weight_set(sd->entry, EFL_GFX_HINT_EXPAND, 0);
    efl_gfx_hint_fill_set(sd->entry, EINA_TRUE, EINA_TRUE);
 
-   elm_box_pack_end(sd->box, sd->entry);
+   efl_pack(sd->box, sd->entry);
 
    sd->view_state = TAGS_VIEW_ENTRY;
 
@@ -929,7 +779,7 @@ _view_init(Evas_Object *obj, Efl_Ui_Tags_Data *sd)
 
         edje_object_size_min_calc(sd->end, &button_min_width, &button_min_height);
         elm_coords_finger_size_adjust(1, &button_min_width, 1, &button_min_height);
-        efl_gfx_hint_size_restricted_min_set(sd->end, EINA_SIZE2D(button_min_width, button_min_height));
+        efl_gfx_hint_size_min_set(sd->end, EINA_SIZE2D(button_min_width, button_min_height));
         elm_widget_sub_object_add(obj, sd->end);
      }
 }
@@ -1067,12 +917,12 @@ _efl_ui_tags_editable_set(Eo *obj EINA_UNUSED, Efl_Ui_Tags_Data *sd, Eina_Bool e
 
    if (sd->editable && (sd->view_state != TAGS_VIEW_SHRINK))
      {
-        elm_box_pack_end(sd->box, sd->entry);
+        efl_pack(sd->box, sd->entry);
         evas_object_show(sd->entry);
      }
    else
      {
-        elm_box_unpack(sd->box, sd->entry);
+        efl_pack_unpack(sd->box, sd->entry);
         evas_object_hide(sd->entry);
      }
 }

src/lib/elementary/efl_ui_text.c

@@ -47,7 +47,6 @@ struct _Efl_Ui_Text_Data
    Evas_Object                          *start_handler;
    Evas_Object                          *end_handler;
    Ecore_Job                            *deferred_decoration_job;
-   Ecore_Timer                          *longpress_timer;
    Ecore_Timer                          *delay_write;
    /* for deferred appending */
    Ecore_Idler                          *append_text_idler;
@@ -1427,8 +1426,6 @@ _long_press_cb(void *data, const Efl_Event *ev EINA_UNUSED)
      _menu_call(data);
 
    sd->long_pressed = EINA_TRUE;
-
-   sd->longpress_timer = NULL;
 }
 
 static void
@@ -1522,7 +1519,8 @@ _mouse_up_cb(void *data,
    if (sd->disabled) return;
    if (ev->button == 1)
      {
-        ELM_SAFE_FREE(sd->longpress_timer, ecore_timer_del);
+        efl_input_clickable_longpress_abort(data, 1);
+
         /* Since context menu disabled flag was checked at long press start while mouse
          * down, hence the same should be checked at mouse up from a long press
          * as well */
@@ -1563,6 +1561,7 @@ _mouse_move_cb(void *data,
                void *event_info)
 {
    Evas_Event_Mouse_Move *ev = event_info;
+   Evas_Coord dx, dy;
 
    EFL_UI_TEXT_DATA_GET(data, sd);
 
@@ -1592,38 +1591,18 @@ _mouse_move_cb(void *data,
      {
         if (ev->event_flags & EVAS_EVENT_FLAG_ON_HOLD)
           {
-             ELM_SAFE_FREE(sd->longpress_timer, ecore_timer_del);
-          }
-        else if (sd->longpress_timer)
-          {
-             Evas_Coord dx, dy;
-
-             dx = sd->downx - ev->cur.canvas.x;
-             dx *= dx;
-             dy = sd->downy - ev->cur.canvas.y;
-             dy *= dy;
-             if ((dx + dy) >
-                 ((_elm_config->finger_size / 2) *
-                  (_elm_config->finger_size / 2)))
-               {
-                  ELM_SAFE_FREE(sd->longpress_timer, ecore_timer_del);
-               }
+             efl_input_clickable_longpress_abort(data, 1);
           }
      }
-   else if (sd->longpress_timer)
-     {
-        Evas_Coord dx, dy;
 
-        dx = sd->downx - ev->cur.canvas.x;
-        dx *= dx;
-        dy = sd->downy - ev->cur.canvas.y;
-        dy *= dy;
-        if ((dx + dy) >
-            ((_elm_config->finger_size / 2) *
-             (_elm_config->finger_size / 2)))
-          {
-             ELM_SAFE_FREE(sd->longpress_timer, ecore_timer_del);
-          }
+   dx = sd->downx - ev->cur.canvas.x;
+   dx *= dx;
+   dy = sd->downy - ev->cur.canvas.y;
+   dy *= dy;
+   if ((dx + dy) > ((_elm_config->finger_size / 2) *
+                    (_elm_config->finger_size / 2)))
+     {
+        efl_input_clickable_longpress_abort(data, 1);
      }
 }
 
@@ -1716,7 +1695,7 @@ _selection_handlers_offset_calc(Evas_Object *obj, Evas_Object *handler)
         sd->oy = pos.y + cy + (ch / 2);
      }
 
-   ELM_SAFE_FREE(sd->longpress_timer, ecore_timer_del);
+   efl_input_clickable_longpress_abort(obj, 1);
    sd->long_pressed = EINA_FALSE;
 }
 
@@ -1799,7 +1778,7 @@ _start_handler_mouse_move_cb(void *data,
    efl_text_cursor_position_set(sd->text_obj,
          efl_text_cursor_get(sd->text_obj, EFL_TEXT_CURSOR_GET_TYPE_MAIN), pos);
 
-   ELM_SAFE_FREE(sd->longpress_timer, ecore_timer_del);
+   efl_input_clickable_longpress_abort(data, 1);
    sd->long_pressed = EINA_FALSE;
 }
 
@@ -1879,7 +1858,7 @@ _end_handler_mouse_move_cb(void *data,
    pos = efl_text_cursor_position_get(sd->text_obj, sd->sel_handler_cursor);
    /* Set the main cursor. */
    efl_text_cursor_position_set(sd->text_obj, efl_text_cursor_get(data, EFL_TEXT_CURSOR_GET_TYPE_MAIN), pos);
-   ELM_SAFE_FREE(sd->longpress_timer, ecore_timer_del);
+   efl_input_clickable_longpress_abort(data, 1);
    sd->long_pressed = EINA_FALSE;
 }
 
@@ -2266,7 +2245,6 @@ _efl_ui_text_efl_object_destructor(Eo *obj, Efl_Ui_Text_Data *sd)
         ELM_SAFE_FREE(sd->append_text_left, free);
         sd->append_text_idler = NULL;
      }
-   ecore_timer_del(sd->longpress_timer);
    EINA_LIST_FREE(sd->items, it)
      {
         eina_stringshare_del(it->label);

src/lib/elementary/efl_ui_timepicker.c

@@ -123,17 +123,17 @@ _fields_init(Eo *obj)
    //Field create.
    pd->hour = efl_add(EFL_UI_SPIN_BUTTON_CLASS, obj,
                       efl_ui_range_limits_set(efl_added, 1, 12),
-                      efl_ui_spin_button_circulate_set(efl_added, EINA_TRUE),
+                      efl_ui_spin_button_wraparound_set(efl_added, EINA_TRUE),
                       efl_ui_spin_button_editable_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_SPIN_EVENT_CHANGED,_field_changed_cb, obj));
+                      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_circulate_set(efl_added, EINA_TRUE),
+                     efl_ui_spin_button_wraparound_set(efl_added, EINA_TRUE),
                      efl_ui_spin_button_editable_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_SPIN_EVENT_CHANGED,_field_changed_cb, obj));
+                     efl_event_callback_add(efl_added, EFL_UI_RANGE_EVENT_CHANGED,_field_changed_cb, obj));
 
    pd->ampm = efl_add(EFL_UI_BUTTON_CLASS, obj,
                       efl_event_callback_add(efl_added, EFL_INPUT_EVENT_CLICKED, _field_changed_cb, obj),

src/lib/elementary/efl_ui_win.c

@@ -4612,18 +4612,30 @@ _elm_win_frame_add(Efl_Ui_Win_Data *sd, const char *element, const char *style)
    else
      {
         Eina_Bool set = EINA_FALSE;
+        Eina_Bool legacy = elm_widget_is_legacy(sd->obj);
 
-        sd->icon = elm_icon_add(sd->obj);
+        if (legacy)
+          sd->icon = elm_icon_add(sd->obj);
+        else
+          sd->icon = efl_add(EFL_UI_IMAGE_CLASS, sd->obj);
 
         if (sd->icon_name)
-          set = elm_icon_standard_set(sd->icon, sd->icon_name);
+          {
+             if (legacy)
+               set = elm_icon_standard_set(sd->icon, sd->icon_name);
+             else
+               set = efl_ui_image_icon_set(sd->icon, sd->icon_name);
+          }
         if (((!sd->icon_name) || (!set)) && _elm_appname)
           {
              Efreet_Desktop *d;
              d = efreet_util_desktop_exec_find(_elm_appname);
              if (d)
                {
-                  elm_icon_standard_set(sd->icon, d->icon);
+                  if (legacy)
+                    elm_icon_standard_set(sd->icon, d->icon);
+                  else
+                    efl_ui_image_icon_set(sd->icon, d->icon);
                   efreet_desktop_free(d);
                }
           }

src/lib/elementary/elc_player.c

@@ -88,7 +88,7 @@ EFL_CALLBACKS_ARRAY_DEFINE(_emotion_cb,
 );
 
 EFL_CALLBACKS_ARRAY_DEFINE(_slider_cb,
-   { EFL_UI_SLIDER_EVENT_CHANGED, _update_position },
+   { EFL_UI_RANGE_EVENT_CHANGED, _update_position },
    { EFL_UI_SLIDER_EVENT_SLIDER_DRAG_START, _drag_start },
    { EFL_UI_SLIDER_EVENT_SLIDER_DRAG_STOP, _drag_stop }
 );
@@ -630,7 +630,7 @@ _elm_player_efl_canvas_group_group_add(Eo *obj, Elm_Player_Data *priv)
    elm_layout_content_set(obj, "elm.swallow.media_player.volumeslider",
                           priv->vslider);
    efl_event_callback_add
-     (priv->vslider, EFL_UI_SLIDER_EVENT_CHANGED, _update_volume, obj);
+     (priv->vslider, EFL_UI_RANGE_EVENT_CHANGED, _update_volume, obj);
 
    elm_layout_sizing_eval(obj);
    elm_widget_can_focus_set(obj, EINA_TRUE);

src/lib/elementary/elm_colorselector.c

@@ -604,8 +604,8 @@ _update_hsla_from_colorbar(Evas_Object *obj, Color_Type type, double x)
    _update_colorbars(sd);
    if ((sd->mode == ELM_COLORSELECTOR_ALL) || (sd->mode == ELM_COLORSELECTOR_PICKER))
      _color_picker_init(sd);
-   efl_event_callback_legacy_call(obj, ELM_COLORSELECTOR_EVENT_CHANGED, NULL);
-   efl_event_callback_legacy_call(obj, ELM_COLORSELECTOR_EVENT_CHANGED_USER, NULL);
+   evas_object_smart_callback_call(obj, "changed", NULL);
+   evas_object_smart_callback_call(obj, "changed,user", NULL);
 }
 
 static void
@@ -662,7 +662,7 @@ _colors_set(Evas_Object *obj,
    if ((sd->mode == ELM_COLORSELECTOR_ALL) || (sd->mode == ELM_COLORSELECTOR_PICKER))
      _color_picker_init(sd);
    if (!mode_change)
-     efl_event_callback_legacy_call(obj, ELM_COLORSELECTOR_EVENT_CHANGED, NULL);
+     evas_object_smart_callback_call(obj, "changed", NULL);
 }
 
 static void
@@ -707,7 +707,7 @@ _spinner_changed_cb(void *data, const Efl_Event *event)
          break;
      }
    evas_object_data_del(event->object, "_changed");
-   efl_event_callback_legacy_call(parent, ELM_COLORSELECTOR_EVENT_CHANGED_USER, NULL);
+   evas_object_smart_callback_call(parent, "changed,user", NULL);
 }
 
 #ifdef HAVE_ELEMENTARY_X
@@ -795,7 +795,7 @@ _mouse_up_cb(void *data, int type EINA_UNUSED, void *event EINA_UNUSED)
 
    _unselect_selected_item(sd);
    _colors_set(o, r, g, b, 0xFF, EINA_FALSE);
-   efl_event_callback_legacy_call(o, ELM_COLORSELECTOR_EVENT_CHANGED_USER, NULL);
+   evas_object_smart_callback_call(o, "changed,user", NULL);
 
    return EINA_TRUE;
 }
@@ -1348,9 +1348,8 @@ _elm_colorselector_efl_ui_widget_theme_apply(Eo *obj, Elm_Colorselector_Data *sd
         vpadstr = edje_object_data_get
             (wd->resize_obj, "vertical_pad");
         if (vpadstr) v_pad = atoi(vpadstr);
-
         scale = efl_gfx_entity_scale_get(obj) * elm_config_scale_get() / edje_object_base_scale_get(wd->resize_obj);
-        efl_gfx_arrangement_content_padding_set(sd->palette_box, h_pad * scale, v_pad * scale, 0);
+        elm_box_padding_set(sd->palette_box, h_pad * scale, v_pad * scale);
 
         EINA_LIST_FOREACH(sd->items, elist, eo_item)
           {
@@ -1535,7 +1534,7 @@ _elm_colorselector_efl_canvas_group_calculate(Eo *obj, Elm_Colorselector_Data *s
         return;
      }
 
-   efl_pack_layout_request(sd->palette_box);
+   efl_canvas_group_calculate(sd->palette_box);
    edje_object_size_min_calc(wd->resize_obj, &minw, &minh);
    evas_object_size_hint_min_set(obj, minw, minh);
 }
@@ -1569,8 +1568,7 @@ _on_color_long_press(void *data)
 
    sd->longpress_timer = NULL;
 
-   efl_event_callback_legacy_call
-     (WIDGET(item), ELM_COLORSELECTOR_EVENT_COLOR_ITEM_LONGPRESSED, EO_OBJ(item));
+   evas_object_smart_callback_call(WIDGET(item), "color,item,longpressed", EO_OBJ(item));
 
    return ECORE_CALLBACK_CANCEL;
 }
@@ -1644,8 +1642,7 @@ _on_color_released(void *data,
    elm_object_signal_emit(VIEW(item), "elm,state,selected", "elm");
    elm_colorselector_color_set(WIDGET(item), item->color->r, item->color->g,
                                item->color->b, item->color->a);
-   efl_event_callback_legacy_call
-     (WIDGET(item), ELM_COLORSELECTOR_EVENT_COLOR_ITEM_SELECTED, EO_OBJ(item));
+   evas_object_smart_callback_call(WIDGET(item), "color,item,selected", EO_OBJ(item));
 
    eo_temp_item = eina_list_data_get(sd->selected);
    if (eo_temp_item && (eo_temp_item != EO_OBJ(item)))
@@ -1875,7 +1872,7 @@ _palette_colors_load(Evas_Object *obj)
         item->color->b = color->b;
         item->color->a = color->a;
 
-        efl_pack(sd->palette_box, VIEW(item));
+        elm_box_pack_end(sd->palette_box, VIEW(item));
         evas_object_color_set(item->color_obj,
                               (item->color->r * item->color->a) / 255,
                               (item->color->g * item->color->a) / 255,
@@ -1888,14 +1885,6 @@ _palette_colors_load(Evas_Object *obj)
    sd->config_load = EINA_TRUE;
 }
 
-static inline void
-_palette_box_prepare(Eo *o)
-{
-   efl_ui_layout_orientation_set(o, EFL_UI_LAYOUT_ORIENTATION_HORIZONTAL);
-   efl_gfx_hint_weight_set(o, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
-   efl_gfx_entity_visible_set(o, EINA_FALSE);
-}
-
 static void
 _create_colorpalette(Evas_Object *obj)
 {
@@ -1908,16 +1897,15 @@ _create_colorpalette(Evas_Object *obj)
    ELM_WIDGET_DATA_GET_OR_RETURN(obj, wd);
 
    if (sd->palette_box) return;
-   if (elm_widget_is_legacy(obj))
-     {
-        sd->palette_box = elm_legacy_add(EFL_UI_BOX_FLOW_CLASS, obj);
-        evas_object_size_hint_align_set(sd->palette_box, EVAS_HINT_FILL, EVAS_HINT_FILL);
-     }
-   else
-     {
-        sd->palette_box = efl_add(EFL_UI_BOX_FLOW_CLASS, obj);
-     }
-   _palette_box_prepare(sd->palette_box);
+   sd->palette_box = elm_box_add(obj);
+   elm_box_layout_set
+     (sd->palette_box, evas_object_box_layout_flow_horizontal, NULL, NULL);
+   elm_box_horizontal_set(sd->palette_box, EINA_TRUE);
+   evas_object_size_hint_weight_set
+     (sd->palette_box, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
+   evas_object_size_hint_align_set
+     (sd->palette_box, EVAS_HINT_FILL, EVAS_HINT_FILL);
+   elm_box_homogeneous_set(sd->palette_box, EINA_TRUE);
 
    hpadstr = edje_object_data_get(wd->resize_obj, "horizontal_pad");
    if (hpadstr) h_pad = atoi(hpadstr);
@@ -1925,8 +1913,8 @@ _create_colorpalette(Evas_Object *obj)
    if (vpadstr) v_pad = atoi(vpadstr);
 
    scale = efl_gfx_entity_scale_get(obj) * elm_config_scale_get() / edje_object_base_scale_get(wd->resize_obj);
-   efl_gfx_arrangement_content_padding_set(sd->palette_box, h_pad * scale, v_pad * scale, 0);
-   efl_gfx_arrangement_content_align_set(sd->palette_box, 0.0, 0.0);
+   elm_box_padding_set(sd->palette_box, h_pad * scale, v_pad * scale);
+   elm_box_align_set(sd->palette_box, 0.0, 0.0);
    if (!elm_layout_content_set(obj, "elm.palette", sd->palette_box))
      elm_layout_content_set(obj, "palette", sd->palette_box);
    sd->palette_name = eina_stringshare_add("default");
@@ -2467,7 +2455,7 @@ _elm_colorselector_palette_color_add(Eo *obj, Elm_Colorselector_Data *sd, int r,
    item->color->b = b;
    item->color->a = a;
 
-   efl_pack(sd->palette_box, VIEW(item));
+   elm_box_pack_end(sd->palette_box, VIEW(item));
    evas_object_color_set(item->color_obj,
                          (item->color->r * item->color->a) / 255,
                          (item->color->g * item->color->a) / 255,
@@ -2540,8 +2528,7 @@ _elm_color_item_selected_set(Eo *eo_item,
           if (eo_item == eo_temp_item) sd->selected = l;
 
         elm_object_signal_emit(VIEW(item), "elm,anim,activate", "elm");
-        efl_event_callback_legacy_call
-          (WIDGET(item), ELM_COLORSELECTOR_EVENT_COLOR_ITEM_SELECTED, eo_item);
+        evas_object_smart_callback_call(WIDGET(item), "color,item,selected", EO_OBJ(item));
      }
 }
 

src/lib/elementary/elm_slider.c

@@ -603,7 +603,7 @@ _elm_slider_val_fetch(Evas_Object *obj, Elm_Slider_Data *pd, Eina_Bool user_even
         id->intvl_from = val;
         if (user_event)
           {
-             efl_event_callback_legacy_call(obj, EFL_UI_SLIDER_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);
              evented = EINA_TRUE;
@@ -616,7 +616,7 @@ _elm_slider_val_fetch(Evas_Object *obj, Elm_Slider_Data *pd, Eina_Bool user_even
         /* avoid emitting two events and setting a timer twice */
         if (user_event && (!evented))
           {
-             efl_event_callback_legacy_call(obj, EFL_UI_SLIDER_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);
           }

src/lib/eolian/Eolian.h

@@ -348,8 +348,7 @@ typedef enum
    EOLIAN_TYPE_BUILTIN_STRINGSHARE,
    EOLIAN_TYPE_BUILTIN_STRBUF,
 
-   EOLIAN_TYPE_BUILTIN_VOID_PTR,
-   EOLIAN_TYPE_BUILTIN_FREE_CB
+   EOLIAN_TYPE_BUILTIN_VOID_PTR
 } Eolian_Type_Builtin_Type;
 
 typedef enum

src/lib/eolian/database_type.c

@@ -189,17 +189,6 @@ static void
 _atype_to_str(const Eolian_Typedecl *tp, Eina_Strbuf *buf)
 {
    eina_strbuf_append(buf, "typedef ");
-
-   if (tp->base_type->type == EOLIAN_TYPE_REGULAR)
-     {
-        if (!strcmp(tp->base_type->base.name, "__builtin_free_cb"))
-          {
-             eina_strbuf_append(buf, "void (*");
-             eina_strbuf_append(buf, tp->base.c_name);
-             eina_strbuf_append(buf, ")(void *data)");
-             return;
-          }
-     }
    database_type_to_str(tp->base_type, buf, tp->base.c_name,
                         EOLIAN_C_TYPE_DEFAULT);
 }

src/lib/eolian/database_validate.c

@@ -255,6 +255,13 @@ _validate_type(Validate_State *vals, Eolian_Type *tp)
                 /* validate types in brackets so transitive fields get written */
                 while (itp)
                   {
+                     if (vals->stable && itp->is_ptr)
+                       {
+                          _eo_parser_log(&itp->base,
+                                         "pointer types not allowed in '%s' in stable context",
+                                         tp->base.name);
+                          return EINA_FALSE;
+                       }
                      if (!_validate_type(vals, itp))
                        return EINA_FALSE;
                      itp = itp->next_type;
@@ -284,7 +291,6 @@ _validate_type(Validate_State *vals, Eolian_Type *tp)
                   {
                    case KW_void_ptr:
                    case KW___undefined_type:
-                   case KW___builtin_free_cb:
                      if (vals->stable)
                        {
                           _eo_parser_log(&tp->base,

src/lib/eolian/eo_lexer.h

@@ -64,7 +64,6 @@ enum Tokens
     KW(mstring), KW(string), KW(stringshare), KW(strbuf), \
     \
     KW(void_ptr), \
-    KW(__builtin_free_cb), \
     KW(function), \
     KW(__undefined_type), \
     \

src/lib/eolian_cxx/grammar/klass_def.hpp

@@ -375,10 +375,11 @@ struct type_def
    bool has_own;
    bool is_ptr;
    bool is_beta;
+   std::string doc_summary;
 
    type_def() = default;
-   type_def(variant_type original_type, std::string c_type, bool has_own, bool is_ptr, bool is_beta)
-     : original_type(original_type), c_type(c_type), has_own(has_own), is_ptr(is_ptr), is_beta(is_beta) {}
+   type_def(variant_type original_type, std::string c_type, bool has_own, bool is_ptr, bool is_beta, std::string doc_summary)
+     : original_type(original_type), c_type(c_type), has_own(has_own), is_ptr(is_ptr), is_beta(is_beta), doc_summary(doc_summary) {}
 
    type_def(Eolian_Type const* eolian_type, Eolian_Unit const* unit, Eolian_C_Type_Type ctype)
    {
@@ -422,7 +423,7 @@ inline bool operator!=(type_def const& lhs, type_def const& rhs)
   return !(lhs == rhs);
 }
 
-type_def const void_ {attributes::regular_type_def{"void", {qualifier_info::is_none, {}}, {}}, "void", false, false, false};
+type_def const void_ {attributes::regular_type_def{"void", {qualifier_info::is_none, {}}, {}}, "void", false, false, false, ""};
 
 inline void type_def::set(Eolian_Type const* eolian_type, Eolian_Unit const* unit, Eolian_C_Type_Type ctype)
 {
@@ -434,6 +435,11 @@ inline void type_def::set(Eolian_Type const* eolian_type, Eolian_Unit const* uni
 
    Eolian_Typedecl const* decl = eolian_type_typedecl_get(eolian_type);
    is_beta = decl && eolian_object_is_beta(EOLIAN_OBJECT(decl));
+   if (decl)
+     {
+        documentation_def documentation = eolian_typedecl_documentation_get(decl);
+        doc_summary = documentation.summary;
+     }
    switch( ::eolian_type_type_get(eolian_type))
      {
      case EOLIAN_TYPE_VOID:
@@ -872,7 +878,7 @@ struct function_def
                char typenam[2] = { 0, };
                typenam[0] = template_typename++;
                std::string statement = "auto fw_" + param.param_name + " = new ::efl::eolian::function_wrapper<";
-               statement += param.type.c_type + ", " + typenam + ">(" + param.param_name + ");";
+               statement += param.type.c_type + ", " + typenam + ", ::efl::eolian::" + param.type.c_type + "__function_tag>(" + param.param_name + ");";
                statements.push_back(statement);
             }
        }

src/lib/eolian_cxx/grammar/type_function_declaration.hpp

@@ -37,9 +37,9 @@ struct type_function_declaration_generator {
 
       if (!as_generator(
              "template <typename F>\n"
-             "struct function_wrapper<" << string << ", F> {\n"
+             "struct function_wrapper<" << string << ", F, struct " << string << "__function_tag> {\n"
              << scope_tab << "function_wrapper(F cxx_func) : _cxx_func(cxx_func) {}\n"
-             ).generate(sink, f.c_name, ctx))
+             ).generate(sink, std::make_tuple(f.c_name, f.c_name), ctx))
         return false;
 
       if (!as_generator(
@@ -49,9 +49,9 @@ struct type_function_declaration_generator {
              << "private:\n"
              << scope_tab << "F _cxx_func;\n"
              << scope_tab << "static void deleter(void *data) {\n"
-             << scope_tab << scope_tab << "delete static_cast<function_wrapper<" << string << ", F>*>(data);\n"
+             << scope_tab << scope_tab << "delete static_cast<function_wrapper<" << string << ", F, ::efl::eolian::" << string << "__function_tag>*>(data);\n"
              << scope_tab << "}\n"
-             ).generate(sink, std::make_tuple(f.c_name, f.c_name), ctx))
+             ).generate(sink, std::make_tuple(f.c_name, f.c_name, f.c_name), ctx))
         return false;
 
       std::vector<std::string> c_args;
@@ -61,8 +61,8 @@ struct type_function_declaration_generator {
              scope_tab << "static " << string << " caller(void *cxx_call_data"
              << *(string) << ") {\n"
              << scope_tab << scope_tab << "auto fw = static_cast<function_wrapper<"
-             << string << ", F>*>(cxx_call_data);\n"
-             ).generate(sink, std::make_tuple(f.return_type.c_type, c_args, f.c_name), ctx))
+             << string << ", F, ::efl::eolian::" << string << "__function_tag>*>(cxx_call_data);\n"
+             ).generate(sink, std::make_tuple(f.return_type.c_type, c_args, f.c_name, f.c_name), ctx))
         return false;
 
       if (f.return_type != attributes::void_

src/lib/evas/Evas_GL.h

@@ -4781,7 +4781,220 @@ typedef struct __GLsync*   GLsync;
 #define GL_MAX_VERTEX_ATTRIB_RELATIVE_OFFSET 0x82D9
 #define GL_MAX_VERTEX_ATTRIB_BINDINGS     0x82DA
 #define GL_MAX_VERTEX_ATTRIB_STRIDE       0x82E5
+#endif
 
+/* OpenGLES 3.2 */
+#ifndef __gl32_h_
+#define __gl32_h_ 1
+
+typedef void (*GLDEBUGPROC)(GLenum source,GLenum type,GLuint id,GLenum severity,GLsizei length,const GLchar *message,const void *userParam);
+
+#define GL_MULTISAMPLE_LINE_WIDTH_RANGE   0x9381
+#define GL_MULTISAMPLE_LINE_WIDTH_GRANULARITY 0x9382
+#define GL_MULTIPLY                       0x9294
+#define GL_SCREEN                         0x9295
+#define GL_OVERLAY                        0x9296
+#define GL_DARKEN                         0x9297
+#define GL_LIGHTEN                        0x9298
+#define GL_COLORDODGE                     0x9299
+#define GL_COLORBURN                      0x929A
+#define GL_HARDLIGHT                      0x929B
+#define GL_SOFTLIGHT                      0x929C
+#define GL_DIFFERENCE                     0x929E
+#define GL_EXCLUSION                      0x92A0
+#define GL_HSL_HUE                        0x92AD
+#define GL_HSL_SATURATION                 0x92AE
+#define GL_HSL_COLOR                      0x92AF
+#define GL_HSL_LUMINOSITY                 0x92B0
+#define GL_DEBUG_OUTPUT_SYNCHRONOUS       0x8242
+#define GL_DEBUG_NEXT_LOGGED_MESSAGE_LENGTH 0x8243
+#define GL_DEBUG_CALLBACK_FUNCTION        0x8244
+#define GL_DEBUG_CALLBACK_USER_PARAM      0x8245
+#define GL_DEBUG_SOURCE_API               0x8246
+#define GL_DEBUG_SOURCE_WINDOW_SYSTEM     0x8247
+#define GL_DEBUG_SOURCE_SHADER_COMPILER   0x8248
+#define GL_DEBUG_SOURCE_THIRD_PARTY       0x8249
+#define GL_DEBUG_SOURCE_APPLICATION       0x824A
+#define GL_DEBUG_SOURCE_OTHER             0x824B
+#define GL_DEBUG_TYPE_ERROR               0x824C
+#define GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR 0x824D
+#define GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR  0x824E
+#define GL_DEBUG_TYPE_PORTABILITY         0x824F
+#define GL_DEBUG_TYPE_PERFORMANCE         0x8250
+#define GL_DEBUG_TYPE_OTHER               0x8251
+#define GL_DEBUG_TYPE_MARKER              0x8268
+#define GL_DEBUG_TYPE_PUSH_GROUP          0x8269
+#define GL_DEBUG_TYPE_POP_GROUP           0x826A
+#define GL_DEBUG_SEVERITY_NOTIFICATION    0x826B
+#define GL_MAX_DEBUG_GROUP_STACK_DEPTH    0x826C
+#define GL_DEBUG_GROUP_STACK_DEPTH        0x826D
+#define GL_BUFFER                         0x82E0
+#define GL_SHADER                         0x82E1
+#define GL_PROGRAM                        0x82E2
+#define GL_VERTEX_ARRAY                   0x8074
+#define GL_QUERY                          0x82E3
+#define GL_PROGRAM_PIPELINE               0x82E4
+#define GL_SAMPLER                        0x82E6
+#define GL_MAX_LABEL_LENGTH               0x82E8
+#define GL_MAX_DEBUG_MESSAGE_LENGTH       0x9143
+#define GL_MAX_DEBUG_LOGGED_MESSAGES      0x9144
+#define GL_DEBUG_LOGGED_MESSAGES          0x9145
+#define GL_DEBUG_SEVERITY_HIGH            0x9146
+#define GL_DEBUG_SEVERITY_MEDIUM          0x9147
+#define GL_DEBUG_SEVERITY_LOW             0x9148
+#define GL_DEBUG_OUTPUT                   0x92E0
+#define GL_CONTEXT_FLAG_DEBUG_BIT         0x00000002
+#define GL_STACK_OVERFLOW                 0x0503
+#define GL_STACK_UNDERFLOW                0x0504
+#define GL_GEOMETRY_SHADER                0x8DD9
+#define GL_GEOMETRY_SHADER_BIT            0x00000004
+#define GL_GEOMETRY_VERTICES_OUT          0x8916
+#define GL_GEOMETRY_INPUT_TYPE            0x8917
+#define GL_GEOMETRY_OUTPUT_TYPE           0x8918
+#define GL_GEOMETRY_SHADER_INVOCATIONS    0x887F
+#define GL_LAYER_PROVOKING_VERTEX         0x825E
+#define GL_LINES_ADJACENCY                0x000A
+#define GL_LINE_STRIP_ADJACENCY           0x000B
+#define GL_TRIANGLES_ADJACENCY            0x000C
+#define GL_TRIANGLE_STRIP_ADJACENCY       0x000D
+#define GL_MAX_GEOMETRY_UNIFORM_COMPONENTS 0x8DDF
+#define GL_MAX_GEOMETRY_UNIFORM_BLOCKS    0x8A2C
+#define GL_MAX_COMBINED_GEOMETRY_UNIFORM_COMPONENTS 0x8A32
+#define GL_MAX_GEOMETRY_INPUT_COMPONENTS  0x9123
+#define GL_MAX_GEOMETRY_OUTPUT_COMPONENTS 0x9124
+#define GL_MAX_GEOMETRY_OUTPUT_VERTICES   0x8DE0
+#define GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS 0x8DE1
+#define GL_MAX_GEOMETRY_SHADER_INVOCATIONS 0x8E5A
+#define GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS 0x8C29
+#define GL_MAX_GEOMETRY_ATOMIC_COUNTER_BUFFERS 0x92CF
+#define GL_MAX_GEOMETRY_ATOMIC_COUNTERS   0x92D5
+#define GL_MAX_GEOMETRY_IMAGE_UNIFORMS    0x90CD
+#define GL_MAX_GEOMETRY_SHADER_STORAGE_BLOCKS 0x90D7
+#define GL_FIRST_VERTEX_CONVENTION        0x8E4D
+#define GL_LAST_VERTEX_CONVENTION         0x8E4E
+#define GL_UNDEFINED_VERTEX               0x8260
+#define GL_PRIMITIVES_GENERATED           0x8C87
+#define GL_FRAMEBUFFER_DEFAULT_LAYERS     0x9312
+#define GL_MAX_FRAMEBUFFER_LAYERS         0x9317
+#define GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS 0x8DA8
+#define GL_FRAMEBUFFER_ATTACHMENT_LAYERED 0x8DA7
+#define GL_REFERENCED_BY_GEOMETRY_SHADER  0x9309
+#define GL_PRIMITIVE_BOUNDING_BOX         0x92BE
+#define GL_CONTEXT_FLAG_ROBUST_ACCESS_BIT 0x00000004
+#define GL_CONTEXT_FLAGS                  0x821E
+#define GL_LOSE_CONTEXT_ON_RESET          0x8252
+#define GL_GUILTY_CONTEXT_RESET           0x8253
+#define GL_INNOCENT_CONTEXT_RESET         0x8254
+#define GL_UNKNOWN_CONTEXT_RESET          0x8255
+#define GL_RESET_NOTIFICATION_STRATEGY    0x8256
+#define GL_NO_RESET_NOTIFICATION          0x8261
+#define GL_CONTEXT_LOST                   0x0507
+#define GL_SAMPLE_SHADING                 0x8C36
+#define GL_MIN_SAMPLE_SHADING_VALUE       0x8C37
+#define GL_MIN_FRAGMENT_INTERPOLATION_OFFSET 0x8E5B
+#define GL_MAX_FRAGMENT_INTERPOLATION_OFFSET 0x8E5C
+#define GL_FRAGMENT_INTERPOLATION_OFFSET_BITS 0x8E5D
+#define GL_PATCHES                        0x000E
+#define GL_PATCH_VERTICES                 0x8E72
+#define GL_TESS_CONTROL_OUTPUT_VERTICES   0x8E75
+#define GL_TESS_GEN_MODE                  0x8E76
+#define GL_TESS_GEN_SPACING               0x8E77
+#define GL_TESS_GEN_VERTEX_ORDER          0x8E78
+#define GL_TESS_GEN_POINT_MODE            0x8E79
+#define GL_ISOLINES                       0x8E7A
+#define GL_QUADS                          0x0007
+#define GL_FRACTIONAL_ODD                 0x8E7B
+#define GL_FRACTIONAL_EVEN                0x8E7C
+#define GL_MAX_PATCH_VERTICES             0x8E7D
+#define GL_MAX_TESS_GEN_LEVEL             0x8E7E
+#define GL_MAX_TESS_CONTROL_UNIFORM_COMPONENTS 0x8E7F
+#define GL_MAX_TESS_EVALUATION_UNIFORM_COMPONENTS 0x8E80
+#define GL_MAX_TESS_CONTROL_TEXTURE_IMAGE_UNITS 0x8E81
+#define GL_MAX_TESS_EVALUATION_TEXTURE_IMAGE_UNITS 0x8E82
+#define GL_MAX_TESS_CONTROL_OUTPUT_COMPONENTS 0x8E83
+#define GL_MAX_TESS_PATCH_COMPONENTS      0x8E84
+#define GL_MAX_TESS_CONTROL_TOTAL_OUTPUT_COMPONENTS 0x8E85
+#define GL_MAX_TESS_EVALUATION_OUTPUT_COMPONENTS 0x8E86
+#define GL_MAX_TESS_CONTROL_UNIFORM_BLOCKS 0x8E89
+#define GL_MAX_TESS_EVALUATION_UNIFORM_BLOCKS 0x8E8A
+#define GL_MAX_TESS_CONTROL_INPUT_COMPONENTS 0x886C
+#define GL_MAX_TESS_EVALUATION_INPUT_COMPONENTS 0x886D
+#define GL_MAX_COMBINED_TESS_CONTROL_UNIFORM_COMPONENTS 0x8E1E
+#define GL_MAX_COMBINED_TESS_EVALUATION_UNIFORM_COMPONENTS 0x8E1F
+#define GL_MAX_TESS_CONTROL_ATOMIC_COUNTER_BUFFERS 0x92CD
+#define GL_MAX_TESS_EVALUATION_ATOMIC_COUNTER_BUFFERS 0x92CE
+#define GL_MAX_TESS_CONTROL_ATOMIC_COUNTERS 0x92D3
+#define GL_MAX_TESS_EVALUATION_ATOMIC_COUNTERS 0x92D4
+#define GL_MAX_TESS_CONTROL_IMAGE_UNIFORMS 0x90CB
+#define GL_MAX_TESS_EVALUATION_IMAGE_UNIFORMS 0x90CC
+#define GL_MAX_TESS_CONTROL_SHADER_STORAGE_BLOCKS 0x90D8
+#define GL_MAX_TESS_EVALUATION_SHADER_STORAGE_BLOCKS 0x90D9
+#define GL_PRIMITIVE_RESTART_FOR_PATCHES_SUPPORTED 0x8221
+#define GL_IS_PER_PATCH                   0x92E7
+#define GL_REFERENCED_BY_TESS_CONTROL_SHADER 0x9307
+#define GL_REFERENCED_BY_TESS_EVALUATION_SHADER 0x9308
+#define GL_TESS_CONTROL_SHADER            0x8E88
+#define GL_TESS_EVALUATION_SHADER         0x8E87
+#define GL_TESS_CONTROL_SHADER_BIT        0x00000008
+#define GL_TESS_EVALUATION_SHADER_BIT     0x00000010
+#define GL_TEXTURE_BORDER_COLOR           0x1004
+#define GL_CLAMP_TO_BORDER                0x812D
+#define GL_TEXTURE_BUFFER                 0x8C2A
+#define GL_TEXTURE_BUFFER_BINDING         0x8C2A
+#define GL_MAX_TEXTURE_BUFFER_SIZE        0x8C2B
+#define GL_TEXTURE_BINDING_BUFFER         0x8C2C
+#define GL_TEXTURE_BUFFER_DATA_STORE_BINDING 0x8C2D
+#define GL_TEXTURE_BUFFER_OFFSET_ALIGNMENT 0x919F
+#define GL_SAMPLER_BUFFER                 0x8DC2
+#define GL_INT_SAMPLER_BUFFER             0x8DD0
+#define GL_UNSIGNED_INT_SAMPLER_BUFFER    0x8DD8
+#define GL_IMAGE_BUFFER                   0x9051
+#define GL_INT_IMAGE_BUFFER               0x905C
+#define GL_UNSIGNED_INT_IMAGE_BUFFER      0x9067
+#define GL_TEXTURE_BUFFER_OFFSET          0x919D
+#define GL_TEXTURE_BUFFER_SIZE            0x919E
+#define GL_COMPRESSED_RGBA_ASTC_4x4       0x93B0
+#define GL_COMPRESSED_RGBA_ASTC_5x4       0x93B1
+#define GL_COMPRESSED_RGBA_ASTC_5x5       0x93B2
+#define GL_COMPRESSED_RGBA_ASTC_6x5       0x93B3
+#define GL_COMPRESSED_RGBA_ASTC_6x6       0x93B4
+#define GL_COMPRESSED_RGBA_ASTC_8x5       0x93B5
+#define GL_COMPRESSED_RGBA_ASTC_8x6       0x93B6
+#define GL_COMPRESSED_RGBA_ASTC_8x8       0x93B7
+#define GL_COMPRESSED_RGBA_ASTC_10x5      0x93B8
+#define GL_COMPRESSED_RGBA_ASTC_10x6      0x93B9
+#define GL_COMPRESSED_RGBA_ASTC_10x8      0x93BA
+#define GL_COMPRESSED_RGBA_ASTC_10x10     0x93BB
+#define GL_COMPRESSED_RGBA_ASTC_12x10     0x93BC
+#define GL_COMPRESSED_RGBA_ASTC_12x12     0x93BD
+#define GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4 0x93D0
+#define GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4 0x93D1
+#define GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5 0x93D2
+#define GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5 0x93D3
+#define GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6 0x93D4
+#define GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x5 0x93D5
+#define GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x6 0x93D6
+#define GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x8 0x93D7
+#define GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x5 0x93D8
+#define GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x6 0x93D9
+#define GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x8 0x93DA
+#define GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x10 0x93DB
+#define GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x10 0x93DC
+#define GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x12 0x93DD
+#define GL_TEXTURE_CUBE_MAP_ARRAY         0x9009
+#define GL_TEXTURE_BINDING_CUBE_MAP_ARRAY 0x900A
+#define GL_SAMPLER_CUBE_MAP_ARRAY         0x900C
+#define GL_SAMPLER_CUBE_MAP_ARRAY_SHADOW  0x900D
+#define GL_INT_SAMPLER_CUBE_MAP_ARRAY     0x900E
+#define GL_UNSIGNED_INT_SAMPLER_CUBE_MAP_ARRAY 0x900F
+#define GL_IMAGE_CUBE_MAP_ARRAY           0x9054
+#define GL_INT_IMAGE_CUBE_MAP_ARRAY       0x905F
+#define GL_UNSIGNED_INT_IMAGE_CUBE_MAP_ARRAY 0x906A
+#define GL_TEXTURE_2D_MULTISAMPLE_ARRAY   0x9102
+#define GL_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY 0x9105
+#define GL_SAMPLER_2D_MULTISAMPLE_ARRAY   0x910B
+#define GL_INT_SAMPLER_2D_MULTISAMPLE_ARRAY 0x910C
+#define GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY 0x910D
 #endif
 
 /*
@@ -4927,8 +5140,9 @@ typedef unsigned long long EvasGLTime;
  * Version 3: [version 2] + Wayland extensions
  * Version 4: [version 3] + GLES3.0 + GLES3.0 extensions
  * Version 5: [version 4] + GLES3.1
+ * Version 6: [version 5] + GLES3.2
  */
-#define EVAS_GL_API_VERSION 5
+#define EVAS_GL_API_VERSION 6
 
 /**
  * @brief The Evas GL API
@@ -5855,6 +6069,63 @@ EvasGLImage *img = glapi->evasglCreateImageForContext
     void         (*glVertexBindingDivisor) (GLuint bindingindex, GLuint divisor);
    /** @} */
 
+   /**
+    * @anchor gles3.2
+    * @name OpenGL-ES 3.2.
+    *
+    * Evas_GL_API version 6.
+    *
+    * The following functions are supported in all OpenGL-ES 3.2 contexts.
+    * @{
+    */
+   /* This defines shows that Evas_GL_API supports GLES3.2 APIs */
+    void         (*glBlendBarrier) (void);
+    void         (*glCopyImageSubData) (GLuint srcName, GLenum srcTarget, GLint srcLevel, GLint srcX, GLint srcY, GLint srcZ, GLuint dstName, GLenum dstTarget, GLint dstLevel, GLint dstX, GLint dstY, GLint dstZ, GLsizei srcWidth, GLsizei srcHeight, GLsizei srcDepth);
+    void         (*glDebugMessageControl) (GLenum source, GLenum type, GLenum severity, GLsizei count, const GLuint *ids, GLboolean enabled);
+    void         (*glDebugMessageInsert) (GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, const GLchar *buf);
+    void         (*glDebugMessageCallback) (GLDEBUGPROC callback, const void *userParam);
+    GLuint       (*glGetDebugMessageLog) (GLuint count, GLsizei bufSize, GLenum *sources, GLenum *types, GLuint *ids, GLenum *severities, GLsizei *lengths, GLchar *messageLog);
+    void         (*glPushDebugGroup) (GLenum source, GLuint id, GLsizei length, const GLchar *message);
+    void         (*glPopDebugGroup) (void);
+    void         (*glObjectLabel) (GLenum identifier, GLuint name, GLsizei length, const GLchar *label);
+    void         (*glGetObjectLabel) (GLenum identifier, GLuint name, GLsizei bufSize, GLsizei *length, GLchar *label);
+    void         (*glObjectPtrLabel) (const void *ptr, GLsizei length, const GLchar *label);
+    void         (*glGetObjectPtrLabel) (const void *ptr, GLsizei bufSize, GLsizei *length, GLchar *label);
+    //void (*glGetPointerv) (GLenum pname, void **params);
+    void         (*glEnablei) (GLenum target, GLuint index);
+    void         (*glDisablei) (GLenum target, GLuint index);
+    void         (*glBlendEquationi) (GLuint buf, GLenum mode);
+    void         (*glBlendEquationSeparatei) (GLuint buf, GLenum modeRGB, GLenum modeAlpha);
+    void         (*glBlendFunci) (GLuint buf, GLenum src, GLenum dst);
+    void         (*glBlendFuncSeparatei) (GLuint buf, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha);
+    void         (*glColorMaski) (GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a);
+    GLboolean    (*glIsEnabledi) (GLenum target, GLuint index);
+    void         (*glDrawElementsBaseVertex) (GLenum mode, GLsizei count, GLenum type, const void *indices, GLint basevertex);
+    void         (*glDrawRangeElementsBaseVertex) (GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void *indices, GLint basevertex);
+    void         (*glDrawElementsInstancedBaseVertex) (GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount, GLint basevertex);
+    void         (*glFramebufferTexture) (GLenum target, GLenum attachment, GLuint texture, GLint level);
+    void         (*glPrimitiveBoundingBox) (GLfloat minX, GLfloat minY, GLfloat minZ, GLfloat minW, GLfloat maxX, GLfloat maxY, GLfloat maxZ, GLfloat maxW);
+    GLenum       (*glGetGraphicsResetStatus) (void);
+    void         (*glReadnPixels) (GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLsizei bufSize, void *data);
+    void         (*glGetnUniformfv) (GLuint program, GLint location, GLsizei bufSize, GLfloat *params);
+    void         (*glGetnUniformiv) (GLuint program, GLint location, GLsizei bufSize, GLint *params);
+    void         (*glGetnUniformuiv) (GLuint program, GLint location, GLsizei bufSize, GLuint *params);
+    void         (*glMinSampleShading) (GLfloat value);
+    void         (*glPatchParameteri) (GLenum pname, GLint value);
+    void         (*glTexParameterIiv) (GLenum target, GLenum pname, const GLint *params);
+    void         (*glTexParameterIuiv) (GLenum target, GLenum pname, const GLuint *params);
+    void         (*glGetTexParameterIiv) (GLenum target, GLenum pname, GLint *params);
+    void         (*glGetTexParameterIuiv) (GLenum target, GLenum pname, GLuint *params);
+    void         (*glSamplerParameterIiv) (GLuint sampler, GLenum pname, const GLint *param);
+    void         (*glSamplerParameterIuiv) (GLuint sampler, GLenum pname, const GLuint *param);
+    void         (*glGetSamplerParameterIiv) (GLuint sampler, GLenum pname, GLint *params);
+    void         (*glGetSamplerParameterIuiv) (GLuint sampler, GLenum pname, GLuint *params);
+    void         (*glTexBuffer) (GLenum target, GLenum internalformat, GLuint buffer);
+    void         (*glTexBufferRange) (GLenum target, GLenum internalformat, GLuint buffer, GLintptr offset, GLsizeiptr size);
+    void         (*glTexStorage3DMultisample) (GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations);
+
+   /** @} */
+
    /* Future calls will be added down here for expansion, when adding
     * new APIs here, please bump the struct version number (together with
     * the EFL version bump).

src/lib/evas/canvas/efl_input_clickable.c

@@ -118,4 +118,19 @@ _efl_input_clickable_button_state_reset(Eo *obj EINA_UNUSED, Efl_Input_Clickable
    state->pressed = EINA_FALSE;
 }
 
+EOLIAN static void
+_efl_input_clickable_longpress_abort(Eo *obj EINA_UNUSED, Efl_Input_Clickable_Data *pd, unsigned int button)
+{
+   Button_State *state;
+   EINA_SAFETY_ON_FALSE_RETURN(button < 3);
+
+   state = &pd->state[button];
+   EINA_SAFETY_ON_NULL_RETURN(state);
+
+   INF("Widget %s,%p - longpress is aborted(%d)", efl_class_name_get(obj), obj, button);
+
+   if (state->timer)
+     efl_del(state->timer);
+   state->timer = NULL;
+}
 #include "efl_input_clickable.eo.c"

src/lib/evas/canvas/efl_input_clickable.eo

@@ -36,6 +36,15 @@ mixin @beta Efl.Input.Clickable
             button : uint;
          }
       }
+      longpress_abort @protected {
+         [[This aborts ongoing longpress event.
+
+           That is, this will stop the timer for longpress.
+         ]]
+         params {
+            button : uint;
+         }
+      }
    }
    events {
       clicked: Efl.Input.Clickable_Clicked; [[Called when object is in sequence pressed and unpressed, by the primary button]]

src/lib/evas/canvas/evas_events.c

@@ -2250,6 +2250,8 @@ _canvas_event_feed_mouse_move_internal(Evas_Public_Data *e, Efl_Input_Pointer_Da
         copy = evas_event_list_copy(pdata->seat->object.in);
         EINA_LIST_FOREACH(copy, l, eo_obj)
           {
+             Eina_Bool check_nogrep = EINA_FALSE;
+
              obj = efl_data_scope_get(eo_obj, EFL_CANVAS_OBJECT_CLASS);
              obj_pdata = _evas_object_pointer_data_get(pdata, obj);
              if (!obj_pdata)
@@ -2258,6 +2260,9 @@ _canvas_event_feed_mouse_move_internal(Evas_Public_Data *e, Efl_Input_Pointer_Da
                       ev->device);
                   continue;
                }
+             if ((obj_pdata->pointer_mode == EVAS_OBJECT_POINTER_MODE_NOGRAB_NO_REPEAT_UPDOWN) &&
+                 (pdata->seat->nogrep > 0))
+               check_nogrep = EINA_TRUE;
              if ((!e->is_frozen) &&
                  _evas_event_object_pointer_allow(eo_obj, obj, obj_pdata) &&
                  (!evas_object_is_source_invisible(eo_obj, obj) ||
@@ -2275,8 +2280,7 @@ _canvas_event_feed_mouse_move_internal(Evas_Public_Data *e, Efl_Input_Pointer_Da
                }
              else
                 outs = eina_list_append(outs, eo_obj);
-             if ((obj_pdata->pointer_mode == EVAS_OBJECT_POINTER_MODE_NOGRAB_NO_REPEAT_UPDOWN) &&
-                 (pdata->seat->nogrep > 0))
+             if (check_nogrep)
                {
                   eina_list_free(copy);
                   eina_list_free(outs);

src/lib/evas/canvas/evas_object_text.c

@@ -455,34 +455,38 @@ _evas_text_efl_text_font_font_set(Eo *eo_obj, Evas_Text_Data *o, const char *fon
    Evas_Object_Protected_Data *obj = efl_data_scope_get(eo_obj, EFL_CANVAS_OBJECT_CLASS);
    Evas_Font_Description *fdesc;
 
-   if ((!font) || (size <= 0)) return;
+   if (!font && size <= 0) return;
 
    evas_object_async_block(obj);
    if ((size == o->cur.size) &&
        (o->cur.font && !strcmp(font, o->cur.font))) return;
 
-   /* We can't assume the given font is same with current fdesc by comparing string.
-      Since Evas starts to supporting "auto" for language,
-      the given font string should be parsed once before comparing it. */
-   fdesc = evas_font_desc_new();
-
-   /* Set default language according to locale. */
-   eina_stringshare_replace(&(fdesc->lang), evas_font_lang_normalize("auto"));
-   evas_font_name_parse(fdesc, font);
-
-   if (o->cur.fdesc && !evas_font_desc_cmp(fdesc, o->cur.fdesc) &&
-       (size == o->cur.size))
+   if (font)
      {
-        evas_font_desc_unref(fdesc);
-        return;
+        /* We can't assume the given font is same with current fdesc by comparing string.
+           Since Evas starts to supporting "auto" for language,
+           the given font string should be parsed once before comparing it. */
+        fdesc = evas_font_desc_new();
+
+        /* Set default language according to locale. */
+        eina_stringshare_replace(&(fdesc->lang), evas_font_lang_normalize("auto"));
+        evas_font_name_parse(fdesc, font);
+
+        if (o->cur.fdesc && !evas_font_desc_cmp(fdesc, o->cur.fdesc) &&
+            (size == o->cur.size))
+          {
+             evas_font_desc_unref(fdesc);
+             return;
+          }
+
+        if (o->cur.fdesc) evas_font_desc_unref(o->cur.fdesc);
+        o->cur.fdesc = fdesc;
+        eina_stringshare_replace(&o->cur.font, font);
+        o->prev.font = NULL;
      }
 
-   if (o->cur.fdesc) evas_font_desc_unref(o->cur.fdesc);
-   o->cur.fdesc = fdesc;
-
-   o->cur.size = size;
-   eina_stringshare_replace(&o->cur.font, font);
-   o->prev.font = NULL;
+   if ( size > 0 )
+      o->cur.size = size;
 
    _evas_text_font_reload(eo_obj, o);
 }

src/lib/evas/canvas/evas_object_textblock.c

@@ -15808,13 +15808,13 @@ _efl_canvas_text_efl_text_font_font_set(Eo *obj EINA_UNUSED, Efl_Canvas_Text_Dat
 
    Eina_Stringshare *nfont;
 
-   if (o->default_format.info.size != size)
+   if (size > 0 && o->default_format.info.size != size)
      {
         o->default_format.info.size = size;
         changed = EINA_TRUE;
      }
 
-   if (o->default_format.info.font != font)
+   if (font && o->default_format.info.font != font)
      {
         nfont = eina_stringshare_add(font);
         if (nfont == _FMT_INFO(font))

src/modules/elementary/prefs/elm_slider.c

@@ -27,7 +27,7 @@ elm_prefs_slider_add(const Elm_Prefs_Item_Iface *iface EINA_UNUSED,
    evas_object_data_set(obj, "prefs_type", (void *)type);
 
    efl_event_callback_add
-     (obj, EFL_UI_SLIDER_EVENT_CHANGED, _item_changed_cb, cb);
+     (obj, EFL_UI_RANGE_EVENT_CHANGED, _item_changed_cb, cb);
    if (type == ELM_PREFS_TYPE_INT)
      {
         elm_slider_unit_format_set(obj, "%1.0f");

src/modules/evas/engines/gl_common/evas_gl_api.c

@@ -800,6 +800,66 @@ _evgl_glFramebufferParameteri(GLenum target, GLenum pname, GLint param)
    _gles3_api.glFramebufferParameteri(target, pname, param);
 }
 
+static void
+_evgl_glFramebufferTexture(GLenum target, GLenum attachment, GLuint texture, GLint level)
+{
+    EVGL_Resource *rsc;
+    EVGL_Context *ctx;
+
+    if (!(rsc=_evgl_tls_resource_get()))
+      {
+         ERR("Unable to execute GL command. Error retrieving tls");
+         return;
+      }
+
+    if (!rsc->current_eng)
+      {
+         ERR("Unable to retrive Current Engine");
+         return;
+      }
+
+    ctx = rsc->current_ctx;
+    if (!ctx)
+      {
+         ERR("Unable to retrive Current Context");
+         return;
+      }
+
+    if (!_evgl_direct_enabled())
+      {
+         if (ctx->version == EVAS_GL_GLES_2_X)
+           {
+              if (target == GL_FRAMEBUFFER && ctx->current_fbo == 0)
+                {
+                   SET_GL_ERROR(GL_INVALID_OPERATION);
+                   return;
+                }
+           }
+         else if (ctx->version == EVAS_GL_GLES_3_X)
+           {
+              if (target == GL_DRAW_FRAMEBUFFER || target == GL_FRAMEBUFFER)
+                {
+                   if (ctx->current_draw_fbo == 0)
+                     {
+                        SET_GL_ERROR(GL_INVALID_OPERATION);
+                        return;
+                     }
+                }
+              else if (target == GL_READ_FRAMEBUFFER)
+                {
+                   if (ctx->current_read_fbo == 0)
+                     {
+                        SET_GL_ERROR(GL_INVALID_OPERATION);
+                        return;
+                     }
+                }
+           }
+      }
+
+   _gles3_api.glFramebufferTexture(target, attachment, texture, level);
+}
+
+
 static void
 _evgl_glFramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
 {
@@ -2724,114 +2784,54 @@ _normal_gles3_api_get(Evas_GL_API *funcs, int minor_version)
 
 // GLES 3.0 NEW APIs
 #define ORD(name) EVAS_API_OVERRIDE(name, funcs, evgl_gles3_)
-   ORD(glBeginQuery);
-   ORD(glBeginTransformFeedback);
-   ORD(glBindBufferBase);
-   ORD(glBindBufferRange);
-   ORD(glBindSampler);
-   ORD(glBindTransformFeedback);
-   ORD(glBindVertexArray);
-   ORD(glBlitFramebuffer);
-   ORD(glClearBufferfi);
-   ORD(glClearBufferfv);
-   ORD(glClearBufferiv);
-   ORD(glClearBufferuiv);
-   ORD(glClientWaitSync);
-   ORD(glCompressedTexImage3D);
-   ORD(glCompressedTexSubImage3D);
-   ORD(glCopyBufferSubData);
-   ORD(glCopyTexSubImage3D);
-   ORD(glDeleteQueries);
-   ORD(glDeleteSamplers);
-   ORD(glDeleteSync);
-   ORD(glDeleteTransformFeedbacks);
-   ORD(glDeleteVertexArrays);
-   ORD(glDrawArraysInstanced);
-   ORD(glDrawBuffers);
-   ORD(glDrawElementsInstanced);
-   ORD(glDrawRangeElements);
-   ORD(glEndQuery);
-   ORD(glEndTransformFeedback);
-   ORD(glFenceSync);
-   ORD(glFlushMappedBufferRange);
-   ORD(glFramebufferTextureLayer);
-   ORD(glGenQueries);
-   ORD(glGenSamplers);
-   ORD(glGenTransformFeedbacks);
-   ORD(glGenVertexArrays);
-   ORD(glGetActiveUniformBlockiv);
-   ORD(glGetActiveUniformBlockName);
-   ORD(glGetActiveUniformsiv);
-   ORD(glGetBufferParameteri64v);
-   ORD(glGetBufferPointerv);
-   ORD(glGetFragDataLocation);
-   ORD(glGetInteger64i_v);
-   ORD(glGetInteger64v);
-   ORD(glGetIntegeri_v);
-   ORD(glGetInternalformativ);
-   ORD(glGetProgramBinary);
-   ORD(glGetQueryiv);
-   ORD(glGetQueryObjectuiv);
-   ORD(glGetSamplerParameterfv);
-   ORD(glGetSamplerParameteriv);
-   ORD(glGetStringi);
-   ORD(glGetSynciv);
-   ORD(glGetTransformFeedbackVarying);
-   ORD(glGetUniformBlockIndex);
-   ORD(glGetUniformIndices);
-   ORD(glGetUniformuiv);
-   ORD(glGetVertexAttribIiv);
-   ORD(glGetVertexAttribIuiv);
-   ORD(glInvalidateFramebuffer);
-   ORD(glInvalidateSubFramebuffer);
-   ORD(glIsQuery);
-   ORD(glIsSampler);
-   ORD(glIsSync);
-   ORD(glIsTransformFeedback);
-   ORD(glIsVertexArray);
-   ORD(glMapBufferRange);
-   ORD(glPauseTransformFeedback);
-   ORD(glProgramBinary);
-   ORD(glProgramParameteri);
-   ORD(glReadBuffer);
-   ORD(glRenderbufferStorageMultisample);
-   ORD(glResumeTransformFeedback);
-   ORD(glSamplerParameterf);
-   ORD(glSamplerParameterfv);
-   ORD(glSamplerParameteri);
-   ORD(glSamplerParameteriv);
-   ORD(glTexImage3D);
-   ORD(glTexStorage2D);
-   ORD(glTexStorage3D);
-   ORD(glTexSubImage3D);
-   ORD(glTransformFeedbackVaryings);
-   ORD(glUniform1ui);
-   ORD(glUniform1uiv);
-   ORD(glUniform2ui);
-   ORD(glUniform2uiv);
-   ORD(glUniform3ui);
-   ORD(glUniform3uiv);
-   ORD(glUniform4ui);
-   ORD(glUniform4uiv);
-   ORD(glUniformBlockBinding);
-   ORD(glUniformMatrix2x3fv);
-   ORD(glUniformMatrix3x2fv);
-   ORD(glUniformMatrix2x4fv);
-   ORD(glUniformMatrix4x2fv);
-   ORD(glUniformMatrix3x4fv);
-   ORD(glUniformMatrix4x3fv);
-   ORD(glUnmapBuffer);
-   ORD(glVertexAttribDivisor);
-   ORD(glVertexAttribI4i);
-   ORD(glVertexAttribI4iv);
-   ORD(glVertexAttribI4ui);
-   ORD(glVertexAttribI4uiv);
-   ORD(glVertexAttribIPointer);
-   ORD(glWaitSync);
-
-   if (minor_version > 0)
+   switch (minor_version)
      {
-        //GLES 3.1
+      case 2:
+        ORD(glBlendBarrier);
+        ORD(glCopyImageSubData);
+        ORD(glDebugMessageControl);
+        ORD(glDebugMessageInsert);
+        ORD(glDebugMessageCallback);
+        ORD(glGetDebugMessageLog);
+        ORD(glPushDebugGroup);
+        ORD(glPopDebugGroup);
+        ORD(glObjectLabel);
+        ORD(glGetObjectLabel);
+        ORD(glObjectPtrLabel);
+        ORD(glGetObjectPtrLabel);
+        ORD(glGetPointerv);
+        ORD(glEnablei);
+        ORD(glDisablei);
+        ORD(glBlendEquationi);
+        ORD(glBlendEquationSeparatei);
+        ORD(glBlendFunci);
+        ORD(glBlendFuncSeparatei);
+        ORD(glColorMaski);
+        ORD(glIsEnabledi);
+        ORD(glDrawElementsBaseVertex);
+        ORD(glDrawRangeElementsBaseVertex);
+        ORD(glDrawElementsInstancedBaseVertex);
+        ORD(glFramebufferTexture);
+        ORD(glPrimitiveBoundingBox);
+        ORD(glGetGraphicsResetStatus);
+        ORD(glReadnPixels);
+        ORD(glGetnUniformfv);
+        ORD(glGetnUniformiv);
+        ORD(glGetnUniformuiv);
+        ORD(glMinSampleShading);
+        ORD(glPatchParameteri);
+        ORD(glTexParameterIiv);
+        ORD(glTexParameterIuiv);
+        ORD(glGetTexParameterIiv);
+        ORD(glGetTexParameterIuiv);
+        ORD(glSamplerParameterIiv);
+        ORD(glSamplerParameterIuiv);
+        ORD(glGetSamplerParameterIiv);
+        ORD(glGetSamplerParameterIuiv);
+        ORD(glTexBuffer);
+        ORD(glTexBufferRange);
+        ORD(glTexStorage3DMultisample);
+      case 1:
         ORD(glDispatchCompute);
         ORD(glDispatchComputeIndirect);
         ORD(glDrawArraysIndirect);
@@ -2900,6 +2900,111 @@ _normal_gles3_api_get(Evas_GL_API *funcs, int minor_version)
         ORD(glVertexAttribIFormat);
         ORD(glVertexAttribBinding);
         ORD(glVertexBindingDivisor);
+      case 0:
+        ORD(glBeginQuery);
+        ORD(glBeginTransformFeedback);
+        ORD(glBindBufferBase);
+        ORD(glBindBufferRange);
+        ORD(glBindSampler);
+        ORD(glBindTransformFeedback);
+        ORD(glBindVertexArray);
+        ORD(glBlitFramebuffer);
+        ORD(glClearBufferfi);
+        ORD(glClearBufferfv);
+        ORD(glClearBufferiv);
+        ORD(glClearBufferuiv);
+        ORD(glClientWaitSync);
+        ORD(glCompressedTexImage3D);
+        ORD(glCompressedTexSubImage3D);
+        ORD(glCopyBufferSubData);
+        ORD(glCopyTexSubImage3D);
+        ORD(glDeleteQueries);
+        ORD(glDeleteSamplers);
+        ORD(glDeleteSync);
+        ORD(glDeleteTransformFeedbacks);
+        ORD(glDeleteVertexArrays);
+        ORD(glDrawArraysInstanced);
+        ORD(glDrawBuffers);
+        ORD(glDrawElementsInstanced);
+        ORD(glDrawRangeElements);
+        ORD(glEndQuery);
+        ORD(glEndTransformFeedback);
+        ORD(glFenceSync);
+        ORD(glFlushMappedBufferRange);
+        ORD(glFramebufferTextureLayer);
+        ORD(glGenQueries);
+        ORD(glGenSamplers);
+        ORD(glGenTransformFeedbacks);
+        ORD(glGenVertexArrays);
+        ORD(glGetActiveUniformBlockiv);
+        ORD(glGetActiveUniformBlockName);
+        ORD(glGetActiveUniformsiv);
+        ORD(glGetBufferParameteri64v);
+        ORD(glGetBufferPointerv);
+        ORD(glGetFragDataLocation);
+        ORD(glGetInteger64i_v);
+        ORD(glGetInteger64v);
+        ORD(glGetIntegeri_v);
+        ORD(glGetInternalformativ);
+        ORD(glGetProgramBinary);
+        ORD(glGetQueryiv);
+        ORD(glGetQueryObjectuiv);
+        ORD(glGetSamplerParameterfv);
+        ORD(glGetSamplerParameteriv);
+        ORD(glGetStringi);
+        ORD(glGetSynciv);
+        ORD(glGetTransformFeedbackVarying);
+        ORD(glGetUniformBlockIndex);
+        ORD(glGetUniformIndices);
+        ORD(glGetUniformuiv);
+        ORD(glGetVertexAttribIiv);
+        ORD(glGetVertexAttribIuiv);
+        ORD(glInvalidateFramebuffer);
+        ORD(glInvalidateSubFramebuffer);
+        ORD(glIsQuery);
+        ORD(glIsSampler);
+        ORD(glIsSync);
+        ORD(glIsTransformFeedback);
+        ORD(glIsVertexArray);
+        ORD(glMapBufferRange);
+        ORD(glPauseTransformFeedback);
+        ORD(glProgramBinary);
+        ORD(glProgramParameteri);
+        ORD(glReadBuffer);
+        ORD(glRenderbufferStorageMultisample);
+        ORD(glResumeTransformFeedback);
+        ORD(glSamplerParameterf);
+        ORD(glSamplerParameterfv);
+        ORD(glSamplerParameteri);
+        ORD(glSamplerParameteriv);
+        ORD(glTexImage3D);
+        ORD(glTexStorage2D);
+        ORD(glTexStorage3D);
+        ORD(glTexSubImage3D);
+        ORD(glTransformFeedbackVaryings);
+        ORD(glUniform1ui);
+        ORD(glUniform1uiv);
+        ORD(glUniform2ui);
+        ORD(glUniform2uiv);
+        ORD(glUniform3ui);
+        ORD(glUniform3uiv);
+        ORD(glUniform4ui);
+        ORD(glUniform4uiv);
+        ORD(glUniformBlockBinding);
+        ORD(glUniformMatrix2x3fv);
+        ORD(glUniformMatrix3x2fv);
+        ORD(glUniformMatrix2x4fv);
+        ORD(glUniformMatrix4x2fv);
+        ORD(glUniformMatrix3x4fv);
+        ORD(glUniformMatrix4x3fv);
+        ORD(glUnmapBuffer);
+        ORD(glVertexAttribDivisor);
+        ORD(glVertexAttribI4i);
+        ORD(glVertexAttribI4iv);
+        ORD(glVertexAttribI4ui);
+        ORD(glVertexAttribI4uiv);
+        ORD(glVertexAttribIPointer);
+        ORD(glWaitSync);
      }
 
 #undef ORD
@@ -3057,115 +3162,54 @@ _debug_gles3_api_get(Evas_GL_API *funcs, int minor_version)
    ORD(glBindFramebuffer);
    ORD(glBindRenderbuffer);
 
-   // GLES 3.0 new APIs
-   ORD(glBeginQuery);
-   ORD(glBeginTransformFeedback);
-   ORD(glBindBufferBase);
-   ORD(glBindBufferRange);
-   ORD(glBindSampler);
-   ORD(glBindTransformFeedback);
-   ORD(glBindVertexArray);
-   ORD(glBlitFramebuffer);
-   ORD(glClearBufferfi);
-   ORD(glClearBufferfv);
-   ORD(glClearBufferiv);
-   ORD(glClearBufferuiv);
-   ORD(glClientWaitSync);
-   ORD(glCompressedTexImage3D);
-   ORD(glCompressedTexSubImage3D);
-   ORD(glCopyBufferSubData);
-   ORD(glCopyTexSubImage3D);
-   ORD(glDeleteQueries);
-   ORD(glDeleteSamplers);
-   ORD(glDeleteSync);
-   ORD(glDeleteTransformFeedbacks);
-   ORD(glDeleteVertexArrays);
-   ORD(glDrawArraysInstanced);
-   ORD(glDrawBuffers);
-   ORD(glDrawElementsInstanced);
-   ORD(glDrawRangeElements);
-   ORD(glEndQuery);
-   ORD(glEndTransformFeedback);
-   ORD(glFenceSync);
-   ORD(glFlushMappedBufferRange);
-   ORD(glFramebufferTextureLayer);
-   ORD(glGenQueries);
-   ORD(glGenSamplers);
-   ORD(glGenTransformFeedbacks);
-   ORD(glGenVertexArrays);
-   ORD(glGetActiveUniformBlockiv);
-   ORD(glGetActiveUniformBlockName);
-   ORD(glGetActiveUniformsiv);
-   ORD(glGetBufferParameteri64v);
-   ORD(glGetBufferPointerv);
-   ORD(glGetFragDataLocation);
-   ORD(glGetInteger64i_v);
-   ORD(glGetInteger64v);
-   ORD(glGetIntegeri_v);
-   ORD(glGetInternalformativ);
-   ORD(glGetProgramBinary);
-   ORD(glGetQueryiv);
-   ORD(glGetQueryObjectuiv);
-   ORD(glGetSamplerParameterfv);
-   ORD(glGetSamplerParameteriv);
-   ORD(glGetStringi);
-   ORD(glGetSynciv);
-   ORD(glGetTransformFeedbackVarying);
-   ORD(glGetUniformBlockIndex);
-   ORD(glGetUniformIndices);
-   ORD(glGetUniformuiv);
-   ORD(glGetVertexAttribIiv);
-   ORD(glGetVertexAttribIuiv);
-   ORD(glInvalidateFramebuffer);
-   ORD(glInvalidateSubFramebuffer);
-   ORD(glIsQuery);
-   ORD(glIsSampler);
-   ORD(glIsSync);
-   ORD(glIsTransformFeedback);
-   ORD(glIsVertexArray);
-   ORD(glMapBufferRange);
-   ORD(glPauseTransformFeedback);
-   ORD(glProgramBinary);
-   ORD(glProgramParameteri);
-   ORD(glReadBuffer);
-   ORD(glRenderbufferStorageMultisample);
-   ORD(glResumeTransformFeedback);
-   ORD(glSamplerParameterf);
-   ORD(glSamplerParameterfv);
-   ORD(glSamplerParameteri);
-   ORD(glSamplerParameteriv);
-   ORD(glTexImage3D);
-   ORD(glTexStorage2D);
-   ORD(glTexStorage3D);
-   ORD(glTexSubImage3D);
-   ORD(glTransformFeedbackVaryings);
-   ORD(glUniform1ui);
-   ORD(glUniform1uiv);
-   ORD(glUniform2ui);
-   ORD(glUniform2uiv);
-   ORD(glUniform3ui);
-   ORD(glUniform3uiv);
-   ORD(glUniform4ui);
-   ORD(glUniform4uiv);
-   ORD(glUniformBlockBinding);
-   ORD(glUniformMatrix2x3fv);
-   ORD(glUniformMatrix3x2fv);
-   ORD(glUniformMatrix2x4fv);
-   ORD(glUniformMatrix4x2fv);
-   ORD(glUniformMatrix3x4fv);
-   ORD(glUniformMatrix4x3fv);
-   ORD(glUnmapBuffer);
-   ORD(glVertexAttribDivisor);
-   ORD(glVertexAttribI4i);
-   ORD(glVertexAttribI4iv);
-   ORD(glVertexAttribI4ui);
-   ORD(glVertexAttribI4uiv);
-   ORD(glVertexAttribIPointer);
-   ORD(glWaitSync);
-
-   if (minor_version > 0)
+   switch (minor_version)
      {
-        //GLES 3.1
+      case 2:
+        ORD(glBlendBarrier);
+        ORD(glCopyImageSubData);
+        ORD(glDebugMessageControl);
+        ORD(glDebugMessageInsert);
+        ORD(glDebugMessageCallback);
+        ORD(glGetDebugMessageLog);
+        ORD(glPushDebugGroup);
+        ORD(glPopDebugGroup);
+        ORD(glObjectLabel);
+        ORD(glGetObjectLabel);
+        ORD(glObjectPtrLabel);
+        ORD(glGetObjectPtrLabel);
+        ORD(glGetPointerv);
+        ORD(glEnablei);
+        ORD(glDisablei);
+        ORD(glBlendEquationi);
+        ORD(glBlendEquationSeparatei);
+        ORD(glBlendFunci);
+        ORD(glBlendFuncSeparatei);
+        ORD(glColorMaski);
+        ORD(glIsEnabledi);
+        ORD(glDrawElementsBaseVertex);
+        ORD(glDrawRangeElementsBaseVertex);
+        ORD(glDrawElementsInstancedBaseVertex);
+        ORD(glFramebufferTexture);
+        ORD(glPrimitiveBoundingBox);
+        ORD(glGetGraphicsResetStatus);
+        ORD(glReadnPixels);
+        ORD(glGetnUniformfv);
+        ORD(glGetnUniformiv);
+        ORD(glGetnUniformuiv);
+        ORD(glMinSampleShading);
+        ORD(glPatchParameteri);
+        ORD(glTexParameterIiv);
+        ORD(glTexParameterIuiv);
+        ORD(glGetTexParameterIiv);
+        ORD(glGetTexParameterIuiv);
+        ORD(glSamplerParameterIiv);
+        ORD(glSamplerParameterIuiv);
+        ORD(glGetSamplerParameterIiv);
+        ORD(glGetSamplerParameterIuiv);
+        ORD(glTexBuffer);
+        ORD(glTexBufferRange);
+        ORD(glTexStorage3DMultisample);
+      case 1:
         ORD(glDispatchCompute);
         ORD(glDispatchComputeIndirect);
         ORD(glDrawArraysIndirect);
@@ -3234,6 +3278,111 @@ _debug_gles3_api_get(Evas_GL_API *funcs, int minor_version)
         ORD(glVertexAttribIFormat);
         ORD(glVertexAttribBinding);
         ORD(glVertexBindingDivisor);
+      case 0:
+        ORD(glBeginQuery);
+        ORD(glBeginTransformFeedback);
+        ORD(glBindBufferBase);
+        ORD(glBindBufferRange);
+        ORD(glBindSampler);
+        ORD(glBindTransformFeedback);
+        ORD(glBindVertexArray);
+        ORD(glBlitFramebuffer);
+        ORD(glClearBufferfi);
+        ORD(glClearBufferfv);
+        ORD(glClearBufferiv);
+        ORD(glClearBufferuiv);
+        ORD(glClientWaitSync);
+        ORD(glCompressedTexImage3D);
+        ORD(glCompressedTexSubImage3D);
+        ORD(glCopyBufferSubData);
+        ORD(glCopyTexSubImage3D);
+        ORD(glDeleteQueries);
+        ORD(glDeleteSamplers);
+        ORD(glDeleteSync);
+        ORD(glDeleteTransformFeedbacks);
+        ORD(glDeleteVertexArrays);
+        ORD(glDrawArraysInstanced);
+        ORD(glDrawBuffers);
+        ORD(glDrawElementsInstanced);
+        ORD(glDrawRangeElements);
+        ORD(glEndQuery);
+        ORD(glEndTransformFeedback);
+        ORD(glFenceSync);
+        ORD(glFlushMappedBufferRange);
+        ORD(glFramebufferTextureLayer);
+        ORD(glGenQueries);
+        ORD(glGenSamplers);
+        ORD(glGenTransformFeedbacks);
+        ORD(glGenVertexArrays);
+        ORD(glGetActiveUniformBlockiv);
+        ORD(glGetActiveUniformBlockName);
+        ORD(glGetActiveUniformsiv);
+        ORD(glGetBufferParameteri64v);
+        ORD(glGetBufferPointerv);
+        ORD(glGetFragDataLocation);
+        ORD(glGetInteger64i_v);
+        ORD(glGetInteger64v);
+        ORD(glGetIntegeri_v);
+        ORD(glGetInternalformativ);
+        ORD(glGetProgramBinary);
+        ORD(glGetQueryiv);
+        ORD(glGetQueryObjectuiv);
+        ORD(glGetSamplerParameterfv);
+        ORD(glGetSamplerParameteriv);
+        ORD(glGetStringi);
+        ORD(glGetSynciv);
+        ORD(glGetTransformFeedbackVarying);
+        ORD(glGetUniformBlockIndex);
+        ORD(glGetUniformIndices);
+        ORD(glGetUniformuiv);
+        ORD(glGetVertexAttribIiv);
+        ORD(glGetVertexAttribIuiv);
+        ORD(glInvalidateFramebuffer);
+        ORD(glInvalidateSubFramebuffer);
+        ORD(glIsQuery);
+        ORD(glIsSampler);
+        ORD(glIsSync);
+        ORD(glIsTransformFeedback);
+        ORD(glIsVertexArray);
+        ORD(glMapBufferRange);
+        ORD(glPauseTransformFeedback);
+        ORD(glProgramBinary);
+        ORD(glProgramParameteri);
+        ORD(glReadBuffer);
+        ORD(glRenderbufferStorageMultisample);
+        ORD(glResumeTransformFeedback);
+        ORD(glSamplerParameterf);
+        ORD(glSamplerParameterfv);
+        ORD(glSamplerParameteri);
+        ORD(glSamplerParameteriv);
+        ORD(glTexImage3D);
+        ORD(glTexStorage2D);
+        ORD(glTexStorage3D);
+        ORD(glTexSubImage3D);
+        ORD(glTransformFeedbackVaryings);
+        ORD(glUniform1ui);
+        ORD(glUniform1uiv);
+        ORD(glUniform2ui);
+        ORD(glUniform2uiv);
+        ORD(glUniform3ui);
+        ORD(glUniform3uiv);
+        ORD(glUniform4ui);
+        ORD(glUniform4uiv);
+        ORD(glUniformBlockBinding);
+        ORD(glUniformMatrix2x3fv);
+        ORD(glUniformMatrix3x2fv);
+        ORD(glUniformMatrix2x4fv);
+        ORD(glUniformMatrix4x2fv);
+        ORD(glUniformMatrix3x4fv);
+        ORD(glUniformMatrix4x3fv);
+        ORD(glUnmapBuffer);
+        ORD(glVertexAttribDivisor);
+        ORD(glVertexAttribI4i);
+        ORD(glVertexAttribI4iv);
+        ORD(glVertexAttribI4ui);
+        ORD(glVertexAttribI4uiv);
+        ORD(glVertexAttribIPointer);
+        ORD(glWaitSync);
      }
 
 #undef ORD
@@ -3259,118 +3408,54 @@ _evgl_load_gles3_apis(void *dl_handle, Evas_GL_API *funcs, int minor_version,
    // Used to update extensions
    ORD(glGetString);
 
-   // GLES 3.0 new APIs
-   ORD(glBeginQuery);
-   ORD(glBeginTransformFeedback);
-   ORD(glBindBufferBase);
-   ORD(glBindBufferRange);
-   ORD(glBindSampler);
-   ORD(glBindTransformFeedback);
-   ORD(glBindVertexArray);
-   ORD(glBlitFramebuffer);
-   ORD(glClearBufferfi);
-   ORD(glClearBufferfv);
-   ORD(glClearBufferiv);
-   ORD(glClearBufferuiv);
-   ORD(glClientWaitSync);
-   ORD(glCompressedTexImage3D);
-   ORD(glCompressedTexSubImage3D);
-   ORD(glCopyBufferSubData);
-   ORD(glCopyTexSubImage3D);
-   ORD(glDeleteQueries);
-   ORD(glDeleteSamplers);
-   ORD(glDeleteSync);
-   ORD(glDeleteTransformFeedbacks);
-   ORD(glDeleteVertexArrays);
-   ORD(glDrawArraysInstanced);
-   ORD(glDrawBuffers);
-   ORD(glDrawElementsInstanced);
-   ORD(glDrawRangeElements);
-   ORD(glEndQuery);
-   ORD(glEndTransformFeedback);
-   ORD(glFenceSync);
-   ORD(glFlushMappedBufferRange);
-   ORD(glFramebufferTextureLayer);
-   ORD(glGenQueries);
-   ORD(glGenSamplers);
-   ORD(glGenTransformFeedbacks);
-   ORD(glGenVertexArrays);
-   ORD(glGetActiveUniformBlockiv);
-   ORD(glGetActiveUniformBlockName);
-   ORD(glGetActiveUniformsiv);
-   ORD(glGetBufferParameteri64v);
-   ORD(glGetBufferPointerv);
-   ORD(glGetFragDataLocation);
-   ORD(glGetInteger64i_v);
-   ORD(glGetInteger64v);
-   ORD(glGetIntegeri_v);
-   ORD(glGetInternalformativ);
-   ORD(glGetProgramBinary);
-   ORD(glGetQueryiv);
-   ORD(glGetQueryObjectuiv);
-   ORD(glGetSamplerParameterfv);
-   ORD(glGetSamplerParameteriv);
-   ORD(glGetStringi);
-   ORD(glGetSynciv);
-   ORD(glGetTransformFeedbackVarying);
-   ORD(glGetUniformBlockIndex);
-   ORD(glGetUniformIndices);
-   ORD(glGetUniformuiv);
-   ORD(glGetVertexAttribIiv);
-   ORD(glGetVertexAttribIuiv);
-   ORD(glInvalidateFramebuffer);
-   ORD(glInvalidateSubFramebuffer);
-   ORD(glIsQuery);
-   ORD(glIsSampler);
-   ORD(glIsSync);
-   ORD(glIsTransformFeedback);
-   ORD(glIsVertexArray);
-   ORD(glMapBufferRange);
-   ORD(glPauseTransformFeedback);
-   ORD(glProgramBinary);
-   ORD(glProgramParameteri);
-   ORD(glReadBuffer);
-   ORD(glRenderbufferStorageMultisample);
-   ORD(glResumeTransformFeedback);
-   ORD(glSamplerParameterf);
-   ORD(glSamplerParameterfv);
-   ORD(glSamplerParameteri);
-   ORD(glSamplerParameteriv);
-   ORD(glTexImage3D);
-   ORD(glTexStorage2D);
-   ORD(glTexStorage3D);
-   ORD(glTexSubImage3D);
-   ORD(glTransformFeedbackVaryings);
-   ORD(glUniform1ui);
-   ORD(glUniform1uiv);
-   ORD(glUniform2ui);
-   ORD(glUniform2uiv);
-   ORD(glUniform3ui);
-   ORD(glUniform3uiv);
-   ORD(glUniform4ui);
-   ORD(glUniform4uiv);
-   ORD(glUniformBlockBinding);
-   ORD(glUniformMatrix2x3fv);
-   ORD(glUniformMatrix3x2fv);
-   ORD(glUniformMatrix2x4fv);
-   ORD(glUniformMatrix4x2fv);
-   ORD(glUniformMatrix3x4fv);
-   ORD(glUniformMatrix4x3fv);
-   ORD(glUnmapBuffer);
-   ORD(glVertexAttribDivisor);
-   ORD(glVertexAttribI4i);
-   ORD(glVertexAttribI4iv);
-   ORD(glVertexAttribI4ui);
-   ORD(glVertexAttribI4uiv);
-   ORD(glVertexAttribIPointer);
-   ORD(glWaitSync);
-
-   if (minor_version > 0)
+   switch (minor_version)
      {
-        // OpenGL ES 3.0 is supported, return true even if 3.1 isn't there
-        ret_value = EINA_TRUE;
-
-        // OpenGL ES 3.1
+      case 2:
+        ORD(glBlendBarrier);
+        ORD(glCopyImageSubData);
+        ORD(glDebugMessageControl);
+        ORD(glDebugMessageInsert);
+        ORD(glDebugMessageCallback);
+        ORD(glGetDebugMessageLog);
+        ORD(glPushDebugGroup);
+        ORD(glPopDebugGroup);
+        ORD(glObjectLabel);
+        ORD(glGetObjectLabel);
+        ORD(glObjectPtrLabel);
+        ORD(glGetObjectPtrLabel);
+        ORD(glGetPointerv);
+        ORD(glEnablei);
+        ORD(glDisablei);
+        ORD(glBlendEquationi);
+        ORD(glBlendEquationSeparatei);
+        ORD(glBlendFunci);
+        ORD(glBlendFuncSeparatei);
+        ORD(glColorMaski);
+        ORD(glIsEnabledi);
+        ORD(glDrawElementsBaseVertex);
+        ORD(glDrawRangeElementsBaseVertex);
+        ORD(glDrawElementsInstancedBaseVertex);
+        ORD(glFramebufferTexture);
+        ORD(glPrimitiveBoundingBox);
+        ORD(glGetGraphicsResetStatus);
+        ORD(glReadnPixels);
+        ORD(glGetnUniformfv);
+        ORD(glGetnUniformiv);
+        ORD(glGetnUniformuiv);
+        ORD(glMinSampleShading);
+        ORD(glPatchParameteri);
+        ORD(glTexParameterIiv);
+        ORD(glTexParameterIuiv);
+        ORD(glGetTexParameterIiv);
+        ORD(glGetTexParameterIuiv);
+        ORD(glSamplerParameterIiv);
+        ORD(glSamplerParameterIuiv);
+        ORD(glGetSamplerParameterIiv);
+        ORD(glGetSamplerParameterIuiv);
+        ORD(glTexBuffer);
+        ORD(glTexBufferRange);
+        ORD(glTexStorage3DMultisample);
+      case 1:
         ORD(glDispatchCompute);
         ORD(glDispatchComputeIndirect);
         ORD(glDrawArraysIndirect);
@@ -3439,6 +3524,111 @@ _evgl_load_gles3_apis(void *dl_handle, Evas_GL_API *funcs, int minor_version,
         ORD(glVertexAttribIFormat);
         ORD(glVertexAttribBinding);
         ORD(glVertexBindingDivisor);
+      case 0:
+        ORD(glBeginQuery);
+        ORD(glBeginTransformFeedback);
+        ORD(glBindBufferBase);
+        ORD(glBindBufferRange);
+        ORD(glBindSampler);
+        ORD(glBindTransformFeedback);
+        ORD(glBindVertexArray);
+        ORD(glBlitFramebuffer);
+        ORD(glClearBufferfi);
+        ORD(glClearBufferfv);
+        ORD(glClearBufferiv);
+        ORD(glClearBufferuiv);
+        ORD(glClientWaitSync);
+        ORD(glCompressedTexImage3D);
+        ORD(glCompressedTexSubImage3D);
+        ORD(glCopyBufferSubData);
+        ORD(glCopyTexSubImage3D);
+        ORD(glDeleteQueries);
+        ORD(glDeleteSamplers);
+        ORD(glDeleteSync);
+        ORD(glDeleteTransformFeedbacks);
+        ORD(glDeleteVertexArrays);
+        ORD(glDrawArraysInstanced);
+        ORD(glDrawBuffers);
+        ORD(glDrawElementsInstanced);
+        ORD(glDrawRangeElements);
+        ORD(glEndQuery);
+        ORD(glEndTransformFeedback);
+        ORD(glFenceSync);
+        ORD(glFlushMappedBufferRange);
+        ORD(glFramebufferTextureLayer);
+        ORD(glGenQueries);
+        ORD(glGenSamplers);
+        ORD(glGenTransformFeedbacks);
+        ORD(glGenVertexArrays);
+        ORD(glGetActiveUniformBlockiv);
+        ORD(glGetActiveUniformBlockName);
+        ORD(glGetActiveUniformsiv);
+        ORD(glGetBufferParameteri64v);
+        ORD(glGetBufferPointerv);
+        ORD(glGetFragDataLocation);
+        ORD(glGetInteger64i_v);
+        ORD(glGetInteger64v);
+        ORD(glGetIntegeri_v);
+        ORD(glGetInternalformativ);
+        ORD(glGetProgramBinary);
+        ORD(glGetQueryiv);
+        ORD(glGetQueryObjectuiv);
+        ORD(glGetSamplerParameterfv);
+        ORD(glGetSamplerParameteriv);
+        ORD(glGetStringi);
+        ORD(glGetSynciv);
+        ORD(glGetTransformFeedbackVarying);
+        ORD(glGetUniformBlockIndex);
+        ORD(glGetUniformIndices);
+        ORD(glGetUniformuiv);
+        ORD(glGetVertexAttribIiv);
+        ORD(glGetVertexAttribIuiv);
+        ORD(glInvalidateFramebuffer);
+        ORD(glInvalidateSubFramebuffer);
+        ORD(glIsQuery);
+        ORD(glIsSampler);
+        ORD(glIsSync);
+        ORD(glIsTransformFeedback);
+        ORD(glIsVertexArray);
+        ORD(glMapBufferRange);
+        ORD(glPauseTransformFeedback);
+        ORD(glProgramBinary);
+        ORD(glProgramParameteri);
+        ORD(glReadBuffer);
+        ORD(glRenderbufferStorageMultisample);
+        ORD(glResumeTransformFeedback);
+        ORD(glSamplerParameterf);
+        ORD(glSamplerParameterfv);
+        ORD(glSamplerParameteri);
+        ORD(glSamplerParameteriv);
+        ORD(glTexImage3D);
+        ORD(glTexStorage2D);
+        ORD(glTexStorage3D);
+        ORD(glTexSubImage3D);
+        ORD(glTransformFeedbackVaryings);
+        ORD(glUniform1ui);
+        ORD(glUniform1uiv);
+        ORD(glUniform2ui);
+        ORD(glUniform2uiv);
+        ORD(glUniform3ui);
+        ORD(glUniform3uiv);
+        ORD(glUniform4ui);
+        ORD(glUniform4uiv);
+        ORD(glUniformBlockBinding);
+        ORD(glUniformMatrix2x3fv);
+        ORD(glUniformMatrix3x2fv);
+        ORD(glUniformMatrix2x4fv);
+        ORD(glUniformMatrix4x2fv);
+        ORD(glUniformMatrix3x4fv);
+        ORD(glUniformMatrix4x3fv);
+        ORD(glUnmapBuffer);
+        ORD(glVertexAttribDivisor);
+        ORD(glVertexAttribI4i);
+        ORD(glVertexAttribI4iv);
+        ORD(glVertexAttribI4ui);
+        ORD(glVertexAttribI4uiv);
+        ORD(glVertexAttribIPointer);
+        ORD(glWaitSync);
      }
 #undef ORD
 

src/modules/evas/engines/gl_common/evas_gl_api_gles3_def.h

@@ -4,6 +4,8 @@ _EVASGL_FUNCTION_PRIVATE_BEGIN_VOID( glReadBuffer, (GLenum src), (src))
 //GLES 3.1
 _EVASGL_FUNCTION_PRIVATE_BEGIN_VOID( glFramebufferParameteri, (GLenum target, GLenum pname, GLint param), (target, pname, param))
 _EVASGL_FUNCTION_PRIVATE_BEGIN_VOID( glGetFramebufferParameteriv, (GLenum target, GLenum pname, GLint *params), (target, pname, params))
+//GLES 3.2
+_EVASGL_FUNCTION_PRIVATE_BEGIN_VOID( glFramebufferTexture, (GLenum target, GLenum attachment, GLuint texture, GLint level), (target, attachment, texture, level))
 
 _EVASGL_FUNCTION_BEGIN_VOID( glBeginQuery, (GLenum target, GLuint id), (target, id))
 _EVASGL_FUNCTION_BEGIN_VOID( glBeginTransformFeedback, (GLenum primitiveMode), (primitiveMode))
@@ -175,3 +177,48 @@ _EVASGL_FUNCTION_BEGIN_VOID( glVertexAttribFormat, (GLuint attribindex, GLint si
 _EVASGL_FUNCTION_BEGIN_VOID( glVertexAttribIFormat, (GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset), (attribindex, size, type, relativeoffset))
 _EVASGL_FUNCTION_BEGIN_VOID( glVertexAttribBinding, (GLuint attribindex, GLuint bindingindex), (attribindex, bindingindex))
 _EVASGL_FUNCTION_BEGIN_VOID( glVertexBindingDivisor, (GLuint bindingindex, GLuint divisor), (bindingindex, divisor))
+
+//GLES 3.2
+_EVASGL_FUNCTION_BEGIN_VOID( glBlendBarrier, (void), ())
+_EVASGL_FUNCTION_BEGIN_VOID( glCopyImageSubData, (GLuint srcName, GLenum srcTarget, GLint srcLevel, GLint srcX, GLint srcY, GLint srcZ, GLuint dstName, GLenum dstTarget, GLint dstLevel, GLint dstX, GLint dstY, GLint dstZ, GLsizei srcWidth, GLsizei srcHeight, GLsizei srcDepth), (srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth))
+_EVASGL_FUNCTION_BEGIN_VOID( glDebugMessageControl, (GLenum source, GLenum type, GLenum severity, GLsizei count, const GLuint *ids, GLboolean enabled), (source, type, severity, count, ids, enabled))
+_EVASGL_FUNCTION_BEGIN_VOID( glDebugMessageInsert, (GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, const GLchar *buf), (source, type, id, severity, length, buf))
+_EVASGL_FUNCTION_BEGIN_VOID( glDebugMessageCallback, (void (*callback)(GLenum source,GLenum type,GLuint id,GLenum severity,GLsizei length,const GLchar *message,const void *userParam), const void *userParam), (callback, userParam))
+_EVASGL_FUNCTION_BEGIN (GLuint, glGetDebugMessageLog, (GLuint count, GLsizei bufSize, GLenum *sources, GLenum *types, GLuint *ids, GLenum *severities, GLsizei *lengths, GLchar *messageLog), (count, bufSize, sources, types, ids, severities, lengths, messageLog))
+_EVASGL_FUNCTION_BEGIN_VOID( glPushDebugGroup, (GLenum source, GLuint id, GLsizei length, const GLchar *message),(source, id, length, message))
+_EVASGL_FUNCTION_BEGIN_VOID( glPopDebugGroup, (void), ())
+_EVASGL_FUNCTION_BEGIN_VOID( glObjectLabel, (GLenum identifier, GLuint name, GLsizei length, const GLchar *label),(identifier, name, length, label))
+_EVASGL_FUNCTION_BEGIN_VOID( glGetObjectLabel, (GLenum identifier, GLuint name, GLsizei bufSize, GLsizei *length, GLchar *label), (identifier, name, bufSize, length, label))
+_EVASGL_FUNCTION_BEGIN_VOID( glObjectPtrLabel, (const void *ptr, GLsizei length, const GLchar *label), (ptr, length, label))
+_EVASGL_FUNCTION_BEGIN_VOID( glGetObjectPtrLabel, (const void *ptr, GLsizei bufSize, GLsizei *length, GLchar *label), (ptr, bufSize, length, label))
+_EVASGL_FUNCTION_BEGIN_VOID( glGetPointerv, (GLenum pname, void **params), (pname, params))
+_EVASGL_FUNCTION_BEGIN_VOID( glEnablei, (GLenum target, GLuint index), (target, index))
+_EVASGL_FUNCTION_BEGIN_VOID( glDisablei, (GLenum target, GLuint index), (target, index))
+_EVASGL_FUNCTION_BEGIN_VOID( glBlendEquationi, (GLuint buf, GLenum mode), (buf, mode))
+_EVASGL_FUNCTION_BEGIN_VOID( glBlendEquationSeparatei, (GLuint buf, GLenum modeRGB, GLenum modeAlpha), (buf, modeRGB, modeAlpha))
+_EVASGL_FUNCTION_BEGIN_VOID( glBlendFunci, (GLuint buf, GLenum src, GLenum dst), (buf, src, dst))
+_EVASGL_FUNCTION_BEGIN_VOID( glBlendFuncSeparatei, (GLuint buf, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha), (buf, srcRGB, dstRGB, srcAlpha, dstAlpha))
+_EVASGL_FUNCTION_BEGIN_VOID( glColorMaski, (GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a), (index, r, g, b, a))
+_EVASGL_FUNCTION_BEGIN(GLboolean, glIsEnabledi, (GLenum target, GLuint index), (target, index))
+_EVASGL_FUNCTION_BEGIN_VOID( glDrawElementsBaseVertex, (GLenum mode, GLsizei count, GLenum type, const void *indices, GLint basevertex), (mode, count, type, indices, basevertex))
+_EVASGL_FUNCTION_BEGIN_VOID( glDrawRangeElementsBaseVertex, (GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void *indices, GLint basevertex), (mode, start, end, count, type, indices, basevertex))
+_EVASGL_FUNCTION_BEGIN_VOID( glDrawElementsInstancedBaseVertex, (GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount, GLint basevertex), (mode, count, type, indices, instancecount, basevertex))
+_EVASGL_FUNCTION_BEGIN_VOID( glPrimitiveBoundingBox, (GLfloat minX, GLfloat minY, GLfloat minZ, GLfloat minW, GLfloat maxX, GLfloat maxY, GLfloat maxZ, GLfloat maxW), (minX, minY, minZ, minW, maxX, maxY, maxZ, maxW))
+_EVASGL_FUNCTION_BEGIN(GLenum, glGetGraphicsResetStatus, (void), ())
+_EVASGL_FUNCTION_BEGIN_VOID( glReadnPixels, (GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLsizei bufSize, void *data), (x, y, width, height, format, type, bufSize, data))
+_EVASGL_FUNCTION_BEGIN_VOID( glGetnUniformfv, (GLuint program, GLint location, GLsizei bufSize, GLfloat *params), (program, location, bufSize, params))
+_EVASGL_FUNCTION_BEGIN_VOID( glGetnUniformiv, (GLuint program, GLint location, GLsizei bufSize, GLint *params), (program, location, bufSize, params))
+_EVASGL_FUNCTION_BEGIN_VOID( glGetnUniformuiv, (GLuint program, GLint location, GLsizei bufSize, GLuint *params), (program, location, bufSize, params))
+_EVASGL_FUNCTION_BEGIN_VOID( glMinSampleShading, (GLfloat value), (value))
+_EVASGL_FUNCTION_BEGIN_VOID( glPatchParameteri, (GLenum pname, GLint value), (pname, value))
+_EVASGL_FUNCTION_BEGIN_VOID( glTexParameterIiv, (GLenum target, GLenum pname, const GLint *params), (target, pname, params))
+_EVASGL_FUNCTION_BEGIN_VOID( glTexParameterIuiv, (GLenum target, GLenum pname, const GLuint *params), (target, pname, params))
+_EVASGL_FUNCTION_BEGIN_VOID( glGetTexParameterIiv, (GLenum target, GLenum pname, GLint *params), (target, pname, params))
+_EVASGL_FUNCTION_BEGIN_VOID( glGetTexParameterIuiv, (GLenum target, GLenum pname, GLuint *params), (target, pname, params))
+_EVASGL_FUNCTION_BEGIN_VOID( glSamplerParameterIiv, (GLuint sampler, GLenum pname, const GLint *param), (sampler, pname, param))
+_EVASGL_FUNCTION_BEGIN_VOID( glSamplerParameterIuiv, (GLuint sampler, GLenum pname, const GLuint *param), (sampler, pname, param))
+_EVASGL_FUNCTION_BEGIN_VOID( glGetSamplerParameterIiv, (GLuint sampler, GLenum pname, GLint *params), (sampler, pname, params))
+_EVASGL_FUNCTION_BEGIN_VOID( glGetSamplerParameterIuiv, (GLuint sampler, GLenum pname, GLuint *params), (sampler, pname, params))
+_EVASGL_FUNCTION_BEGIN_VOID( glTexBuffer, (GLenum target, GLenum internalformat, GLuint buffer), (target, internalformat, buffer))
+_EVASGL_FUNCTION_BEGIN_VOID( glTexBufferRange, (GLenum target, GLenum internalformat, GLuint buffer, GLintptr offset, GLsizeiptr size), (target, internalformat, buffer, offset, size))
+_EVASGL_FUNCTION_BEGIN_VOID( glTexStorage3DMultisample, (GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations), (target, samples, internalformat, width, height, depth, fixedsamplelocations))

src/tests/ecore_wl2/ecore_wl2_suite.c

@@ -12,6 +12,7 @@ static const Efl_Test_Case etc[] =
    { "Ecore_Wl2", ecore_wl2_test_init },
    { "Display", ecore_wl2_test_display },
    { "Window", ecore_wl2_test_window },
+   { "Input", ecore_wl2_test_input },
 #endif
    { NULL, NULL }
 };

src/tests/ecore_wl2/ecore_wl2_suite.h

@@ -7,5 +7,6 @@
 void ecore_wl2_test_init(TCase *tc);
 void ecore_wl2_test_display(TCase *tc);
 void ecore_wl2_test_window(TCase *tc);
+void ecore_wl2_test_input(TCase *tc);
 
 #endif

src/tests/ecore_wl2/ecore_wl2_test_display.c

@@ -174,8 +174,7 @@ ecore_wl2_test_display(TCase *tc)
         tcase_add_test(tc, wl2_display_get);
         tcase_add_test(tc, wl2_display_name_get);
      }
-
-   if (getenv("WAYLAND_DISPLAY"))
+   else if (getenv("WAYLAND_DISPLAY"))
      {
         /* tests here are for client-side functions */
         printf("Wayland Compositor detected. Testing client-side functions\n");

src/tests/ecore_wl2/ecore_wl2_test_input.c

@@ -0,0 +1,144 @@
+#ifdef HAVE_CONFIG_H
+# include "config.h"
+#endif
+
+#include <stdio.h>
+#include <unistd.h>
+#include <Eina.h>
+#include <Ecore.h>
+#include <Ecore_Wl2.h>
+
+#include "ecore_wl2_suite.h"
+
+static Ecore_Wl2_Display *
+_display_connect(void)
+{
+   Ecore_Wl2_Display *disp;
+
+   disp = ecore_wl2_display_connect(NULL);
+   return disp;
+}
+
+EFL_START_TEST(wl2_input_seat_get)
+{
+   Ecore_Wl2_Display *disp;
+   Ecore_Wl2_Input *input;
+   Eina_Iterator *itr;
+
+   disp = _display_connect();
+   ck_assert(disp != NULL);
+
+   itr = ecore_wl2_display_inputs_get(disp);
+   ck_assert(itr != NULL);
+
+   EINA_ITERATOR_FOREACH(itr, input)
+     {
+        struct wl_seat *seat;
+
+        seat = ecore_wl2_input_seat_get(input);
+        ck_assert(seat != NULL);
+     }
+
+   eina_iterator_free(itr);
+}
+EFL_END_TEST
+
+EFL_START_TEST(wl2_input_seat_id_get)
+{
+   Ecore_Wl2_Display *disp;
+   Ecore_Wl2_Input *input;
+   Eina_Iterator *itr;
+
+   disp = _display_connect();
+   ck_assert(disp != NULL);
+
+   itr = ecore_wl2_display_inputs_get(disp);
+   ck_assert(itr != NULL);
+
+   EINA_ITERATOR_FOREACH(itr, input)
+     {
+        int id;
+
+        id = ecore_wl2_input_seat_id_get(input);
+        ck_assert_int_ne(id, 0);
+     }
+
+   eina_iterator_free(itr);
+}
+EFL_END_TEST
+
+EFL_START_TEST(wl2_input_display_get)
+{
+   Ecore_Wl2_Display *disp;
+   Ecore_Wl2_Input *input;
+   Eina_Iterator *itr;
+
+   disp = _display_connect();
+   ck_assert(disp != NULL);
+
+   itr = ecore_wl2_display_inputs_get(disp);
+   ck_assert(itr != NULL);
+
+   EINA_ITERATOR_FOREACH(itr, input)
+     {
+        ck_assert(ecore_wl2_input_display_get(input) != NULL);
+     }
+
+   eina_iterator_free(itr);
+}
+EFL_END_TEST
+
+EFL_START_TEST(wl2_input_keymap_get)
+{
+   Ecore_Wl2_Display *disp;
+   Ecore_Wl2_Input *input;
+   Eina_Iterator *itr;
+
+   disp = _display_connect();
+   ck_assert(disp != NULL);
+
+   itr = ecore_wl2_display_inputs_get(disp);
+   ck_assert(itr != NULL);
+
+   EINA_ITERATOR_FOREACH(itr, input)
+     {
+        ck_assert(ecore_wl2_input_keymap_get(input) != NULL);
+     }
+
+   eina_iterator_free(itr);
+}
+EFL_END_TEST
+
+EFL_START_TEST(wl2_input_name_get)
+{
+   Ecore_Wl2_Display *disp;
+   Ecore_Wl2_Input *input;
+   Eina_Iterator *itr;
+
+   disp = _display_connect();
+   ck_assert(disp != NULL);
+
+   itr = ecore_wl2_display_inputs_get(disp);
+   ck_assert(itr != NULL);
+
+   EINA_ITERATOR_FOREACH(itr, input)
+     {
+        printf("Input: <%s>\n", ecore_wl2_input_name_get(input));
+     }
+
+   eina_iterator_free(itr);
+}
+EFL_END_TEST
+
+void
+ecore_wl2_test_input(TCase *tc)
+{
+   if (getenv("WAYLAND_DISPLAY"))
+     {
+        tcase_add_test(tc, wl2_input_seat_get);
+        tcase_add_test(tc, wl2_input_seat_id_get);
+        tcase_add_test(tc, wl2_input_display_get);
+        tcase_add_test(tc, wl2_input_keymap_get);
+        tcase_add_test(tc, wl2_input_name_get);
+     }
+}

src/tests/ecore_wl2/ecore_wl2_test_window.c

@@ -58,7 +58,7 @@ EFL_START_TEST(wl2_window_surface_test)
    ck_assert(surf != NULL);
 
    id = ecore_wl2_window_surface_id_get(win);
-   ck_assert_int_lt(id, 0);
+   ck_assert_int_gt(id, 0);
 
    ck_assert_int_eq(wl_proxy_get_id((struct wl_proxy *)surf), id);
 }
@@ -77,7 +77,7 @@ EFL_START_TEST(wl2_window_rotation_get)
    ck_assert(win != NULL);
 
    rot = ecore_wl2_window_rotation_get(win);
-   ck_assert_int_lt(rot, 0);
+   ck_assert_int_ge(rot, 0);
 }
 EFL_END_TEST
 

src/tests/ecore_wl2/meson.build

@@ -4,7 +4,8 @@ ecore_wl2_suite_src = [
   'ecore_wl2_tests_helpers.h',
   'ecore_wl2_test_ecore_wl2.c',
   'ecore_wl2_test_display.c',
-  'ecore_wl2_test_window.c'
+  'ecore_wl2_test_window.c',
+  'ecore_wl2_test_input.c'
 ]
 
 ecore_wl2_suite = executable('ecore_wl2_suite',

src/tests/elementary/efl_ui_test_position_manager_common.c

@@ -12,8 +12,7 @@ static Eo* win;
 
 static Eina_Array *arr_obj;
 static Eina_Inarray *arr_size;
-static Eina_Accessor inner_size_acc;
-static Eina_Accessor *size_acc;
+
 static void
 item_container_setup()
 {
@@ -26,54 +25,44 @@ item_container_teardown()
    win = NULL;
 }
 
-static Eina_Bool
-_get_at(Eina_Accessor *it EINA_UNUSED, unsigned int idx, void **data)
+static int
+_size_accessor_get_at(void *data EINA_UNUSED, int start_id, Eina_Rw_Slice memory)
 {
-   Eina_Size2D *result_ptr = (void*)data;
-   Eina_Size2D *inner_result;
+   int i;
 
-   if (!eina_accessor_data_get(size_acc, idx, (void*)&inner_result))
-     return EINA_FALSE;
-   *result_ptr = *inner_result;
-   return EINA_TRUE;
+   for (i = start_id; i < (int)(MIN(start_id + memory.len, eina_inarray_count(arr_size))); ++i)
+     {
+         Eina_Size2D *size = eina_inarray_nth(arr_size, i);
+
+         ((Eina_Size2D*)memory.mem)[i - start_id] = *size;
+     }
+   return i - start_id;
 }
 
-static void
-_free_cb(Eina_Accessor *it EINA_UNUSED)
+static int
+_obj_accessor_get_at(void *data EINA_UNUSED, int start_id, Eina_Rw_Slice memory)
 {
-   eina_accessor_free(size_acc);
+   int i;
+
+   for (i = start_id; i < (int)(MIN(start_id + memory.len, eina_array_count(arr_obj))); ++i)
+     {
+         Efl_Gfx_Entity *geom = eina_array_data_get(arr_obj, i);
+
+         ((Efl_Gfx_Entity**)memory.mem)[i - start_id] = geom;
+     }
+
+   return i - start_id;
 }
-
-static Eina_Bool
-_lock_cb(Eina_Accessor *it EINA_UNUSED)
-{
-   return eina_accessor_lock(size_acc);
-}
-
-static Eina_Accessor*
-_clone_cb(Eina_Accessor *it EINA_UNUSED)
-{
-   return eina_accessor_clone(size_acc);
-}
-
-
 static void
 _initial_setup(void)
 {
    arr_obj = eina_array_new(10);
    arr_size = eina_inarray_new(sizeof(Eina_Size2D), 10);
-   size_acc = eina_inarray_accessor_new(arr_size);
-
-   inner_size_acc.version = EINA_ACCESSOR_VERSION;
-   EINA_MAGIC_SET(&inner_size_acc, EINA_MAGIC_ACCESSOR);
-   inner_size_acc.get_at = _get_at;
-   inner_size_acc.free = _free_cb;
-   inner_size_acc.lock = _lock_cb;
-   inner_size_acc.clone = _clone_cb;
 
    efl_ui_position_manager_entity_data_access_set(position_manager,
-      eina_array_accessor_new(arr_obj),
-      &inner_size_acc, 0);
+      NULL, _obj_accessor_get_at, NULL,
+      NULL, _size_accessor_get_at, NULL,
+      0);
 }
 
 static int

src/tests/elementary/efl_ui_test_slider.c

@@ -13,7 +13,7 @@ slider_changed(void *data EINA_UNUSED, const Efl_Event *ev)
 {
    event_counter++;
    if (event_counter == 1)
-     efl_event_callback_del(ev->object, EFL_UI_SLIDER_EVENT_CHANGED, slider_changed, NULL);
+     efl_event_callback_del(ev->object, EFL_UI_RANGE_EVENT_CHANGED, slider_changed, NULL);
    else if (event_counter == 2)
      ecore_main_loop_quit();
 }
@@ -26,8 +26,8 @@ EFL_START_TEST(efl_ui_test_slider_events)
 
    efl_gfx_entity_size_set(win, EINA_SIZE2D(400, 100));
    slider = efl_add(EFL_UI_SLIDER_CLASS, win,
-                efl_event_callback_add(efl_added, EFL_UI_SLIDER_EVENT_CHANGED, slider_changed, NULL),
-                efl_event_callback_add(efl_added, EFL_UI_SLIDER_EVENT_STEADY, slider_changed, NULL),
+                efl_event_callback_add(efl_added, EFL_UI_RANGE_EVENT_CHANGED, slider_changed, NULL),
+                efl_event_callback_add(efl_added, EFL_UI_RANGE_EVENT_STEADY, slider_changed, NULL),
                 efl_gfx_entity_size_set(efl_added, EINA_SIZE2D(400, 100))
                 );
 
@@ -60,8 +60,8 @@ EFL_START_TEST(efl_ui_test_slider_step)
 
    efl_gfx_entity_size_set(win, EINA_SIZE2D(400, 100));
    slider = efl_add(EFL_UI_SLIDER_CLASS, win,
-                efl_event_callback_add(efl_added, EFL_UI_SLIDER_EVENT_CHANGED, slider_changed, NULL),
-                efl_event_callback_add(efl_added, EFL_UI_SLIDER_EVENT_STEADY, slider_changed, NULL),
+                efl_event_callback_add(efl_added, EFL_UI_RANGE_EVENT_CHANGED, slider_changed, NULL),
+                efl_event_callback_add(efl_added, EFL_UI_RANGE_EVENT_STEADY, slider_changed, NULL),
                 efl_gfx_entity_size_set(efl_added, EINA_SIZE2D(400, 100))
                 );
    efl_ui_range_limits_set(slider, 0, 100);

src/tests/elementary/efl_ui_test_spin.c

@@ -33,9 +33,9 @@ EFL_START_TEST (spin_value_events)
 
    efl_ui_range_limits_set(spin, -3.0, 3.0);
    efl_ui_range_value_set(spin, 0.0);
-   efl_event_callback_add(spin, EFL_UI_SPIN_EVENT_CHANGED, _set_flag, &changed);
-   efl_event_callback_add(spin, EFL_UI_SPIN_EVENT_MIN_REACHED, _set_flag, &min_reached);
-   efl_event_callback_add(spin, EFL_UI_SPIN_EVENT_MAX_REACHED, _set_flag, &max_reached);
+   efl_event_callback_add(spin, EFL_UI_RANGE_EVENT_CHANGED, _set_flag, &changed);
+   efl_event_callback_add(spin, EFL_UI_RANGE_EVENT_MIN_REACHED, _set_flag, &min_reached);
+   efl_event_callback_add(spin, EFL_UI_RANGE_EVENT_MAX_REACHED, _set_flag, &max_reached);
 
    efl_ui_range_value_set(spin, 1.0);
    ck_assert_int_eq(changed, EINA_TRUE);
@@ -60,41 +60,9 @@ EFL_START_TEST (spin_value_events)
 }
 EFL_END_TEST
 
-EFL_START_TEST (spin_wheel_test)
-{
-   Eina_Bool changed = EINA_FALSE, min_reached = EINA_FALSE, max_reached = EINA_FALSE;
-
-   efl_ui_range_limits_set(spin, -100.0, 100.0);
-   efl_ui_range_value_set(spin, 0.0);
-   efl_ui_range_step_set(spin, 10.0);
-   efl_event_callback_add(spin, EFL_UI_SPIN_EVENT_CHANGED, _set_flag, &changed);
-   efl_event_callback_add(spin, EFL_UI_SPIN_EVENT_MIN_REACHED, _set_flag, &min_reached);
-   efl_event_callback_add(spin, EFL_UI_SPIN_EVENT_MAX_REACHED, _set_flag, &max_reached);
-
-   efl_gfx_entity_size_set(win, EINA_SIZE2D(60, 60));
-   get_me_to_those_events(spin);
-   evas_event_feed_mouse_move(evas_object_evas_get(spin), 30, 30, 1234, NULL);
-   evas_event_feed_mouse_wheel(evas_object_evas_get(spin), -1, -1, 12345, NULL);
-   ck_assert(efl_ui_range_value_get(spin) == 10.0);
-   ck_assert_int_eq(changed, EINA_TRUE);
-   ck_assert_int_eq(min_reached, EINA_FALSE);
-   ck_assert_int_eq(max_reached, EINA_FALSE);
-   changed = EINA_FALSE;
-   min_reached = EINA_FALSE;
-   max_reached = EINA_FALSE;
-
-   evas_event_feed_mouse_wheel(evas_object_evas_get(spin), -1, 1, 12345, NULL);
-   ck_assert(efl_ui_range_value_get(spin) == 0.0);
-   ck_assert_int_eq(changed, EINA_TRUE);
-   ck_assert_int_eq(min_reached, EINA_FALSE);
-   ck_assert_int_eq(max_reached, EINA_FALSE);
-}
-EFL_END_TEST
-
 void efl_ui_test_spin(TCase *tc)
 {
    tcase_add_checked_fixture(tc, fail_on_errors_setup, fail_on_errors_teardown);
    tcase_add_checked_fixture(tc, spin_setup, NULL);
    tcase_add_test(tc, spin_value_events);
-   tcase_add_test(tc, spin_wheel_test);
 }

src/tests/elementary/efl_ui_test_spin_button.c

@@ -46,42 +46,6 @@ click_spin_part(Eo *obj, const char *part)
    click_part(obj, part);
 }
 
-EFL_START_TEST (spin_value_events)
-{
-   Eina_Bool changed = EINA_FALSE, min_reached = EINA_FALSE, max_reached = EINA_FALSE;
-
-   efl_ui_range_limits_set(spin, -3.0, 3.0);
-   efl_ui_range_value_set(spin, 0.0);
-   efl_event_callback_add(spin, EFL_UI_SPIN_EVENT_CHANGED, _set_flag, &changed);
-   efl_event_callback_add(spin, EFL_UI_SPIN_EVENT_MIN_REACHED, _set_flag, &min_reached);
-   efl_event_callback_add(spin, EFL_UI_SPIN_EVENT_MAX_REACHED, _set_flag, &max_reached);
-
-   efl_ui_range_value_set(spin, 1.0);
-   ck_assert_int_eq(changed, EINA_TRUE);
-   ck_assert_int_eq(min_reached, EINA_FALSE);
-   ck_assert_int_eq(max_reached, EINA_FALSE);
-   changed = EINA_FALSE;
-   min_reached = EINA_FALSE;
-   max_reached = EINA_FALSE;
-
-   efl_ui_range_value_set(spin, 3.0);
-   ck_assert_int_eq(changed, EINA_TRUE);
-   ck_assert_int_eq(min_reached, EINA_FALSE);
-   ck_assert_int_eq(max_reached, EINA_TRUE);
-   changed = EINA_FALSE;
-   min_reached = EINA_FALSE;
-   max_reached = EINA_FALSE;
-
-   efl_ui_range_value_set(spin, -3.0);
-   ck_assert_int_eq(changed, EINA_TRUE);
-   ck_assert_int_eq(min_reached, EINA_TRUE);
-   ck_assert_int_eq(max_reached, EINA_FALSE);
-   changed = EINA_FALSE;
-   min_reached = EINA_FALSE;
-   max_reached = EINA_FALSE;
-}
-EFL_END_TEST
-
 EFL_START_TEST (spin_wheel_test)
 {
    Eina_Bool changed = EINA_FALSE, min_reached = EINA_FALSE, max_reached = EINA_FALSE;
@@ -89,9 +53,9 @@ EFL_START_TEST (spin_wheel_test)
    efl_ui_range_limits_set(spin, -100.0, 100.0);
    efl_ui_range_value_set(spin, 0.0);
    efl_ui_range_step_set(spin, 10.0);
-   efl_event_callback_add(spin, EFL_UI_SPIN_EVENT_CHANGED, _set_flag, &changed);
-   efl_event_callback_add(spin, EFL_UI_SPIN_EVENT_MIN_REACHED, _set_flag, &min_reached);
-   efl_event_callback_add(spin, EFL_UI_SPIN_EVENT_MAX_REACHED, _set_flag, &max_reached);
+   efl_event_callback_add(spin, EFL_UI_RANGE_EVENT_CHANGED, _set_flag, &changed);
+   efl_event_callback_add(spin, EFL_UI_RANGE_EVENT_MIN_REACHED, _set_flag, &min_reached);
+   efl_event_callback_add(spin, EFL_UI_RANGE_EVENT_MAX_REACHED, _set_flag, &max_reached);
 
    efl_gfx_entity_size_set(win, EINA_SIZE2D(60, 60));
    get_me_to_those_events(spin);
@@ -122,10 +86,10 @@ EFL_START_TEST (spin_value_inc)
 
    efl_ui_range_limits_set(spin, 0.0, 3.0);
    efl_ui_range_value_set(spin, 1.0);
-   efl_event_callback_add(spin, EFL_UI_SPIN_EVENT_CHANGED, _set_flag, &changed);
-   efl_event_callback_add(spin, EFL_UI_SPIN_EVENT_MIN_REACHED, _set_flag, &min_reached);
-   efl_event_callback_add(spin, EFL_UI_SPIN_EVENT_MAX_REACHED, _set_flag, &max_reached);
-   efl_event_callback_add(spin, EFL_UI_SPIN_BUTTON_EVENT_DELAY_CHANGED, _set_flag_quit, &delay_changed);
+   efl_event_callback_add(spin, EFL_UI_RANGE_EVENT_CHANGED, _set_flag, &changed);
+   efl_event_callback_add(spin, EFL_UI_RANGE_EVENT_MIN_REACHED, _set_flag, &min_reached);
+   efl_event_callback_add(spin, EFL_UI_RANGE_EVENT_MAX_REACHED, _set_flag, &max_reached);
+   efl_event_callback_add(spin, EFL_UI_RANGE_EVENT_STEADY, _set_flag_quit, &delay_changed);
 
    click_spin_part(spin, "efl.inc_button");
 
@@ -147,10 +111,10 @@ EFL_START_TEST (spin_value_inc_max)
 
    efl_ui_range_limits_set(spin, 0.0, 3.0);
    efl_ui_range_value_set(spin, 2.0);
-   efl_event_callback_add(spin, EFL_UI_SPIN_EVENT_CHANGED, _set_flag, &changed);
-   efl_event_callback_add(spin, EFL_UI_SPIN_EVENT_MIN_REACHED, _set_flag, &min_reached);
-   efl_event_callback_add(spin, EFL_UI_SPIN_EVENT_MAX_REACHED, _set_flag, &max_reached);
-   efl_event_callback_add(spin, EFL_UI_SPIN_BUTTON_EVENT_DELAY_CHANGED, _set_flag_quit, &delay_changed);
+   efl_event_callback_add(spin, EFL_UI_RANGE_EVENT_CHANGED, _set_flag, &changed);
+   efl_event_callback_add(spin, EFL_UI_RANGE_EVENT_MIN_REACHED, _set_flag, &min_reached);
+   efl_event_callback_add(spin, EFL_UI_RANGE_EVENT_MAX_REACHED, _set_flag, &max_reached);
+   efl_event_callback_add(spin, EFL_UI_RANGE_EVENT_STEADY, _set_flag_quit, &delay_changed);
 
    click_spin_part(spin, "efl.inc_button");
 
@@ -172,10 +136,10 @@ EFL_START_TEST (spin_value_dec_min)
 
    efl_ui_range_limits_set(spin, 0.0, 3.0);
    efl_ui_range_value_set(spin, 1.0);
-   efl_event_callback_add(spin, EFL_UI_SPIN_EVENT_CHANGED, _set_flag, &changed);
-   efl_event_callback_add(spin, EFL_UI_SPIN_EVENT_MIN_REACHED, _set_flag, &min_reached);
-   efl_event_callback_add(spin, EFL_UI_SPIN_EVENT_MAX_REACHED, _set_flag, &max_reached);
-   efl_event_callback_add(spin, EFL_UI_SPIN_BUTTON_EVENT_DELAY_CHANGED, _set_flag_quit, &delay_changed);
+   efl_event_callback_add(spin, EFL_UI_RANGE_EVENT_CHANGED, _set_flag, &changed);
+   efl_event_callback_add(spin, EFL_UI_RANGE_EVENT_MIN_REACHED, _set_flag, &min_reached);
+   efl_event_callback_add(spin, EFL_UI_RANGE_EVENT_MAX_REACHED, _set_flag, &max_reached);
+   efl_event_callback_add(spin, EFL_UI_RANGE_EVENT_STEADY, _set_flag_quit, &delay_changed);
 
    click_spin_part(spin, "efl.dec_button");
 
@@ -195,7 +159,6 @@ void efl_ui_test_spin_button(TCase *tc)
 {
    tcase_add_checked_fixture(tc, fail_on_errors_setup, fail_on_errors_teardown);
    tcase_add_checked_fixture(tc, spin_setup, NULL);
-   tcase_add_test(tc, spin_value_events);
    tcase_add_test(tc, spin_wheel_test);
    tcase_add_test(tc, spin_value_inc);
    tcase_add_test(tc, spin_value_inc_max);

src/tests/elementary/spec/efl_test_clickable.c

@@ -2,6 +2,8 @@
 # include "elementary_config.h"
 #endif
 
+#define EFL_INPUT_CLICKABLE_PROTECTED 1
+
 #include <Efl_Ui.h>
 #include <Elementary.h>
 #include "efl_ui_spec_suite.h"
@@ -10,7 +12,7 @@
 #include "elm_widget.h"
 /* spec-meta-start
       {"test-interface":"Efl.Ui.Clickable",
-       "test-widgets": ["Efl.Ui.Button", "Efl.Ui.Image", "Efl.Ui.Panes", "Efl.Ui.Frame", "Efl.Ui.Item.Realized"]
+       "test-widgets": ["Efl.Ui.Button", "Efl.Ui.Image", "Efl.Ui.Panes", "Efl.Ui.Frame", "Efl.Ui.Item.Realized", "Efl.Ui.Radio", "Efl.Ui.Check"]
        }
    spec-meta-end
  */
@@ -220,6 +222,33 @@ EFL_START_TEST(long_press_event)
 }
 EFL_END_TEST
 
+EFL_START_TEST(long_press_abort)
+{
+   efl_event_callback_array_add(widget, clickable(), NULL);
+   down(1);
+   iterate_mainloop(0.1);
+   ck_assert_int_eq(event_caller.pressed, 1);
+   event_caller.pressed = 0;
+   assert_event_empty();
+   efl_input_clickable_longpress_abort(widget, 1);
+   iterate_mainloop(2.0);
+   assert_event_empty();
+   up(1);
+   iterate_mainloop(0.1);
+   ck_assert_int_eq(event_caller.clicked, 1);
+   event_caller.clicked = 0;
+   ck_assert_int_eq(event_caller.clicked_params.repeated, 0);
+   ck_assert_int_eq(event_caller.clicked_params.button, 1);
+   ck_assert_int_eq(event_caller.clicked_all, 1);
+   event_caller.clicked_all = 0;
+   ck_assert_int_eq(event_caller.clicked_all_params.repeated, 0);
+   ck_assert_int_eq(event_caller.clicked_all_params.button, 1);
+   ck_assert_int_eq(event_caller.unpressed, 1);
+   event_caller.unpressed = 0;
+   assert_event_empty();
+}
+EFL_END_TEST
+
 EFL_START_TEST(repeated_event)
 {
    efl_event_callback_array_add(widget, clickable(), NULL);
@@ -254,5 +283,6 @@ efl_ui_clickable_behavior_test(TCase *tc)
    tcase_add_checked_fixture(tc, prepare_window, NULL);
    tcase_add_test(tc, simple_left_down_up);
    tcase_add_test(tc, long_press_event);
+   tcase_add_test(tc, long_press_abort);
    tcase_add_test(tc, repeated_event);
 }

src/tests/elementary/spec/efl_test_range_display.c

@@ -81,10 +81,57 @@ EFL_START_TEST(value_setting)
 }
 EFL_END_TEST
 
+static void
+_set_flag(void *data, const Efl_Event *ev)
+{
+   Eina_Bool *b = data;
+
+   ck_assert_int_eq(*b, EINA_FALSE);
+   *b = EINA_TRUE;
+   ck_assert_ptr_eq(ev->info, NULL);
+}
+
+EFL_START_TEST (range_display_value_events)
+{
+   Eina_Bool changed = EINA_FALSE, min_reached = EINA_FALSE, max_reached = EINA_FALSE;
+
+   efl_ui_range_limits_set(widget, -3.0, 3.0);
+   efl_ui_range_value_set(widget, 0.0);
+   efl_event_callback_add(widget, EFL_UI_RANGE_EVENT_CHANGED, _set_flag, &changed);
+   efl_event_callback_add(widget, EFL_UI_RANGE_EVENT_MIN_REACHED, _set_flag, &min_reached);
+   efl_event_callback_add(widget, EFL_UI_RANGE_EVENT_MAX_REACHED, _set_flag, &max_reached);
+
+   efl_ui_range_value_set(widget, 1.0);
+   ck_assert_int_eq(changed, EINA_TRUE);
+   ck_assert_int_eq(min_reached, EINA_FALSE);
+   ck_assert_int_eq(max_reached, EINA_FALSE);
+   changed = EINA_FALSE;
+   min_reached = EINA_FALSE;
+   max_reached = EINA_FALSE;
+
+   efl_ui_range_value_set(widget, 3.0);
+   ck_assert_int_eq(changed, EINA_TRUE);
+   ck_assert_int_eq(min_reached, EINA_FALSE);
+   ck_assert_int_eq(max_reached, EINA_TRUE);
+   changed = EINA_FALSE;
+   min_reached = EINA_FALSE;
+   max_reached = EINA_FALSE;
+
+   efl_ui_range_value_set(widget, -3.0);
+   ck_assert_int_eq(changed, EINA_TRUE);
+   ck_assert_int_eq(min_reached, EINA_TRUE);
+   ck_assert_int_eq(max_reached, EINA_FALSE);
+   changed = EINA_FALSE;
+   min_reached = EINA_FALSE;
+   max_reached = EINA_FALSE;
+}
+EFL_END_TEST
+
 void
 efl_ui_range_display_behavior_test(TCase *tc)
 {
    tcase_add_test(tc, value_setting_limits);
    tcase_add_test(tc, limit_setting);
    tcase_add_test(tc, value_setting);
+   tcase_add_test(tc, range_display_value_events);
 }

src/tests/elementary/spec/efl_test_range_interactive.c

@@ -3,7 +3,9 @@
 #endif
 
 #include <Efl_Ui.h>
+#include <Elementary.h>
 #include "efl_ui_spec_suite.h"
+#include "efl_ui_suite.h"
 #include "suite_helpers.h"
 
 /* spec-meta-start
@@ -30,9 +32,60 @@ EFL_START_TEST(step_setting)
 }
 EFL_END_TEST
 
+static void
+_steady_cb(void *data, const Efl_Event *ev EINA_UNUSED)
+{
+   int *count = data;
+   *count = *count + 1;
+   efl_loop_quit(efl_main_loop_get(), EINA_VALUE_EMPTY);
+}
+
+static Eina_Value
+_quit_ml(void *data EINA_UNUSED, const Eina_Value v EINA_UNUSED,  const Eina_Future *dead_future EINA_UNUSED)
+{
+   efl_loop_quit(efl_main_loop_get(), EINA_VALUE_EMPTY);
+   return EINA_VALUE_EMPTY;
+}
+
+EFL_START_TEST(steady_event)
+{
+   Evas *e;
+   int count = 0;
+
+   if (efl_isa(widget, EFL_UI_SPIN_CLASS)) return;
+
+   efl_event_callback_add(widget, EFL_UI_RANGE_EVENT_STEADY, _steady_cb, &count),
+   efl_ui_range_limits_set(widget, 0, 100);
+   efl_ui_range_step_set(widget, 10);
+   efl_ui_range_value_set(widget, 20);
+
+   e = evas_object_evas_get(win);
+
+   efl_layout_signal_process(widget, EINA_TRUE);
+   get_me_to_those_events(widget);
+
+   int x, y, w, h;
+
+   evas_object_geometry_get(widget, &x, &y, &w, &h);
+   evas_event_feed_mouse_in(e, 0, NULL);
+   evas_event_feed_mouse_move(e, x + (w / 2), y + (h / 2), 0, NULL);
+   evas_event_feed_mouse_wheel(e, -1, 1, 0, NULL);
+   evas_event_feed_mouse_up(e, 1, 0, 0, NULL);
+   efl_layout_signal_process(widget, EINA_TRUE);
+   ck_assert_int_eq(efl_ui_range_value_get(widget), 10);
+
+   Eina_Future *f = efl_loop_timeout(efl_main_loop_get(), 10.0);
+   eina_future_then(f, _quit_ml);
+
+   efl_loop_begin(efl_main_loop_get());
+   ck_assert_int_eq(count, 1);
+}
+EFL_END_TEST
+
 void
 efl_ui_range_display_interactive_behavior_test(TCase *tc)
 {
    tcase_add_test(tc, step_setting);
+   tcase_add_test(tc, steady_event);
 }
 

src/tests/eolian/data/complex_type.eo

@@ -1,10 +1,8 @@
-struct @free(efl_del) @extern Eo;
-
 class Complex_Type {
    methods {
       @property a {
          set {
-            return: list<array<ptr(Eo) @owned> > @owned;
+            return: list<array<strbuf @owned> > @owned;
          }
          get {
          }