Merge branch 'master' into devs/hermet/lottie

Makefile.am

@@ -519,7 +519,7 @@ pkgbuild::
 
 clean-local:
 	rm -rf benchmark coverage
-	@find . -name '*eo.legacy.c' -delete
+	@find . -name '*.eo.legacy.c' -delete
 
 DISTCLEANFILES= \
 ./src/lib/emile/Makefile \

configure.ac

@@ -1581,8 +1581,6 @@ fi
 EFL_CHECK_LIBS([EMILE], [zlib])
 
 EFL_INTERNAL_DEPEND_PKG([EMILE], [eina])
-requirements_cflags_emile="${requirements_cflags_emile} -I\${top_srcdir}/src/lib/efl -I\${top_builddir}/src/lib/efl"
-requirements_pc_emile="efl >= ${PACKAGE_VERSION} ${requirements_pc_emile}"
 
 EFL_EVAL_PKGS([EMILE])
 
@@ -1634,8 +1632,6 @@ fi
 
 EFL_INTERNAL_DEPEND_PKG([EET], [eina])
 EFL_INTERNAL_DEPEND_PKG([EET], [emile])
-requirements_pc_eet="${requirements_pc_eet} ${requirements_pc_emile}"
-requirements_cflags_eet="${requirements_cflags_eet} ${requirements_cflags_emile}"
 
 EFL_EVAL_PKGS([EET])
 
@@ -2542,19 +2538,6 @@ AC_ARG_ENABLE([pixman-image-scale-sample],
    ],
    [have_pixman_image_scale_sample="no"])
 
-# Tile rotate
-AC_ARG_ENABLE([tile-rotate],
-   [AS_HELP_STRING([--enable-tile-rotate],[Enable tiled rotate algorithm. @<:@default=disabled@:>@])],
-   [
-    if test "x${enableval}" = "xyes" ; then
-       have_tile_rotate="yes"
-       CFOPT_WARNING="xyes"
-    else
-       have_tile_rotate="no"
-    fi
-  ],
-  [have_tile_rotate="no"])
-
 # Ecore Buffer
 AC_ARG_ENABLE([ecore-buffer],
    [AS_HELP_STRING([--enable-ecore-buffer],[enable ecore-buffer. @<:@default=disabled@:>@])],
@@ -2989,13 +2972,6 @@ AC_CHECK_LIB([m], [lround],
 
 ### Configuration
 
-## Tile rotation
-
-if test "x${have_tile_rotate}" = "xyes" ; then
-   AC_DEFINE(TILE_ROTATE, 1, [Enable tiled rotate algorithm])
-fi
-
-
 ## dither options
 
 AC_ARG_WITH([evas-dither-mask],

examples_checks.py

@@ -0,0 +1,142 @@
+#!/usr/bin/python3
+import os
+import sys
+import subprocess
+import json
+import time
+import concurrent.futures
+import argparse
+import tempfile
+
+#
+# preparation calls for the examples
+#
+
+def prep_eina_file_02():
+  f = tempfile.NamedTemporaryFile(delete=False)
+  f.write(b"Simulation")
+  return [f.name, "/tmp/copy_file"]
+
+def prep_eina_xattr_01():
+  f = tempfile.NamedTemporaryFile(delete=False)
+  f.write(b"Simulation")
+  return ["list", f.name]
+
+def prep_eina_xattr_02():
+  f1 = tempfile.NamedTemporaryFile(delete=False)
+  f1.write(b"Simulation")
+  f2 = tempfile.NamedTemporaryFile(delete=False)
+  f2.write(b"Simulation2")
+  return [f1.name, f2.name]
+
+def prep_eet_data_simple():
+  f1 = tempfile.NamedTemporaryFile(delete=False)
+  f1.write(b"Simulation")
+  f2 = tempfile.NamedTemporaryFile(delete=False)
+  f2.write(b"Simulation2")
+  return [f1.name, f2.name]
+
+def prep_eet_data_nested():
+  f1 = tempfile.NamedTemporaryFile(delete=False)
+  f1.write(b"Simulation")
+  f2 = tempfile.NamedTemporaryFile(delete=False)
+  f2.write(b"Simulation2")
+  return [f1.name, f2.name]
+
+def prep_eet_data_file_descriptor_01():
+  f1 = tempfile.NamedTemporaryFile(delete=False)
+  f1.write(b"Simulation")
+  f2 = tempfile.NamedTemporaryFile(delete=False)
+  f2.write(b"Simulation2")
+  return [f1.name, f2.name, "acc", "Example-Simulation"]
+
+def prep_eet_data_file_descriptor_02():
+  f1 = tempfile.NamedTemporaryFile(delete=False)
+  f1.write(b"Simulation")
+  f2 = tempfile.NamedTemporaryFile(delete=False)
+  f2.write(b"Simulation2")
+  return [f1.name, f2.name, "union", "5", "Example-Simulation"]
+
+example_preparation = {
+  "eina_file_02" : prep_eina_file_02,
+  "eina_xattr_01" : prep_eina_xattr_01,
+  "eina_xattr_02" : prep_eina_xattr_02,
+  "eet-data-simple" : prep_eet_data_simple,
+  "eet-data-nested" : prep_eet_data_nested,
+  "eet-data-simple" : prep_eet_data_simple,
+  "eet-data-file_descriptor_01" : prep_eet_data_file_descriptor_01,
+  "eet-data-file_descriptor_02" : prep_eet_data_file_descriptor_02,
+}
+
+#
+# Holds up the state of the ran examples
+#
+
+class State:
+  def __init__(self, examples):
+    self.max_n = examples
+    self.n = 1
+    self.count_fail = 0
+    self.count_success = 0
+    self.count_err_output = 0
+    print("Found "+str(self.max_n)+" Examples")
+
+  def add_run(self, command, error_in_output, exitcode):
+    print("{}/{} {} {} {} ".format(self.n, self.max_n, ("SUCCESS" if exitcode == 0 else "FAIL"), ("CLEAN" if error_in_output == False else "ERR"), command))
+    self.n = self.n + 1
+    if exitcode != 0:
+      self.count_fail += 1
+    if error_in_output == True:
+      self.count_err_output += 1
+    if exitcode == 0 and error_in_output == False:
+      self.count_success += 1
+
+  def print_summary(self):
+    print("Summary")
+    print("  Failed: "+str(self.count_fail)+"/"+str(self.max_n))
+    print("  Errored: "+str(self.count_err_output)+"/"+str(self.max_n))
+    print("  Success: "+str(self.count_success)+"/"+str(self.max_n))
+
+#
+# this simulates the startup of the example, and the closing after 1s
+#
+
+def simulate_example(example):
+  args = []
+  if os.path.basename(example) in example_preparation:
+    args = example_preparation[os.path.basename(example)]()
+  run = subprocess.Popen([G.builddir + "/" + example] + args,
+      stdout = subprocess.PIPE,
+      stderr = subprocess.PIPE,
+  )
+  time.sleep(1)
+  run.terminate()
+  try:
+    outs, errs = run.communicate(timeout=2)
+  except Exception as e:
+    run.kill()
+    return (example, True, -1)
+  else:
+    return (example, True if b'ERR' in outs or b'ERR' in errs else False, run.poll())
+
+
+parser = argparse.ArgumentParser(description='Run the examples of efl')
+parser.add_argument('builddir', metavar='build', help='the path where to find the meson build directory')
+
+G = parser.parse_args()
+#Run meson to fetch all examples
+meson_introspect = subprocess.Popen(["meson", "introspect", G.builddir, "--targets"],
+      stdout = subprocess.PIPE,
+      stderr = subprocess.PIPE,
+)
+meson_introspect.poll()
+build_targets = json.loads(meson_introspect.stdout.read())
+examples = [b["filename"] for b in build_targets if "examples" in b["filename"] and b["type"] == "executable"]
+state = State(len(examples))
+#simulate all examples in parallel with up to 5 runners
+with concurrent.futures.ThreadPoolExecutor(max_workers=5) as executor:
+  futures = [executor.submit(simulate_example, example) for example in examples]
+  for future in concurrent.futures.as_completed(futures):
+    example_run = future.result()
+    state.add_run(example_run[0], example_run[1], example_run[2])
+state.print_summary()

src/Makefile_Ector.am

@@ -163,6 +163,7 @@ lib_ector_libector_la_CPPFLAGS = -I$(top_builddir)/src/lib/efl \
 -DPACKAGE_BIN_DIR=\"$(bindir)\" \
 -DPACKAGE_LIB_DIR=\"$(libdir)\" \
 -DPACKAGE_DATA_DIR=\"$(datadir)/ector\" \
+-DEFL_BETA_API_SUPPORT=1 \
 @VALGRIND_CFLAGS@ \
 @SSE3_CFLAGS@
 

src/Makefile_Elementary.am

@@ -1822,6 +1822,7 @@ TESTS += tests/elementary/elm_suite tests/elementary/efl_ui_suite
 tests_elementary_elm_suite_SOURCES = \
 	tests/elementary/suite_helpers.c \
 	tests/elementary/elm_suite.c \
+	tests/elementary/elm_suite_build.c \
 	tests/elementary/elm_test_atspi.c \
 	tests/elementary/elm_test_check.c \
 	tests/elementary/elm_test_colorselector.c \
@@ -1922,6 +1923,7 @@ tests_elementary_efl_ui_suite_SOURCES = \
 	tests/elementary/suite_helpers.c \
 	tests/elementary/suite_helpers.h \
 	tests/elementary/efl_ui_suite.c \
+	tests/elementary/efl_ui_build.c \
 	tests/elementary/elm_test_init.c \
 	tests/elementary/efl_ui_test_atspi.c \
 	tests/elementary/efl_ui_test_focus_common.c \
@@ -1929,6 +1931,7 @@ tests_elementary_efl_ui_suite_SOURCES = \
 	tests/elementary/efl_ui_test_focus.c \
 	tests/elementary/efl_ui_test_focus_sub.c \
 	tests/elementary/efl_ui_test_box.c \
+	tests/elementary/efl_ui_test_box_flow.c \
 	tests/elementary/efl_ui_test_table.c \
 	tests/elementary/efl_ui_test_relative_layout.c \
 	tests/elementary/efl_ui_test_grid.c \

src/Makefile_Eolian.am

@@ -159,13 +159,10 @@ tests/eolian/data/struct_ref.h \
 tests/eolian/data/struct_ref_stub.h \
 tests/eolian/data/owning.eo.c \
 tests/eolian/data/class_simple_ref.c \
-tests/eolian/data/class_simple_ref.legacy.c \
 tests/eolian/data/override_ref.c \
 tests/eolian/data/class_simple_ref_eo.h \
-tests/eolian/data/class_simple_ref_legacy.h \
 tests/eolian/data/import_types_ref.h \
 tests/eolian/data/docs_ref.h \
-tests/eolian/data/docs_ref_legacy.h \
 tests/eolian/data/function_types_ref.h \
 tests/eolian/data/function_as_argument_impl_ref.c \
 tests/eolian/data/function_as_argument_ref.c \

src/bin/eeze/eeze_scanner/eeze_scanner.c

@@ -513,7 +513,7 @@ main(void)
      }
 
    efl_event_callback_add(server, EFL_NET_SERVER_EVENT_CLIENT_ADD, cl_add, NULL);
-   efl_event_callback_add(server, EFL_NET_SERVER_EVENT_ERROR, server_error, NULL);
+   efl_event_callback_add(server, EFL_NET_SERVER_EVENT_SERVER_ERROR, server_error, NULL);
 
 #ifdef EFL_NET_SERVER_UNIX_CLASS
    {

src/bin/efl/efl_debugd.c

@@ -570,7 +570,7 @@ _local_server_create(void)
      }
 
    efl_event_callback_add(_local_server, EFL_NET_SERVER_EVENT_CLIENT_ADD, _client_add, NULL);
-   efl_event_callback_add(_local_server, EFL_NET_SERVER_EVENT_ERROR, _error, NULL);
+   efl_event_callback_add(_local_server, EFL_NET_SERVER_EVENT_SERVER_ERROR, _error, NULL);
 
 #ifdef EFL_NET_SERVER_UNIX_CLASS
    {
@@ -620,7 +620,7 @@ _remote_server_create(void)
       efl_net_server_fd_reuse_address_set(inner_server, EINA_TRUE);
    }
    efl_event_callback_add(_remote_server, EFL_NET_SERVER_EVENT_CLIENT_ADD, _client_add, NULL);
-   efl_event_callback_add(_remote_server, EFL_NET_SERVER_EVENT_ERROR, _error, NULL);
+   efl_event_callback_add(_remote_server, EFL_NET_SERVER_EVENT_SERVER_ERROR, _error, NULL);
 
    sprintf(address, "127.0.0.1:%d", REMOTE_SERVER_PORT);
    err = efl_net_server_serve(_remote_server, address);

src/bin/elementary/test_ui_box.c

@@ -179,15 +179,7 @@ homo_check_cb(void *data, const Efl_Event *event)
 {
    Eina_Bool chk = elm_check_selected_get(event->object);
    Eo *box = efl_key_wref_get(data, "box");
-   efl_ui_box_flow_homogenous_set(box, chk);
+   efl_ui_box_homogeneous_set(box, chk);
-}
-
-static void
-max_size_check_cb(void *data, const Efl_Event *event)
-{
-   Eina_Bool chk = elm_check_selected_get(event->object);
-   Eo *box = efl_key_wref_get(data, "box");
-   efl_ui_box_flow_max_size_set(box, chk);
 }
 
 static void
@@ -358,14 +350,6 @@ test_ui_box(void *data EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event_in
    efl_pack(bx, o);
    efl_gfx_entity_visible_set(o, 1);
 
-   o = elm_check_add(win);
-   elm_check_selected_set(o, 0);
-   elm_object_text_set(o, "Homogenous + Max");
-   efl_event_callback_add(o, EFL_UI_CHECK_EVENT_CHANGED, max_size_check_cb, win);
-   efl_gfx_hint_align_set(o, 0, 0);
-   efl_pack(bx, o);
-   efl_gfx_entity_visible_set(o, 1);
-
    o = elm_check_add(win);
    elm_check_selected_set(o, 0);
    elm_object_text_set(o, "Custom layout");

src/bin/eolian/docs.c

@@ -111,7 +111,7 @@ _generate_ref(const Eolian_State *state, const char *refn, Eina_Strbuf *wbuf,
 
    if (!fn) goto noref;
 
-   Eina_Stringshare *fcn = eolian_function_full_c_name_get(fn, ftype, use_legacy);
+   Eina_Stringshare *fcn = eolian_function_full_c_name_get(fn, ftype);
    if (!fcn) goto noref;
    eina_strbuf_append(wbuf, fcn);
    eina_stringshare_del(fcn);
@@ -408,8 +408,7 @@ eo_gen_docs_event_gen(const Eolian_State *state, const Eolian_Event *ev,
 
 Eina_Strbuf *
 eo_gen_docs_func_gen(const Eolian_State *state, const Eolian_Function *fid,
-                     Eolian_Function_Type ftype, int indent,
+                     Eolian_Function_Type ftype, int indent)
-                     Eina_Bool use_legacy)
 {
    const Eolian_Function_Parameter *par = NULL;
    const Eolian_Function_Parameter *vpar = NULL;
@@ -427,28 +426,7 @@ eo_gen_docs_func_gen(const Eolian_State *state, const Eolian_Function *fid,
 
    int curl = 0;
 
-   const char *group = NULL;
+   const char *group = eolian_class_name_get(eolian_function_class_get(fid));
-   char legacy_group_name[1024];
-   if (use_legacy)
-     {
-        // Generate legacy doxygen group name
-        const char *prefix =
-          eolian_class_legacy_prefix_get(eolian_function_class_get(fid));
-        unsigned int i;
-        snprintf(legacy_group_name, sizeof(legacy_group_name),
-                 "%s_Group", prefix);
-        for (i = 0; i < strlen(legacy_group_name); i++)
-          {
-             if ((i == 0) || (legacy_group_name[i - 1] == '_'))
-               legacy_group_name[i] = toupper(legacy_group_name[i]);
-          }
-        group = legacy_group_name;
-     }
-   else
-     {
-        group = eolian_class_name_get(eolian_function_class_get(fid));
-     }
-
    const Eolian_Implement *fimp = eolian_function_implement_get(fid);
 
    if (ftype == EOLIAN_METHOD)
@@ -539,7 +517,7 @@ eo_gen_docs_func_gen(const Eolian_State *state, const Eolian_Function *fid,
    if (!desc && !par && !vpar && !rdoc && (ftype == EOLIAN_METHOD || !pdoc))
      {
         _gen_doc_brief(state, sum ? sum : "No description supplied.", since, group,
-                       NULL, indent, buf, use_legacy);
+                       NULL, indent, buf, EINA_FALSE);
         return buf;
      }
 
@@ -550,7 +528,7 @@ eo_gen_docs_func_gen(const Eolian_State *state, const Eolian_Function *fid,
    eina_strbuf_append(buf, " * @brief ");
    curl += sizeof(" * @brief ") - 1;
    _append_section(state, sum ? sum : "No description supplied.",
-                   indent, curl, buf, wbuf, use_legacy);
+                   indent, curl, buf, wbuf, EINA_FALSE);
 
    eina_strbuf_append_char(buf, '\n');
    if (desc || since || par || rdoc || pdoc)
@@ -563,7 +541,7 @@ eo_gen_docs_func_gen(const Eolian_State *state, const Eolian_Function *fid,
      {
         curl = _indent_line(buf, indent);
         eina_strbuf_append(buf, " * ");
-        _append_section(state, desc, indent, curl + 3, buf, wbuf, use_legacy);
+        _append_section(state, desc, indent, curl + 3, buf, wbuf, EINA_FALSE);
         eina_strbuf_append_char(buf, '\n');
         if (par || rdoc || pdoc || since)
           {
@@ -578,7 +556,7 @@ eo_gen_docs_func_gen(const Eolian_State *state, const Eolian_Function *fid,
         curl = _indent_line(buf, indent);
         eina_strbuf_append(buf, " * ");
         _append_section(state, eolian_documentation_summary_get(pdoc), indent,
-            curl + 3, buf, wbuf, use_legacy);
+            curl + 3, buf, wbuf, EINA_FALSE);
         eina_strbuf_append_char(buf, '\n');
         if (pdesc)
           {
@@ -586,7 +564,7 @@ eo_gen_docs_func_gen(const Eolian_State *state, const Eolian_Function *fid,
              eina_strbuf_append(buf, " *\n");
              curl = _indent_line(buf, indent);
              eina_strbuf_append(buf, " * ");
-             _append_section(state, pdesc, indent, curl + 3, buf, wbuf, use_legacy);
+             _append_section(state, pdesc, indent, curl + 3, buf, wbuf, EINA_FALSE);
              eina_strbuf_append_char(buf, '\n');
           }
         if (par || rdoc || since)
@@ -641,7 +619,7 @@ eo_gen_docs_func_gen(const Eolian_State *state, const Eolian_Function *fid,
              eina_strbuf_append_char(buf, ' ');
              curl += 1;
              _append_section(state, eolian_documentation_summary_get(adoc),
-                             indent, curl, buf, wbuf, use_legacy);
+                             indent, curl, buf, wbuf, EINA_FALSE);
           }
 
         eina_strbuf_append_char(buf, '\n');
@@ -674,7 +652,7 @@ eo_gen_docs_func_gen(const Eolian_State *state, const Eolian_Function *fid,
         eina_strbuf_append(buf, " * @return ");
         curl += sizeof(" * @return ") - 1;
         _append_section(state, eolian_documentation_summary_get(rdoc), indent,
-            curl, buf, wbuf, use_legacy);
+            curl, buf, wbuf, EINA_FALSE);
         eina_strbuf_append_char(buf, '\n');
         if (since)
           {

src/bin/eolian/docs.h

@@ -22,12 +22,11 @@ Eina_Strbuf *eo_gen_docs_full_gen(const Eolian_State *state, const Eolian_Docume
  * @param[in] fid te function
  * @param[in] type the function type (either METHOD, PROP_GET, PROP_SET)
  * @param[in] indent by how many spaces to indent the comment from second line
- * @param[in] use_legacy whether to use legacy names
  *
  * @return A documentation comment
  *
  */
-Eina_Strbuf *eo_gen_docs_func_gen(const Eolian_State *state, const Eolian_Function *fid, Eolian_Function_Type ftype, int indent, Eina_Bool use_legacy);
+Eina_Strbuf *eo_gen_docs_func_gen(const Eolian_State *state, const Eolian_Function *fid, Eolian_Function_Type ftype, int indent);
 
 /*
  * @brief Generate event documentation

src/bin/eolian/headers.c

@@ -67,10 +67,9 @@ eo_gen_params(Eina_Iterator *itr, Eina_Strbuf *buf,
 
 static void
 _gen_func(const Eolian_State *state, const Eolian_Function *fid,
-          Eolian_Function_Type ftype, Eina_Strbuf *buf, char *cname,
+          Eolian_Function_Type ftype, Eina_Strbuf *buf, char *cnameu)
-          char *cnameu, Eina_Bool legacy)
 {
-   Eina_Stringshare *fcn = eolian_function_full_c_name_get(fid, ftype, legacy);
+   Eina_Stringshare *fcn = eolian_function_full_c_name_get(fid, ftype);
    if (!fcn)
      return;
 
@@ -90,11 +89,9 @@ _gen_func(const Eolian_State *state, const Eolian_Function *fid,
 
    Eolian_Object_Scope fsc = eolian_function_scope_get(fid, ftype);
 
-   /* this one will never be satisfied in legacy */
    if (eolian_function_is_beta(fid))
      eina_strbuf_append(buf, "#ifdef EFL_BETA_API_SUPPORT\n");
-   /* XXX: is this right? we expose potentially internal stuff into legacy */
+   if (fsc == EOLIAN_SCOPE_PROTECTED)
-   if (!legacy && (fsc == EOLIAN_SCOPE_PROTECTED))
      eina_strbuf_append_printf(buf, "#ifdef %s_PROTECTED\n", cnameu);
 
    const Eolian_Implement *fimp = eolian_function_implement_get(fid);
@@ -104,12 +101,12 @@ _gen_func(const Eolian_State *state, const Eolian_Function *fid,
      hasdoc = !!eolian_implement_documentation_get(fimp, EOLIAN_PROPERTY);
    if (hasdoc)
      {
-        Eina_Strbuf *dbuf = eo_gen_docs_func_gen(state, fid, ftype, 0, legacy);
+        Eina_Strbuf *dbuf = eo_gen_docs_func_gen(state, fid, ftype, 0);
         eina_strbuf_append(buf, eina_strbuf_string_get(dbuf));
         eina_strbuf_append_char(buf, '\n');
         eina_strbuf_free(dbuf);
      }
-   eina_strbuf_append(buf, legacy ? "EAPI " : "EOAPI ");
+   eina_strbuf_append(buf, "EOAPI ");
    if (rtp)
      {
         Eina_Stringshare *rtps = eolian_type_c_type_get(rtp, EOLIAN_C_TYPE_RETURN);
@@ -135,10 +132,7 @@ _gen_func(const Eolian_State *state, const Eolian_Function *fid,
           {
              eina_strbuf_append(buf, "const ");
           }
-        if (legacy)
+        eina_strbuf_append(buf, "Eo *obj");
-          eina_strbuf_append_printf(buf, "%s *obj", cname);
-        else
-          eina_strbuf_append(buf, "Eo *obj");
      }
 
    eo_gen_params(eolian_property_keys_get(fid, ftype), buf, &flagbuf, &nidx, EOLIAN_PROPERTY);
@@ -174,7 +168,7 @@ _gen_func(const Eolian_State *state, const Eolian_Function *fid,
      }
    eina_strbuf_append(buf, ";\n");
 
-   if (!legacy && (fsc == EOLIAN_SCOPE_PROTECTED))
+   if (fsc == EOLIAN_SCOPE_PROTECTED)
      eina_strbuf_append_printf(buf, "#endif\n");
    if (eolian_function_is_beta(fid))
      eina_strbuf_append_printf(buf, "#endif /* EFL_BETA_API_SUPPORT */\n");
@@ -184,129 +178,119 @@ void
 eo_gen_header_gen(const Eolian_State *state, const Eolian_Class *cl,
                   Eina_Strbuf *buf, Eina_Bool legacy)
 {
-   if (!cl)
+   if (!cl || legacy)
      return;
 
-   char *cname = NULL, *cnameu = NULL;
+   Eina_Iterator *itr;
-   eo_gen_class_names_get(cl, &cname, &cnameu, NULL);
+   Eolian_Event *ev;
+   char *cnameu = NULL;
+   eo_gen_class_names_get(cl, NULL, &cnameu, NULL);
 
    /* class definition */
 
-   if (!legacy && eolian_class_is_beta(cl))
+   if (eolian_class_is_beta(cl))
      {
         eina_strbuf_append(buf, "#ifdef EFL_BETA_API_SUPPORT\n");
      }
-   if (!legacy)
+   const Eolian_Documentation *doc = eolian_class_documentation_get(cl);
+   if (doc)
      {
-        const Eolian_Documentation *doc = eolian_class_documentation_get(cl);
+        Eina_Strbuf *cdoc = eo_gen_docs_full_gen(state, doc,
-        if (doc)
+           eolian_class_name_get(cl), 0, EINA_FALSE);
+        if (cdoc)
           {
-             Eina_Strbuf *cdoc = eo_gen_docs_full_gen(state, doc,
+             eina_strbuf_append(buf, eina_strbuf_string_get(cdoc));
-                eolian_class_name_get(cl), 0, EINA_FALSE);
+             eina_strbuf_append_char(buf, '\n');
-             if (cdoc)
+             eina_strbuf_free(cdoc);
-               {
-                  eina_strbuf_append(buf, eina_strbuf_string_get(cdoc));
-                  eina_strbuf_append_char(buf, '\n');
-                  eina_strbuf_free(cdoc);
-               }
           }
-
-        Eina_Stringshare *mname = eolian_class_c_name_get(cl);
-        Eina_Stringshare *gname = eolian_class_c_get_function_name_get(cl);
-        eina_strbuf_append_printf(buf, "#define %s %s()\n\n", mname, gname);
-        eina_stringshare_del(mname);
-
-        eina_strbuf_append_printf(buf, "EWAPI const Efl_Class *%s(void);\n", gname);
-        eina_stringshare_del(gname);
      }
 
-   /* method section */
+   Eina_Stringshare *mname = eolian_class_c_name_get(cl);
-   {
+   Eina_Stringshare *gname = eolian_class_c_get_function_name_get(cl);
-      Eina_Iterator *itr = eolian_class_implements_get(cl);
+   eina_strbuf_append_printf(buf, "#define %s %s()\n\n", mname, gname);
-      if (!itr)
+   eina_stringshare_del(mname);
-        goto events;
 
-      const Eolian_Implement *imp;
+   eina_strbuf_append_printf(buf, "EWAPI const Efl_Class *%s(void);\n", gname);
-      EINA_ITERATOR_FOREACH(itr, imp)
+   eina_stringshare_del(gname);
-        {
+
-           if (eolian_implement_class_get(imp) != cl)
+   /* method section */
-             continue;
+   itr = eolian_class_implements_get(cl);
-           Eolian_Function_Type ftype = EOLIAN_UNRESOLVED;
+   if (!itr)
-           const Eolian_Function *fid = eolian_implement_function_get(imp, &ftype);
+     goto events;
-           /* beta can only exist for eo api */
+
-           if (legacy && eolian_function_is_beta(fid))
+   const Eolian_Implement *imp;
-             continue;
+   EINA_ITERATOR_FOREACH(itr, imp)
-           eina_strbuf_append_char(buf, '\n');
+     {
-           switch (ftype)
+        if (eolian_implement_class_get(imp) != cl)
-             {
+          continue;
-              case EOLIAN_PROP_GET:
+        Eolian_Function_Type ftype = EOLIAN_UNRESOLVED;
-              case EOLIAN_PROP_SET:
+        const Eolian_Function *fid = eolian_implement_function_get(imp, &ftype);
-                _gen_func(state, fid, ftype, buf, cname, cnameu, legacy);
+        eina_strbuf_append_char(buf, '\n');
-                break;
+         switch (ftype)
-              case EOLIAN_PROPERTY:
+          {
-                _gen_func(state, fid, EOLIAN_PROP_SET, buf, cname, cnameu, legacy);
+           case EOLIAN_PROP_GET:
-                eina_strbuf_append_char(buf, '\n');
+           case EOLIAN_PROP_SET:
-                _gen_func(state, fid, EOLIAN_PROP_GET, buf, cname, cnameu, legacy);
+             _gen_func(state, fid, ftype, buf, cnameu);
-                break;
+             break;
-              default:
+           case EOLIAN_PROPERTY:
-                _gen_func(state, fid, EOLIAN_METHOD, buf, cname, cnameu, legacy);
+             _gen_func(state, fid, EOLIAN_PROP_SET, buf, cnameu);
-             }
+             eina_strbuf_append_char(buf, '\n');
-        }
+              _gen_func(state, fid, EOLIAN_PROP_GET, buf, cnameu);
-      eina_iterator_free(itr);
+             break;
-   }
+           default:
+             _gen_func(state, fid, EOLIAN_METHOD, buf, cnameu);
+          }
+     }
+   eina_iterator_free(itr);
 
 events:
    /* event section */
-   if (!legacy)
+   itr = eolian_class_events_get(cl);
+   EINA_ITERATOR_FOREACH(itr, ev)
      {
-        Eina_Iterator *itr = eolian_class_events_get(cl);
+        Eina_Stringshare *evn = eolian_event_c_name_get(ev);
-        Eolian_Event *ev;
+        Eolian_Object_Scope evs = eolian_event_scope_get(ev);
-        EINA_ITERATOR_FOREACH(itr, ev)
+
+        if (evs == EOLIAN_SCOPE_PRIVATE)
+          continue;
+
+        if (eolian_event_is_beta(ev))
           {
-             Eina_Stringshare *evn = eolian_event_c_name_get(ev);
+             eina_strbuf_append(buf, "#ifdef EFL_BETA_API_SUPPORT\n");
-             Eolian_Object_Scope evs = eolian_event_scope_get(ev);
-
-             if (evs == EOLIAN_SCOPE_PRIVATE)
-               continue;
-
-             if (eolian_event_is_beta(ev))
-               {
-                  eina_strbuf_append(buf, "#ifdef EFL_BETA_API_SUPPORT\n");
-               }
-             if (evs == EOLIAN_SCOPE_PROTECTED)
-               {
-                  if (!eolian_event_is_beta(ev))
-                    eina_strbuf_append_char(buf, '\n');
-                  eina_strbuf_append_printf(buf, "#ifdef %s_PROTECTED\n", cnameu);
-               }
-
-             if (!eolian_event_is_beta(ev) && evs == EOLIAN_SCOPE_PUBLIC)
-               eina_strbuf_append_char(buf, '\n');
-
-             eina_strbuf_append_printf(buf, "EWAPI extern const "
-                                       "Efl_Event_Description _%s;\n\n", evn);
-
-             Eina_Strbuf *evdbuf = eo_gen_docs_event_gen(state, ev,
-                eolian_class_name_get(cl));
-             eina_strbuf_append(buf, eina_strbuf_string_get(evdbuf));
-             eina_strbuf_append_char(buf, '\n');
-             eina_strbuf_free(evdbuf);
-             eina_strbuf_append_printf(buf, "#define %s (&(_%s))\n", evn, evn);
-
-             if (evs == EOLIAN_SCOPE_PROTECTED)
-               eina_strbuf_append(buf, "#endif\n");
-             if (eolian_event_is_beta(ev))
-               eina_strbuf_append(buf, "#endif /* EFL_BETA_API_SUPPORT */\n");
-
-             eina_stringshare_del(evn);
           }
-        eina_iterator_free(itr);
+        if (evs == EOLIAN_SCOPE_PROTECTED)
+          {
+             if (!eolian_event_is_beta(ev))
+               eina_strbuf_append_char(buf, '\n');
+             eina_strbuf_append_printf(buf, "#ifdef %s_PROTECTED\n", cnameu);
+          }
+
+        if (!eolian_event_is_beta(ev) && evs == EOLIAN_SCOPE_PUBLIC)
+          eina_strbuf_append_char(buf, '\n');
+
+        eina_strbuf_append_printf(buf, "EWAPI extern const "
+                                  "Efl_Event_Description _%s;\n\n", evn);
+
+        Eina_Strbuf *evdbuf = eo_gen_docs_event_gen(state, ev,
+           eolian_class_name_get(cl));
+        eina_strbuf_append(buf, eina_strbuf_string_get(evdbuf));
+        eina_strbuf_append_char(buf, '\n');
+        eina_strbuf_free(evdbuf);
+        eina_strbuf_append_printf(buf, "#define %s (&(_%s))\n", evn, evn);
+
+        if (evs == EOLIAN_SCOPE_PROTECTED)
+          eina_strbuf_append(buf, "#endif\n");
+        if (eolian_event_is_beta(ev))
+          eina_strbuf_append(buf, "#endif /* EFL_BETA_API_SUPPORT */\n");
+
+        eina_stringshare_del(evn);
      }
-   if (!legacy && eolian_class_is_beta(cl))
+   eina_iterator_free(itr);
+
+   if (eolian_class_is_beta(cl))
      {
         eina_strbuf_append(buf, "#endif /* EFL_BETA_API_SUPPORT */\n");
      }
 
-   free(cname);
    free(cnameu);
 }

src/bin/eolian/main.c

@@ -396,47 +396,20 @@ _write_source(const Eolian_State *eos, const char *ofname,
 {
    INF("generating source: %s", ofname);
    Eina_Strbuf *buf = eina_strbuf_new();
-   Eina_Strbuf *lbuf = eina_strbuf_new();
-   Eina_Strbuf *oflname = eina_strbuf_new();
    Eina_Bool ret = EINA_FALSE;
 
-   const char *lext = strrchr(ofname, '.');
-   if (!lext)
-     {
-        eina_strbuf_append(oflname, ofname);
-        eina_strbuf_append(oflname, ".legacy.c");
-     }
-   else
-     {
-        eina_strbuf_append_length(oflname, ofname, strlen(ofname) - strlen(lext));
-        eina_strbuf_append(oflname, ".legacy");
-        eina_strbuf_append(oflname, lext);
-     }
-   const char *lfname = eina_strbuf_string_get(oflname);
-     {
-        const char *p1 = strrchr(lfname, '/');
-        const char *p2 = strrchr(lfname, '\\');
-        lfname = (p1 || p2) ? ((p1 > p2) ? (p1 + 1) : (p2 + 1)) : lfname;
-     }
    const Eolian_Class *cl = eolian_state_class_by_file_get(eos, ifname);
    eo_gen_types_source_gen(eolian_state_objects_by_file_get(eos, ifname), buf);
-   eo_gen_source_gen(cl, buf, lbuf, lfname);
+   eo_gen_source_gen(cl, buf);
    if (cl || (eot && eina_strbuf_length_get(buf)))
      {
         if (!_write_file(ofname, buf))
           goto done;
-        if (eina_strbuf_length_get(lbuf))
-          {
-             if (!_write_file(eina_strbuf_string_get(oflname), lbuf))
-               goto done;
-          }
         ret = EINA_TRUE;
      }
 
 done:
    eina_strbuf_free(buf);
-   eina_strbuf_free(lbuf);
-   eina_strbuf_free(oflname);
    return ret;
 }
 

src/bin/eolian/sources.c

@@ -351,14 +351,14 @@ _gen_reflect_get(Eina_Strbuf *buf, const char *cnamel, const Eolian_Type *valt,
      eina_hash_set(refh, &fid, (void *)EOLIAN_PROP_GET);
 
    eina_strbuf_append(buf, "\nstatic Eina_Value\n");
-   eina_strbuf_append_printf(buf, "__eolian_%s_%s_get_reflect(Eo *obj)\n",
+   eina_strbuf_append_printf(buf, "__eolian_%s_%s_get_reflect(const Eo *obj)\n",
      cnamel, eolian_function_name_get(fid));
    eina_strbuf_append(buf, "{\n");
 
    Eina_Stringshare *ct = eolian_type_c_type_get(valt, EOLIAN_C_TYPE_RETURN);
    const char *starsp = (ct[strlen(ct) - 1] != '*') ? " " : "";
 
-   Eina_Stringshare *fcn = eolian_function_full_c_name_get(fid, EOLIAN_PROP_GET, EINA_FALSE);
+   Eina_Stringshare *fcn = eolian_function_full_c_name_get(fid, EOLIAN_PROP_GET);
    eina_strbuf_append_printf(buf, "   %s%sval = %s(obj);\n", ct, starsp, fcn);
    eina_stringshare_del(fcn);
    eina_stringshare_del(ct);
@@ -402,7 +402,7 @@ _gen_reflect_set(Eina_Strbuf *buf, const char *cnamel, const Eolian_Type *valt,
    eina_strbuf_append(buf, "         goto end;\n");
    eina_strbuf_append(buf, "      }\n");
 
-   Eina_Stringshare *fcn = eolian_function_full_c_name_get(fid, EOLIAN_PROP_SET, EINA_FALSE);
+   Eina_Stringshare *fcn = eolian_function_full_c_name_get(fid, EOLIAN_PROP_SET);
    eina_strbuf_append_printf(buf, "   %s(obj, cval);\n", fcn);
    eina_stringshare_del(fcn);
 
@@ -449,8 +449,7 @@ _emit_class_function(Eina_Strbuf *buf, const Eolian_Function *fid, const Eolian_
 static void
 _gen_func(const Eolian_Class *cl, const Eolian_Function *fid,
           Eolian_Function_Type ftype, Eina_Strbuf *buf,
-          const Eolian_Implement *impl, Eina_Strbuf *lbuf,
+          const Eolian_Implement *impl, Eina_Hash *refh)
-          Eina_Hash *refh)
 {
    Eina_Bool is_empty = eolian_implement_is_empty(impl, ftype);
    Eina_Bool is_auto = eolian_implement_is_auto(impl, ftype);
@@ -819,7 +818,7 @@ _gen_func(const Eolian_Class *cl, const Eolian_Function *fid,
           {
              //we have owned parameters we need to take care of
              eina_strbuf_append_printf(buf, "static void\n");
-             eina_strbuf_append_printf(buf, "_%s_ownership_fallback(%s)\n{\n", eolian_function_full_c_name_get(fid, ftype, EINA_FALSE), eina_strbuf_string_get(params_full) + 2);
+             eina_strbuf_append_printf(buf, "_%s_ownership_fallback(%s)\n{\n", eolian_function_full_c_name_get(fid, ftype), eina_strbuf_string_get(params_full) + 2);
 
              eina_strbuf_append_buffer(buf, fallback_free_ownership);
              eina_strbuf_append_printf(buf, "}\n\n");
@@ -842,7 +841,7 @@ _gen_func(const Eolian_Class *cl, const Eolian_Function *fid,
 
         eina_strbuf_append_char(buf, '(');
 
-        Eina_Stringshare *eofn = eolian_function_full_c_name_get(fid, ftype, EINA_FALSE);
+        Eina_Stringshare *eofn = eolian_function_full_c_name_get(fid, ftype);
         eina_strbuf_append(buf, eofn);
 
         if (strcmp(rtpn, "void"))
@@ -852,7 +851,7 @@ _gen_func(const Eolian_Class *cl, const Eolian_Function *fid,
           }
 
         if (fallback_free_ownership)
-          eina_strbuf_append_printf(buf, ", _%s_ownership_fallback(%s);", eolian_function_full_c_name_get(fid, ftype, EINA_FALSE), eina_strbuf_string_get(params));
+          eina_strbuf_append_printf(buf, ", _%s_ownership_fallback(%s);", eolian_function_full_c_name_get(fid, ftype), eina_strbuf_string_get(params));
 
         if (has_params)
           {
@@ -864,59 +863,10 @@ _gen_func(const Eolian_Class *cl, const Eolian_Function *fid,
 
         eina_strbuf_append(buf, ");\n");
 
-        /* now try legacy */
-        Eina_Stringshare *lfn = eolian_function_full_c_name_get(fid, ftype, EINA_TRUE);
-        if (!eolian_function_is_beta(fid) && lfn)
-          {
-             eina_strbuf_append(lbuf, "\nEAPI ");
-             eina_strbuf_append(lbuf, rtpn);
-             eina_strbuf_append_char(lbuf, '\n');
-             eina_strbuf_append(lbuf, lfn);
-             /* param list */
-             eina_strbuf_append_char(lbuf, '(');
-             /* for class funcs, offset the params to remove comma */
-             int poff = 2;
-             if (!eolian_function_is_class(fid))
-               {
-                  /* non-class funcs have the obj though */
-                  poff = 0;
-                  if ((ftype == EOLIAN_PROP_GET) || eolian_function_object_is_const(fid))
-                    eina_strbuf_append(lbuf, "const ");
-                  eina_strbuf_append_printf(lbuf, "%s *obj", cname);
-               }
-             eina_strbuf_append(lbuf, eina_strbuf_string_get(params_full) + poff);
-             eina_strbuf_append(lbuf, ")\n{\n");
-             /* body */
-             if (strcmp(rtpn, "void"))
-               eina_strbuf_append(lbuf, "   return ");
-             else
-               eina_strbuf_append(lbuf, "   ");
-             eina_strbuf_append(lbuf, eofn);
-             eina_strbuf_append_char(lbuf, '(');
-             if (!eolian_function_is_class(fid))
-               eina_strbuf_append(lbuf, "obj");
-             else
-               {
-                  Eina_Stringshare *mname = eolian_class_c_name_get(cl);
-                  eina_strbuf_append(lbuf, mname);
-                  eina_stringshare_del(mname);
-               }
-             if (has_params)
-               eina_strbuf_append_printf(lbuf, ", %s", eina_strbuf_string_get(params));
-             eina_strbuf_append(lbuf, ");\n}\n");
-          }
-
-        eina_stringshare_del(lfn);
         eina_stringshare_del(eofn);
      }
    if (impl_same_class && eolian_function_is_class(fid))
-     {
+     _emit_class_function(buf, fid, rtp, params_full, ocnamel, func_suffix, params, eolian_function_full_c_name_get(fid, ftype));
-        const char *legacy_name = eolian_function_full_c_name_get(fid, ftype, EINA_TRUE);
-
-        _emit_class_function(buf, fid, rtp, params_full, ocnamel, func_suffix, params, eolian_function_full_c_name_get(fid, ftype, EINA_FALSE));
-        if (legacy_name)
-          _emit_class_function(buf, fid, rtp, params_full, ocnamel, func_suffix, params, legacy_name);
-     }
 
    free(cname);
    free(cnamel);
@@ -937,7 +887,7 @@ _gen_opfunc(const Eolian_Function *fid, Eolian_Function_Type ftype,
             Eina_Strbuf *buf, const Eolian_Implement *impl, Eina_Bool pinit,
             const char *cnamel, const char *ocnamel)
 {
-   Eina_Stringshare *fnm = eolian_function_full_c_name_get(fid, ftype, EINA_FALSE);
+   Eina_Stringshare *fnm = eolian_function_full_c_name_get(fid, ftype);
    eina_strbuf_append(buf, "      EFL_OBJECT_OP_FUNC(");
    eina_strbuf_append(buf, fnm);
    eina_strbuf_append(buf, ", ");
@@ -1086,8 +1036,7 @@ _gen_initializer(const Eolian_Class *cl, Eina_Strbuf *buf, Eina_Hash *refh)
 }
 
 void
-eo_gen_source_gen(const Eolian_Class *cl, Eina_Strbuf *buf, Eina_Strbuf *lbuf,
+eo_gen_source_gen(const Eolian_Class *cl, Eina_Strbuf *buf)
-                  const char *lfname)
 {
    if (!cl)
      return;
@@ -1135,14 +1084,14 @@ eo_gen_source_gen(const Eolian_Class *cl, Eina_Strbuf *buf, Eina_Strbuf *lbuf,
              {
               case EOLIAN_PROP_GET:
               case EOLIAN_PROP_SET:
-                _gen_func(cl, fid, ftype, buf, imp, lbuf, refh);
+                _gen_func(cl, fid, ftype, buf, imp, refh);
                 break;
               case EOLIAN_PROPERTY:
-                _gen_func(cl, fid, EOLIAN_PROP_SET, buf, imp, lbuf, refh);
+                _gen_func(cl, fid, EOLIAN_PROP_SET, buf, imp, refh);
-                _gen_func(cl, fid, EOLIAN_PROP_GET, buf, imp, lbuf, refh);
+                _gen_func(cl, fid, EOLIAN_PROP_GET, buf, imp, refh);
                 break;
               default:
-                _gen_func(cl, fid, EOLIAN_METHOD, buf, imp, lbuf, refh);
+                _gen_func(cl, fid, EOLIAN_METHOD, buf, imp, refh);
              }
         }
       eina_iterator_free(itr);
@@ -1230,10 +1179,6 @@ eo_gen_source_gen(const Eolian_Class *cl, Eina_Strbuf *buf, Eina_Strbuf *lbuf,
    /* terminate inherits */
    eina_strbuf_append(buf, ", NULL);\n");
 
-   /* append legacy include if there */
-   if (eina_strbuf_length_get(lbuf))
-     eina_strbuf_append_printf(buf, "\n#include \"%s\"\n", lfname);
-
    /* and we're done */
    free(cnamel);
    eina_hash_free(_funcs_params_init_get);
@@ -1395,7 +1340,7 @@ _gen_proto(const Eolian_Class *cl, const Eolian_Function *fid,
    if (strlen(efname) >= (sizeof("destructor") - 1) && !impl_same_class)
      if (!strcmp(efname + strlen(efname) - sizeof("destructor") + 1, "destructor"))
        {
-          Eina_Stringshare *fcn = eolian_function_full_c_name_get(fid, ftype, EINA_FALSE);
+          Eina_Stringshare *fcn = eolian_function_full_c_name_get(fid, ftype);
           Eina_Stringshare *mname = eolian_class_c_name_get(cl);
           eina_strbuf_append(buf, "   ");
           eina_strbuf_append(buf, fcn);

src/bin/eolian/sources.h

@@ -3,7 +3,7 @@
 
 #include "main.h"
 
-void eo_gen_source_gen(const Eolian_Class *cl, Eina_Strbuf *buf, Eina_Strbuf *lbuf, const char *lfname);
+void eo_gen_source_gen(const Eolian_Class *cl, Eina_Strbuf *buf);
 void eo_gen_impl_gen(const Eolian_Class *cl, Eina_Strbuf *buf);
 
 #endif

src/bin/eolian/types.c

@@ -156,6 +156,12 @@ _type_generate(const Eolian_State *state, const Eolian_Typedecl *tp,
         eina_strbuf_reset(buf);
         break;
      }
+   eina_strbuf_append_char(buf, ';');
+   if (eolian_typedecl_is_beta(tp))
+     {
+        eina_strbuf_prepend(buf, "#ifdef EFL_BETA_API_SUPPORT\n");
+        eina_strbuf_append(buf, "\n#endif /* EFL_BETA_API_SUPPORT */");
+     }
    return buf;
 }
 
@@ -200,6 +206,11 @@ _var_generate(const Eolian_State *state, const Eolian_Variable *vr, Eina_Bool le
         eina_stringshare_del(ct);
      }
    free(fn);
+   if (eolian_variable_is_beta(vr))
+     {
+        eina_strbuf_prepend(buf, "#ifdef EFL_BETA_API_SUPPORT\n");
+        eina_strbuf_append(buf, "\n#endif /* EFL_BETA_API_SUPPORT */");
+     }
    return buf;
 }
 
@@ -252,7 +263,7 @@ void eo_gen_types_header_gen(const Eolian_State *state,
         if (tbuf)
           {
              eina_strbuf_append(buf, eina_strbuf_string_get(tbuf));
-             eina_strbuf_append(buf, ";\n\n");
+             eina_strbuf_append(buf, "\n\n");
              eina_strbuf_free(tbuf);
           }
      }

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

@@ -50,7 +50,7 @@ struct documentation_generator
       {
          case ::EOLIAN_METHOD:
            if (blacklist::is_function_blacklisted(
-                 ::eolian_function_full_c_name_get(function, ftype, EINA_FALSE))) return "";
+                 ::eolian_function_full_c_name_get(function, ftype))) return "";
            name += ".";
            name += name_helpers::managed_method_name(
              ::eolian_object_short_name_get(klass), eo_name);

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

@@ -51,6 +51,7 @@ struct unpack_event_args_visitor
            , {"int", [&arg] { return arg + ".ToInt32()"; }}
            , {"uint", [&arg] { return "(uint)" + arg + ".ToInt32()";}}
            , {"string", [&arg] { return "Eina.StringConversion.NativeUtf8ToManagedString(" + arg + ")"; }}
+           , {"stringshare", [&arg] { return "Eina.StringConversion.NativeUtf8ToManagedString(" + arg + ")"; }}
            , {"Eina.Error", [&arg] { return "(Eina.Error)Marshal.PtrToStructure(" + arg + ", typeof(Eina.Error))"; }}
         };
 

src/bindings/luajit/eolian.lua

@@ -295,6 +295,7 @@ ffi.cdef [[
     const char *eolian_object_name_get(const Eolian_Object *obj);
     const char *eolian_object_short_name_get(const Eolian_Object *obj);
     Eina_Iterator *eolian_object_namespaces_get(const Eolian_Object *obj);
+    Eina_Bool eolian_object_is_beta(const Eolian_Object *obj);
     Eina_Bool eolian_state_directory_add(Eolian_State *state, const char *dir);
     Eina_Bool eolian_state_system_directory_add(Eolian_State *state);
     Eina_Iterator *eolian_state_eo_file_paths_get(const Eolian_State *state);
@@ -334,7 +335,6 @@ ffi.cdef [[
 
     Eolian_Class_Type eolian_class_type_get(const Eolian_Class *klass);
     const Eolian_Documentation *eolian_class_documentation_get(const Eolian_Class *klass);
-    const char *eolian_class_legacy_prefix_get(const Eolian_Class *klass);
     const char *eolian_class_eo_prefix_get(const Eolian_Class *klass);
     const char *eolian_class_data_type_get(const Eolian_Class *klass);
     const Eolian_Class *eolian_class_parent_get(const Eolian_Class *klass);
@@ -342,13 +342,10 @@ ffi.cdef [[
     Eina_Iterator *eolian_class_functions_get(const Eolian_Class *klass, Eolian_Function_Type func_type);
     Eolian_Function_Type eolian_function_type_get(const Eolian_Function *function_id);
     Eolian_Object_Scope eolian_function_scope_get(const Eolian_Function *function_id, Eolian_Function_Type ftype);
-    const char *eolian_function_full_c_name_get(const Eolian_Function *function_id, Eolian_Function_Type ftype, Eina_Bool use_legacy);
+    const char *eolian_function_full_c_name_get(const Eolian_Function *function_id, Eolian_Function_Type ftype);
     const Eolian_Function *eolian_class_function_by_name_get(const Eolian_Class *klass, const char *func_name, Eolian_Function_Type f_type);
-    const char *eolian_function_legacy_get(const Eolian_Function *function_id, Eolian_Function_Type f_type);
     const Eolian_Implement *eolian_function_implement_get(const Eolian_Function *function_id);
-    Eina_Bool eolian_function_is_legacy_only(const Eolian_Function *function_id, Eolian_Function_Type ftype);
     Eina_Bool eolian_function_is_class(const Eolian_Function *function_id);
-    Eina_Bool eolian_function_is_beta(const Eolian_Function *function_id);
     Eina_Bool eolian_function_is_constructor(const Eolian_Function *function_id, const Eolian_Class *klass);
     Eina_Bool eolian_function_is_function_pointer(const Eolian_Function *function_id);
     Eina_Iterator *eolian_property_keys_get(const Eolian_Function *foo_id, Eolian_Function_Type ftype);
@@ -385,7 +382,6 @@ ffi.cdef [[
     const Eolian_Class *eolian_event_class_get(const Eolian_Event *event);
     const Eolian_Documentation *eolian_event_documentation_get(const Eolian_Event *event);
     Eolian_Object_Scope eolian_event_scope_get(const Eolian_Event *event);
-    Eina_Bool eolian_event_is_beta(const Eolian_Event *event);
     Eina_Bool eolian_event_is_hot(const Eolian_Event *event);
     Eina_Bool eolian_event_is_restart(const Eolian_Event *event);
     const char *eolian_event_c_name_get(const Eolian_Event *event);
@@ -573,6 +569,10 @@ local object_idx, wrap_object = gen_wrap {
     namespaces_get = function(self)
         return iterator.String_Iterator(
             eolian.eolian_object_namespaces_get(cast_obj(self)))
+    end,
+
+    is_beta = function(self)
+        return eolian.eolian_object_is_beta(cast_obj(self)) ~= 0
     end
 }
 
@@ -1063,36 +1063,22 @@ M.Function = ffi.metatype("Eolian_Function", {
             return tonumber(eolian.eolian_function_scope_get(self, ftype))
         end,
 
-        full_c_name_get = function(self, ftype, use_legacy)
+        full_c_name_get = function(self, ftype)
-            local v = eolian.eolian_function_full_c_name_get(self, ftype, use_legacy or false)
+            local v = eolian.eolian_function_full_c_name_get(self, ftype)
             if v == nil then return nil end
             return ffi_stringshare(v)
         end,
 
-        legacy_get = function(self, ftype)
-            local v = eolian.eolian_function_legacy_get(self, ftype)
-            if v == nil then return nil end
-            return ffi.string(v)
-        end,
-
         implement_get = function(self)
             local v = eolian.eolian_function_implement_get(self)
             if v == nil then return nil end
             return v
         end,
 
-        is_legacy_only = function(self, ftype)
-            return eolian.eolian_function_is_legacy_only(self, ftype) ~= 0
-        end,
-
         is_class = function(self)
             return eolian.eolian_function_is_class(self) ~= 0
         end,
 
-        is_beta = function(self)
-            return eolian.eolian_function_is_beta(self) ~= 0
-        end,
-
         is_constructor = function(self, klass)
             return eolian.eolian_function_is_constructor(self, klass) ~= 0
         end,
@@ -1289,10 +1275,6 @@ ffi.metatype("Eolian_Event", {
             return ffi_stringshare(v)
         end,
 
-        is_beta = function(self)
-            return eolian.eolian_event_is_beta(self) ~= 0
-        end,
-
         is_hot = function(self)
             return eolian.eolian_event_is_hot(self) ~= 0
         end,
@@ -1323,12 +1305,6 @@ M.Class = ffi.metatype("Eolian_Class", {
             return v
         end,
 
-        legacy_prefix_get = function(self)
-            local v = eolian.eolian_class_legacy_prefix_get(self)
-            if v == nil then return nil end
-            return ffi.string(v)
-        end,
-
         eo_prefix_get = function(self)
             local v = eolian.eolian_class_eo_prefix_get(self)
             if v == nil then

src/examples/ecore/efl_io_buffered_stream_example.c

@@ -236,7 +236,7 @@ efl_main(void *data EINA_UNUSED,
    /* The TCP client to use to send/receive network data */
    dialer = efl_add(EFL_NET_DIALER_TCP_CLASS, ev->object,
                     efl_name_set(efl_added, "dialer"),
-                    efl_event_callback_add(efl_added, EFL_NET_DIALER_EVENT_CONNECTED, _dialer_connected, NULL));
+                    efl_event_callback_add(efl_added, EFL_NET_DIALER_EVENT_DIALER_CONNECTED, _dialer_connected, NULL));
    if (!dialer)
      {
         fprintf(stderr, "ERROR: could not create Efl_Net_Dialer_Tcp\n");

src/examples/ecore/efl_io_copier_example.c

@@ -77,9 +77,9 @@ _dialer_connected(void *data EINA_UNUSED, const Efl_Event *event)
 }
 
 EFL_CALLBACKS_ARRAY_DEFINE(dialer_cbs,
-                           { EFL_NET_DIALER_EVENT_RESOLVED, _dialer_resolved },
+                           { EFL_NET_DIALER_EVENT_DIALER_RESOLVED, _dialer_resolved },
-                           { EFL_NET_DIALER_EVENT_ERROR, _dialer_error },
+                           { EFL_NET_DIALER_EVENT_DIALER_ERROR, _dialer_error },
-                           { EFL_NET_DIALER_EVENT_CONNECTED, _dialer_connected });
+                           { EFL_NET_DIALER_EVENT_DIALER_CONNECTED, _dialer_connected });
 
 static void
 _http_headers_done(void *data EINA_UNUSED, const Efl_Event *event)

src/examples/ecore/efl_io_queue_example.c

@@ -305,7 +305,7 @@ efl_main(void *data EINA_UNUSED,
    /* The TCP client to use to send/receive network data */
    dialer = efl_add(EFL_NET_DIALER_TCP_CLASS, loop,
                     efl_name_set(efl_added, "dialer"),
-                    efl_event_callback_add(efl_added, EFL_NET_DIALER_EVENT_CONNECTED, _dialer_connected, NULL));
+                    efl_event_callback_add(efl_added, EFL_NET_DIALER_EVENT_DIALER_CONNECTED, _dialer_connected, NULL));
    if (!dialer)
      {
         fprintf(stderr, "ERROR: could not create Efl_Net_Dialer_Tcp\n");

src/examples/ecore/efl_net_dialer_http_example.c

@@ -71,9 +71,9 @@ _http_headers_done(void *data EINA_UNUSED, const Efl_Event *event)
 
 EFL_CALLBACKS_ARRAY_DEFINE(dialer_cbs,
                            { EFL_NET_DIALER_HTTP_EVENT_HEADERS_DONE, _http_headers_done },
-                           { EFL_NET_DIALER_EVENT_CONNECTED, _connected },
+                           { EFL_NET_DIALER_EVENT_DIALER_CONNECTED, _connected },
-                           { EFL_NET_DIALER_EVENT_RESOLVED, _resolved },
+                           { EFL_NET_DIALER_EVENT_DIALER_RESOLVED, _resolved },
-                           { EFL_NET_DIALER_EVENT_ERROR, _error },
+                           { EFL_NET_DIALER_EVENT_DIALER_ERROR, _error },
                            { EFL_IO_CLOSER_EVENT_CLOSED, _closed },
                            { EFL_IO_READER_EVENT_EOS, _eos });
 

src/examples/ecore/efl_net_dialer_simple_example.c

@@ -176,8 +176,8 @@ _done(void *data EINA_UNUSED, const Efl_Event *event)
 }
 
 EFL_CALLBACKS_ARRAY_DEFINE(dialer_cbs,
-                           { EFL_NET_DIALER_EVENT_CONNECTED, _connected }, /* optional */
+                           { EFL_NET_DIALER_EVENT_DIALER_CONNECTED, _connected }, /* optional */
-                           { EFL_NET_DIALER_EVENT_RESOLVED, _resolved }, /* optional */
+                           { EFL_NET_DIALER_EVENT_DIALER_RESOLVED, _resolved }, /* optional */
                            { EFL_IO_READER_EVENT_CAN_READ_CHANGED, _can_read }, /* optional, can be used to read data, here just for monitoring */
                            { EFL_IO_READER_EVENT_EOS, _eos }, /* recommended, notifies no more incoming data */
                            { EFL_IO_BUFFERED_STREAM_EVENT_LINE, _line }, /* optional, could use 'slice,changed' or 'can_read,changed' instead */

src/examples/ecore/efl_net_dialer_udp_example.c

@@ -156,9 +156,9 @@ _error(void *data EINA_UNUSED, const Efl_Event *event)
 }
 
 EFL_CALLBACKS_ARRAY_DEFINE(dialer_cbs,
-                           { EFL_NET_DIALER_EVENT_CONNECTED, _connected },
+                           { EFL_NET_DIALER_EVENT_DIALER_CONNECTED, _connected },
-                           { EFL_NET_DIALER_EVENT_RESOLVED, _resolved },
+                           { EFL_NET_DIALER_EVENT_DIALER_RESOLVED, _resolved },
-                           { EFL_NET_DIALER_EVENT_ERROR, _error },
+                           { EFL_NET_DIALER_EVENT_DIALER_ERROR, _error },
                            { EFL_IO_READER_EVENT_CAN_READ_CHANGED, _can_read },
                            { EFL_IO_WRITER_EVENT_CAN_WRITE_CHANGED, _can_write }
                            );

src/examples/ecore/efl_net_dialer_unix_example.c

@@ -108,9 +108,9 @@ _error(void *data EINA_UNUSED, const Efl_Event *event)
 }
 
 EFL_CALLBACKS_ARRAY_DEFINE(dialer_cbs,
-                           { EFL_NET_DIALER_EVENT_CONNECTED, _connected },
+                           { EFL_NET_DIALER_EVENT_DIALER_CONNECTED, _connected },
-                           { EFL_NET_DIALER_EVENT_RESOLVED, _resolved },
+                           { EFL_NET_DIALER_EVENT_DIALER_RESOLVED, _resolved },
-                           { EFL_NET_DIALER_EVENT_ERROR, _error },
+                           { EFL_NET_DIALER_EVENT_DIALER_ERROR, _error },
                            { EFL_IO_READER_EVENT_EOS, _eos },
                            { EFL_IO_READER_EVENT_CAN_READ_CHANGED, _can_read },
                            { EFL_IO_WRITER_EVENT_CAN_WRITE_CHANGED, _can_write }

src/examples/ecore/efl_net_dialer_websocket_autobahntestee.c

@@ -247,8 +247,8 @@ EFL_CALLBACKS_ARRAY_DEFINE(dialer_cbs,
                            { EFL_NET_DIALER_WEBSOCKET_EVENT_CLOSED_REASON, _ws_closed_reason },
                            { EFL_NET_DIALER_WEBSOCKET_EVENT_MESSAGE_TEXT, _ws_message_text },
                            { EFL_NET_DIALER_WEBSOCKET_EVENT_MESSAGE_BINARY, _ws_message_binary },
-                           { EFL_NET_DIALER_EVENT_CONNECTED, _connected },
+                           { EFL_NET_DIALER_EVENT_DIALER_CONNECTED, _connected },
-                           { EFL_NET_DIALER_EVENT_ERROR, _error },
+                           { EFL_NET_DIALER_EVENT_DIALER_ERROR, _error },
                            { EFL_IO_CLOSER_EVENT_CLOSED, _closed },
                            { EFL_IO_READER_EVENT_EOS, _eos },
                            { EFL_EVENT_DEL, _del });

src/examples/ecore/efl_net_dialer_websocket_example.c

@@ -145,9 +145,9 @@ EFL_CALLBACKS_ARRAY_DEFINE(dialer_cbs,
                            { EFL_NET_DIALER_WEBSOCKET_EVENT_CLOSED_REASON, _ws_closed_reason },
                            { EFL_NET_DIALER_WEBSOCKET_EVENT_MESSAGE_TEXT, _ws_message_text },
                            { EFL_NET_DIALER_WEBSOCKET_EVENT_MESSAGE_BINARY, _ws_message_binary },
-                           { EFL_NET_DIALER_EVENT_CONNECTED, _connected },
+                           { EFL_NET_DIALER_EVENT_DIALER_CONNECTED, _connected },
-                           { EFL_NET_DIALER_EVENT_RESOLVED, _resolved },
+                           { EFL_NET_DIALER_EVENT_DIALER_RESOLVED, _resolved },
-                           { EFL_NET_DIALER_EVENT_ERROR, _error },
+                           { EFL_NET_DIALER_EVENT_DIALER_ERROR, _error },
                            { EFL_IO_CLOSER_EVENT_CLOSED, _closed },
                            { EFL_IO_READER_EVENT_EOS, _eos });
 

src/examples/ecore/efl_net_dialer_windows_example.c

@@ -106,9 +106,9 @@ _error(void *data EINA_UNUSED, const Efl_Event *event)
 }
 
 EFL_CALLBACKS_ARRAY_DEFINE(dialer_cbs,
-                           { EFL_NET_DIALER_EVENT_CONNECTED, _connected },
+                           { EFL_NET_DIALER_EVENT_DIALER_CONNECTED, _connected },
-                           { EFL_NET_DIALER_EVENT_RESOLVED, _resolved },
+                           { EFL_NET_DIALER_EVENT_DIALER_RESOLVED, _resolved },
-                           { EFL_NET_DIALER_EVENT_ERROR, _error },
+                           { EFL_NET_DIALER_EVENT_DIALER_ERROR, _error },
                            { EFL_IO_READER_EVENT_EOS, _eos },
                            { EFL_IO_READER_EVENT_CAN_READ_CHANGED, _can_read },
                            { EFL_IO_WRITER_EVENT_CAN_WRITE_CHANGED, _can_write }

src/examples/ecore/efl_net_server_example.c

@@ -450,7 +450,7 @@ _server_serving(void *data EINA_UNUSED, const Efl_Event *event)
 EFL_CALLBACKS_ARRAY_DEFINE(server_cbs,
                            { EFL_NET_SERVER_EVENT_CLIENT_ADD, _server_client_add },
                            { EFL_NET_SERVER_EVENT_CLIENT_REJECTED, _server_client_rejected },
-                           { EFL_NET_SERVER_EVENT_ERROR, _server_error },
+                           { EFL_NET_SERVER_EVENT_SERVER_ERROR, _server_error },
                            { EFL_NET_SERVER_EVENT_SERVING, _server_serving });
 
 static const char * protocols[] = {

src/examples/ecore/efl_net_server_simple_example.c

@@ -254,7 +254,7 @@ _server_serving(void *data EINA_UNUSED, const Efl_Event *event)
 EFL_CALLBACKS_ARRAY_DEFINE(server_cbs,
                            { EFL_NET_SERVER_EVENT_CLIENT_ADD, _server_client_add },
                            { EFL_NET_SERVER_EVENT_CLIENT_REJECTED, _server_client_rejected },
-                           { EFL_NET_SERVER_EVENT_ERROR, _server_error },
+                           { EFL_NET_SERVER_EVENT_SERVER_ERROR, _server_error },
                            { EFL_NET_SERVER_EVENT_SERVING, _server_serving });
 
 static const char * protocols[] = {

src/examples/ecore/efl_net_socket_ssl_dialer_example.c

@@ -177,9 +177,9 @@ _error(void *data EINA_UNUSED, const Efl_Event *event)
 }
 
 EFL_CALLBACKS_ARRAY_DEFINE(dialer_cbs,
-                           { EFL_NET_DIALER_EVENT_CONNECTED, _connected },
+                           { EFL_NET_DIALER_EVENT_DIALER_CONNECTED, _connected },
-                           { EFL_NET_DIALER_EVENT_RESOLVED, _resolved },
+                           { EFL_NET_DIALER_EVENT_DIALER_RESOLVED, _resolved },
-                           { EFL_NET_DIALER_EVENT_ERROR, _error });
+                           { EFL_NET_DIALER_EVENT_DIALER_ERROR, _error });
 
 
 static char *

src/examples/ecore/efl_net_socket_ssl_server_example.c

@@ -153,7 +153,7 @@ _server_serving(void *data EINA_UNUSED, const Efl_Event *event)
 
 EFL_CALLBACKS_ARRAY_DEFINE(server_cbs,
                            { EFL_NET_SERVER_EVENT_CLIENT_ADD, _server_client_add },
-                           { EFL_NET_SERVER_EVENT_ERROR, _server_error },
+                           { EFL_NET_SERVER_EVENT_SERVER_ERROR, _server_error },
                            { EFL_NET_SERVER_EVENT_SERVING, _server_serving });
 
 static const char *ciphers_strs[] = {

src/examples/ecore/efl_thread.c

@@ -53,11 +53,11 @@ _th_read_change(void *data EINA_UNUSED, const Efl_Event *ev)
                   if (!strcmp(s, "one"))
                     efl_add(EFL_LOOP_TIMER_CLASS, obj,
                             efl_loop_timer_interval_set(efl_added, 2.0),
-                            efl_event_callback_add(efl_added, EFL_LOOP_TIMER_EVENT_TICK, _th_timeout, obj));
+                            efl_event_callback_add(efl_added, EFL_LOOP_TIMER_EVENT_TIMER_TICK, _th_timeout, obj));
                   else
                     efl_add(EFL_LOOP_TIMER_CLASS, obj,
                             efl_loop_timer_interval_set(efl_added, 1.0),
-                            efl_event_callback_add(efl_added, EFL_LOOP_TIMER_EVENT_TICK, _th_timeout, obj));
+                            efl_event_callback_add(efl_added, EFL_LOOP_TIMER_EVENT_TIMER_TICK, _th_timeout, obj));
                   eina_accessor_free(args_access);
                }
           }

src/examples/elementary/efl_ui_list_example_1.c

@@ -126,8 +126,8 @@ elm_main(int argc EINA_UNUSED, char **argv)
    priv_d.list = list = efl_add(EFL_UI_LIST_CLASS, wbox);
    efl_gfx_hint_weight_set(list, EFL_GFX_HINT_EXPAND, 0.9);
 
-   efl_event_callback_add(list, EFL_UI_EVENT_SELECTED, _list_selected, NULL);
+   efl_event_callback_add(list, EFL_UI_EVENT_SELECTABLE_SELECTED, _list_selected, NULL);
-   efl_event_callback_add(list, EFL_UI_EVENT_UNSELECTED, _list_unselected, NULL);
+   efl_event_callback_add(list, EFL_UI_EVENT_SELECTABLE_UNSELECTED, _list_unselected, NULL);
    efl_event_callback_add(list, EFL_UI_EVENT_PRESSED, _list_pressed, NULL);
    efl_event_callback_add(list, EFL_UI_EVENT_UNPRESSED, _list_unpressed, NULL);
    efl_event_callback_add(list, EFL_UI_EVENT_LONGPRESSED, _list_longpressed, NULL);

src/examples/eolian_cxx/ns_colourable.eo

@@ -5,7 +5,6 @@ class Ns.Colourable extends Efl.Object
     methods {
         rgb_24bits_constructor {
             [[RGB Constructor.]]
-            legacy: null;
             params {
                 @in rgb: int; [[24-bit RGB Component.]]
             }

src/examples/eolian_cxx/ns_colourablesquare.eo

@@ -14,7 +14,6 @@ class Ns.ColourableSquare extends Ns.Colourable
             }
         }
         size_constructor {
-            legacy: null;
             params {
                 @in size: int;
             }

src/lib/ecore/Ecore.h

@@ -274,7 +274,10 @@
 
 #include <Eina.h>
 #include <Eo.h>
+
+#ifdef EFL_BETA_API_SUPPORT
 #include <Efl.h>
+#endif
 
 #ifdef EAPI
 # undef EAPI

src/lib/ecore/Efl_Core.h

@@ -5,8 +5,9 @@
 
 #include <Eina.h>
 #include <Eo.h>
+#ifdef EFL_BETA_API_SUPPORT
 #include <Efl.h>
-
+#endif
 #ifdef EAPI
 # undef EAPI
 #endif

src/lib/ecore/ecore.c

@@ -321,7 +321,7 @@ ecore_init(void)
            efl_add(EFL_LOOP_TIMER_CLASS, efl_main_loop_get(),
                    efl_loop_timer_interval_set(efl_added, sec / 2),
                    efl_event_callback_add(efl_added,
-                                          EFL_LOOP_TIMER_EVENT_TICK,
+                                          EFL_LOOP_TIMER_EVENT_TIMER_TICK,
                                           _systemd_watchdog_cb, NULL));
         unsetenv("WATCHDOG_USEC");
 

src/lib/ecore/ecore_exe_posix.c

@@ -858,7 +858,7 @@ _impl_ecore_exe_kill(Ecore_Exe *obj EINA_UNUSED, Ecore_Exe_Data *exe)
    efl_del(exe->doomsday_clock);
    exe->doomsday_clock = efl_add(EFL_LOOP_TIMER_CLASS, obj,
                                  efl_event_callback_add(efl_added,
-                                                        EFL_LOOP_TIMER_EVENT_TICK,
+                                                        EFL_LOOP_TIMER_EVENT_TIMER_TICK,
                                                         _ecore_exe_make_sure_its_really_dead,
                                                         obj),
                                  efl_loop_timer_interval_set(efl_added, 10.0));
@@ -896,7 +896,7 @@ _ecore_exe_make_sure_its_dead(void *data, const Efl_Event *event)
           INF("Sending KILL signal to allegedly dead PID %d.", exe->pid);
         exe->doomsday_clock = efl_add(EFL_LOOP_TIMER_CLASS, exe_obj,
                                       efl_event_callback_add(efl_added,
-                                                             EFL_LOOP_TIMER_EVENT_TICK,
+                                                             EFL_LOOP_TIMER_EVENT_TIMER_TICK,
                                                              _ecore_exe_make_sure_its_really_dead,
                                                              exe_obj),
                                       efl_loop_timer_interval_set(efl_added, 10.0));
@@ -1295,7 +1295,7 @@ _ecore_exe_dead_attach(Ecore_Exe *obj)
    if (exe->doomsday_clock) return;
    exe->doomsday_clock = efl_add(EFL_LOOP_TIMER_CLASS, obj,
                                  efl_event_callback_add(efl_added,
-                                                        EFL_LOOP_TIMER_EVENT_TICK,
+                                                        EFL_LOOP_TIMER_EVENT_TIMER_TICK,
                                                         _ecore_exe_make_sure_its_dead,
                                                         obj),
                                  efl_loop_timer_interval_set(efl_added, 10.0));

src/lib/ecore/ecore_signal.c

@@ -447,7 +447,7 @@ _ecore_signal_waitpid(Eina_Bool once, siginfo_t info)
                     efl_add(EFL_LOOP_TIMER_CLASS, ML_OBJ,
                             efl_loop_timer_interval_set(efl_added, 0.1),
                             efl_event_callback_add
-                            (efl_added, EFL_LOOP_TIMER_EVENT_TICK,
+                            (efl_added, EFL_LOOP_TIMER_EVENT_TIMER_TICK,
                              _ecore_signal_exe_exit_delay, e));
                   _ecore_exe_doomsday_clock_set(e->exe, doomsday_clock);
                }

src/lib/ecore/ecore_timer.c

@@ -79,7 +79,7 @@ _check_timer_event_catcher_add(void *data, const Efl_Event *event)
 
    for (i = 0; array[i].desc != NULL; i++)
      {
-        if (array[i].desc == EFL_LOOP_TIMER_EVENT_TICK)
+        if (array[i].desc == EFL_LOOP_TIMER_EVENT_TIMER_TICK)
           {
              if (timer->listening++ > 0) return;
              _efl_loop_timer_util_instanciate(timer->loop_data, timer);
@@ -99,7 +99,7 @@ _check_timer_event_catcher_del(void *data, const Efl_Event *event)
 
    for (i = 0; array[i].desc != NULL; i++)
      {
-        if (array[i].desc == EFL_LOOP_TIMER_EVENT_TICK)
+        if (array[i].desc == EFL_LOOP_TIMER_EVENT_TIMER_TICK)
           {
              if ((--timer->listening) > 0) return;
              _efl_loop_timer_util_instanciate(timer->loop_data, timer);
@@ -164,7 +164,7 @@ _ecore_timer_legacy_tick(void *data, const Efl_Event *event)
 }
 
 EFL_CALLBACKS_ARRAY_DEFINE(legacy_timer,
-                          { EFL_LOOP_TIMER_EVENT_TICK, _ecore_timer_legacy_tick },
+                          { EFL_LOOP_TIMER_EVENT_TIMER_TICK, _ecore_timer_legacy_tick },
                           { EFL_EVENT_DEL, _ecore_timer_legacy_del });
 
 EAPI Ecore_Timer *
@@ -240,26 +240,26 @@ ecore_timer_del(Ecore_Timer *timer)
 }
 
 EOLIAN static void
-_efl_loop_timer_interval_set(Eo *obj EINA_UNUSED, Efl_Loop_Timer_Data *timer, double in)
+_efl_loop_timer_timer_interval_set(Eo *obj EINA_UNUSED, Efl_Loop_Timer_Data *timer, double in)
 {
    if (in < 0.0) in = 0.0;
    timer->in = in;
 }
 
 EOLIAN static double
-_efl_loop_timer_interval_get(const Eo *obj EINA_UNUSED, Efl_Loop_Timer_Data *timer)
+_efl_loop_timer_timer_interval_get(const Eo *obj EINA_UNUSED, Efl_Loop_Timer_Data *timer)
 {
    return timer->in;
 }
 
 EOLIAN static void
-_efl_loop_timer_delay(Eo *obj EINA_UNUSED, Efl_Loop_Timer_Data *pd, double add)
+_efl_loop_timer_timer_delay(Eo *obj EINA_UNUSED, Efl_Loop_Timer_Data *pd, double add)
 {
    _efl_loop_timer_util_delay(pd, add);
 }
 
 EOLIAN static void
-_efl_loop_timer_reset(Eo *obj EINA_UNUSED, Efl_Loop_Timer_Data *timer)
+_efl_loop_timer_timer_reset(Eo *obj EINA_UNUSED, Efl_Loop_Timer_Data *timer)
 {
    double now, add;
 
@@ -280,7 +280,7 @@ _efl_loop_timer_reset(Eo *obj EINA_UNUSED, Efl_Loop_Timer_Data *timer)
 }
 
 EOLIAN static void
-_efl_loop_timer_loop_reset(Eo *obj EINA_UNUSED, Efl_Loop_Timer_Data *timer)
+_efl_loop_timer_timer_loop_reset(Eo *obj EINA_UNUSED, Efl_Loop_Timer_Data *timer)
 {
    double now, add;
 
@@ -301,7 +301,7 @@ _efl_loop_timer_loop_reset(Eo *obj EINA_UNUSED, Efl_Loop_Timer_Data *timer)
 }
 
 EOLIAN static double
-_efl_loop_timer_pending_get(const Eo *obj EINA_UNUSED, Efl_Loop_Timer_Data *timer)
+_efl_loop_timer_time_pending_get(const Eo *obj EINA_UNUSED, Efl_Loop_Timer_Data *timer)
 {
    double now, ret = 0.0;
 
@@ -639,7 +639,7 @@ _efl_loop_timer_expired_call(Eo *obj EINA_UNUSED, Efl_Loop_Data *pd, double when
 
         efl_ref(timer->object);
         eina_evlog("+timer", timer, 0.0, NULL);
-        efl_event_callback_call(timer->object, EFL_LOOP_TIMER_EVENT_TICK, NULL);
+        efl_event_callback_call(timer->object, EFL_LOOP_TIMER_EVENT_TIMER_TICK, NULL);
         eina_evlog("-timer", timer, 0.0, NULL);
 
         // may have changed in recursive main loops

src/lib/ecore/efl_exe.eo

@@ -1,4 +1,4 @@
-enum Efl.Exe_Signal {
+enum @beta Efl.Exe_Signal {
    [[ ]]
    int,
    quit,
@@ -11,7 +11,7 @@ enum Efl.Exe_Signal {
    usr2
 }
 
-enum Efl.Exe_Flags {
+enum @beta Efl.Exe_Flags {
    [[ ]]
    none             = 0,
    group_leader     = 1,

src/lib/ecore/efl_loop.c

@@ -192,7 +192,7 @@ _check_event_catcher_add(void *data, const Efl_Event *event)
                   pd->poll_high = efl_add
                     (EFL_LOOP_TIMER_CLASS, event->object,
                      efl_event_callback_add(efl_added,
-                                            EFL_LOOP_TIMER_EVENT_TICK,
+                                            EFL_LOOP_TIMER_EVENT_TIMER_TICK,
                                             _poll_trigger,
                                             EFL_LOOP_EVENT_POLL_HIGH),
                      efl_loop_timer_interval_set(efl_added, 1.0 / 60.0));
@@ -206,7 +206,7 @@ _check_event_catcher_add(void *data, const Efl_Event *event)
                   pd->poll_medium = efl_add
                     (EFL_LOOP_TIMER_CLASS, event->object,
                      efl_event_callback_add(efl_added,
-                                            EFL_LOOP_TIMER_EVENT_TICK,
+                                            EFL_LOOP_TIMER_EVENT_TIMER_TICK,
                                             _poll_trigger,
                                             EFL_LOOP_EVENT_POLL_MEDIUM),
                      efl_loop_timer_interval_set(efl_added, 6));
@@ -220,7 +220,7 @@ _check_event_catcher_add(void *data, const Efl_Event *event)
                   pd->poll_low = efl_add
                     (EFL_LOOP_TIMER_CLASS, event->object,
                      efl_event_callback_add(efl_added,
-                                            EFL_LOOP_TIMER_EVENT_TICK,
+                                            EFL_LOOP_TIMER_EVENT_TIMER_TICK,
                                             _poll_trigger,
                                             EFL_LOOP_EVENT_POLL_LOW),
                      efl_loop_timer_interval_set(efl_added, 66));
@@ -493,7 +493,7 @@ _efl_loop_timeout(Eo *obj, Efl_Loop_Data *pd EINA_UNUSED, double tim)
    d->timer = efl_add(EFL_LOOP_TIMER_CLASS, obj,
                       efl_loop_timer_interval_set(efl_added, tim),
                       efl_event_callback_add(efl_added,
-                                             EFL_LOOP_TIMER_EVENT_TICK,
+                                             EFL_LOOP_TIMER_EVENT_TIMER_TICK,
                                              _efl_loop_timeout_done, d),
                       efl_event_callback_add(efl_added,
                                              EFL_EVENT_DEL,

src/lib/ecore/efl_loop_handler.eo

@@ -1,4 +1,4 @@
-enum Efl.Loop_Handler_Flags {
+enum @beta Efl.Loop_Handler_Flags {
    [[ A set of flags that can be OR'd together to indicate which are
    desired ]]
    none = 0, [[ No I/O is desired (generally useless) ]]

src/lib/ecore/efl_loop_timer.eo

@@ -10,7 +10,7 @@ class @beta Efl.Loop_Timer extends Efl.Loop_Consumer
      The @Efl.Object.event_freeze and @Efl.Object.event_thaw calls are used to pause and unpause the timer.
    ]]
    methods {
-      @property interval {
+      @property timer_interval {
          [[Interval the timer ticks on.]]
          set {
             [[If set during a timer call this will affect the next interval.]]
@@ -21,13 +21,13 @@ class @beta Efl.Loop_Timer extends Efl.Loop_Consumer
             in: double(-1.0); [[The new interval in seconds]]
          }
       }
-      @property pending {
+      @property time_pending {
          [[Pending time regarding a timer.]]
          get {
             return: double; [[Pending time]]
          }
       }
-      reset {
+      timer_reset {
           [[Resets a timer to its full interval. This effectively makes the
             timer start ticking off from zero now.
 
@@ -36,12 +36,12 @@ class @beta Efl.Loop_Timer extends Efl.Loop_Consumer
             @since 1.2
           ]]
       }
-      loop_reset {
+      timer_loop_reset {
          [[This effectively resets a timer but based on the time when this iteration of the main loop started.
            @since 1.18
     ]]
       }
-      delay {
+      timer_delay {
          [[Adds a delay to the next occurrence of a timer.
            This doesn't affect the timer interval.
          ]]
@@ -51,10 +51,10 @@ class @beta Efl.Loop_Timer extends Efl.Loop_Consumer
       }
    }
    events {
-      tick: void; [[Event triggered when the specified time as passed.]]
+      timer,tick: void; [[Event triggered when the specified time as passed.]]
    }
    constructors {
-      .interval;
+      .timer_interval;
    }
    implements {
       Efl.Object.constructor;

src/lib/ecore/efl_loop_timer_eo.legacy.c

@@ -14,7 +14,7 @@ ecore_timer_interval_get(const Efl_Loop_Timer *obj)
 EAPI double
 ecore_timer_pending_get(const Efl_Loop_Timer *obj)
 {
-   return efl_loop_timer_pending_get(obj);
+   return efl_loop_timer_time_pending_get(obj);
 }
 
 EAPI void

src/lib/ecore/efl_threadio.eo

@@ -1,13 +1,13 @@
 import efl_object;
 
-function EFlThreadIOCall {
+function @beta EFlThreadIOCall {
    [[ A Function to call on the "other end" of a thread obvject ]]
    params {
       @cref event: Efl.Event; [[ ]]
    }
 };
 
-function EFlThreadIOCallSync {
+function @beta EFlThreadIOCallSync {
    [[ A Function to call on the "other end" of a thread obvject ]]
    params {
       @cref event: Efl.Event; [[ ]]

src/lib/ecore/efl_view_model.c

@@ -304,7 +304,7 @@ _efl_view_model_property_changed(void *data, const Efl_Event *event)
 
         eina_array_push(nev.changed_properties, property);
 
-        src = eina_stringshare_add(property);
+        src = eina_stringshare_ref(property);
         bind = _efl_view_model_property_bind_lookup(pd, src);
         if (bind)
           {

src/lib/ecore/efl_view_model.eo

@@ -1,4 +1,4 @@
-function EflViewModelPropertyGet {
+function @beta EflViewModelPropertyGet {
    [[Function called when a property is get.]]
    params {
       @in view_model: const(Efl.View_Model); [[The ViewModel object the @.property.get is issued on.]]
@@ -7,7 +7,7 @@ function EflViewModelPropertyGet {
    return: any_value_ptr; [[The property value.]]
 };
 
-function EflViewModelPropertySet {
+function @beta EflViewModelPropertySet {
    [[Function called when a property is set.]]
    params {
       @in view_model: Efl.View_Model; [[The ViewModel object the @.property.set is issued on.]]

src/lib/ecore_audio/ecore_audio.eo

@@ -1,7 +1,7 @@
 type @extern Ecore.Audio.Vio: __undefined_type; [[Ecore audio vio type]] /* FIXME: Had function pointer members. */
 type @extern efl_key_data_free_func: __undefined_type; [[Efl key data free function type]] /* FIXME: Function pointers not allowed. */
 
-enum Ecore.Audio.Format {
+enum @beta Ecore.Audio.Format {
     [[Ecore audio format type]]
     auto, [[Automatically detect the format (for inputs)]]
     raw, [[RAW samples (float)]]

src/lib/ecore_con/ecore_con_legacy.c

@@ -1420,9 +1420,9 @@ EFL_CALLBACKS_ARRAY_DEFINE(_ecore_con_server_dialer_cbs,
                            { EFL_IO_BUFFERED_STREAM_EVENT_READ_FINISHED, _ecore_con_server_dialer_read_finished },
                            { EFL_IO_BUFFERED_STREAM_EVENT_FINISHED, _ecore_con_server_dialer_finished },
                            { EFL_IO_BUFFERED_STREAM_EVENT_ERROR, _ecore_con_server_dialer_error },
-                           { EFL_NET_DIALER_EVENT_ERROR, _ecore_con_server_dialer_error },
+                           { EFL_NET_DIALER_EVENT_DIALER_ERROR, _ecore_con_server_dialer_error },
-                           { EFL_NET_DIALER_EVENT_RESOLVED, _ecore_con_server_dialer_resolved },
+                           { EFL_NET_DIALER_EVENT_DIALER_RESOLVED, _ecore_con_server_dialer_resolved },
-                           { EFL_NET_DIALER_EVENT_CONNECTED, _ecore_con_server_dialer_connected });
+                           { EFL_NET_DIALER_EVENT_DIALER_CONNECTED, _ecore_con_server_dialer_connected });
 
 static void
 _ecore_con_server_server_client_add(void *data, const Efl_Event *event)
@@ -1495,7 +1495,7 @@ _ecore_con_server_server_error(void *data, const Efl_Event *event)
 EFL_CALLBACKS_ARRAY_DEFINE(_ecore_con_server_server_cbs,
                            { EFL_NET_SERVER_EVENT_CLIENT_ADD, _ecore_con_server_server_client_add },
                            { EFL_NET_SERVER_EVENT_SERVING, _ecore_con_server_server_serving },
-                           { EFL_NET_SERVER_EVENT_ERROR, _ecore_con_server_server_error });
+                           { EFL_NET_SERVER_EVENT_SERVER_ERROR, _ecore_con_server_server_error });
 
 /**
  * @addtogroup Ecore_Con_Server_Group Ecore Connection Server Functions

src/lib/ecore_con/ecore_con_url.c

@@ -508,7 +508,7 @@ _ecore_con_url_dialer_headers_done(void *data, const Efl_Event *event EINA_UNUSE
 EFL_CALLBACKS_ARRAY_DEFINE(ecore_con_url_dialer_cbs,
                            { EFL_IO_READER_EVENT_CAN_READ_CHANGED, _ecore_con_url_dialer_can_read_changed },
                            { EFL_IO_READER_EVENT_EOS, _ecore_con_url_dialer_eos },
-                           { EFL_NET_DIALER_EVENT_ERROR, _ecore_con_url_dialer_error },
+                           { EFL_NET_DIALER_EVENT_DIALER_ERROR, _ecore_con_url_dialer_error },
                            { EFL_NET_DIALER_HTTP_EVENT_HEADERS_DONE, _ecore_con_url_dialer_headers_done });
 
 static Eina_Bool

src/lib/ecore_con/efl_net_control_access_point.eo

@@ -1,4 +1,4 @@
-enum Efl.Net.Control.Access_Point_State {
+enum @beta Efl.Net.Control.Access_Point_State {
     [[Provides the access point state.
 
       @since 1.19
@@ -12,7 +12,7 @@ enum Efl.Net.Control.Access_Point_State {
     failure, [[The connection attempt failed, @Efl.Net.Control.Access_Point.error will provide more details]]
 }
 
-enum Efl.Net.Control.Access_Point_Error {
+enum @beta Efl.Net.Control.Access_Point_Error {
     [[The reason for the connection error.
 
       @since 1.19
@@ -25,7 +25,7 @@ enum Efl.Net.Control.Access_Point_Error {
     login_failed, [[Login or authentication information was incorrect, agent_request_input event may be emitted.]]
 }
 
-enum Efl.Net.Control.Access_Point_Security {
+enum @beta Efl.Net.Control.Access_Point_Security {
     [[Bitwise-able securities supported by an access point.
 
       @since 1.19
@@ -37,7 +37,7 @@ enum Efl.Net.Control.Access_Point_Security {
     ieee802_1x = (1 << 3), [[IEEE 802.1X]]
 }
 
-enum Efl.Net.Control.Access_Point_Ipv4_Method {
+enum @beta Efl.Net.Control.Access_Point_Ipv4_Method {
     [[The method used to configure IPv4
 
       @since 1.19
@@ -48,7 +48,7 @@ enum Efl.Net.Control.Access_Point_Ipv4_Method {
     unset, [[Only to be used with @Efl.Net.Control.Access_Point.configuration_ipv4]]
 }
 
-enum Efl.Net.Control.Access_Point_Ipv6_Method {
+enum @beta Efl.Net.Control.Access_Point_Ipv6_Method {
     [[The method used to configure IPv6
 
       @since 1.19
@@ -63,7 +63,7 @@ enum Efl.Net.Control.Access_Point_Ipv6_Method {
     unset, [[Only to be used with @Efl.Net.Control.Access_Point.configuration_ipv6]]
 }
 
-enum Efl.Net.Control.Access_Point_Proxy_Method {
+enum @beta Efl.Net.Control.Access_Point_Proxy_Method {
     [[The method used to configure Proxies.
 
       @since 1.19

src/lib/ecore_con/efl_net_control_manager.eo

@@ -2,7 +2,7 @@ import eina_types;
 import efl_net_control_access_point;
 import efl_net_control_technology;
 
-enum Efl.Net.Control.State {
+enum @beta Efl.Net.Control.State {
     [[Provides the global network connectivity state.
 
       For more details, use @Efl.Net.Control.Manager access points and
@@ -15,7 +15,7 @@ enum Efl.Net.Control.State {
     online, [[At least one access point is connected and the internet has been verified]]
 }
 
-enum Efl.Net.Control.Agent_Request_Input_Field {
+enum @beta Efl.Net.Control.Agent_Request_Input_Field {
     [[Bitwise-able fields requested to the agent.
 
       @since 1.19
@@ -27,7 +27,7 @@ enum Efl.Net.Control.Agent_Request_Input_Field {
     wps = (1 << 4), [[Use WPS authentication. If passphrase is present, this is an alternative to that.]]
 }
 
-struct Efl.Net.Control.Agent_Request_Input_Information {
+struct @beta Efl.Net.Control.Agent_Request_Input_Information {
     [[Name-value information pair provided to the agent.
 
       @since 1.19
@@ -36,7 +36,7 @@ struct Efl.Net.Control.Agent_Request_Input_Information {
     value: string; [[The contents of the information]]
 }
 
-struct Efl.Net.Control.Agent_Request_Input {
+struct @beta Efl.Net.Control.Agent_Request_Input {
     [[Requests input to the agent.
 
       @since 1.19
@@ -47,7 +47,7 @@ struct Efl.Net.Control.Agent_Request_Input {
     informational: list<ptr(Efl.Net.Control.Agent_Request_Input_Information)>; [[Such as the previous passphrase, VPN host]]
 }
 
-struct Efl.Net.Control.Agent_Error {
+struct @beta Efl.Net.Control.Agent_Error {
     [[Reports error to the agent.
 
       @since 1.19
@@ -56,7 +56,7 @@ struct Efl.Net.Control.Agent_Error {
     message: string; [[The error message.]]
 }
 
-struct Efl.Net.Control.Agent_Browser_Url {
+struct @beta Efl.Net.Control.Agent_Browser_Url {
     [[Reports to agent that it should open a browser at a given URL.
 
       @since 1.19

src/lib/ecore_con/efl_net_control_technology.eo

@@ -1,4 +1,4 @@
-enum Efl.Net.Control.Technology_Type {
+enum @beta Efl.Net.Control.Technology_Type {
     [[Technology types
 
       @since 1.19

src/lib/ecore_con/efl_net_dialer.eo

@@ -112,7 +112,7 @@ interface @beta Efl.Net.Dialer extends Efl.Net.Socket {
 
     events {
         /* FIXME: Might be NULL, but @nullable does not work on event types */
-        resolved: string; [[Notifies @.address_dial was resolved to
+        dialer,resolved: string; [[Notifies @.address_dial was resolved to
                             @Efl.Net.Socket.address_remote.
 
                             This is emitted before "connected" and may
@@ -124,9 +124,9 @@ interface @beta Efl.Net.Dialer extends Efl.Net.Socket {
                             may be emitted multiple times, such as
                             HTTP.
                           ]]
-        error: Eina.Error; [[Some error happened and the socket
+        dialer,error: Eina.Error; [[Some error happened and the socket
                              stopped working.
                            ]]
-        connected: void; [[Notifies the socket is connected to the remote peer.]]
+        dialer,connected: void; [[Notifies the socket is connected to the remote peer.]]
     }
 }

src/lib/ecore_con/efl_net_dialer_http.c

@@ -318,7 +318,7 @@ _efl_net_dialer_http_curlm_check(Efl_Net_Dialer_Http_Curlm *cm)
         efl_ref(dialer);
         pd = efl_data_scope_get(dialer, MY_CLASS);
         if (pd->error)
-          efl_event_callback_call(dialer, EFL_NET_DIALER_EVENT_ERROR, &pd->error);
+          efl_event_callback_call(dialer, EFL_NET_DIALER_EVENT_DIALER_ERROR, &pd->error);
         if (pd->recv.used > 0) pd->pending_eos = EINA_TRUE;
         else
           {
@@ -369,7 +369,7 @@ _efl_net_dialer_http_curlm_timer_schedule(CURLM *multi EINA_UNUSED, long timeout
      {
         cm->timer = efl_add(EFL_LOOP_TIMER_CLASS, cm->loop,
                             efl_loop_timer_interval_set(efl_added, seconds),
-                            efl_event_callback_add(efl_added, EFL_LOOP_TIMER_EVENT_TICK, _efl_net_dialer_http_curlm_timer_do, cm));
+                            efl_event_callback_add(efl_added, EFL_LOOP_TIMER_EVENT_TIMER_TICK, _efl_net_dialer_http_curlm_timer_do, cm));
         EINA_SAFETY_ON_NULL_RETURN_VAL(cm->timer, -1);
      }
 
@@ -1460,7 +1460,7 @@ _efl_net_dialer_http_efl_net_dialer_connected_set(Eo *o, Efl_Net_Dialer_Http_Dat
     * allow_redirects will trigger more than once
     */
    pd->connected = connected;
-   if (connected) efl_event_callback_call(o, EFL_NET_DIALER_EVENT_CONNECTED, NULL);
+   if (connected) efl_event_callback_call(o, EFL_NET_DIALER_EVENT_DIALER_CONNECTED, NULL);
 }
 
 EOLIAN static Eina_Bool
@@ -1524,7 +1524,7 @@ EOLIAN static void
 _efl_net_dialer_http_efl_net_socket_address_remote_set(Eo *o, Efl_Net_Dialer_Http_Data *pd, const char *address)
 {
    if (eina_stringshare_replace(&pd->address_remote, address))
-     efl_event_callback_call(o, EFL_NET_DIALER_EVENT_RESOLVED, NULL);
+     efl_event_callback_call(o, EFL_NET_DIALER_EVENT_DIALER_RESOLVED, NULL);
 }
 
 EOLIAN static const char *

src/lib/ecore_con/efl_net_dialer_http.eo

@@ -1,6 +1,6 @@
 import efl_net_http_types;
 
-enum Efl.Net.Dialer_Http_Primary_Mode {
+enum @beta Efl.Net.Dialer_Http_Primary_Mode {
     [[Primary HTTP mode]]
     auto, [[HTTP auto mode]]
     download, [[HTTP download mode]]

src/lib/ecore_con/efl_net_dialer_simple.c

@@ -33,14 +33,14 @@ static void
 _efl_net_dialer_simple_inner_io_resolved(void *data, const Efl_Event *event)
 {
    Eo *o = data;
-   efl_event_callback_call(o, EFL_NET_DIALER_EVENT_RESOLVED, event->info);
+   efl_event_callback_call(o, EFL_NET_DIALER_EVENT_DIALER_RESOLVED, event->info);
 }
 
 static void
 _efl_net_dialer_simple_inner_io_error(void *data, const Efl_Event *event)
 {
    Eo *o = data;
-   efl_event_callback_call(o, EFL_NET_DIALER_EVENT_ERROR, event->info);
+   efl_event_callback_call(o, EFL_NET_DIALER_EVENT_DIALER_ERROR, event->info);
 }
 
 static void
@@ -48,13 +48,13 @@ _efl_net_dialer_simple_inner_io_connected(void *data, const Efl_Event *event)
 {
    Eo *o = data;
 
-   efl_event_callback_call(o, EFL_NET_DIALER_EVENT_CONNECTED, event->info);
+   efl_event_callback_call(o, EFL_NET_DIALER_EVENT_DIALER_CONNECTED, event->info);
 }
 
 EFL_CALLBACKS_ARRAY_DEFINE(_efl_net_dialer_simple_inner_io_cbs,
-                           { EFL_NET_DIALER_EVENT_RESOLVED, _efl_net_dialer_simple_inner_io_resolved },
+                           { EFL_NET_DIALER_EVENT_DIALER_RESOLVED, _efl_net_dialer_simple_inner_io_resolved },
-                           { EFL_NET_DIALER_EVENT_ERROR, _efl_net_dialer_simple_inner_io_error },
+                           { EFL_NET_DIALER_EVENT_DIALER_ERROR, _efl_net_dialer_simple_inner_io_error },
-                           { EFL_NET_DIALER_EVENT_CONNECTED, _efl_net_dialer_simple_inner_io_connected });
+                           { EFL_NET_DIALER_EVENT_DIALER_CONNECTED, _efl_net_dialer_simple_inner_io_connected });
 
 EOLIAN static Efl_Object *
 _efl_net_dialer_simple_efl_object_finalize(Eo *o, Efl_Net_Dialer_Simple_Data *pd)

src/lib/ecore_con/efl_net_dialer_ssl.c

@@ -50,7 +50,7 @@ _efl_net_dialer_ssl_error(void *data EINA_UNUSED, const Efl_Event *event)
 {
    Eo *o = event->object;
    Eina_Error *perr = event->info;
-   efl_event_callback_call(o, EFL_NET_DIALER_EVENT_ERROR, perr);
+   efl_event_callback_call(o, EFL_NET_DIALER_EVENT_DIALER_ERROR, perr);
 }
 
 EFL_CALLBACKS_ARRAY_DEFINE(_efl_net_dialer_ssl_cbs,
@@ -134,7 +134,7 @@ _efl_net_dialer_ssl_connect_timeout(Eo *o, void *data EINA_UNUSED, const Eina_Va
 
    efl_ref(o);
    efl_io_reader_eos_set(o, EINA_TRUE);
-   efl_event_callback_call(o, EFL_NET_DIALER_EVENT_ERROR, &err);
+   efl_event_callback_call(o, EFL_NET_DIALER_EVENT_DIALER_ERROR, &err);
    efl_unref(o);
    return v;
 }
@@ -205,7 +205,7 @@ _efl_net_dialer_ssl_efl_net_dialer_connected_set(Eo *o, Efl_Net_Dialer_Ssl_Data
      eina_future_cancel(pd->connect_timeout);
    if (pd->connected == connected) return;
    pd->connected = connected;
-   if (connected) efl_event_callback_call(o, EFL_NET_DIALER_EVENT_CONNECTED, NULL);
+   if (connected) efl_event_callback_call(o, EFL_NET_DIALER_EVENT_DIALER_CONNECTED, NULL);
 }
 
 EOLIAN static Eina_Bool

src/lib/ecore_con/efl_net_dialer_tcp.c

@@ -99,7 +99,7 @@ _efl_net_dialer_tcp_connect_timeout(Eo *o, void *data EINA_UNUSED, const Eina_Va
 
    efl_ref(o);
    efl_io_reader_eos_set(o, EINA_TRUE);
-   efl_event_callback_call(o, EFL_NET_DIALER_EVENT_ERROR, &err);
+   efl_event_callback_call(o, EFL_NET_DIALER_EVENT_DIALER_ERROR, &err);
    efl_unref(o);
    return v;
 }
@@ -128,7 +128,7 @@ _efl_net_dialer_tcp_connected(void *data, const struct sockaddr *addr, socklen_t
    efl_loop_fd_set(o, sockfd);
    if (efl_net_socket_address_remote_get(o))
      {
-        efl_event_callback_call(o, EFL_NET_DIALER_EVENT_RESOLVED, NULL);
+        efl_event_callback_call(o, EFL_NET_DIALER_EVENT_DIALER_RESOLVED, NULL);
         efl_net_dialer_connected_set(o, EINA_TRUE);
      }
    else
@@ -148,11 +148,11 @@ _efl_net_dialer_tcp_connected(void *data, const struct sockaddr *addr, socklen_t
              if (efl_net_ip_port_fmt(buf, sizeof(buf), addr))
                {
                   efl_net_socket_address_remote_set(o, buf);
-                  efl_event_callback_call(o, EFL_NET_DIALER_EVENT_RESOLVED, NULL);
+                  efl_event_callback_call(o, EFL_NET_DIALER_EVENT_DIALER_RESOLVED, NULL);
                }
           }
         efl_io_reader_eos_set(o, EINA_TRUE);
-        efl_event_callback_call(o, EFL_NET_DIALER_EVENT_ERROR, &err);
+        efl_event_callback_call(o, EFL_NET_DIALER_EVENT_DIALER_ERROR, &err);
      }
 
    efl_unref(o);
@@ -245,7 +245,7 @@ _efl_net_dialer_tcp_efl_net_dialer_connected_set(Eo *o, Efl_Net_Dialer_Tcp_Data
    if (!connected) _efl_net_dialer_tcp_async_stop(pd);
    if (pd->connected == connected) return;
    pd->connected = connected;
-   if (connected) efl_event_callback_call(o, EFL_NET_DIALER_EVENT_CONNECTED, NULL);
+   if (connected) efl_event_callback_call(o, EFL_NET_DIALER_EVENT_DIALER_CONNECTED, NULL);
 }
 
 EOLIAN static Eina_Bool

src/lib/ecore_con/efl_net_dialer_udp.c

@@ -95,7 +95,7 @@ _efl_net_dialer_udp_resolver_timeout(Eo *o, void *data EINA_UNUSED, const Eina_V
 
    efl_ref(o);
    efl_io_reader_eos_set(o, EINA_TRUE);
-   efl_event_callback_call(o, EFL_NET_DIALER_EVENT_ERROR, &err);
+   efl_event_callback_call(o, EFL_NET_DIALER_EVENT_DIALER_ERROR, &err);
    efl_unref(o);
    return v;
 }
@@ -184,7 +184,7 @@ _efl_net_dialer_udp_resolved_bind(Eo *o, Efl_Net_Dialer_Udp_Data *pd EINA_UNUSED
    if (remote_address)
      {
         efl_net_socket_udp_init(o, remote_address);
-        efl_event_callback_call(o, EFL_NET_DIALER_EVENT_RESOLVED, NULL);
+        efl_event_callback_call(o, EFL_NET_DIALER_EVENT_DIALER_RESOLVED, NULL);
         efl_del(remote_address);
      }
    efl_net_dialer_connected_set(o, EINA_TRUE);
@@ -230,12 +230,12 @@ _efl_net_dialer_udp_resolved(void *data, const char *host EINA_UNUSED, const cha
              if (efl_net_ip_port_fmt(buf, sizeof(buf), result->ai_addr))
                {
                   efl_net_socket_address_remote_set(o, buf);
-                  efl_event_callback_call(o, EFL_NET_DIALER_EVENT_RESOLVED, NULL);
+                  efl_event_callback_call(o, EFL_NET_DIALER_EVENT_DIALER_RESOLVED, NULL);
                }
           }
 
         efl_io_reader_eos_set(o, EINA_TRUE);
-        efl_event_callback_call(o, EFL_NET_DIALER_EVENT_ERROR, &err);
+        efl_event_callback_call(o, EFL_NET_DIALER_EVENT_DIALER_ERROR, &err);
      }
    freeaddrinfo(result);
 
@@ -319,7 +319,7 @@ _efl_net_dialer_udp_efl_net_dialer_connected_set(Eo *o, Efl_Net_Dialer_Udp_Data
    if (pd->resolver.timeout) eina_future_cancel(pd->resolver.timeout);
    if (pd->connected == connected) return;
    pd->connected = connected;
-   if (connected) efl_event_callback_call(o, EFL_NET_DIALER_EVENT_CONNECTED, NULL);
+   if (connected) efl_event_callback_call(o, EFL_NET_DIALER_EVENT_DIALER_CONNECTED, NULL);
 }
 
 EOLIAN static Eina_Bool

src/lib/ecore_con/efl_net_dialer_unix.c

@@ -84,7 +84,7 @@ _efl_net_dialer_unix_connect_timeout(Eo *o, void *data EINA_UNUSED, const Eina_V
 
    efl_ref(o);
    efl_io_reader_eos_set(o, EINA_TRUE);
-   efl_event_callback_call(o, EFL_NET_DIALER_EVENT_ERROR, &err);
+   efl_event_callback_call(o, EFL_NET_DIALER_EVENT_DIALER_ERROR, &err);
    efl_unref(o);
    return v;
 }
@@ -105,7 +105,7 @@ _efl_net_dialer_unix_connected(void *data, const struct sockaddr *addr, socklen_
    efl_loop_fd_set(o, sockfd);
    if (efl_net_socket_address_remote_get(o))
      {
-        efl_event_callback_call(o, EFL_NET_DIALER_EVENT_RESOLVED, NULL);
+        efl_event_callback_call(o, EFL_NET_DIALER_EVENT_DIALER_RESOLVED, NULL);
         efl_net_dialer_connected_set(o, EINA_TRUE);
      }
    else
@@ -120,7 +120,7 @@ _efl_net_dialer_unix_connected(void *data, const struct sockaddr *addr, socklen_
    if (err)
      {
         efl_io_reader_eos_set(o, EINA_TRUE);
-        efl_event_callback_call(o, EFL_NET_DIALER_EVENT_ERROR, &err);
+        efl_event_callback_call(o, EFL_NET_DIALER_EVENT_DIALER_ERROR, &err);
      }
 
    efl_unref(o);
@@ -222,7 +222,7 @@ _efl_net_dialer_unix_efl_net_dialer_connected_set(Eo *o, Efl_Net_Dialer_Unix_Dat
    if (pd->connect.timeout) eina_future_cancel(pd->connect.timeout);
    if (pd->connected == connected) return;
    pd->connected = connected;
-   if (connected) efl_event_callback_call(o, EFL_NET_DIALER_EVENT_CONNECTED, NULL);
+   if (connected) efl_event_callback_call(o, EFL_NET_DIALER_EVENT_DIALER_CONNECTED, NULL);
 }
 
 EOLIAN static Eina_Bool

src/lib/ecore_con/efl_net_dialer_websocket.c

@@ -350,7 +350,7 @@ _efl_net_dialer_websocket_job_send(Eo *o, Efl_Net_Dialer_Websocket_Data *pd)
    if ((err) && (err != EAGAIN))
      {
         ERR("could not write to HTTP socket #%d '%s'", err, eina_error_msg_get(err));
-        efl_event_callback_call(o, EFL_NET_DIALER_EVENT_ERROR, &err);
+        efl_event_callback_call(o, EFL_NET_DIALER_EVENT_DIALER_ERROR, &err);
      }
 }
 
@@ -730,7 +730,7 @@ _efl_net_dialer_websocket_job_receive(Eo *o, Efl_Net_Dialer_Websocket_Data *pd)
        eina_error_msg_get(err));
    efl_ref(o);
    efl_io_closer_close(pd->http);
-   efl_event_callback_call(o, EFL_NET_DIALER_EVENT_ERROR, &err);
+   efl_event_callback_call(o, EFL_NET_DIALER_EVENT_DIALER_ERROR, &err);
    efl_unref(o);
 }
 
@@ -819,7 +819,7 @@ _efl_net_dialer_websocket_http_error(void *data, const Efl_Event *event)
      return;
    efl_ref(o);
    if (!efl_io_closer_closed_get(o)) efl_io_closer_close(o);
-   efl_event_callback_call(o, EFL_NET_DIALER_EVENT_ERROR, perr);
+   efl_event_callback_call(o, EFL_NET_DIALER_EVENT_DIALER_ERROR, perr);
    efl_unref(o);
 }
 
@@ -846,7 +846,7 @@ _efl_net_dialer_websocket_http_headers_done(void *data, const Efl_Event *event E
             status, EFL_NET_HTTP_STATUS_SWITCHING_PROTOCOLS);
         efl_ref(o);
         efl_io_closer_close(pd->http);
-        efl_event_callback_call(o, EFL_NET_DIALER_EVENT_ERROR, &err);
+        efl_event_callback_call(o, EFL_NET_DIALER_EVENT_DIALER_ERROR, &err);
         efl_unref(o);
         return;
      }
@@ -887,7 +887,7 @@ _efl_net_dialer_websocket_http_headers_done(void *data, const Efl_Event *event E
             upgraded, connection_websocket, accepted);
         efl_ref(o);
         efl_io_closer_close(pd->http);
-        efl_event_callback_call(o, EFL_NET_DIALER_EVENT_ERROR, &err);
+        efl_event_callback_call(o, EFL_NET_DIALER_EVENT_DIALER_ERROR, &err);
         efl_unref(o);
         return;
      }
@@ -934,7 +934,7 @@ EFL_CALLBACKS_ARRAY_DEFINE(_efl_net_dialer_websocket_http_cbs,
                            {EFL_IO_READER_EVENT_CAN_READ_CHANGED, _efl_net_dialer_websocket_http_can_read_changed},
                            {EFL_IO_WRITER_EVENT_CAN_WRITE_CHANGED, _efl_net_dialer_websocket_http_can_write_changed},
                            {EFL_IO_CLOSER_EVENT_CLOSED, _efl_net_dialer_websocket_http_closed},
-                           {EFL_NET_DIALER_EVENT_ERROR, _efl_net_dialer_websocket_http_error},
+                           {EFL_NET_DIALER_EVENT_DIALER_ERROR, _efl_net_dialer_websocket_http_error},
                            {EFL_NET_DIALER_HTTP_EVENT_HEADERS_DONE, _efl_net_dialer_websocket_http_headers_done});
 
 EOLIAN static Efl_Object *
@@ -1182,7 +1182,7 @@ _efl_net_dialer_websocket_efl_net_dialer_connected_set(Eo *o, Efl_Net_Dialer_Web
    if (pd->connected == connected) return;
    pd->connected = connected;
    if (connected)
-     efl_event_callback_call(o, EFL_NET_DIALER_EVENT_CONNECTED, NULL);
+     efl_event_callback_call(o, EFL_NET_DIALER_EVENT_DIALER_CONNECTED, NULL);
 }
 
 EOLIAN static Eina_Bool
@@ -1225,7 +1225,7 @@ EOLIAN static void
 _efl_net_dialer_websocket_efl_net_socket_address_remote_set(Eo *o EINA_UNUSED, Efl_Net_Dialer_Websocket_Data *pd, const char *address)
 {
    if (eina_stringshare_replace(&pd->address_remote, address))
-     efl_event_callback_call(o, EFL_NET_DIALER_EVENT_RESOLVED, NULL);
+     efl_event_callback_call(o, EFL_NET_DIALER_EVENT_DIALER_RESOLVED, NULL);
 }
 
 EOLIAN static const char *

src/lib/ecore_con/efl_net_dialer_websocket.eo

@@ -1,7 +1,7 @@
 import eina_types;
 import efl_net_http_types;
 
-enum Efl.Net.Dialer_Websocket_Streaming_Mode {
+enum @beta Efl.Net.Dialer_Websocket_Streaming_Mode {
     [[How to map WebSocket to EFL I/O Interfaces.
 
       @since 1.19
@@ -11,7 +11,7 @@ enum Efl.Net.Dialer_Websocket_Streaming_Mode {
     text, [[@Efl.Io.Writer.write will result in @Efl.Net.Dialer_Websocket.text_send]]
 }
 
-enum Efl.Net.Dialer_Websocket_Close_Reason {
+enum @beta Efl.Net.Dialer_Websocket_Close_Reason {
     [[Registered reasons for the CLOSE (opcode=0x8).
 
       These are the well known reasons, with some ranges being defined
@@ -38,7 +38,7 @@ enum Efl.Net.Dialer_Websocket_Close_Reason {
     private_end = 4999, [[Applications can use range 4000-4999]]
 }
 
-struct Efl.Net.Dialer_Websocket_Closed_Reason {
+struct @beta Efl.Net.Dialer_Websocket_Closed_Reason {
     [[Close reason event payload.
 
       @since 1.19

src/lib/ecore_con/efl_net_dialer_windows.c

@@ -100,7 +100,7 @@ _efl_net_dialer_windows_efl_net_dialer_dial(Eo *o, Efl_Net_Dialer_Windows_Data *
 
    efl_net_socket_address_remote_set(o, sstr);
    efl_net_socket_address_local_set(o, cstr);
-   efl_event_callback_call(o, EFL_NET_DIALER_EVENT_RESOLVED, NULL);
+   efl_event_callback_call(o, EFL_NET_DIALER_EVENT_DIALER_RESOLVED, NULL);
    efl_net_dialer_connected_set(o, EINA_TRUE);
 
    return _efl_net_socket_windows_io_start(o);
@@ -125,7 +125,7 @@ _efl_net_dialer_windows_efl_net_dialer_connected_set(Eo *o, Efl_Net_Dialer_Windo
 {
    if (pd->connected == connected) return;
    pd->connected = connected;
-   if (connected) efl_event_callback_call(o, EFL_NET_DIALER_EVENT_CONNECTED, NULL);
+   if (connected) efl_event_callback_call(o, EFL_NET_DIALER_EVENT_DIALER_CONNECTED, NULL);
 }
 
 EOLIAN static Eina_Bool

src/lib/ecore_con/efl_net_http_types.eot

@@ -1,6 +1,6 @@
 import eina_types;
 
-enum Efl.Net.Http.Version {
+enum @beta Efl.Net.Http.Version {
     [[HTTP protocol versions]]
 
     v1_0 = 100, [[HTTP version 1.0]]
@@ -8,7 +8,7 @@ enum Efl.Net.Http.Version {
     v2_0 = 200, [[HTTP version 2.0]]
 }
 
-enum Efl.Net.Http.Authentication_Method {
+enum @beta Efl.Net.Http.Authentication_Method {
     [[HTTP authentication methods]]
 
     none = 0, [[HTTP authentication method none]]
@@ -21,7 +21,7 @@ enum Efl.Net.Http.Authentication_Method {
     any = Efl.Net.Http.Authentication_Method.any_safe | Efl.Net.Http.Authentication_Method.basic, [[HTTP authentication method any]]
 }
 
-enum Efl.Net.Http.Status {
+enum @beta Efl.Net.Http.Status {
     [[Common HTTP status codes. A more detailed description on the various HTTPS status codes can be
     found one Wikipedia: https://en.wikipedia.org/wiki/List_of_HTTP_status_codes]]
 
@@ -109,7 +109,7 @@ enum Efl.Net.Http.Status {
     network_authentication_required = 511, [[HTTP status code: network authentication required]]
 }
 
-struct Efl.Net.Http.Header {
+struct @beta Efl.Net.Http.Header {
     [[An HTTP Header.
 
       Do not assume strings are Eina_Stringshare and they may be

src/lib/ecore_con/efl_net_ip_address.eo

@@ -1,6 +1,6 @@
 import eina_types;
 
-struct Efl.Net.Ip_Address_Resolve_Results {
+struct @beta Efl.Net.Ip_Address_Resolve_Results {
     [[The results of @Efl.Net.Ip_Address.resolve call.
 
       This structure is created by @Efl.Net.Ip_Address.resolve.

src/lib/ecore_con/efl_net_server.eo

@@ -26,7 +26,7 @@ interface @beta Efl.Net.Server {
                                    excess, see @.clients_limit.
                                  ]]
 
-        error: Eina.Error; [[An error has occurred and the server needs
+        server,error: Eina.Error; [[An error has occurred and the server needs
                              to be stopped.
                            ]]
         serving: void; [[Notifies the server is ready to accept clients.

src/lib/ecore_con/efl_net_server_fd.c

@@ -81,7 +81,7 @@ _efl_net_server_fd_event_error(void *data EINA_UNUSED, const Efl_Event *event)
    Eina_Error err = EBADF;
 
    efl_net_server_serving_set(o, EINA_FALSE);
-   efl_event_callback_call(o, EFL_NET_SERVER_EVENT_ERROR, &err);
+   efl_event_callback_call(o, EFL_NET_SERVER_EVENT_SERVER_ERROR, &err);
 }
 
 EOLIAN static Efl_Object *
@@ -474,7 +474,7 @@ _efl_net_server_fd_process_incoming_data(Eo *o, Efl_Net_Server_Fd_Data *pd)
      {
         Eina_Error err = efl_net_socket_error_get();
         ERR("accept(" SOCKET_FMT "): %s", fd, eina_error_msg_get(err));
-        efl_event_callback_call(o, EFL_NET_SERVER_EVENT_ERROR, &err);
+        efl_event_callback_call(o, EFL_NET_SERVER_EVENT_SERVER_ERROR, &err);
         return;
      }
 

src/lib/ecore_con/efl_net_server_simple.c

@@ -109,7 +109,7 @@ static void
 _efl_net_server_simple_inner_server_error(void *data, const Efl_Event *event)
 {
    Eo *o = data;
-   efl_event_callback_call(o, EFL_NET_SERVER_EVENT_ERROR, event->info);
+   efl_event_callback_call(o, EFL_NET_SERVER_EVENT_SERVER_ERROR, event->info);
 }
 
 static void
@@ -122,7 +122,7 @@ _efl_net_server_simple_inner_server_serving(void *data, const Efl_Event *event)
 EFL_CALLBACKS_ARRAY_DEFINE(_efl_net_server_simple_inner_server_cbs,
                            { EFL_NET_SERVER_EVENT_CLIENT_ADD, _efl_net_server_simple_inner_server_client_add },
                            { EFL_NET_SERVER_EVENT_CLIENT_REJECTED, _efl_net_server_simple_inner_server_client_rejected },
-                           { EFL_NET_SERVER_EVENT_ERROR, _efl_net_server_simple_inner_server_error },
+                           { EFL_NET_SERVER_EVENT_SERVER_ERROR, _efl_net_server_simple_inner_server_error },
                            { EFL_NET_SERVER_EVENT_SERVING, _efl_net_server_simple_inner_server_serving });
 
 EOLIAN static Efl_Object *

src/lib/ecore_con/efl_net_server_tcp.c

@@ -138,7 +138,7 @@ _efl_net_server_tcp_resolved(void *data, const char *host EINA_UNUSED, const cha
    freeaddrinfo(result);
 
  end:
-   if (err) efl_event_callback_call(o, EFL_NET_SERVER_EVENT_ERROR, &err);
+   if (err) efl_event_callback_call(o, EFL_NET_SERVER_EVENT_SERVER_ERROR, &err);
 
    efl_unref(o);
 }

src/lib/ecore_con/efl_net_server_udp.c

@@ -142,7 +142,7 @@ _efl_net_server_udp_resolved_bind(Eo *o, Efl_Net_Server_Udp_Data *pd, const stru
         if (mr)
           {
              ERR("could not join pending multicast group '%s': %s", mcast_addr, eina_error_msg_get(mr));
-             efl_event_callback_call(o, EFL_NET_SERVER_EVENT_ERROR, &mr);
+             efl_event_callback_call(o, EFL_NET_SERVER_EVENT_SERVER_ERROR, &mr);
           }
      }
 
@@ -191,7 +191,7 @@ _efl_net_server_udp_resolved(void *data, const char *host EINA_UNUSED, const cha
    freeaddrinfo(result);
 
  end:
-   if (err) efl_event_callback_call(o, EFL_NET_SERVER_EVENT_ERROR, &err);
+   if (err) efl_event_callback_call(o, EFL_NET_SERVER_EVENT_SERVER_ERROR, &err);
 
    efl_unref(o);
 }
@@ -328,7 +328,7 @@ _efl_net_server_udp_efl_net_server_fd_process_incoming_data(Eo *o, Efl_Net_Serve
         Eina_Error err = efl_net_socket_error_get();
         ERR("recvfrom(" SOCKET_FMT ", %p, %zu, 0, %p, %d): %s", fd, buf, buflen, &addr, addrlen, eina_error_msg_get(err));
         free(buf);
-        efl_event_callback_call(o, EFL_NET_SERVER_EVENT_ERROR, &err);
+        efl_event_callback_call(o, EFL_NET_SERVER_EVENT_SERVER_ERROR, &err);
         return;
      }
    if ((size_t)r < buflen)
@@ -341,7 +341,7 @@ _efl_net_server_udp_efl_net_server_fd_process_incoming_data(Eo *o, Efl_Net_Serve
 
              free(buf);
              ERR("Out of memory on efl net udp data incoming");
-             efl_event_callback_call(o, EFL_NET_SERVER_EVENT_ERROR, &err);
+             efl_event_callback_call(o, EFL_NET_SERVER_EVENT_SERVER_ERROR, &err);
              return;
           }
      }

src/lib/ecore_con/efl_net_server_unix.c

@@ -165,7 +165,7 @@ _efl_net_server_unix_bind(Eo *o, Efl_Net_Server_Unix_Data *pd)
  error:
    if (err)
      {
-        efl_event_callback_call(o, EFL_NET_SERVER_EVENT_ERROR, &err);
+        efl_event_callback_call(o, EFL_NET_SERVER_EVENT_SERVER_ERROR, &err);
         if (fd != INVALID_SOCKET) closesocket(fd);
         efl_loop_fd_set(o, SOCKET_TO_LOOP_FD(INVALID_SOCKET));
      }

src/lib/ecore_con/efl_net_server_windows.c

@@ -151,7 +151,7 @@ _efl_net_server_windows_client_listen_failure(void *data, Eo *client EINA_UNUSED
      }
 
    if (err)
-     efl_event_callback_call(o, EFL_NET_SERVER_EVENT_ERROR, &err);
+     efl_event_callback_call(o, EFL_NET_SERVER_EVENT_SERVER_ERROR, &err);
 
    // TODO: create a new one on failure?
 

src/lib/ecore_con/efl_net_session.eo

@@ -1,4 +1,4 @@
-enum Efl.Net.Session_State {
+enum @beta Efl.Net.Session_State {
     [[Provides the session connectivity state.
 
       @since 1.19
@@ -9,7 +9,7 @@ enum Efl.Net.Session_State {
 }
 
 /* keep in sync with efl_net_control_technology.eo, comment what doesn't make sense */
-enum Efl.Net.Session_Technology {
+enum @beta Efl.Net.Session_Technology {
     [[Bitwise-able technologies to allow for a network session.
 
       @since 1.9

src/lib/ecore_con/efl_net_socket_ssl.c

@@ -225,7 +225,7 @@ efl_net_socket_ssl_sock_resolved(void *data, const Efl_Event *event EINA_UNUSED)
 
    if (pd->torndown) return;
 
-   efl_event_callback_call(o, EFL_NET_DIALER_EVENT_RESOLVED, NULL);
+   efl_event_callback_call(o, EFL_NET_DIALER_EVENT_DIALER_RESOLVED, NULL);
 }
 
 static void
@@ -250,8 +250,8 @@ efl_net_socket_ssl_sock_connected(void *data, const Efl_Event *event EINA_UNUSED
 }
 
 EFL_CALLBACKS_ARRAY_DEFINE(efl_net_socket_ssl_sock_dialer_cbs,
-                           {EFL_NET_DIALER_EVENT_RESOLVED, efl_net_socket_ssl_sock_resolved},
+                           {EFL_NET_DIALER_EVENT_DIALER_RESOLVED, efl_net_socket_ssl_sock_resolved},
-                           {EFL_NET_DIALER_EVENT_CONNECTED, efl_net_socket_ssl_sock_connected});
+                           {EFL_NET_DIALER_EVENT_DIALER_CONNECTED, efl_net_socket_ssl_sock_connected});
 
 static void
 _efl_net_socket_ssl_context_del(void *data, const Efl_Event *event EINA_UNUSED)

src/lib/ecore_con/efl_net_ssl_types.eot

@@ -1,4 +1,4 @@
-enum Efl.Net.Ssl.Verify_Mode {
+enum @beta Efl.Net.Ssl.Verify_Mode {
     [[Defines how remote peers should be verified.
 
       @since 1.19
@@ -8,7 +8,7 @@ enum Efl.Net.Ssl.Verify_Mode {
     required, [[Always verify and fail if certificate wasn't provided]]
 }
 
-enum Efl.Net.Ssl.Cipher {
+enum @beta Efl.Net.Ssl.Cipher {
     [[Defines the SSL/TLS version to use.
 
       Prefer 'auto' or one of the TLS variants.

src/lib/ecore_ipc/ecore_ipc.c

@@ -607,8 +607,8 @@ _ecore_ipc_dialer_connected(void *data, const Efl_Event *event EINA_UNUSED)
 
 EFL_CALLBACKS_ARRAY_DEFINE(_ecore_ipc_dialer_cbs,
                            { EFL_IO_READER_EVENT_EOS, _ecore_ipc_dialer_eos },
-                           { EFL_NET_DIALER_EVENT_ERROR, _ecore_ipc_dialer_error },
+                           { EFL_NET_DIALER_EVENT_DIALER_ERROR, _ecore_ipc_dialer_error },
-                           { EFL_NET_DIALER_EVENT_CONNECTED, _ecore_ipc_dialer_connected });
+                           { EFL_NET_DIALER_EVENT_DIALER_CONNECTED, _ecore_ipc_dialer_connected });
 
 static Eina_Bool ecore_ipc_server_data_process(Ecore_Ipc_Server *svr, void *data, int size, Eina_Bool *stolen);
 

src/lib/ector/Ector.h

@@ -3,8 +3,9 @@
 
 #include <Eina.h>
 #include <Eo.h>
+#ifdef EFL_BETA_API_SUPPORT
 #include <Efl.h>
-
+#endif
 #ifdef EAPI
 # undef EAPI
 #endif

src/lib/ector/ector_buffer.eo

@@ -1,6 +1,6 @@
 import efl_gfx_types;
 
-enum Ector.Buffer.Flag {
+enum @beta Ector.Buffer.Flag {
    [[Buffer capabilities]]
    none              = 0x00, [[Buffer may not have any backing, indicates an invalid buffer.]]
    cpu_readable      = 0x01, [[Can be read from the CPU after map. Reading may still be very slow.]]
@@ -13,7 +13,7 @@ enum Ector.Buffer.Flag {
 /* non_coherent      = 0x80, [[Memory may be mapped but will not be coherent between GPU and CPU. Call flush or invalidate to synchronize it.]] */
 }
 
-enum Ector.Buffer.Access_Flag {
+enum @beta Ector.Buffer.Access_Flag {
    [[Buffer access permissions]]
    none      = 0x0, [[No access permission]]
    read      = 0x1, [[Read access permission]]

src/lib/edje/Edje_Legacy.h

@@ -1533,16 +1533,32 @@ EAPI double edje_object_base_scale_get(const Evas_Object *obj);
  * @{
  */
 
-/** Dragable properties values */
+/**
-typedef Efl_Ui_Drag_Dir Edje_Drag_Dir;
+ * @defgroup Edje_Part_Drag Edje Drag
-/** Not dragable */
+ *
-#define EDJE_DRAG_DIR_NONE EFL_UI_DRAG_DIR_NONE
+ * @brief Functions that deal with dragable parts.
-/** Dragable horizontally */
+ *
-#define EDJE_DRAG_DIR_X     EFL_UI_DRAG_DIR_X
+ * To create a movable part it must be declared as dragable
-/** Dragable verically */
+ * in EDC file. To do so, one must define a "dragable" block inside
-#define EDJE_DRAG_DIR_Y    EFL_UI_DRAG_DIR_Y
+ * the "part" block.
-/** Dragable in both directions */
+ *
-#define EDJE_DRAG_DIR_XY   EFL_UI_DRAG_DIR_XY
+ * These functions are used to set dragging properties to a
+ * part or get dragging information about it.
+ *
+ * @see @ref tutorial_edje_drag
+ *
+ * @ingroup Edje_Object_Part
+ *
+ * @{
+ */
+
+typedef enum _Edje_Drag_Dir
+{
+   EDJE_DRAG_DIR_NONE = 0,
+   EDJE_DRAG_DIR_X = 1,
+   EDJE_DRAG_DIR_Y = 2,
+   EDJE_DRAG_DIR_XY = 3
+} Edje_Drag_Dir;
 
 
 /**

src/lib/edje/edje_entry.c

@@ -2889,9 +2889,9 @@ _edje_entry_init(Edje *ed)
                                   _edje_key_down_cb, ed);
    evas_object_event_callback_add(ed->obj, EVAS_CALLBACK_KEY_UP,
                                   _edje_key_up_cb, ed);
-   efl_event_callback_add(ed->base.evas, EFL_CANVAS_SCENE_EVENT_FOCUS_IN,
+   efl_event_callback_add(ed->base.evas, EFL_CANVAS_SCENE_EVENT_SCENE_FOCUS_IN,
                           _evas_focus_in_cb, ed);
-   efl_event_callback_add(ed->base.evas, EFL_CANVAS_SCENE_EVENT_FOCUS_OUT,
+   efl_event_callback_add(ed->base.evas, EFL_CANVAS_SCENE_EVENT_SCENE_FOCUS_OUT,
                           _evas_focus_out_cb, ed);
 }
 
@@ -2910,9 +2910,9 @@ _edje_entry_shutdown(Edje *ed)
                                   _edje_key_down_cb);
    evas_object_event_callback_del(ed->obj, EVAS_CALLBACK_KEY_UP,
                                   _edje_key_up_cb);
-   efl_event_callback_del(ed->base.evas, EFL_CANVAS_SCENE_EVENT_FOCUS_IN,
+   efl_event_callback_del(ed->base.evas, EFL_CANVAS_SCENE_EVENT_SCENE_FOCUS_IN,
                           _evas_focus_in_cb, ed);
-   efl_event_callback_del(ed->base.evas, EFL_CANVAS_SCENE_EVENT_FOCUS_OUT,
+   efl_event_callback_del(ed->base.evas, EFL_CANVAS_SCENE_EVENT_SCENE_FOCUS_OUT,
                           _evas_focus_out_cb, ed);
 }
 

src/lib/edje/edje_smart.c

@@ -454,7 +454,7 @@ edje_object_file_get(const Edje_Object *obj, const char **file, const char **gro
 }
 
 EOLIAN static void
-_efl_canvas_layout_efl_canvas_object_paragraph_direction_set(Eo *obj, Edje *ed, Evas_BiDi_Direction dir)
+_efl_canvas_layout_efl_canvas_object_paragraph_direction_set(Eo *obj, Edje *ed, Efl_Text_Bidirectional_Type dir)
 {
    efl_canvas_object_paragraph_direction_set(efl_super(obj, MY_CLASS), dir);
 

src/lib/edje/edje_text.c

@@ -499,7 +499,7 @@ arrange_text:
       FLOAT_T align_x;
       if (params->type.text->align.x < FROM_INT(0))
         {
-           if (evas_object_text_direction_get(ep->object) ==
+           if ((Evas_BiDi_Direction)evas_object_text_direction_get(ep->object) ==
                EVAS_BIDI_DIRECTION_RTL)
              {
                 align_x = FROM_INT(1);

src/lib/edje/efl_canvas_layout_part_text.eo

@@ -1,4 +1,4 @@
-enum Efl.Canvas.Layout_Part_Text_Expand
+enum @beta Efl.Canvas.Layout_Part_Text_Expand
 {
    [[Text layout policy to enforce. If none is set, min/max descriptions
      are taken in considerations solely.

src/lib/edje/efl_layout_calc.eo

@@ -1,6 +1,6 @@
 import eina_types;
 
-interface @beta Efl.Layout.Calc
+interface Efl.Layout.Calc
 {
    [[This interface defines a common set of APIs used to trigger calculations
      with layout objects.

src/lib/edje/efl_layout_group.eo

@@ -1,6 +1,6 @@
 import eina_types;
 
-interface @beta Efl.Layout.Group
+interface Efl.Layout.Group
 {
    [[APIs representing static data from a group in an edje file.
 

src/lib/edje/efl_layout_signal.eo

@@ -17,7 +17,7 @@ function EflLayoutSignalCb {
   }
 };
 
-interface @beta Efl.Layout.Signal
+interface Efl.Layout.Signal
 {
    [[Layouts asynchronous messaging and signaling interface.
 

src/lib/efl/interfaces/efl_canvas_pointer.eo

@@ -1,10 +1,11 @@
 import efl_input_device;
 
-interface @beta Efl.Canvas.Pointer
+interface Efl.Canvas.Pointer
 {
    [[Efl Canvas Pointer interface]]
    methods {
-      @property pointer_inside {
+      /* FIXME Efl.Input.Device is not stable yet*/
+      @property pointer_inside @beta {
          get {
             [[Returns whether the mouse pointer is logically inside the
               canvas.

src/lib/efl/interfaces/efl_canvas_scene.eo

@@ -1,7 +1,7 @@
 import efl_input_device;
 import efl_gfx_types;
 
-interface @beta Efl.Canvas.Scene
+interface Efl.Canvas.Scene
 {
    [[Interface containing basic canvas-related methods and events.]]
    methods {
@@ -142,7 +142,8 @@ interface @beta Efl.Canvas.Scene
             ]]
          }
       }
-      seats {
+      /* FIXME Efl.Input.Device is not stable yet*/
+      seats @beta {
          [[Iterate over the available input device seats for the canvas.
 
            A "seat" is the term used for a group of input devices, typically including
@@ -154,7 +155,8 @@ interface @beta Efl.Canvas.Scene
          return: iterator<Efl.Input.Device> @owned;
             [[An iterator over the attached seats.]]
       }
-      @property device {
+      /* FIXME Efl.Input.Device is not stable yet*/
+      @property device @beta{
          [[An input device attached to this canvas, found by name.
 
            Note: This function is meant to find seats and not individual
@@ -172,7 +174,8 @@ interface @beta Efl.Canvas.Scene
             seat: Efl.Input.Device; [[The device or seat, $null if not found.]]
          }
       }
-      @property seat {
+      /* FIXME Efl.Input.Device is not stable yet*/
+      @property seat @beta {
          [[Get a seat attached to this canvas using the seat's id property.
 
            Seats are associated with an arbitrary integer id. The id is not a
@@ -191,7 +194,8 @@ interface @beta Efl.Canvas.Scene
             seat: Efl.Input.Device; [[The seat or $null if not found.]]
          }
       }
-      @property seat_default {
+      /* FIXME Efl.Input.Device is not stable yet*/
+      @property seat_default @beta {
          [[Get the default seat attached to this canvas.
 
            A canvas may have exactly one default seat.
@@ -206,7 +210,8 @@ interface @beta Efl.Canvas.Scene
             seat: Efl.Input.Device; [[The default seat or $null if one does not exist.]]
          }
       }
-      @property pointer_position {
+      /* FIXME Efl.Input.Device is not stable yet*/
+      @property pointer_position @beta {
          get {
             [[This function returns the current known pointer coordinates
 
@@ -224,15 +229,15 @@ interface @beta Efl.Canvas.Scene
       }
    }
    events {
-      focus,in: Efl.Input.Focus; [[Called when canvas got focus]]
+      scene,focus,in: Efl.Input.Focus; [[Called when scene got focus]]
-      focus,out: Efl.Input.Focus; [[Called when canvas lost focus]]
+      scene,focus,out: Efl.Input.Focus; [[Called when scene lost focus]]
       object,focus,in: Efl.Input.Focus; [[Called when object got focus]]
       object,focus,out: Efl.Input.Focus; [[Called when object lost focus]]
       render,pre: void; [[Called when pre render happens]]
       /* FIXME: event_info can be NULL, but @nullable tag does not work on events yet */
       render,post: Efl.Gfx.Event.Render_Post; [[Called when post render happens]]
-      device,changed: Efl.Input.Device; [[Called when input device changed]]
+      device,changed @beta : Efl.Input.Device; [[Called when input device changed]]
-      device,added: Efl.Input.Device; [[Called when input device was added]]
+      device,added @beta: Efl.Input.Device; [[Called when input device was added]]
-      device,removed: Efl.Input.Device; [[Called when input device was removed]]
+      device,removed @beta : Efl.Input.Device; [[Called when input device was removed]]
    }
 }

src/lib/efl/interfaces/efl_container.eo

@@ -1,4 +1,4 @@
-interface @beta Efl.Container
+interface Efl.Container
 {
    [[Common interface for objects that have multiple contents (sub objects).
 

src/lib/efl/interfaces/efl_content.eo

@@ -1,4 +1,4 @@
-interface @beta Efl.Content
+interface Efl.Content
 {
    [[Common interface for objects that have a (single) content.
 

src/lib/efl/interfaces/efl_file.eo

@@ -1,7 +1,7 @@
 import eina_types;
 import efl_gfx_types;
 
-mixin @beta Efl.File requires Efl.Object {
+mixin Efl.File requires Efl.Object {
    [[Efl file interface]]
    methods {
       @property mmap {
@@ -62,7 +62,7 @@ mixin @beta Efl.File requires Efl.Object {
               You must not modify the strings on the returned pointers.]]
          }
          values {
-            key: string; [[The group that the image belongs to, in case 
+            key: string; [[The group that the image belongs to, in case
                                             it's an EET(including Edje case) file. This can be used
                                             as a key inside evas image cache if this is a normal image
                                             file not eet file.]]

src/lib/efl/interfaces/efl_file_save.eo

@@ -9,7 +9,7 @@ struct Efl.File_Save_Info
    encoding: string; [[The encoding to use when saving the file.]]
 }
 
-interface @beta Efl.File_Save {
+interface Efl.File_Save {
    [[Efl file saving interface]]
    methods {
       save @const {

src/lib/efl/interfaces/efl_gfx_buffer.eo

@@ -2,7 +2,7 @@ import efl_gfx_types;
 import eina_types;
 
 /* FIXME: this is very very low level. expose to apps? */
-enum Efl.Gfx.Buffer_Access_Mode {
+enum @beta Efl.Gfx.Buffer_Access_Mode {
    [[Graphics buffer access mode]]
    none      = 0x0, [[No buffer access]]
    read      = 0x1, [[Read access to buffer]]

src/lib/efl/interfaces/efl_gfx_color.eo

@@ -1,6 +1,6 @@
 import efl_gfx_types;
 
-mixin @beta Efl.Gfx.Color
+mixin Efl.Gfx.Color
 {
    [[Efl Gfx Color mixin class]]
    data: null;

src/lib/efl/interfaces/efl_gfx_entity.eo

@@ -1,6 +1,6 @@
 import eina_types;
 
-interface @beta Efl.Gfx.Entity {
+interface Efl.Gfx.Entity {
    [[Efl graphics interface]]
    eo_prefix: efl_gfx_entity;
    methods {