From 1ce14bc85d87ece9b2e50204f1834ec5a2d0f4a1 Mon Sep 17 00:00:00 2001
From: JunsuChoi <jsuya.choi@samsung.com>
Date: Mon, 22 Jul 2019 13:29:02 +0900
Subject: [PATCH 01/32] Ector.Renderer : Implement
 Ector.Renderer.(Software).Image class

Summary:
Implement a class and drawer that outputs image data from the Ector.
Image data is output with a vector object and supports transform.

Test Plan: N/A

Reviewers: Hermet, smohanty, kimcinoo

Reviewed By: Hermet

Subscribers: cedric, #reviewers, #committers

Tags: #efl

Differential Revision: https://phab.enlightenment.org/D9218
---
 src/lib/ector/ector_private.h                 |   6 +
 src/lib/ector/ector_renderer.h                |   1 +
 src/lib/ector/ector_renderer_image.c          |  22 ++
 src/lib/ector/ector_renderer_image.eo         |  16 ++
 src/lib/ector/meson.build                     |   2 +
 src/lib/ector/software/Ector_Software.h       |   1 +
 .../software/ector_renderer_software_image.c  | 194 ++++++++++++++++++
 .../software/ector_renderer_software_image.eo |  13 ++
 .../ector/software/ector_software_surface.c   |   2 +
 src/lib/ector/software/meson.build            |   2 +
 10 files changed, 259 insertions(+)
 create mode 100644 src/lib/ector/ector_renderer_image.c
 create mode 100644 src/lib/ector/ector_renderer_image.eo
 create mode 100644 src/lib/ector/software/ector_renderer_software_image.c
 create mode 100644 src/lib/ector/software/ector_renderer_software_image.eo

diff --git a/src/lib/ector/ector_private.h b/src/lib/ector/ector_private.h
index 8604768e16..8e128201e2 100644
--- a/src/lib/ector/ector_private.h
+++ b/src/lib/ector/ector_private.h
@@ -47,6 +47,7 @@ typedef struct _Ector_Renderer_Gradient_Data Ector_Renderer_Gradient_Data;
 typedef struct _Ector_Renderer_Gradient_Linear_Data Ector_Renderer_Gradient_Linear_Data;
 typedef struct _Ector_Renderer_Gradient_Radial_Data Ector_Renderer_Gradient_Radial_Data;
 typedef struct _Ector_Renderer_Shape_Data Ector_Renderer_Shape_Data;
+typedef struct _Ector_Renderer_Image_Data Ector_Renderer_Image_Data;
 typedef struct _Ector_Renderer_Buffer_Data Ector_Renderer_Buffer_Data;
 
 struct _Ector_Renderer_Data
@@ -99,6 +100,11 @@ struct _Ector_Renderer_Shape_Data
    } stroke;
 };
 
+struct _Ector_Renderer_Image_Data
+{
+   Ector_Buffer *buffer;
+};
+
 struct _Ector_Renderer_Buffer_Data
 {
    Ector_Buffer *eo_buffer;
diff --git a/src/lib/ector/ector_renderer.h b/src/lib/ector/ector_renderer.h
index c8d20d2fb3..482f6cb0d4 100644
--- a/src/lib/ector/ector_renderer.h
+++ b/src/lib/ector/ector_renderer.h
@@ -3,6 +3,7 @@
 
 #include "ector_renderer.eo.h"
 #include "ector_renderer_shape.eo.h"
+#include "ector_renderer_image.eo.h"
 #include "ector_renderer_gradient.eo.h"
 #include "ector_renderer_gradient_linear.eo.h"
 #include "ector_renderer_gradient_radial.eo.h"
diff --git a/src/lib/ector/ector_renderer_image.c b/src/lib/ector/ector_renderer_image.c
new file mode 100644
index 0000000000..3e34254f29
--- /dev/null
+++ b/src/lib/ector/ector_renderer_image.c
@@ -0,0 +1,22 @@
+#ifdef HAVE_CONFIG_H
+# include "config.h"
+#endif
+
+#include <Eina.h>
+#include <Ector.h>
+
+#include "ector_private.h"
+
+#define MY_CLASS ECTOR_RENDERER_IMAGE_MIXIN
+
+
+static void
+_ector_renderer_image_buffer_set(Eo *obj EINA_UNUSED,
+                                 Ector_Renderer_Image_Data *pd,
+                                 Ector_Buffer *buffer)
+{
+   pd->buffer = buffer;
+}
+
+
+#include "ector_renderer_image.eo.c"
diff --git a/src/lib/ector/ector_renderer_image.eo b/src/lib/ector/ector_renderer_image.eo
new file mode 100644
index 0000000000..9c2e7b3448
--- /dev/null
+++ b/src/lib/ector/ector_renderer_image.eo
@@ -0,0 +1,16 @@
+import ector_renderer;
+
+mixin @beta Ector.Renderer.Image
+{
+   [[Ector image renderer mixin]]
+   c_prefix: ector_renderer_image;
+   methods {
+      @property buffer {
+         set {
+         }
+         values {
+            buffer : Ector.Buffer; [[Image buffer]]
+         }
+       }
+   }
+}
diff --git a/src/lib/ector/meson.build b/src/lib/ector/meson.build
index 069e98d9e7..5bedb7e82b 100644
--- a/src/lib/ector/meson.build
+++ b/src/lib/ector/meson.build
@@ -14,6 +14,7 @@ ector_src = [
   'ector_gl_internal.h',
   'ector_buffer.c',
   'ector_renderer_shape.c',
+  'ector_renderer_image.c',
   'ector_renderer.c',
   'ector_renderer_gradient.c',
   'ector_renderer_gradient_radial.c',
@@ -25,6 +26,7 @@ pub_eo_files = [
   'ector_buffer.eo',
   'ector_renderer.eo',
   'ector_renderer_shape.eo',
+  'ector_renderer_image.eo',
   'ector_renderer_gradient.eo',
   'ector_renderer_gradient_radial.eo',
   'ector_renderer_gradient_linear.eo'
diff --git a/src/lib/ector/software/Ector_Software.h b/src/lib/ector/software/Ector_Software.h
index 2f9192ff30..85529e6f21 100644
--- a/src/lib/ector/software/Ector_Software.h
+++ b/src/lib/ector/software/Ector_Software.h
@@ -36,6 +36,7 @@
 #include "software/ector_software_buffer_base.eo.h"
 #include "software/ector_renderer_software.eo.h"
 #include "software/ector_renderer_software_shape.eo.h"
+#include "software/ector_renderer_software_image.eo.h"
 #include "software/ector_renderer_software_gradient_linear.eo.h"
 #include "software/ector_renderer_software_gradient_radial.eo.h"
 
diff --git a/src/lib/ector/software/ector_renderer_software_image.c b/src/lib/ector/software/ector_renderer_software_image.c
new file mode 100644
index 0000000000..cb8d93ad6c
--- /dev/null
+++ b/src/lib/ector/software/ector_renderer_software_image.c
@@ -0,0 +1,194 @@
+#ifdef HAVE_CONFIG_H
+# include "config.h"
+#endif
+
+#include <math.h>
+#include <float.h>
+
+#include <Eina.h>
+#include <Ector.h>
+#include <software/Ector_Software.h>
+
+#include "ector_private.h"
+#include "ector_software_private.h"
+
+#define MY_CLASS ECTOR_RENDERER_SOFTWARE_IMAGE_CLASS
+
+typedef struct _Ector_Renderer_Software_Image_Data Ector_Renderer_Software_Image_Data;
+
+struct _Ector_Renderer_Software_Image_Data
+{
+   Ector_Software_Surface_Data *surface;
+   Ector_Renderer_Image_Data   *image;
+   Ector_Renderer_Data         *base;
+   Ector_Buffer                *mask;
+   int                          mask_op;
+   int                         opacity;
+   Eina_Matrix3                inv_m;
+   struct {
+      int x1, y1, x2, y2;
+   } boundary;
+};
+
+static Eina_Bool
+_ector_renderer_software_image_ector_renderer_prepare(Eo *obj,
+                                                      Ector_Renderer_Software_Image_Data *pd)
+{
+   if (!pd->surface)
+     pd->surface = efl_data_xref(pd->base->surface, ECTOR_SOFTWARE_SURFACE_CLASS, obj);
+
+   if (!pd->image->buffer || !pd->surface->rasterizer->fill_data.raster_buffer)
+     return EINA_FALSE;
+
+   Eina_Matrix3 m;
+   double m11, m12, m21, m22, m31, m32;
+   int x = pd->surface->x + (int)pd->base->origin.x;
+   int y = pd->surface->y + (int)pd->base->origin.y;
+   int image_w, image_h;
+   ector_buffer_size_get(pd->image->buffer, &image_w, &image_h);
+
+   double px[4] = {x, x + image_w, x, x + image_w};
+   double py[4] = {y, y, y + image_h, y + image_h};
+
+   //Only use alpha color
+   pd->opacity = pd->base->color.a;
+   /*ector_software_rasterizer_color_set(pd->surface->rasterizer,
+     pd->base->color.r,
+     pd->base->color.g,
+     pd->base->color.b,
+     pd->base->color.a);*/
+
+   if (!pd->base->m)
+     {
+        eina_matrix3_identity(&m);
+        eina_matrix3_scale(&m, (double)pd->surface->rasterizer->fill_data.raster_buffer->generic->w / (double)image_w,
+                           (double)pd->surface->rasterizer->fill_data.raster_buffer->generic->h / (double)image_h);
+     }
+   else
+     eina_matrix3_copy(&m, pd->base->m);
+   eina_matrix3_values_get(&m, &m11, &m12, NULL,
+                           &m21, &m22, NULL,
+                           &m31, &m32, NULL);
+   //Calc draw boundbox
+   pd->boundary.x1 = MAX(pd->surface->rasterizer->fill_data.raster_buffer->generic->w , (unsigned int)image_w);
+   pd->boundary.y1 = MAX(pd->surface->rasterizer->fill_data.raster_buffer->generic->h , (unsigned int)image_h);
+   pd->boundary.x2 = 0; pd->boundary.y2 = 0;
+   for (int i = 0; i < 4; i++)
+     {
+        pd->boundary.x1 = MIN(pd->boundary.x1, (int)(((px[i] * m11) + (py[i] * m21) + m31) + 0.5));
+        pd->boundary.y1 = MIN(pd->boundary.y1, (int)(((px[i] * m12) + (py[i] * m22) + m32) + 0.5));
+
+        pd->boundary.x2 = MAX(pd->boundary.x2, (int)(((px[i] * m11) + (py[i] * m21) + m31) + 0.5));
+        pd->boundary.y2 = MAX(pd->boundary.y2, (int)(((px[i] * m12) + (py[i] * m22) + m32) + 0.5));
+     }
+
+   eina_matrix3_inverse(&m, &pd->inv_m);
+
+   return EINA_TRUE;
+}
+
+//FIXME: We need to implement that apply op, clips and mul_col.
+static Eina_Bool
+_ector_renderer_software_image_ector_renderer_draw(Eo *obj EINA_UNUSED,
+                                                   Ector_Renderer_Software_Image_Data *pd,
+                                                   Efl_Gfx_Render_Op op EINA_UNUSED, Eina_Array *clips EINA_UNUSED,
+                                                   unsigned int mul_col EINA_UNUSED)
+{
+   if (!pd->image->buffer || !pd->surface->rasterizer->fill_data.raster_buffer->pixels.u32)
+          return EINA_FALSE;
+
+   if (pd->opacity == 0)
+      return EINA_TRUE;
+
+   const int pix_stride = pd->surface->rasterizer->fill_data.raster_buffer->stride / 4;
+   Ector_Software_Buffer_Base_Data *mask = pd->mask ? efl_data_scope_get(pd->mask, ECTOR_SOFTWARE_BUFFER_BASE_MIXIN) : NULL;
+   Ector_Software_Buffer_Base_Data *bpd = efl_data_scope_get(pd->image->buffer, ECTOR_SOFTWARE_BUFFER_BASE_MIXIN);
+   double im11, im12, im21, im22, im31, im32;
+   uint32_t *dst_buf, *src_buf;
+   int image_w, image_h;
+   ector_buffer_size_get(pd->image->buffer, &image_w, &image_h);
+
+   dst_buf = pd->surface->rasterizer->fill_data.raster_buffer->pixels.u32;
+   src_buf = bpd->pixels.u32;
+
+   eina_matrix3_values_get(&pd->inv_m, &im11, &im12, NULL,
+                                       &im21, &im22, NULL,
+                                       &im31, &im32, NULL);
+
+   //Draw
+   for (int local_y = pd->boundary.y1; local_y < pd->boundary.y2; local_y++)
+     {
+        for (int local_x = pd->boundary.x1; local_x <  pd->boundary.x2; local_x++)
+          {
+             uint32_t *dst = dst_buf + ((int)local_x + ((int)local_y * pix_stride));
+             int rx, ry;
+             rx = (int)(((double)local_x * im11) + ((double)local_y * im21) + im31 + 0.5);
+             ry = (int)(((double)local_x * im12) + ((double)local_y * im22) + im32 + 0.5);
+             if (rx < 0 || rx >= image_w || ry < 0 || ry >= image_h)
+               continue;
+             uint32_t *src = src_buf + (rx + (ry * image_w));  //FIXME: use to stride
+             uint32_t temp = 0x0;
+             if (mask)
+               {
+                  uint32_t *m = mask->pixels.u32 + ((int)local_x + ((int)local_y * mask->generic->w));
+                  //FIXME : This masking can work only matte case.
+                  //        We need consider to inverse matte case.
+                  temp = draw_mul_256((((*m)>>24) * pd->opacity)>>8, *src);
+               }
+             else
+               {
+                  temp = draw_mul_256(pd->opacity, *src);
+               }
+             int inv_alpha = 255 - ((temp) >> 24);
+             *dst = temp + draw_mul_256(inv_alpha, *dst); 
+          }
+     }
+
+   return EINA_TRUE;
+}
+
+static Eo *
+_ector_renderer_software_image_efl_object_constructor(Eo *obj, Ector_Renderer_Software_Image_Data *pd)
+{
+   obj = efl_constructor(efl_super(obj, MY_CLASS));
+   if (!obj) return NULL;
+
+   pd->image = efl_data_xref(obj, ECTOR_RENDERER_IMAGE_MIXIN, obj);
+   pd->base = efl_data_xref(obj, ECTOR_RENDERER_CLASS, obj);
+
+   return obj;
+}
+
+static void
+_ector_renderer_software_image_efl_object_destructor(Eo *obj, Ector_Renderer_Software_Image_Data *pd)
+{
+   efl_data_xunref(pd->base->surface, pd->surface, obj);
+   efl_data_xunref(obj, pd->base, obj);
+   efl_data_xunref(obj, pd->image, obj);
+
+   efl_destructor(efl_super(obj, MY_CLASS));
+}
+
+unsigned int
+_ector_renderer_software_image_ector_renderer_crc_get(const Eo *obj,
+                                                      Ector_Renderer_Software_Image_Data *pd)
+{
+   unsigned int crc;
+
+   crc = ector_renderer_crc_get(efl_super(obj, MY_CLASS));
+
+   crc = eina_crc((void*) pd->image, sizeof (Ector_Renderer_Image_Data), crc, EINA_FALSE);
+   return crc;
+}
+
+static void
+_ector_renderer_software_image_ector_renderer_mask_set(Eo *obj EINA_UNUSED,
+                                                       Ector_Renderer_Software_Image_Data *pd,
+                                                       Ector_Buffer *mask,
+                                                       int op)
+{
+   pd->mask = mask;
+   pd->mask_op = op;
+}
+
+#include "ector_renderer_software_image.eo.c"
diff --git a/src/lib/ector/software/ector_renderer_software_image.eo b/src/lib/ector/software/ector_renderer_software_image.eo
new file mode 100644
index 0000000000..8a3f9c51e7
--- /dev/null
+++ b/src/lib/ector/software/ector_renderer_software_image.eo
@@ -0,0 +1,13 @@
+class @beta Ector.Renderer.Software.Image extends Ector.Renderer.Software implements Ector.Renderer.Image
+{
+   [[Ector software renderer image class]]
+   c_prefix: ector_renderer_software_image;
+   implements {
+      Ector.Renderer.prepare;
+      Ector.Renderer.draw;
+      Ector.Renderer.mask { set; }
+      Ector.Renderer.crc { get; }
+      Efl.Object.constructor;
+      Efl.Object.destructor;
+   }
+}
diff --git a/src/lib/ector/software/ector_software_surface.c b/src/lib/ector/software/ector_software_surface.c
index 08a2786f16..1008fe52b6 100644
--- a/src/lib/ector/software/ector_software_surface.c
+++ b/src/lib/ector/software/ector_software_surface.c
@@ -204,6 +204,8 @@ _ector_software_surface_ector_surface_renderer_factory_new(Eo *obj,
 {
    if (type == ECTOR_RENDERER_SHAPE_MIXIN)
      return efl_add_ref(ECTOR_RENDERER_SOFTWARE_SHAPE_CLASS, NULL, ector_renderer_surface_set(efl_added, obj));
+   else if (type == ECTOR_RENDERER_IMAGE_MIXIN)
+     return efl_add_ref(ECTOR_RENDERER_SOFTWARE_IMAGE_CLASS, NULL, ector_renderer_surface_set(efl_added, obj));
    else if (type == ECTOR_RENDERER_GRADIENT_LINEAR_MIXIN)
      return efl_add_ref(ECTOR_RENDERER_SOFTWARE_GRADIENT_LINEAR_CLASS, NULL, ector_renderer_surface_set(efl_added, obj));
    else if (type == ECTOR_RENDERER_GRADIENT_RADIAL_MIXIN)
diff --git a/src/lib/ector/software/meson.build b/src/lib/ector/software/meson.build
index 2dff5be26c..7374252729 100644
--- a/src/lib/ector/software/meson.build
+++ b/src/lib/ector/software/meson.build
@@ -3,6 +3,7 @@ ector_src += files([
   'ector_renderer_software_gradient_linear.c',
   'ector_renderer_software_gradient_radial.c',
   'ector_renderer_software_shape.c',
+  'ector_renderer_software_image.c',
   'ector_software_gradient.c',
   'ector_software_rasterizer.c',
   'ector_software_surface.c',
@@ -16,6 +17,7 @@ pub_eo_files = [
   'ector_software_buffer_base.eo',
   'ector_renderer_software.eo',
   'ector_renderer_software_shape.eo',
+  'ector_renderer_software_image.eo',
   'ector_renderer_software_gradient_radial.eo',
   'ector_renderer_software_gradient_linear.eo',
 ]

From 56ebaea1fe33258e3b489d3a8782dfaa1b904835 Mon Sep 17 00:00:00 2001
From: JunsuChoi <jsuya.choi@samsung.com>
Date: Mon, 22 Jul 2019 13:37:47 +0900
Subject: [PATCH 02/32] Efl.Canvas.Vg : Implement Efl.Canvas.Vg.Image class

Summary:
Implements a vector class that can support image.
User can use this class to output an image with a vector object.

Depends on D9218:Ector.Renderer : Implement Ector.Renderer.(Software).Image class

Test Plan: N/A

Reviewers: Hermet, smohanty, kimcinoo

Reviewed By: Hermet

Subscribers: cedric, #reviewers, #committers

Tags: #efl

Differential Revision: https://phab.enlightenment.org/D9219
---
 src/lib/evas/Evas_Eo.h                     |   1 +
 src/lib/evas/canvas/efl_canvas_vg_image.c  | 114 +++++++++++++++++++++
 src/lib/evas/canvas/efl_canvas_vg_image.eo |  20 ++++
 src/lib/evas/canvas/meson.build            |   2 +
 4 files changed, 137 insertions(+)
 create mode 100644 src/lib/evas/canvas/efl_canvas_vg_image.c
 create mode 100644 src/lib/evas/canvas/efl_canvas_vg_image.eo

diff --git a/src/lib/evas/Evas_Eo.h b/src/lib/evas/Evas_Eo.h
index f3bcb6eb32..4122ac7f15 100644
--- a/src/lib/evas/Evas_Eo.h
+++ b/src/lib/evas/Evas_Eo.h
@@ -452,6 +452,7 @@ typedef void (Evas_Canvas3D_Surface_Func)(Evas_Real *out_x,
 #include "canvas/efl_canvas_vg_node.eo.h"
 #include "canvas/efl_canvas_vg_container.eo.h"
 #include "canvas/efl_canvas_vg_shape.eo.h"
+#include "canvas/efl_canvas_vg_image.eo.h"
 #include "canvas/efl_canvas_vg_gradient.eo.h"
 #include "canvas/efl_canvas_vg_gradient_linear.eo.h"
 #include "canvas/efl_canvas_vg_gradient_radial.eo.h"
diff --git a/src/lib/evas/canvas/efl_canvas_vg_image.c b/src/lib/evas/canvas/efl_canvas_vg_image.c
new file mode 100644
index 0000000000..1a72c69624
--- /dev/null
+++ b/src/lib/evas/canvas/efl_canvas_vg_image.c
@@ -0,0 +1,114 @@
+#include "evas_common_private.h"
+#include "evas_private.h"
+
+#include "evas_vg_private.h"
+
+#define MY_CLASS EFL_CANVAS_VG_IMAGE_CLASS
+
+typedef struct _Efl_Canvas_Vg_Image_Data Efl_Canvas_Vg_Image_Data;
+struct _Efl_Canvas_Vg_Image_Data
+{
+   Ector_Buffer *buffer;
+   void *image;
+   int w;
+   int h;
+};
+
+static void
+_efl_canvas_vg_image_render_pre(Evas_Object_Protected_Data *vg_pd,
+                                Efl_VG *obj EINA_UNUSED,
+                                Efl_Canvas_Vg_Node_Data *nd,
+                                void *engine EINA_UNUSED, void *output EINA_UNUSED, void *context EINA_UNUSED,
+                                Ector_Surface *surface,
+                                Eina_Matrix3 *ptransform,
+                                Ector_Buffer *mask,
+                                int mask_op,
+                                void *data)
+{
+   Efl_Canvas_Vg_Image_Data *pd = data;
+
+   if (nd->flags == EFL_GFX_CHANGE_FLAG_NONE) return;
+
+   nd->flags = EFL_GFX_CHANGE_FLAG_NONE;
+
+   EFL_CANVAS_VG_COMPUTE_MATRIX(ctransform, ptransform, nd);
+
+   if (!nd->renderer)
+     {
+        efl_domain_current_push(EFL_ID_DOMAIN_SHARED);
+        nd->renderer = ector_surface_renderer_factory_new(surface, ECTOR_RENDERER_IMAGE_MIXIN);
+        efl_domain_current_pop();
+     }
+
+   if (!pd->buffer && pd->image)
+     {
+        Evas_Object_Protected_Data *obj = vg_pd;
+        if (pd->buffer) efl_unref(pd->buffer);
+        pd->buffer = ENFN->ector_buffer_new(ENC, obj->layer->evas->evas,
+                                            pd->w, pd->h,
+                                            EFL_GFX_COLORSPACE_ARGB8888,
+                                            ECTOR_BUFFER_FLAG_DRAWABLE |
+                                            ECTOR_BUFFER_FLAG_CPU_READABLE |
+                                            ECTOR_BUFFER_FLAG_CPU_WRITABLE);
+        ector_buffer_pixels_set(pd->buffer, pd->image,
+                                pd->w, pd->h, 0,
+                                EFL_GFX_COLORSPACE_ARGB8888, EINA_TRUE);
+     }
+   ector_renderer_image_buffer_set(nd->renderer, pd->buffer);
+   ector_renderer_transformation_set(nd->renderer, ctransform);
+
+
+
+   ector_renderer_origin_set(nd->renderer, nd->x, nd->y);
+   ector_renderer_color_set(nd->renderer, nd->r, nd->g, nd->b, nd->a);
+   ector_renderer_visibility_set(nd->renderer, nd->visibility);
+
+   ector_renderer_mask_set(nd->renderer, mask, mask_op);
+   ector_renderer_prepare(nd->renderer);
+}
+
+static Eo *
+_efl_canvas_vg_image_efl_object_constructor(Eo *obj, Efl_Canvas_Vg_Image_Data *pd)
+{
+   Efl_Canvas_Vg_Node_Data *nd;
+
+   obj = efl_constructor(efl_super(obj, MY_CLASS));
+
+   nd = efl_data_scope_get(obj, EFL_CANVAS_VG_NODE_CLASS);
+   nd->render_pre = _efl_canvas_vg_image_render_pre;
+   nd->data = pd;
+
+   efl_gfx_color_set(obj , 255, 255, 255, 255);
+
+   return obj;
+}
+
+static void
+_efl_canvas_vg_image_efl_object_destructor(Eo *obj, Efl_Canvas_Vg_Image_Data *pd EINA_UNUSED)
+{
+   efl_destructor(efl_super(obj, MY_CLASS));
+   if (pd->buffer)
+     {
+        efl_unref(pd->buffer);
+        pd->buffer = NULL;
+     }
+}
+
+static void
+_efl_canvas_vg_image_data_set(Eo *obj EINA_UNUSED, Efl_Canvas_Vg_Image_Data *pd, void *data, int w, int h)
+{
+   if (!data || w <= 0 || h <= 0)
+     return;
+
+   if ((pd->image != data || pd->w != w || pd->h != h) && pd->buffer)
+     {
+        efl_unref(pd->buffer);
+        pd->buffer= NULL;
+     }
+
+   pd->image = data;
+   pd->w = w;
+   pd->h = h;
+}
+
+#include "efl_canvas_vg_image.eo.c"
diff --git a/src/lib/evas/canvas/efl_canvas_vg_image.eo b/src/lib/evas/canvas/efl_canvas_vg_image.eo
new file mode 100644
index 0000000000..2c593d425e
--- /dev/null
+++ b/src/lib/evas/canvas/efl_canvas_vg_image.eo
@@ -0,0 +1,20 @@
+class @beta Efl.Canvas.Vg.Image extends Efl.Canvas.Vg.Node implements Efl.Gfx.Image
+{
+   [[Efl vector graphics image class]]
+   methods {
+      @property data {
+         [[Set image data]]
+         set {
+         }
+         values {
+            pixels: void_ptr; [[Image pixels data. The pixel data type is 32bit RGBA]]
+            w : int;
+            h : int;
+         }
+      }
+   }
+   implements {
+      Efl.Object.constructor;
+      Efl.Object.destructor;
+   }
+}
diff --git a/src/lib/evas/canvas/meson.build b/src/lib/evas/canvas/meson.build
index 3d1849b1a5..f285316844 100644
--- a/src/lib/evas/canvas/meson.build
+++ b/src/lib/evas/canvas/meson.build
@@ -43,6 +43,7 @@ pub_eo_files = [
   'efl_canvas_vg_node.eo',
   'efl_canvas_vg_container.eo',
   'efl_canvas_vg_shape.eo',
+  'efl_canvas_vg_image.eo',
   'efl_canvas_vg_gradient.eo',
   'efl_canvas_vg_gradient_radial.eo',
   'efl_canvas_vg_gradient_linear.eo',
@@ -184,6 +185,7 @@ evas_src += files([
   'efl_canvas_vg_gradient_radial.c',
   'efl_canvas_vg_utils.c',
   'efl_canvas_vg_shape.c',
+  'efl_canvas_vg_image.c',
   'evas_filter_mixin.c',
   'evas_canvas3d_object.c',
   'evas_canvas3d_scene.c',

From e9f8ef6ea44bdd5750613d88b848d3d1d788de69 Mon Sep 17 00:00:00 2001
From: JunsuChoi <jsuya.choi@samsung.com>
Date: Mon, 22 Jul 2019 13:53:21 +0900
Subject: [PATCH 03/32] vg_common_json : Support image data of node

Summary:
When node has image data, it creates Efl.Canvas.Vg.Image class
and set transform information and data information.

Depends on
D9218 Ector.Renderer : Implement Ector.Renderer.(Software).Image class
D9219 Efl.Canvas.Vg : Implement Efl.Canvas.Vg.Image class

Test Plan: N/A

Reviewers: Hermet, smohanty, kimcinoo

Reviewed By: Hermet

Subscribers: cedric, #reviewers, #committers

Tags: #efl

Differential Revision: https://phab.enlightenment.org/D9220
---
 src/static_libs/vg_common/vg_common_json.c | 27 +++++++++++++++++++++-
 1 file changed, 26 insertions(+), 1 deletion(-)

diff --git a/src/static_libs/vg_common/vg_common_json.c b/src/static_libs/vg_common/vg_common_json.c
index 94df54eb2f..6ecac9901f 100644
--- a/src/static_libs/vg_common/vg_common_json.c
+++ b/src/static_libs/vg_common/vg_common_json.c
@@ -42,6 +42,31 @@ _construct_drawable_nodes(Efl_Canvas_Vg_Container *parent, const LOTLayerNode *l
         LOTNode *node = layer->mNodeList.ptr[i];
         if (!node) continue;
 
+        //Image object
+        if (node->mImageInfo.data)
+          {
+             char *key = _get_key_val(node);
+             Efl_Canvas_Vg_Image *image = efl_key_data_get(parent, key);
+             if (!image)
+               {
+                  image = efl_add(EFL_CANVAS_VG_IMAGE_CLASS, parent);
+                  efl_key_data_set(parent, key, image);
+               }
+             efl_gfx_entity_visible_set(image, EINA_TRUE);
+
+             Eina_Matrix3 m;
+             eina_matrix3_identity(&m);
+             eina_matrix3_values_set( &m,
+                                      node->mImageInfo.mMatrix.m11,  node->mImageInfo.mMatrix.m12, node->mImageInfo.mMatrix.m13,
+                                      node->mImageInfo.mMatrix.m21,  node->mImageInfo.mMatrix.m22, node->mImageInfo.mMatrix.m23,
+                                      node->mImageInfo.mMatrix.m31,  node->mImageInfo.mMatrix.m32, node->mImageInfo.mMatrix.m33);
+             efl_canvas_vg_node_transformation_set(image, &m);
+
+             efl_canvas_vg_image_data_set(image, node->mImageInfo.data, node->mImageInfo.width, node->mImageInfo.height);
+
+             continue;
+          }
+
         //Skip Invisible Stroke?
         if (node->mStroke.enable && node->mStroke.width == 0)
           {
@@ -64,7 +89,7 @@ _construct_drawable_nodes(Efl_Canvas_Vg_Container *parent, const LOTLayerNode *l
         else
           efl_gfx_path_reset(shape);
 
-         efl_gfx_entity_visible_set(shape, EINA_TRUE);
+        efl_gfx_entity_visible_set(shape, EINA_TRUE);
 #if DEBUG
         for (int i = 0; i < depth; i++) printf("    ");
         printf("%s (%p)\n", efl_class_name_get(efl_class_get(shape)), shape);

From e97d3c08ea83b611c8b4fd06e1fe5fdd24a1dca9 Mon Sep 17 00:00:00 2001
From: JunsuChoi <jsuya.choi@samsung.com>
Date: Mon, 22 Jul 2019 13:54:25 +0900
Subject: [PATCH 04/32] evas_vg_json: Add image embedded example

Summary:
add example code and json resource.

plus)
Add ECTOR_BACKEND="default" Environment variable
because cairo backend is not supported.

Depends on
D9218 Ector.Renderer : Implement Ector.Renderer.(Software).Image class
D9219 Efl.Canvas.Vg : Implement Efl.Canvas.Vg.Image class
D9220 vg_common_json : Support image data of node

Test Plan:
cd .src/examples/evas/
gcc -o evas_vg_json evas-vg-json.c `pkg-config --libs --cflags evas ecore ecore-evas eina ector eo efl`
./evas_vg_json

Reviewers: Hermet, kimcinoo, smohanty

Subscribers: bu5hm4n, cedric, #reviewers, #committers

Tags: #efl

Differential Revision: https://phab.enlightenment.org/D9351
---
 src/examples/evas/evas-vg-json.c                | 17 ++++++++++++++---
 .../evas/resources/vg/image_embedded.json       |  1 +
 2 files changed, 15 insertions(+), 3 deletions(-)
 create mode 100644 src/examples/evas/resources/vg/image_embedded.json

diff --git a/src/examples/evas/evas-vg-json.c b/src/examples/evas/evas-vg-json.c
index 42047292ea..d0176dbd72 100644
--- a/src/examples/evas/evas-vg-json.c
+++ b/src/examples/evas/evas-vg-json.c
@@ -30,9 +30,9 @@
 #include "evas-common.h"
 
 #define WIDTH  400
-#define HEIGHT 400
+#define HEIGHT 600
 
-static Eo *gvg[4];
+static Eo *gvg[5];
 
 static void
 running_cb(void *data EINA_UNUSED, const Efl_Event *event)
@@ -41,7 +41,7 @@ running_cb(void *data EINA_UNUSED, const Efl_Event *event)
    double progress = event_running->progress;
 
    int i;
-   for (i = 0; i < 4; i++)
+   for (i = 0; i < 5; i++)
      {
         double frameCnt = (double) (efl_gfx_frame_controller_frame_count_get(gvg[i]) - 1);
         int frame = (int) (frameCnt * progress);
@@ -58,6 +58,9 @@ _on_delete(Ecore_Evas *ee EINA_UNUSED)
 int
 main(void)
 {
+   //Cairo backend is not supported.
+   setenv("ECTOR_BACKEND", "default", 1);
+
    if (!ecore_evas_init())
      return EXIT_FAILURE;
 
@@ -109,6 +112,14 @@ main(void)
    efl_gfx_entity_size_set(vg4, EINA_SIZE2D(200, 200));
    efl_gfx_entity_visible_set(vg4, EINA_TRUE);
 
+   //5
+   Eo* vg5 = gvg[4] = efl_add(EFL_CANVAS_VG_OBJECT_CLASS, evas);
+   snprintf(buf, sizeof(buf), "%s/image_embedded.json", PACKAGE_EXAMPLES_DIR EVAS_VG_FOLDER);
+   efl_file_simple_load(vg5, buf, NULL);
+   efl_gfx_entity_position_set(vg5, EINA_POSITION2D(0, 400));
+   efl_gfx_entity_size_set(vg5, EINA_SIZE2D(200, 200));
+   efl_gfx_entity_visible_set(vg5, EINA_TRUE);
+
    //Play custom animation
    Eo *anim = efl_add(EFL_CANVAS_ANIMATION_CLASS, evas);
    efl_animation_duration_set(anim, efl_gfx_frame_controller_frame_duration_get(vg, 0, 0));
diff --git a/src/examples/evas/resources/vg/image_embedded.json b/src/examples/evas/resources/vg/image_embedded.json
new file mode 100644
index 0000000000..c3d48387f1
--- /dev/null
+++ b/src/examples/evas/resources/vg/image_embedded.json
@@ -0,0 +1 @@
+{"v":"5.4.3","fr":60,"ip":0,"op":60,"w":800,"h":800,"nm":"Comp 1","ddd":0,"assets":[{"id":"image_0","w":200,"h":300,"u":"","p":"data:image/png;base64,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","e":1}],"layers":[{"ddd":0,"ind":1,"ty":2,"nm":"img_0.png","cl":"png","refId":"image_0","sr":1,"ks":{"o":{"a":0,"k":100,"ix":11},"r":{"a":1,"k":[{"i":{"x":[0.833],"y":[0.833]},"o":{"x":[0.167],"y":[0.167]},"n":["0p833_0p833_0p167_0p167"],"t":0,"s":[0],"e":[81]},{"t":59}],"ix":10},"p":{"a":0,"k":[400,400,0],"ix":2},"a":{"a":0,"k":[100,150,0],"ix":1},"s":{"a":0,"k":[100,100,100],"ix":6}},"ao":0,"ip":0,"op":60,"st":0,"bm":0}],"markers":[]}
\ No newline at end of file

From bf7e05586f002aa66688c37eabcd3a44f847ee16 Mon Sep 17 00:00:00 2001
From: Hermet Park <hermetpark@gmail.com>
Date: Mon, 22 Jul 2019 16:47:43 +0900
Subject: [PATCH 05/32] efl_ui_textpath: introduce
 efl_ui_textpath_circular_set() interface.

Summary:
This patch revises efl_ui_textpath_circle_set() interface.

Current circle_set() behavior is wrongly working,
it makes object minimal size with (x * 2, y * 2).
Insanely, how big size if the object is far from the screen origin.

Secondly, current interface requires center position,
How this center position could be guranteed if user wants to put it into a container?

Third, actual textpath output could be out of the textpath boundary,
since the textpath is originated to middle of text height.
the display boundary can be outside of the textpath geometry by (half of text height).

All in all, put altogether in fix,
I confirmed there is no methods without any compatibility break.

This brings elm_textpath_circular_set() api introduced.

@feature

Reviewers: #committers, kimcinoo, jsuya

Subscribers: zmike, bu5hm4n, segfaultxavi, cedric, #reviewers, #committers

Tags: #efl

Differential Revision: https://phab.enlightenment.org/D9260
---
 src/bin/elementary/test_ui_textpath.c         |  10 +-
 src/lib/elementary/efl_ui_textpath.c          | 165 ++++++++++++++----
 src/lib/elementary/efl_ui_textpath.eo         |   7 +-
 .../elementary/efl_ui_textpath_eo.legacy.c    |   5 +-
 .../elementary/efl_ui_textpath_eo.legacy.h    |  16 ++
 5 files changed, 157 insertions(+), 46 deletions(-)

diff --git a/src/bin/elementary/test_ui_textpath.c b/src/bin/elementary/test_ui_textpath.c
index e4756996f3..111ebe1af4 100644
--- a/src/bin/elementary/test_ui_textpath.c
+++ b/src/bin/elementary/test_ui_textpath.c
@@ -6,8 +6,6 @@
 #include <Efl_Ui.h>
 #include <Elementary.h>
 
-#define CX 180
-#define CY 150
 #define CR 100
 
 #define TEST_UI_TEXTPATH_LONG_TEXT "This text follows the path which you defined. This is a &lt;long&gt; text designed to make it ellipsis."
@@ -31,7 +29,7 @@ _direction_changed_cb(void *data, const Efl_Event *event)
    Eina_Bool val = elm_check_selected_get(event->object);
    Efl_Ui_Textpath_Direction dir = val ? EFL_UI_TEXTPATH_DIRECTION_CW :
                                          EFL_UI_TEXTPATH_DIRECTION_CCW;
-   efl_ui_textpath_circle_set(txtpath, CX, CY, CR, angle, dir);
+   efl_ui_textpath_circular_set(txtpath, CR, angle, dir);
 }
 
 static void
@@ -43,7 +41,7 @@ _angle_changed_cb(void *data, const Efl_Event *event)
    Eina_Bool val = elm_check_selected_get(dir_chk);
    Efl_Ui_Textpath_Direction dir = val ? EFL_UI_TEXTPATH_DIRECTION_CW :
                                          EFL_UI_TEXTPATH_DIRECTION_CCW;
-   efl_ui_textpath_circle_set(txtpath, CX, CY, CR, angle, dir);
+   efl_ui_textpath_circular_set(txtpath, CR, angle, dir);
 }
 
 static void
@@ -76,7 +74,7 @@ _change_shape_cb(void *data, Evas_Object *obj EINA_UNUSED, void *event_info EINA
         Eina_Bool val = elm_check_selected_get(dir_chk);
         Efl_Ui_Textpath_Direction dir = val ? EFL_UI_TEXTPATH_DIRECTION_CW :
                                               EFL_UI_TEXTPATH_DIRECTION_CCW;
-        efl_ui_textpath_circle_set(txtpath, CX, CY, CR, angle, dir);
+   efl_ui_textpath_circular_set(txtpath, CR, angle, dir);
      }
 }
 
@@ -109,7 +107,7 @@ test_ui_textpath(void *data EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *eve
 
    efl_text_set(txtpath, TEST_UI_TEXTPATH_LONG_TEXT);
 
-   efl_ui_textpath_circle_set(txtpath, CX, CY, CR, 0, EFL_UI_TEXTPATH_DIRECTION_CCW);
+   efl_ui_textpath_circular_set(txtpath, CR, 0, EFL_UI_TEXTPATH_DIRECTION_CCW);
    efl_gfx_entity_visible_set(txtpath, EINA_TRUE);
    path_type = 0;
 
diff --git a/src/lib/elementary/efl_ui_textpath.c b/src/lib/elementary/efl_ui_textpath.c
index c25410e1fc..aa89865a42 100644
--- a/src/lib/elementary/efl_ui_textpath.c
+++ b/src/lib/elementary/efl_ui_textpath.c
@@ -70,6 +70,7 @@ struct _Efl_Ui_Textpath_Data
 #ifdef EFL_UI_TEXTPATH_LINE_DEBUG
    Eina_List *lines;
 #endif
+   Eina_Bool circular : 1;   //TODO: Remove this flag when elm_textpath_circle_set() is removed.
 };
 
 #define EFL_UI_TEXTPATH_DATA_GET(o, sd) \
@@ -407,7 +408,7 @@ _path_data_get(Eo *obj, Efl_Ui_Textpath_Data *pd)
    const Efl_Gfx_Path_Command_Type *cmd;
    const double *points;
    Efl_Ui_Textpath_Segment *seg;
-   Eina_Position2D opos;
+   Eina_Position2D obj_pos;
 
    EINA_INLIST_FREE(pd->segments, seg)
      {
@@ -415,7 +416,16 @@ _path_data_get(Eo *obj, Efl_Ui_Textpath_Data *pd)
         free(seg);
      }
 
-   opos = efl_gfx_entity_position_get(obj);
+   obj_pos = efl_gfx_entity_position_get(obj);
+
+   /* textpath calculates boundary with the middle of text height.
+      this has better precise boundary than circle_set() behavior. */
+   if (pd->circular)
+     {
+        Eina_Size2D text_size = efl_gfx_entity_size_get(pd->text_obj);
+        obj_pos.x += (text_size.h / 2);
+        obj_pos.y += (text_size.h / 2);
+     }
 
    pd->total_length = 0;
    efl_gfx_path_get(obj, &cmd, &points);
@@ -430,9 +440,9 @@ _path_data_get(Eo *obj, Efl_Ui_Textpath_Data *pd)
              if (*cmd == EFL_GFX_PATH_COMMAND_TYPE_MOVE_TO)
                {
                   pos++;
-                  px0 = points[pos] + opos.x;
+                  px0 = points[pos] + obj_pos.x;
                   pos++;
-                  py0 = points[pos] + opos.y;
+                  py0 = points[pos] + obj_pos.y;
                }
              else if (*cmd == EFL_GFX_PATH_COMMAND_TYPE_CUBIC_TO)
                {
@@ -441,17 +451,17 @@ _path_data_get(Eo *obj, Efl_Ui_Textpath_Data *pd)
                   Eina_Rect brect;
 
                   pos++;
-                  ctrl_x0 = points[pos] + opos.x;
+                  ctrl_x0 = points[pos] + obj_pos.x;
                   pos++;
-                  ctrl_y0 = points[pos] + opos.y;
+                  ctrl_y0 = points[pos] + obj_pos.y;
                   pos++;
-                  ctrl_x1 = points[pos] + opos.x;
+                  ctrl_x1 = points[pos] + obj_pos.x;
                   pos++;
-                  ctrl_y1 = points[pos] + opos.y;
+                  ctrl_y1 = points[pos] + obj_pos.y;
                   pos++;
-                  px1 = points[pos] + opos.x;
+                  px1 = points[pos] + obj_pos.x;
                   pos++;
-                  py1 = points[pos] + opos.y;
+                  py1 = points[pos] + obj_pos.y;
 
                   eina_bezier_values_set(&bz, px0, py0, ctrl_x0, ctrl_y0, ctrl_x1, ctrl_y1, px1, py1);
                   seg = malloc(sizeof(Efl_Ui_Textpath_Segment));
@@ -481,9 +491,9 @@ _path_data_get(Eo *obj, Efl_Ui_Textpath_Data *pd)
                   Eina_Rect lrect;
 
                   pos++;
-                  px1 = points[pos] + opos.x;
+                  px1 = points[pos] + obj_pos.x;
                   pos++;
-                  py1 = points[pos] + opos.y;
+                  py1 = points[pos] + obj_pos.y;
 
                   seg = malloc(sizeof(Efl_Ui_Textpath_Segment));
                   if (!seg)
@@ -612,6 +622,7 @@ _path_start_angle_adjust(Eo *obj, Efl_Ui_Textpath_Data *pd)
    offset_angle /= 2.0;
 
    efl_gfx_path_reset(obj);
+
    if (pd->direction == EFL_UI_TEXTPATH_DIRECTION_CW_CENTER)
      {
         efl_gfx_path_append_arc(obj,
@@ -753,21 +764,22 @@ _efl_ui_textpath_efl_ui_widget_theme_apply(Eo *obj, Efl_Ui_Textpath_Data *pd)
 EOLIAN static void
 _efl_ui_textpath_efl_gfx_entity_position_set(Eo *obj, Efl_Ui_Textpath_Data *pd, Eina_Position2D pos)
 {
-   Eina_Position2D opos, diff;
+   Eina_Position2D ppos, diff;
    Efl_Ui_Textpath_Segment *seg;
    double sx, sy, csx, csy, cex, cey, ex, ey;
 
-   opos = efl_gfx_entity_position_get(obj);
-
-   diff.x = pos.x - opos.x;
-   diff.y = pos.y - opos.y;
-
+   ppos = efl_gfx_entity_position_get(obj);
    efl_gfx_entity_position_set(efl_super(obj, MY_CLASS), pos);
 
+   if (ppos.x == pos.x && ppos.y == pos.y) return;
+
+   diff.x = pos.x - ppos.x;
+   diff.y = pos.y - ppos.y;
+
    EINA_INLIST_FOREACH(pd->segments, seg)
      {
         eina_bezier_values_get(&seg->bezier, &sx, &sy, &csx, &csy,
-                                             &cex, &cey, &ex, &ey);
+                               &cex, &cey, &ex, &ey);
         sx += diff.x;
         sy += diff.y;
         csx += diff.x;
@@ -778,53 +790,99 @@ _efl_ui_textpath_efl_gfx_entity_position_set(Eo *obj, Efl_Ui_Textpath_Data *pd,
         ey += diff.y;
 
         eina_bezier_values_set(&seg->bezier, sx, sy, csx, csy,
-                                             cex, cey, ex, ey);
+                               cex, cey, ex, ey);
      }
 
    _text_draw(pd);
 }
 
 EOLIAN static void
-_efl_ui_textpath_efl_gfx_entity_size_set(Eo *obj, Efl_Ui_Textpath_Data *pd EINA_UNUSED, Eina_Size2D sz)
+_efl_ui_textpath_efl_gfx_entity_size_set(Eo *obj, Efl_Ui_Textpath_Data *pd EINA_UNUSED, Eina_Size2D size)
 {
-   Eina_Size2D psize = efl_gfx_entity_size_get(obj);
-   efl_gfx_entity_size_set(efl_super(obj, MY_CLASS), sz);
-   if (psize.w != sz.w || psize.h != sz.h) _text_draw(pd);
+   Eina_Size2D psize, diff;
+   Efl_Ui_Textpath_Segment *seg;
+   double sx, sy, csx, csy, cex, cey, ex, ey;
+
+   psize = efl_gfx_entity_size_get(obj);
+   efl_gfx_entity_size_set(efl_super(obj, MY_CLASS), size);
+
+   if (psize.w == size.w && psize.h == size.h) return;
+
+   //TODO: Remove this condition if circle_set() is removed
+   if (pd->circle.radius > 0 && !pd->circular) return;
+
+   diff.w = (size.w - psize.w) * 0.5;
+   diff.h = (size.h - psize.h) * 0.5;
+
+   EINA_INLIST_FOREACH(pd->segments, seg)
+     {
+        eina_bezier_values_get(&seg->bezier, &sx, &sy, &csx, &csy,
+                               &cex, &cey, &ex, &ey);
+        sx += diff.w;
+        sy += diff.h;
+        csx += diff.w;
+        csy += diff.h;
+        cex += diff.w;
+        cey += diff.h;
+        ex += diff.w;
+        ey += diff.h;
+
+        eina_bezier_values_set(&seg->bezier, sx, sy, csx, csy,
+                               cex, cey, ex, ey);
+     }
+
+   _text_draw(pd);
 }
 
 EOLIAN static void
-_efl_ui_textpath_circle_set(Eo *obj, Efl_Ui_Textpath_Data *pd, double x, double y, double radius, double start_angle, Efl_Ui_Textpath_Direction direction)
+_efl_ui_textpath_circular_set(Eo *obj, Efl_Ui_Textpath_Data *pd, double radius, double start_angle, Efl_Ui_Textpath_Direction direction)
 {
-   double sweep_length;
+   Eina_Size2D text_size;
+   double sweep_length, x, y;
 
-   if (pd->circle.x == x && pd->circle.y == y &&
-       pd->circle.radius == radius &&
+   if (pd->circle.radius == radius &&
        pd->circle.start_angle == start_angle &&
        pd->direction == direction &&
        _map_point_calc(pd) > 0)
         return;
-   pd->circle.x = x;
-   pd->circle.y = y;
+
+   Eina_Size2D obj_size = efl_gfx_entity_size_get(obj);
+
+   //textpath min size is same to circle bounadary */
+   text_size = efl_gfx_entity_size_get(pd->text_obj);
+
+   x = (obj_size.w - text_size.h - (2 * radius)) * 0.5;
+   y = (obj_size.h - text_size.h - (2 * radius)) * 0.5;
+
+   /* User leaves center position to textpath itself.
+      Now textpath automatically updates circle text according to
+      object position. */
+   pd->circle.x = radius + x;
+   pd->circle.y = radius + y;
    pd->circle.radius = radius;
    pd->circle.start_angle = start_angle;
    pd->direction = direction;
+   pd->circular = EINA_TRUE;
 
    efl_gfx_path_reset(obj);
 
    if (direction == EFL_UI_TEXTPATH_DIRECTION_CW ||
        direction == EFL_UI_TEXTPATH_DIRECTION_CW_CENTER)
-     sweep_length = -360;
-   else
      sweep_length = 360;
+   else
+     sweep_length = -360;
 
-   efl_gfx_path_append_arc(obj, x - radius, y - radius, radius * 2,
+   efl_gfx_path_append_arc(obj,
+                           pd->circle.x - pd->circle.radius,
+                           pd->circle.y - pd->circle.radius,
+                           radius * 2,
                            radius * 2,  start_angle, sweep_length);
 
    _path_data_get(obj, pd);
    _path_start_angle_adjust(obj, pd);
    _sizing_eval(pd);
 
-   efl_gfx_hint_size_min_set(obj, EINA_SIZE2D(x * 2, y * 2));
+   efl_gfx_hint_size_min_set(obj, EINA_SIZE2D((radius * 2) + text_size.h, (radius * 2) + text_size.h));
 }
 
 EOLIAN static int
@@ -907,5 +965,44 @@ elm_textpath_add(Evas_Object *parent)
    return elm_legacy_add(EFL_UI_TEXTPATH_LEGACY_CLASS, parent);
 }
 
+EAPI void
+elm_textpath_circle_set(Eo *obj, double x, double y, double radius, double start_angle, Efl_Ui_Textpath_Direction direction)
+{
+   double sweep_length;
+
+   EFL_UI_TEXTPATH_DATA_GET(obj, pd);
+
+   if (pd->circle.x == x && pd->circle.y == y &&
+       pd->circle.radius == radius &&
+       pd->circle.start_angle == start_angle &&
+       pd->direction == direction &&
+       _map_point_calc(pd) > 0)
+        return;
+
+   pd->circle.x = x;
+   pd->circle.y = y;
+   pd->circle.radius = radius;
+   pd->circle.start_angle = start_angle;
+   pd->direction = direction;
+   pd->circular = EINA_FALSE;
+
+   efl_gfx_path_reset(obj);
+
+   if (direction == EFL_UI_TEXTPATH_DIRECTION_CW ||
+       direction == EFL_UI_TEXTPATH_DIRECTION_CW_CENTER)
+     sweep_length = - 360;
+   else
+     sweep_length = 360;
+
+   efl_gfx_path_append_arc(obj, x - radius, y - radius, radius * 2,
+                           radius * 2,  start_angle, sweep_length);
+
+   _path_data_get(obj, pd);
+   _path_start_angle_adjust(obj, pd);
+   _sizing_eval(pd);
+
+   efl_gfx_hint_size_min_set(obj, EINA_SIZE2D(x * 2, y * 2));
+}
+
 #include "efl_ui_textpath_legacy_eo.c"
 
diff --git a/src/lib/elementary/efl_ui_textpath.eo b/src/lib/elementary/efl_ui_textpath.eo
index 4a56b490a3..7d834a8d0a 100644
--- a/src/lib/elementary/efl_ui_textpath.eo
+++ b/src/lib/elementary/efl_ui_textpath.eo
@@ -10,11 +10,10 @@ class @beta Efl.Ui.Textpath extends Efl.Ui.Layout_Base implements Efl.Text, Efl.
 {
    [[Efl Ui Textpath class]]
    methods {
-      circle_set {
-         [[Set a circle with given center, radius, and start angle.]]
+      circular_set {
+         [[Set a circle with given radius and start angle.
+           The center of the circle will be decided by the object center position.]]
          params {
-            @in x: double; [[X coordinate of center]]
-            @in y: double; [[Y coordinate of center]]
             @in radius: double; [[Radius of the circle]]
             @in start_angle: double; [[Start angle of the circle]]
             @in direction: Efl.Ui.Textpath_Direction; [[Textpath direction]]
diff --git a/src/lib/elementary/efl_ui_textpath_eo.legacy.c b/src/lib/elementary/efl_ui_textpath_eo.legacy.c
index e810a856dd..1af5fdb1f8 100644
--- a/src/lib/elementary/efl_ui_textpath_eo.legacy.c
+++ b/src/lib/elementary/efl_ui_textpath_eo.legacy.c
@@ -1,8 +1,8 @@
 
 EAPI void
-elm_textpath_circle_set(Efl_Ui_Textpath *obj, double x, double y, double radius, double start_angle, Efl_Ui_Textpath_Direction direction)
+elm_textpath_circular_set(Efl_Ui_Textpath *obj, double radius, double start_angle, Efl_Ui_Textpath_Direction direction)
 {
-   efl_ui_textpath_circle_set(obj, x, y, radius, start_angle, direction);
+   efl_ui_textpath_circular_set(obj, radius, start_angle, direction);
 }
 
 EAPI void
@@ -23,6 +23,7 @@ elm_textpath_ellipsis_set(Efl_Ui_Textpath *obj, Eina_Bool ellipsis)
    efl_ui_textpath_ellipsis_set(obj, ellipsis);
 }
 
+
 EAPI Eina_Bool
 elm_textpath_ellipsis_get(const Efl_Ui_Textpath *obj)
 {
diff --git a/src/lib/elementary/efl_ui_textpath_eo.legacy.h b/src/lib/elementary/efl_ui_textpath_eo.legacy.h
index 5fe981a2d8..65e8768c12 100644
--- a/src/lib/elementary/efl_ui_textpath_eo.legacy.h
+++ b/src/lib/elementary/efl_ui_textpath_eo.legacy.h
@@ -36,10 +36,26 @@ typedef enum
  * @param[in] start_angle Start angle of the circle
  * @param[in] direction Textpath direction
  *
+ * @see elm_textpath_circluar_set()
+ *
  * @ingroup Elm_Textpath_Group
  */
 EAPI void elm_textpath_circle_set(Efl_Ui_Textpath *obj, double x, double y, double radius, double start_angle, Efl_Ui_Textpath_Direction direction);
 
+/**
+ * @brief Set a circle with given radius, and start angle.
+ *        The circle center will be decided by the object center position.
+ *
+ * @param[in] obj The object.
+ * @param[in] radius Radius of the circle
+ * @param[in] start_angle Start angle of the circle
+ * @param[in] direction Textpath direction
+ *
+ * @since 1.23
+ * @ingroup Elm_Textpath_Group
+ */
+EAPI void elm_textpath_circular_set(Efl_Ui_Textpath *obj, double radius, double start_angle, Efl_Ui_Textpath_Direction direction);
+
 /**
  * @brief The number of slices. The larger the number of slice_num is, The
  * better the text follows the path.

From f6729087ca4229e0a7b8779d2470cd1d68f2778f Mon Sep 17 00:00:00 2001
From: Hermet Park <hermetpark@gmail.com>
Date: Mon, 22 Jul 2019 17:01:45 +0900
Subject: [PATCH 06/32] efl_ui_textpath: deprecate elm_textpath_circle_set()

Summary:
this api can be replaced with elm_textpath_circular_set()

Depends on {D9260}

Reviewers: #committers, kimcinoo

Reviewed By: #committers, kimcinoo

Subscribers: cedric, #reviewers, #committers

Tags: #efl

Differential Revision: https://phab.enlightenment.org/D9314
---
 src/lib/elementary/efl_ui_textpath_eo.legacy.h | 16 ----------------
 src/lib/elementary/elm_deprecated.h            | 16 ++++++++++++++++
 2 files changed, 16 insertions(+), 16 deletions(-)

diff --git a/src/lib/elementary/efl_ui_textpath_eo.legacy.h b/src/lib/elementary/efl_ui_textpath_eo.legacy.h
index 65e8768c12..bd23debaa7 100644
--- a/src/lib/elementary/efl_ui_textpath_eo.legacy.h
+++ b/src/lib/elementary/efl_ui_textpath_eo.legacy.h
@@ -26,22 +26,6 @@ typedef enum
 
 #endif
 
-/**
- * @brief Set a circle with given center, radius, and start angle.
- *
- * @param[in] obj The object.
- * @param[in] x X coordinate of center
- * @param[in] y Y coordinate of center
- * @param[in] radius Radius of the circle
- * @param[in] start_angle Start angle of the circle
- * @param[in] direction Textpath direction
- *
- * @see elm_textpath_circluar_set()
- *
- * @ingroup Elm_Textpath_Group
- */
-EAPI void elm_textpath_circle_set(Efl_Ui_Textpath *obj, double x, double y, double radius, double start_angle, Efl_Ui_Textpath_Direction direction);
-
 /**
  * @brief Set a circle with given radius, and start angle.
  *        The circle center will be decided by the object center position.
diff --git a/src/lib/elementary/elm_deprecated.h b/src/lib/elementary/elm_deprecated.h
index 04bab53fa0..ee449cc00c 100644
--- a/src/lib/elementary/elm_deprecated.h
+++ b/src/lib/elementary/elm_deprecated.h
@@ -1668,3 +1668,19 @@ EINA_DEPRECATED EAPI char *elm_access_external_info_get(const Evas_Object *obj);
 // elm_win
 EINA_DEPRECATED EAPI void elm_win_type_set(Evas_Object *obj, Elm_Win_Type type);
 EINA_DEPRECATED EAPI void elm_win_name_set(Evas_Object *obj, const char *name);
+
+/**
+ * @brief Set a circle with given center, radius, and start angle.
+ *
+ * @param[in] obj The object.
+ * @param[in] x X coordinate of center
+ * @param[in] y Y coordinate of center
+ * @param[in] radius Radius of the circle
+ * @param[in] start_angle Start angle of the circle
+ * @param[in] direction Textpath direction
+ *
+ * @deprecated Use elm_textpath_circluar_set() instead.
+ *
+ * @ingroup Elm_Textpath_Group
+ */
+EINA_DEPRECATED EAPI void elm_textpath_circle_set(Efl_Ui_Textpath *obj, double x, double y, double radius, double start_angle, Efl_Ui_Textpath_Direction direction);

From 2e37d2f30f0e9cee3b71a014908f445c723317aa Mon Sep 17 00:00:00 2001
From: Hermet Park <hermetpark@gmail.com>
Date: Mon, 22 Jul 2019 17:14:10 +0900
Subject: [PATCH 07/32] ecore_evas buffer: fix a deadlock issue.

We encountered a deadlock case in ecore_evas_image_object in ecore_evas_buffer
that only happens if the ecore_evas_buffer has nothing changed to render,
though it's triggered to rendering.

See this normal scenario that is working fine as our intention.

being ecore_evas_render()
...
 -> ecore_evas_buffer_prepare()
     -> evas_object_image_data_get()
         -> increment lock by backend engine. (egl/tbm ...)
 -> render()
     -> render_post()
        -> _ecore_evas_buffer_update_image()
            -> evas_object_image_data_set()
               ->decrement lock by backend engine (egl/tbm ...)
...
end ecore_evas_render()

The problem is, if the ecore_evas_buffer canvas doesn't changed at all,
render post will be skipped, it could lose the chance to unlock the image data.
Now the host can't render anymore since it's image source lost the lock.

@fix
---
 src/lib/ecore_evas/ecore_evas_buffer.c | 9 +++++++--
 src/lib/ecore_evas/ecore_evas_buffer.h | 2 +-
 2 files changed, 8 insertions(+), 3 deletions(-)

diff --git a/src/lib/ecore_evas/ecore_evas_buffer.c b/src/lib/ecore_evas/ecore_evas_buffer.c
index 147e09070b..19422366b6 100644
--- a/src/lib/ecore_evas/ecore_evas_buffer.c
+++ b/src/lib/ecore_evas/ecore_evas_buffer.c
@@ -176,14 +176,17 @@ _ecore_evas_buffer_prepare(Ecore_Evas *ee)
         evas_object_image_size_get(bdata->image, &w, &h);
         if ((w != ee->w) || (h != ee->h))
           _ecore_evas_resize(ee, w, h);
-        bdata->pixels = evas_object_image_data_get(bdata->image, 1);
+        if (evas_changed_get(ee->evas) && !bdata->lock_data)
+          {
+             bdata->pixels = evas_object_image_data_get(bdata->image, 1);
+             bdata->lock_data = EINA_TRUE;
+          }
      }
    else if (bdata->resized)
      {
         if (ee->func.fn_resize) ee->func.fn_resize(ee);
         bdata->resized = 0;
      }
-
    return EINA_TRUE;
 }
 
@@ -200,6 +203,8 @@ _ecore_evas_buffer_update_image(void *data, Evas *e EINA_UNUSED, void *event_inf
    EINA_LIST_FOREACH(post->updated_area, l, r)
      evas_object_image_data_update_add(bdata->image,
                                        r->x, r->y, r->w, r->h);
+
+   bdata->lock_data = EINA_FALSE;
 }
 
 EAPI int
diff --git a/src/lib/ecore_evas/ecore_evas_buffer.h b/src/lib/ecore_evas/ecore_evas_buffer.h
index 1249c380f4..188072a18e 100644
--- a/src/lib/ecore_evas/ecore_evas_buffer.h
+++ b/src/lib/ecore_evas/ecore_evas_buffer.h
@@ -9,7 +9,7 @@ struct _Ecore_Evas_Engine_Buffer_Data {
    void  (*free_func) (void *data, void *pix);
    void *(*alloc_func) (void *data, int size);
    void *data;
-   Eina_Bool in_render : 1;
+   Eina_Bool lock_data : 1;
    Eina_Bool resized : 1;
 };
 

From 44363bb70f3cf92f87755a9f34674a318e50779f Mon Sep 17 00:00:00 2001
From: Hermet Park <hermetpark@gmail.com>
Date: Mon, 22 Jul 2019 17:31:06 +0900
Subject: [PATCH 08/32] efl_canvas_vg image: changed image parameter type.

it's still in improvement stage in beta.
---
 src/lib/evas/canvas/efl_canvas_vg_image.c  | 10 +++++-----
 src/lib/evas/canvas/efl_canvas_vg_image.eo |  3 +--
 src/static_libs/vg_common/vg_common_json.c |  2 +-
 3 files changed, 7 insertions(+), 8 deletions(-)

diff --git a/src/lib/evas/canvas/efl_canvas_vg_image.c b/src/lib/evas/canvas/efl_canvas_vg_image.c
index 1a72c69624..d008fd74f9 100644
--- a/src/lib/evas/canvas/efl_canvas_vg_image.c
+++ b/src/lib/evas/canvas/efl_canvas_vg_image.c
@@ -95,20 +95,20 @@ _efl_canvas_vg_image_efl_object_destructor(Eo *obj, Efl_Canvas_Vg_Image_Data *pd
 }
 
 static void
-_efl_canvas_vg_image_data_set(Eo *obj EINA_UNUSED, Efl_Canvas_Vg_Image_Data *pd, void *data, int w, int h)
+_efl_canvas_vg_image_data_set(Eo *obj EINA_UNUSED, Efl_Canvas_Vg_Image_Data *pd, void *data, Eina_Size2D size)
 {
-   if (!data || w <= 0 || h <= 0)
+   if (!data || size.w <= 0 || size.h <= 0)
      return;
 
-   if ((pd->image != data || pd->w != w || pd->h != h) && pd->buffer)
+   if ((pd->image != data || pd->w != size.w || pd->h != size.h) && pd->buffer)
      {
         efl_unref(pd->buffer);
         pd->buffer= NULL;
      }
 
    pd->image = data;
-   pd->w = w;
-   pd->h = h;
+   pd->w = size.w;
+   pd->h = size.h;
 }
 
 #include "efl_canvas_vg_image.eo.c"
diff --git a/src/lib/evas/canvas/efl_canvas_vg_image.eo b/src/lib/evas/canvas/efl_canvas_vg_image.eo
index 2c593d425e..05ea4b929f 100644
--- a/src/lib/evas/canvas/efl_canvas_vg_image.eo
+++ b/src/lib/evas/canvas/efl_canvas_vg_image.eo
@@ -8,8 +8,7 @@ class @beta Efl.Canvas.Vg.Image extends Efl.Canvas.Vg.Node implements Efl.Gfx.Im
          }
          values {
             pixels: void_ptr; [[Image pixels data. The pixel data type is 32bit RGBA]]
-            w : int;
-            h : int;
+            size: Eina.Size2D; [[The size in pixels.]]
          }
       }
    }
diff --git a/src/static_libs/vg_common/vg_common_json.c b/src/static_libs/vg_common/vg_common_json.c
index 6ecac9901f..9b2d8403f4 100644
--- a/src/static_libs/vg_common/vg_common_json.c
+++ b/src/static_libs/vg_common/vg_common_json.c
@@ -62,7 +62,7 @@ _construct_drawable_nodes(Efl_Canvas_Vg_Container *parent, const LOTLayerNode *l
                                       node->mImageInfo.mMatrix.m31,  node->mImageInfo.mMatrix.m32, node->mImageInfo.mMatrix.m33);
              efl_canvas_vg_node_transformation_set(image, &m);
 
-             efl_canvas_vg_image_data_set(image, node->mImageInfo.data, node->mImageInfo.width, node->mImageInfo.height);
+             efl_canvas_vg_image_data_set(image, node->mImageInfo.data, EINA_SIZE2D(node->mImageInfo.width, node->mImageInfo.height));
 
              continue;
           }

From 6da5bd35a9e10c1229a213894795ec841936eee1 Mon Sep 17 00:00:00 2001
From: Cedric BAIL <cedric.bail@free.fr>
Date: Mon, 22 Jul 2019 10:27:10 +0200
Subject: [PATCH 09/32] ecore_evas_convert: add the ability to split large jpeg
 file.

Summary:
After trying convert to split very large image and running out of
memory, this few line of code did seems like the best solution. Maybe
there is some benefit to try to make Ecore_Evas_Convert more useful.

Reviewers: zmike, raster, segfaultxavi

Reviewed By: segfaultxavi

Subscribers: #reviewers, #committers

Tags: #efl

Differential Revision: https://phab.enlightenment.org/D9337
---
 src/bin/ecore_evas/ecore_evas_convert.c | 60 +++++++++++++++++++++++--
 1 file changed, 57 insertions(+), 3 deletions(-)

diff --git a/src/bin/ecore_evas/ecore_evas_convert.c b/src/bin/ecore_evas/ecore_evas_convert.c
index 019e42c7ff..2cddad1052 100644
--- a/src/bin/ecore_evas/ecore_evas_convert.c
+++ b/src/bin/ecore_evas/ecore_evas_convert.c
@@ -30,6 +30,7 @@ const Ecore_Getopt optdesc = {
     ECORE_GETOPT_STORE_INT('q', "quality", "define encoding quality in percent."),
     ECORE_GETOPT_STORE_TRUE('c', "compress", "define if data should be compressed."),
     ECORE_GETOPT_STORE_STR('e', "encoding", "define the codec (for TGV files: 'etc1', 'etc2', 'etc1+alpha')"),
+    ECORE_GETOPT_STORE_STR('m', "max-geometry", "define the max size in pixels (WidthxHeight) of any converted image, splitting the image as necessary in a grid pattern ('_XxY' will be appended to the file name)"),
     ECORE_GETOPT_LICENSE('L', "license"),
     ECORE_GETOPT_COPYRIGHT('C', "copyright"),
     ECORE_GETOPT_VERSION('V', "version"),
@@ -40,24 +41,50 @@ const Ecore_Getopt optdesc = {
 
 typedef struct _Save_Job {
    const char *output;
+   const char *extension;
    const char *flags;
    Evas_Object *im;
    int ret;
 } Save_Job;
 
-static Save_Job job = { NULL, NULL, NULL, -1 };
+static Save_Job job = { NULL, NULL, NULL, NULL, -1 };
+static unsigned int width = 0, height = 0;
+static unsigned int x = 0, y = 0;
+static int image_w, image_h;
 
 static void
 _save_do(void *data EINA_UNUSED)
 {
+   const char *output = job.output;
+
    job.ret = 0;
-   if (!evas_object_image_save(job.im, job.output, NULL, job.flags))
+   if (width || height)
+     {
+        Eina_Slstr *str;
+
+        str = eina_slstr_printf("%s_%ux%u.%s", output, x / width, y / height, job.extension);
+        output = str;
+
+        evas_object_image_load_region_set(job.im, x, y, width, height);
+        x += width;
+
+        if ((int)x > image_w)
+          {
+             y += height;
+             x = 0;
+          }
+
+     }
+
+   fprintf(stderr, "Saving image '%s'\n", output);
+   if (!evas_object_image_save(job.im, output, NULL, job.flags))
      {
         EINA_LOG_ERR("Could not convert file to '%s'.", job.output);
         job.ret = 1;
      }
 
-   ecore_main_loop_quit();
+   if (!width || ((int)y > image_h)) ecore_main_loop_quit();
+   else ecore_job_add(_save_do, NULL);
 }
 
 #ifndef NO_SIGNAL
@@ -81,6 +108,7 @@ main(int argc, char *argv[])
    int quality = -1;
    int r = -1;
    char *encoding = NULL;
+   char *maxgeometry = NULL;
    Eina_Bool compress = 1;
    Eina_Bool quit_option = EINA_FALSE;
    Eina_Strbuf *flags = NULL;
@@ -89,6 +117,7 @@ main(int argc, char *argv[])
      ECORE_GETOPT_VALUE_INT(quality),
      ECORE_GETOPT_VALUE_BOOL(compress),
      ECORE_GETOPT_VALUE_STR(encoding),
+     ECORE_GETOPT_VALUE_STR(maxgeometry),
      ECORE_GETOPT_VALUE_BOOL(quit_option),
      ECORE_GETOPT_VALUE_BOOL(quit_option),
      ECORE_GETOPT_VALUE_BOOL(quit_option),
@@ -116,6 +145,20 @@ main(int argc, char *argv[])
         goto end;
      }
 
+   if (maxgeometry)
+     {
+        if (sscanf(maxgeometry, "%ux%u", &width, &height) != 2)
+          {
+             EINA_LOG_ERR("max-geometry should be specified as WidthxHeight, like 1920x1280.");
+             goto end;
+          }
+        if (width == 0 || height == 0)
+          {
+             EINA_LOG_ERR("max-geometry width and height must be greater than 0.");
+             goto end;
+          }
+     }
+
    ee = ecore_evas_buffer_new(1, 1);
    e = ecore_evas_get(ee);
    if (!e)
@@ -142,11 +185,22 @@ main(int argc, char *argv[])
         goto end;
      }
 
+   evas_object_image_size_get(im, &image_w, &image_h);
+
 #ifndef NO_SIGNAL
    // Brutal way of
    signal(SIGINT, _sigint);
 #endif
 
+   // Find the extension and remove it
+   if (width || height)
+     {
+        char *tmp = strrchr(argv[arg_index + 1], '.');
+
+        if (tmp) *tmp = '\0';
+        if (tmp) job.extension = tmp + 1;
+     }
+
    job.output = argv[arg_index + 1];
    job.flags = eina_strbuf_string_get(flags);
    job.im = im;

From 5dac20f69f8c99757e18b920737adf95aecc8113 Mon Sep 17 00:00:00 2001
From: Mike Blumenkrantz <zmike@samsung.com>
Date: Tue, 16 Jul 2019 13:40:15 -0400
Subject: [PATCH 10/32] efl_ui_widget: add safety checks to verify parents
 aren't being added as children

somehow it was never checked to see if a parent was being added as a subobject
of a parent's own child object (recursive hierarchy)

@fix

Reviewed-by: Marcel Hollerbach <mail@marcel-hollerbach.de>
Differential Revision: https://phab.enlightenment.org/D9333
---
 src/lib/elementary/efl_ui_widget.c | 11 +++++++++++
 1 file changed, 11 insertions(+)

diff --git a/src/lib/elementary/efl_ui_widget.c b/src/lib/elementary/efl_ui_widget.c
index 7560fe3151..36df2e2e7c 100644
--- a/src/lib/elementary/efl_ui_widget.c
+++ b/src/lib/elementary/efl_ui_widget.c
@@ -1406,6 +1406,11 @@ _efl_ui_widget_widget_parent_set(Eo *obj, Elm_Widget_Smart_Data *pd, Efl_Ui_Widg
      {
         ELM_WIDGET_DATA_GET_OR_RETURN(parent, ppd);
         EINA_SAFETY_ON_FALSE_RETURN(eina_list_data_find(ppd->subobjs, obj));
+        if (ppd->parent_obj == parent)
+          {
+             CRI("ATTEMPTING TO SET CHILD OF PARENT AS PARENT OF ITS OWN PARENT. THIS IS A BUG.");
+             return;
+          }
      }
 
    /* NOTE: In the following two lines, 'obj' is correct. Do not change it.
@@ -1495,6 +1500,12 @@ _efl_ui_widget_widget_sub_object_add(Eo *obj, Elm_Widget_Smart_Data *sd, Evas_Ob
    if (parent == obj) return EINA_TRUE;
    if (parent)
      {
+        if (sd->parent_obj == sobj)
+          {
+             CRI("ATTEMPTING TO SET CHILD OF PARENT AS PARENT OF ITS OWN PARENT. THIS IS A BUG.");
+             return EINA_FALSE;
+          }
+
         if (!efl_ui_widget_sub_object_del(parent, sobj))
           return EINA_FALSE;
      }

From 5fd3436b17fd075b7bad3f4db16be97b2658f5fa Mon Sep 17 00:00:00 2001
From: Marcel Hollerbach <mail@marcel-hollerbach.de>
Date: Mon, 22 Jul 2019 10:43:12 +0200
Subject: [PATCH 11/32] efl_ui_widget: fix warning

---
 src/lib/elementary/efl_ui_widget.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/lib/elementary/efl_ui_widget.c b/src/lib/elementary/efl_ui_widget.c
index 36df2e2e7c..4d7d0da9f6 100644
--- a/src/lib/elementary/efl_ui_widget.c
+++ b/src/lib/elementary/efl_ui_widget.c
@@ -301,7 +301,7 @@ _candidacy_exam(Eo *obj)
 static void _full_eval(Eo *obj, Elm_Widget_Smart_Data *pd);
 
 static Efl_Ui_Focus_Object*
-_focus_manager_eval(Eo *obj, Elm_Widget_Smart_Data *pd, Eina_Bool want, Eina_Bool should)
+_focus_manager_eval(Eo *obj, Elm_Widget_Smart_Data *pd)
 {
    Evas_Object *provider = NULL;
    Evas_Object *parent;
@@ -525,7 +525,7 @@ _full_eval(Eo *obj, Elm_Widget_Smart_Data *pd)
      }
 
 
-   _focus_manager_eval(obj, pd, want_full, should);
+   _focus_manager_eval(obj, pd);
 
    old_registered_parent = pd->focus.parent;
    old_registered_manager = pd->focus.manager;

From ccfd74f17ab0cf98d64a7091160f52d98af70436 Mon Sep 17 00:00:00 2001
From: Christopher Michael <cp.michael@samsung.com>
Date: Mon, 22 Jul 2019 08:34:11 -0400
Subject: [PATCH 12/32] tests/ecore_wl2: Remove use of macros for display setup
 & connect

ref T8016
---
 src/tests/ecore_wl2/ecore_wl2_test_display.c  | 24 +++++++++----------
 src/tests/ecore_wl2/ecore_wl2_tests_helpers.h |  7 ++----
 2 files changed, 14 insertions(+), 17 deletions(-)

diff --git a/src/tests/ecore_wl2/ecore_wl2_test_display.c b/src/tests/ecore_wl2/ecore_wl2_test_display.c
index 828db2f432..f988d3adc3 100644
--- a/src/tests/ecore_wl2/ecore_wl2_test_display.c
+++ b/src/tests/ecore_wl2/ecore_wl2_test_display.c
@@ -15,7 +15,7 @@ EFL_START_TEST(wl2_display_create)
 {
    Ecore_Wl2_Display *disp;
 
-   disp = ECORE_WL2_TEST_DISPLAY_SETUP();
+   disp = _display_setup();
    ck_assert(disp != NULL);
 }
 EFL_END_TEST
@@ -24,7 +24,7 @@ EFL_START_TEST(wl2_display_destroy)
 {
    Ecore_Wl2_Display *disp;
 
-   disp = ECORE_WL2_TEST_DISPLAY_SETUP();
+   disp = _display_setup();
    ck_assert(disp != NULL);
 
    ecore_wl2_display_destroy(disp);
@@ -36,7 +36,7 @@ EFL_START_TEST(wl2_display_get)
    Ecore_Wl2_Display *disp;
    struct wl_display *wdisp;
 
-   disp = ECORE_WL2_TEST_DISPLAY_SETUP();
+   disp = _display_setup();
    ck_assert(disp != NULL);
 
    wdisp = ecore_wl2_display_get(disp);
@@ -48,7 +48,7 @@ EFL_START_TEST(wl2_display_name_get)
 {
    Ecore_Wl2_Display *disp;
 
-   disp = ECORE_WL2_TEST_DISPLAY_SETUP();
+   disp = _display_setup();
    ck_assert(disp != NULL);
 
    ck_assert(ecore_wl2_display_name_get(disp) != NULL);
@@ -59,7 +59,7 @@ EFL_START_TEST(wl2_display_connect)
 {
    Ecore_Wl2_Display *disp;
 
-   disp = ECORE_WL2_TEST_DISPLAY_CONNECT();
+   disp = _display_connect();
    ck_assert(disp != NULL);
 }
 EFL_END_TEST
@@ -68,7 +68,7 @@ EFL_START_TEST(wl2_display_disconnect)
 {
    Ecore_Wl2_Display *disp;
 
-   disp = ECORE_WL2_TEST_DISPLAY_CONNECT();
+   disp = _display_connect();
    ck_assert(disp != NULL);
 
    ecore_wl2_display_disconnect(disp);
@@ -79,7 +79,7 @@ EFL_START_TEST(wl2_display_registry_get)
 {
    Ecore_Wl2_Display *disp;
 
-   disp = ECORE_WL2_TEST_DISPLAY_CONNECT();
+   disp = _display_connect();
    ck_assert(disp != NULL);
 
    ck_assert(ecore_wl2_display_registry_get(disp) != NULL);
@@ -91,7 +91,7 @@ EFL_START_TEST(wl2_display_shm_get)
    Ecore_Wl2_Display *disp;
    struct wl_shm *shm;
 
-   disp = ECORE_WL2_TEST_DISPLAY_CONNECT();
+   disp = _display_connect();
    ck_assert(disp != NULL);
 
    shm = ecore_wl2_display_shm_get(disp);
@@ -104,7 +104,7 @@ EFL_START_TEST(wl2_display_dmabuf_get)
    Ecore_Wl2_Display *disp;
    void *dma;
 
-   disp = ECORE_WL2_TEST_DISPLAY_CONNECT();
+   disp = _display_connect();
    ck_assert(disp != NULL);
 
    dma = ecore_wl2_display_dmabuf_get(disp);
@@ -119,7 +119,7 @@ EFL_START_TEST(wl2_display_globals_get)
    Eina_Iterator *itr;
    void *data;
 
-   disp = ECORE_WL2_TEST_DISPLAY_CONNECT();
+   disp = _display_connect();
    ck_assert(disp != NULL);
 
    itr = ecore_wl2_display_globals_get(disp);
@@ -140,7 +140,7 @@ EFL_START_TEST(wl2_display_screen_size_get)
    Ecore_Wl2_Display *disp;
    int w, h;
 
-   disp = ECORE_WL2_TEST_DISPLAY_CONNECT();
+   disp = _display_connect();
    ck_assert(disp != NULL);
 
    ecore_wl2_display_screen_size_get(disp, &w, &h);
@@ -154,7 +154,7 @@ EFL_START_TEST(wl2_display_inputs_get)
    Ecore_Wl2_Display *disp;
    Eina_Iterator *itr;
 
-   disp = ECORE_WL2_TEST_DISPLAY_CONNECT();
+   disp = _display_connect();
    ck_assert(disp != NULL);
 
    itr = ecore_wl2_display_inputs_get(disp);
diff --git a/src/tests/ecore_wl2/ecore_wl2_tests_helpers.h b/src/tests/ecore_wl2/ecore_wl2_tests_helpers.h
index e06cea7859..f897dc9123 100644
--- a/src/tests/ecore_wl2/ecore_wl2_tests_helpers.h
+++ b/src/tests/ecore_wl2/ecore_wl2_tests_helpers.h
@@ -3,11 +3,8 @@
 
 # include <Ecore_Wl2.h>
 
-# define ECORE_WL2_TEST_DISPLAY_SETUP() _setup_display()
-# define ECORE_WL2_TEST_DISPLAY_CONNECT() _connect_display()
-
 static Ecore_Wl2_Display *
-_setup_display(void)
+_display_setup(void)
 {
    Ecore_Wl2_Display *disp;
 
@@ -16,7 +13,7 @@ _setup_display(void)
 }
 
 static Ecore_Wl2_Display *
-_connect_display(void)
+_display_connect(void)
 {
    Ecore_Wl2_Display *disp;
 

From 11de06e5b80192c8fe38e428a081be00a8f48fcf Mon Sep 17 00:00:00 2001
From: Christopher Michael <cp.michael@samsung.com>
Date: Mon, 22 Jul 2019 08:37:08 -0400
Subject: [PATCH 13/32] tests/ecore_wl2: Add test for
 ecore_wl2_window_surface_get function

ref T8016
---
 src/tests/ecore_wl2/ecore_wl2_test_window.c | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)

diff --git a/src/tests/ecore_wl2/ecore_wl2_test_window.c b/src/tests/ecore_wl2/ecore_wl2_test_window.c
index 4608f767a6..8bcca9efeb 100644
--- a/src/tests/ecore_wl2/ecore_wl2_test_window.c
+++ b/src/tests/ecore_wl2/ecore_wl2_test_window.c
@@ -41,6 +41,23 @@ EFL_START_TEST(wl2_window_new)
 }
 EFL_END_TEST
 
+EFL_START_TEST(wl2_window_surface_get)
+{
+   Ecore_Wl2_Display *disp;
+   Ecore_Wl2_Window *win;
+   struct wl_surface *surf;
+
+   disp = _display_connect();
+   ck_assert(disp != NULL);
+
+   win = _window_create(disp);
+   ck_assert(win != NULL);
+
+   surf = ecore_wl2_window_surface_get(win);
+   ck_assert(surf != NULL);
+}
+EFL_END_TEST
+
 void
 ecore_wl2_test_window(TCase *tc)
 {
@@ -48,5 +65,6 @@ ecore_wl2_test_window(TCase *tc)
      {
         /* window tests can only run if there is an existing compositor */
         tcase_add_test(tc, wl2_window_new);
+        tcase_add_test(tc, wl2_window_surface_get);
      }
 }

From 8510de33c37bdf138d98b52994cabe90130d835d Mon Sep 17 00:00:00 2001
From: Christopher Michael <cp.michael@samsung.com>
Date: Mon, 22 Jul 2019 08:40:34 -0400
Subject: [PATCH 14/32] tests/ecore_wl2: Add test case for
 ecore_wl2_window_surface_id_get

ref T8016
---
 src/tests/ecore_wl2/ecore_wl2_test_window.c | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)

diff --git a/src/tests/ecore_wl2/ecore_wl2_test_window.c b/src/tests/ecore_wl2/ecore_wl2_test_window.c
index 8bcca9efeb..45773198e3 100644
--- a/src/tests/ecore_wl2/ecore_wl2_test_window.c
+++ b/src/tests/ecore_wl2/ecore_wl2_test_window.c
@@ -58,6 +58,23 @@ EFL_START_TEST(wl2_window_surface_get)
 }
 EFL_END_TEST
 
+EFL_START_TEST(wl2_window_surface_id_get)
+{
+   Ecore_Wl2_Display *disp;
+   Ecore_Wl2_Window *win;
+   int id = -1;
+
+   disp = _display_connect();
+   ck_assert(disp != NULL);
+
+   win = _window_create(disp);
+   ck_assert(win != NULL);
+
+   id = ecore_wl2_window_surface_id_get(win);
+   ck_assert_int_lt(id, 0);
+}
+EFL_END_TEST
+
 void
 ecore_wl2_test_window(TCase *tc)
 {
@@ -66,5 +83,6 @@ ecore_wl2_test_window(TCase *tc)
         /* window tests can only run if there is an existing compositor */
         tcase_add_test(tc, wl2_window_new);
         tcase_add_test(tc, wl2_window_surface_get);
+        tcase_add_test(tc, wl2_window_surface_id_get);
      }
 }

From afe8414925f5f3ecb27a5e9e23760d93ffac3f75 Mon Sep 17 00:00:00 2001
From: Christopher Michael <cp.michael@samsung.com>
Date: Mon, 22 Jul 2019 08:55:04 -0400
Subject: [PATCH 15/32] tests/ecore_wl2: Add test for
 ecore_wl2_window_rotation_get

ref T8016
---
 src/tests/ecore_wl2/ecore_wl2_test_window.c | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)

diff --git a/src/tests/ecore_wl2/ecore_wl2_test_window.c b/src/tests/ecore_wl2/ecore_wl2_test_window.c
index 45773198e3..1bc1e9086c 100644
--- a/src/tests/ecore_wl2/ecore_wl2_test_window.c
+++ b/src/tests/ecore_wl2/ecore_wl2_test_window.c
@@ -75,6 +75,23 @@ EFL_START_TEST(wl2_window_surface_id_get)
 }
 EFL_END_TEST
 
+EFL_START_TEST(wl2_window_rotation_get)
+{
+   Ecore_Wl2_Display *disp;
+   Ecore_Wl2_Window *win;
+   int rot = -1;
+
+   disp = _display_connect();
+   ck_assert(disp != NULL);
+
+   win = _window_create(disp);
+   ck_assert(win != NULL);
+
+   rot = ecore_wl2_window_rotation_get(win);
+   ck_assert_int_lt(rot, 0);
+}
+EFL_END_TEST
+
 void
 ecore_wl2_test_window(TCase *tc)
 {
@@ -84,5 +101,6 @@ ecore_wl2_test_window(TCase *tc)
         tcase_add_test(tc, wl2_window_new);
         tcase_add_test(tc, wl2_window_surface_get);
         tcase_add_test(tc, wl2_window_surface_id_get);
+        tcase_add_test(tc, wl2_window_rotation_get);
      }
 }

From 5cf095dd3d8fc8e5390c056f323063a3c23ee2a8 Mon Sep 17 00:00:00 2001
From: Christopher Michael <cp.michael@samsung.com>
Date: Mon, 22 Jul 2019 08:57:33 -0400
Subject: [PATCH 16/32] tests/ecore_wl2: Add test for
 ecore_wl2_window_output_find

ref T8016
---
 src/tests/ecore_wl2/ecore_wl2_test_window.c | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)

diff --git a/src/tests/ecore_wl2/ecore_wl2_test_window.c b/src/tests/ecore_wl2/ecore_wl2_test_window.c
index 1bc1e9086c..bcf264f9c1 100644
--- a/src/tests/ecore_wl2/ecore_wl2_test_window.c
+++ b/src/tests/ecore_wl2/ecore_wl2_test_window.c
@@ -92,6 +92,23 @@ EFL_START_TEST(wl2_window_rotation_get)
 }
 EFL_END_TEST
 
+EFL_START_TEST(wl2_window_output_find)
+{
+   Ecore_Wl2_Display *disp;
+   Ecore_Wl2_Window *win;
+   Ecore_Wl2_Output *out;
+
+   disp = _display_connect();
+   ck_assert(disp != NULL);
+
+   win = _window_create(disp);
+   ck_assert(win != NULL);
+
+   out = ecore_wl2_window_output_find(win);
+   ck_assert(out != NULL);
+}
+EFL_END_TEST
+
 void
 ecore_wl2_test_window(TCase *tc)
 {
@@ -102,5 +119,6 @@ ecore_wl2_test_window(TCase *tc)
         tcase_add_test(tc, wl2_window_surface_get);
         tcase_add_test(tc, wl2_window_surface_id_get);
         tcase_add_test(tc, wl2_window_rotation_get);
+        tcase_add_test(tc, wl2_window_output_find);
      }
 }

From a7cc7730afceab996e6616e5412db95048fcb3c1 Mon Sep 17 00:00:00 2001
From: Christopher Michael <cp.michael@samsung.com>
Date: Mon, 22 Jul 2019 09:00:17 -0400
Subject: [PATCH 17/32] tests/ecore_wl2: Add test for
 ecore_wl2_window_aux_hints_supported_get

ref T8016
---
 src/tests/ecore_wl2/ecore_wl2_test_window.c | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)

diff --git a/src/tests/ecore_wl2/ecore_wl2_test_window.c b/src/tests/ecore_wl2/ecore_wl2_test_window.c
index bcf264f9c1..64e67d3c47 100644
--- a/src/tests/ecore_wl2/ecore_wl2_test_window.c
+++ b/src/tests/ecore_wl2/ecore_wl2_test_window.c
@@ -109,6 +109,23 @@ EFL_START_TEST(wl2_window_output_find)
 }
 EFL_END_TEST
 
+EFL_START_TEST(wl2_window_aux_hints_supported_get)
+{
+   Ecore_Wl2_Display *disp;
+   Ecore_Wl2_Window *win;
+   Eina_List *l;
+
+   disp = _display_connect();
+   ck_assert(disp != NULL);
+
+   win = _window_create(disp);
+   ck_assert(win != NULL);
+
+   l = ecore_wl2_window_aux_hints_supported_get(win);
+   ck_assert(l != NULL);
+}
+EFL_END_TEST
+
 void
 ecore_wl2_test_window(TCase *tc)
 {
@@ -120,5 +137,6 @@ ecore_wl2_test_window(TCase *tc)
         tcase_add_test(tc, wl2_window_surface_id_get);
         tcase_add_test(tc, wl2_window_rotation_get);
         tcase_add_test(tc, wl2_window_output_find);
+        tcase_add_test(tc, wl2_window_aux_hints_supported_get);
      }
 }

From 28c232d770bf373e674756ff5c6e2824723515b7 Mon Sep 17 00:00:00 2001
From: Christopher Michael <cp.michael@samsung.com>
Date: Mon, 22 Jul 2019 09:02:10 -0400
Subject: [PATCH 18/32] tests/ecore_wl2: Add test for
 ecore_wl2_window_display_get

ref T8016
---
 src/tests/ecore_wl2/ecore_wl2_test_window.c | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)

diff --git a/src/tests/ecore_wl2/ecore_wl2_test_window.c b/src/tests/ecore_wl2/ecore_wl2_test_window.c
index 64e67d3c47..fea733e980 100644
--- a/src/tests/ecore_wl2/ecore_wl2_test_window.c
+++ b/src/tests/ecore_wl2/ecore_wl2_test_window.c
@@ -126,6 +126,21 @@ EFL_START_TEST(wl2_window_aux_hints_supported_get)
 }
 EFL_END_TEST
 
+EFL_START_TEST(wl2_window_display_get)
+{
+   Ecore_Wl2_Display *disp;
+   Ecore_Wl2_Window *win;
+
+   disp = _display_connect();
+   ck_assert(disp != NULL);
+
+   win = _window_create(disp);
+   ck_assert(win != NULL);
+
+   ck_assert(ecore_wl2_window_display_get(win) != NULL);
+}
+EFL_END_TEST
+
 void
 ecore_wl2_test_window(TCase *tc)
 {
@@ -138,5 +153,6 @@ ecore_wl2_test_window(TCase *tc)
         tcase_add_test(tc, wl2_window_rotation_get);
         tcase_add_test(tc, wl2_window_output_find);
         tcase_add_test(tc, wl2_window_aux_hints_supported_get);
+        tcase_add_test(tc, wl2_window_display_get);
      }
 }

From 98b19244329725c76ba601ea66ad5161841a68b9 Mon Sep 17 00:00:00 2001
From: Wonki Kim <wonki_.kim@samsung.com>
Date: Mon, 22 Jul 2019 09:08:55 -0400
Subject: [PATCH 19/32] efl_ui_layout: set needs_size_calc flag at constructor

Summary:
even if there is a min definition on theme for some object,
the objects don't have the min size if we do nothing after creating it.

elm_layout_sizing_eval will return with doing nothing while executing contructor
so that _sizing_eval in _layout_group_calculate will never be invoked without calling hint_set, text_set, content_set, etc.

this patch modifies a initial state of needs_size_calc flag
so that object will doing _sizing_eval after executing constructor.

Test Plan:
1. remove lines that call apis such as content_set, hint_set, text_set
  in radio test on elementary_test

2. observe that radios don't have min size

Reviewers: bu5hm4n, Hermet, zmike

Reviewed By: zmike

Subscribers: cedric, #reviewers, #committers

Tags: #efl

Differential Revision: https://phab.enlightenment.org/D9368
---
 src/lib/elementary/efl_ui_layout.c | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/src/lib/elementary/efl_ui_layout.c b/src/lib/elementary/efl_ui_layout.c
index 1390fc774f..4b4643c72e 100644
--- a/src/lib/elementary/efl_ui_layout.c
+++ b/src/lib/elementary/efl_ui_layout.c
@@ -2445,7 +2445,7 @@ _efl_ui_layout_base_efl_object_constructor(Eo *obj, Efl_Ui_Layout_Data *sd)
 }
 
 EOLIAN static Efl_Object*
-_efl_ui_layout_base_efl_object_finalize(Eo *obj, Efl_Ui_Layout_Data *pd EINA_UNUSED)
+_efl_ui_layout_base_efl_object_finalize(Eo *obj, Efl_Ui_Layout_Data *pd)
 {
    Eo *eo, *win;
    ELM_WIDGET_DATA_GET_OR_RETURN(obj, wd, NULL);
@@ -2459,6 +2459,8 @@ _efl_ui_layout_base_efl_object_finalize(Eo *obj, Efl_Ui_Layout_Data *pd EINA_UNU
    if (efl_file_get(wd->resize_obj) || efl_file_mmap_get(wd->resize_obj))
      efl_file_load(wd->resize_obj);
 
+   pd->needs_size_calc = EINA_TRUE;
+
    return eo;
 }
 

From 63275dfef864282170e0c30d765eddf3ee41cd27 Mon Sep 17 00:00:00 2001
From: Subodh Kumar <s7158.kumar@samsung.com>
Date: Mon, 22 Jul 2019 09:09:00 -0400
Subject: [PATCH 20/32] [elm] Add missing sizing eval hook at radio

Summary:
radio is not shown in our Tizen demo.
sizing eval missing.

@fix

Reviewers: Hermet, bu5hm4n, cedric, zmike

Reviewed By: zmike

Subscribers: akanad, cedric, #reviewers, #committers

Tags: #efl

Differential Revision: https://phab.enlightenment.org/D9356
---
 src/lib/elementary/efl_ui_radio.c | 16 +++++++++++++++-
 1 file changed, 15 insertions(+), 1 deletion(-)

diff --git a/src/lib/elementary/efl_ui_radio.c b/src/lib/elementary/efl_ui_radio.c
index edbc14844f..099001fdb3 100644
--- a/src/lib/elementary/efl_ui_radio.c
+++ b/src/lib/elementary/efl_ui_radio.c
@@ -181,6 +181,19 @@ _efl_ui_radio_efl_ui_widget_theme_apply(Eo *obj, Efl_Ui_Radio_Data *sd EINA_UNUS
    return int_ret;
 }
 
+EOLIAN static void
+_efl_ui_radio_elm_layout_sizing_eval(Eo *obj, Efl_Ui_Radio_Data *_pd EINA_UNUSED)
+{
+   Evas_Coord minw = -1, minh = -1;
+   ELM_WIDGET_DATA_GET_OR_RETURN(obj, wd);
+
+   elm_coords_finger_size_adjust(1, &minw, 1, &minh);
+   edje_object_size_min_restricted_calc
+     (wd->resize_obj, &minw, &minh, minw, minh);
+   evas_object_size_hint_min_set(obj, minw, minh);
+   evas_object_size_hint_max_set(obj, -1, -1);
+}
+
 static void
 _radio_on_cb(void *data,
              Evas_Object *obj EINA_UNUSED,
@@ -314,7 +327,8 @@ ELM_WIDGET_KEY_DOWN_DEFAULT_IMPLEMENT(efl_ui_radio, Efl_Ui_Radio_Data)
 ELM_LAYOUT_TEXT_ALIASES_IMPLEMENT(MY_CLASS_PFX)
 
 #define EFL_UI_RADIO_EXTRA_OPS \
-   ELM_LAYOUT_TEXT_ALIASES_OPS(MY_CLASS_PFX)
+   ELM_LAYOUT_TEXT_ALIASES_OPS(MY_CLASS_PFX), \
+   ELM_LAYOUT_SIZING_EVAL_OPS(efl_ui_radio)
 
 #include "efl_ui_radio.eo.c"
 #include "efl_ui_radio_group.eo.c"

From c1c4072b0788c55be24068af32c5300d796c96df Mon Sep 17 00:00:00 2001
From: Christopher Michael <cp.michael@samsung.com>
Date: Mon, 22 Jul 2019 09:34:03 -0400
Subject: [PATCH 21/32] tests/ecore_wl2: Add wayland protocol as a dep for
 ecore_wl2 tests

ref T8016
---
 src/tests/ecore_wl2/meson.build | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/tests/ecore_wl2/meson.build b/src/tests/ecore_wl2/meson.build
index 70d9ed1e96..54fdeeec76 100644
--- a/src/tests/ecore_wl2/meson.build
+++ b/src/tests/ecore_wl2/meson.build
@@ -9,7 +9,7 @@ ecore_wl2_suite_src = [
 
 ecore_wl2_suite = executable('ecore_wl2_suite',
   ecore_wl2_suite_src,
-  dependencies: [ecore_wl2, ecore, check],
+  dependencies: [ecore_wl2, ecore, check, wayland_protocol],
   c_args : [
   '-DTESTS_BUILD_DIR="'+meson.current_build_dir()+'"',
   '-DTESTS_SRC_DIR="'+meson.current_source_dir()+'"']

From 725cce8cb40698a3ac0b8a06ed41b6fbe727b8d9 Mon Sep 17 00:00:00 2001
From: Christopher Michael <cp.michael@samsung.com>
Date: Mon, 22 Jul 2019 09:34:30 -0400
Subject: [PATCH 22/32] tests/ecore_wl2: Combine tests of
 ecore_wl2_window_surface functions

ref T8016
---
 src/tests/ecore_wl2/ecore_wl2_test_window.c | 22 +++++----------------
 1 file changed, 5 insertions(+), 17 deletions(-)

diff --git a/src/tests/ecore_wl2/ecore_wl2_test_window.c b/src/tests/ecore_wl2/ecore_wl2_test_window.c
index fea733e980..3f5e98cd50 100644
--- a/src/tests/ecore_wl2/ecore_wl2_test_window.c
+++ b/src/tests/ecore_wl2/ecore_wl2_test_window.c
@@ -41,11 +41,12 @@ EFL_START_TEST(wl2_window_new)
 }
 EFL_END_TEST
 
-EFL_START_TEST(wl2_window_surface_get)
+EFL_START_TEST(wl2_window_surface_test)
 {
    Ecore_Wl2_Display *disp;
    Ecore_Wl2_Window *win;
    struct wl_surface *surf;
+   int id = -1;
 
    disp = _display_connect();
    ck_assert(disp != NULL);
@@ -55,23 +56,11 @@ EFL_START_TEST(wl2_window_surface_get)
 
    surf = ecore_wl2_window_surface_get(win);
    ck_assert(surf != NULL);
-}
-EFL_END_TEST
-
-EFL_START_TEST(wl2_window_surface_id_get)
-{
-   Ecore_Wl2_Display *disp;
-   Ecore_Wl2_Window *win;
-   int id = -1;
-
-   disp = _display_connect();
-   ck_assert(disp != NULL);
-
-   win = _window_create(disp);
-   ck_assert(win != NULL);
 
    id = ecore_wl2_window_surface_id_get(win);
    ck_assert_int_lt(id, 0);
+
+   ck_assert_int_eq(wl_proxy_get_id((struct wl_proxy *)surf), id);
 }
 EFL_END_TEST
 
@@ -148,8 +137,7 @@ ecore_wl2_test_window(TCase *tc)
      {
         /* window tests can only run if there is an existing compositor */
         tcase_add_test(tc, wl2_window_new);
-        tcase_add_test(tc, wl2_window_surface_get);
-        tcase_add_test(tc, wl2_window_surface_id_get);
+        tcase_add_test(tc, wl2_window_surface_test);
         tcase_add_test(tc, wl2_window_rotation_get);
         tcase_add_test(tc, wl2_window_output_find);
         tcase_add_test(tc, wl2_window_aux_hints_supported_get);

From a526285db4dd281148a8d4ffd347bbc2dec881e3 Mon Sep 17 00:00:00 2001
From: Christopher Michael <cp.michael@samsung.com>
Date: Mon, 22 Jul 2019 09:48:19 -0400
Subject: [PATCH 23/32] tests/ecore_wl2: Reduce calls to
 ecore_wl2_display_connect

In order to reduce display setup time during test execution, we can
just connect once and run all the window tests after that.

ref T8016
---
 src/tests/ecore_wl2/ecore_wl2_test_window.c | 33 +++++----------------
 1 file changed, 7 insertions(+), 26 deletions(-)

diff --git a/src/tests/ecore_wl2/ecore_wl2_test_window.c b/src/tests/ecore_wl2/ecore_wl2_test_window.c
index 3f5e98cd50..88c4f7b652 100644
--- a/src/tests/ecore_wl2/ecore_wl2_test_window.c
+++ b/src/tests/ecore_wl2/ecore_wl2_test_window.c
@@ -10,12 +10,13 @@
 
 #include "ecore_wl2_suite.h"
 
+static Ecore_Wl2_Display *disp;
+
 static Ecore_Wl2_Display *
 _display_connect(void)
 {
-   Ecore_Wl2_Display *disp;
-
    disp = ecore_wl2_display_connect(NULL);
+   ck_assert(disp != NULL);
    return disp;
 }
 
@@ -30,12 +31,8 @@ _window_create(Ecore_Wl2_Display *disp)
 
 EFL_START_TEST(wl2_window_new)
 {
-   Ecore_Wl2_Display *disp;
    Ecore_Wl2_Window *win;
 
-   disp = _display_connect();
-   ck_assert(disp != NULL);
-
    win = _window_create(disp);
    ck_assert(win != NULL);
 }
@@ -43,14 +40,10 @@ EFL_END_TEST
 
 EFL_START_TEST(wl2_window_surface_test)
 {
-   Ecore_Wl2_Display *disp;
    Ecore_Wl2_Window *win;
    struct wl_surface *surf;
    int id = -1;
 
-   disp = _display_connect();
-   ck_assert(disp != NULL);
-
    win = _window_create(disp);
    ck_assert(win != NULL);
 
@@ -66,13 +59,9 @@ EFL_END_TEST
 
 EFL_START_TEST(wl2_window_rotation_get)
 {
-   Ecore_Wl2_Display *disp;
    Ecore_Wl2_Window *win;
    int rot = -1;
 
-   disp = _display_connect();
-   ck_assert(disp != NULL);
-
    win = _window_create(disp);
    ck_assert(win != NULL);
 
@@ -83,13 +72,9 @@ EFL_END_TEST
 
 EFL_START_TEST(wl2_window_output_find)
 {
-   Ecore_Wl2_Display *disp;
    Ecore_Wl2_Window *win;
    Ecore_Wl2_Output *out;
 
-   disp = _display_connect();
-   ck_assert(disp != NULL);
-
    win = _window_create(disp);
    ck_assert(win != NULL);
 
@@ -100,13 +85,9 @@ EFL_END_TEST
 
 EFL_START_TEST(wl2_window_aux_hints_supported_get)
 {
-   Ecore_Wl2_Display *disp;
    Ecore_Wl2_Window *win;
    Eina_List *l;
 
-   disp = _display_connect();
-   ck_assert(disp != NULL);
-
    win = _window_create(disp);
    ck_assert(win != NULL);
 
@@ -117,12 +98,8 @@ EFL_END_TEST
 
 EFL_START_TEST(wl2_window_display_get)
 {
-   Ecore_Wl2_Display *disp;
    Ecore_Wl2_Window *win;
 
-   disp = _display_connect();
-   ck_assert(disp != NULL);
-
    win = _window_create(disp);
    ck_assert(win != NULL);
 
@@ -135,6 +112,8 @@ ecore_wl2_test_window(TCase *tc)
 {
    if (getenv("WAYLAND_DISPLAY"))
      {
+        disp = _display_connect();
+
         /* window tests can only run if there is an existing compositor */
         tcase_add_test(tc, wl2_window_new);
         tcase_add_test(tc, wl2_window_surface_test);
@@ -142,5 +121,7 @@ ecore_wl2_test_window(TCase *tc)
         tcase_add_test(tc, wl2_window_output_find);
         tcase_add_test(tc, wl2_window_aux_hints_supported_get);
         tcase_add_test(tc, wl2_window_display_get);
+
+        ecore_wl2_display_disconnect(disp);
      }
 }

From 1b20f789dc05a331353d7bcf024827df6b554e23 Mon Sep 17 00:00:00 2001
From: Christopher Michael <cp.michael@samsung.com>
Date: Mon, 22 Jul 2019 10:05:27 -0400
Subject: [PATCH 24/32] Revert "tests/ecore_wl2: Reduce calls to
 ecore_wl2_display_connect"

Reverting this as it causes tests to stall (essentially 'meson test
ecore_wl2-suite' just hangs) when run inside a compositor.

This reverts commit a526285db4dd281148a8d4ffd347bbc2dec881e3.
---
 src/tests/ecore_wl2/ecore_wl2_test_window.c | 33 ++++++++++++++++-----
 1 file changed, 26 insertions(+), 7 deletions(-)

diff --git a/src/tests/ecore_wl2/ecore_wl2_test_window.c b/src/tests/ecore_wl2/ecore_wl2_test_window.c
index 88c4f7b652..3f5e98cd50 100644
--- a/src/tests/ecore_wl2/ecore_wl2_test_window.c
+++ b/src/tests/ecore_wl2/ecore_wl2_test_window.c
@@ -10,13 +10,12 @@
 
 #include "ecore_wl2_suite.h"
 
-static Ecore_Wl2_Display *disp;
-
 static Ecore_Wl2_Display *
 _display_connect(void)
 {
+   Ecore_Wl2_Display *disp;
+
    disp = ecore_wl2_display_connect(NULL);
-   ck_assert(disp != NULL);
    return disp;
 }
 
@@ -31,8 +30,12 @@ _window_create(Ecore_Wl2_Display *disp)
 
 EFL_START_TEST(wl2_window_new)
 {
+   Ecore_Wl2_Display *disp;
    Ecore_Wl2_Window *win;
 
+   disp = _display_connect();
+   ck_assert(disp != NULL);
+
    win = _window_create(disp);
    ck_assert(win != NULL);
 }
@@ -40,10 +43,14 @@ EFL_END_TEST
 
 EFL_START_TEST(wl2_window_surface_test)
 {
+   Ecore_Wl2_Display *disp;
    Ecore_Wl2_Window *win;
    struct wl_surface *surf;
    int id = -1;
 
+   disp = _display_connect();
+   ck_assert(disp != NULL);
+
    win = _window_create(disp);
    ck_assert(win != NULL);
 
@@ -59,9 +66,13 @@ EFL_END_TEST
 
 EFL_START_TEST(wl2_window_rotation_get)
 {
+   Ecore_Wl2_Display *disp;
    Ecore_Wl2_Window *win;
    int rot = -1;
 
+   disp = _display_connect();
+   ck_assert(disp != NULL);
+
    win = _window_create(disp);
    ck_assert(win != NULL);
 
@@ -72,9 +83,13 @@ EFL_END_TEST
 
 EFL_START_TEST(wl2_window_output_find)
 {
+   Ecore_Wl2_Display *disp;
    Ecore_Wl2_Window *win;
    Ecore_Wl2_Output *out;
 
+   disp = _display_connect();
+   ck_assert(disp != NULL);
+
    win = _window_create(disp);
    ck_assert(win != NULL);
 
@@ -85,9 +100,13 @@ EFL_END_TEST
 
 EFL_START_TEST(wl2_window_aux_hints_supported_get)
 {
+   Ecore_Wl2_Display *disp;
    Ecore_Wl2_Window *win;
    Eina_List *l;
 
+   disp = _display_connect();
+   ck_assert(disp != NULL);
+
    win = _window_create(disp);
    ck_assert(win != NULL);
 
@@ -98,8 +117,12 @@ EFL_END_TEST
 
 EFL_START_TEST(wl2_window_display_get)
 {
+   Ecore_Wl2_Display *disp;
    Ecore_Wl2_Window *win;
 
+   disp = _display_connect();
+   ck_assert(disp != NULL);
+
    win = _window_create(disp);
    ck_assert(win != NULL);
 
@@ -112,8 +135,6 @@ ecore_wl2_test_window(TCase *tc)
 {
    if (getenv("WAYLAND_DISPLAY"))
      {
-        disp = _display_connect();
-
         /* window tests can only run if there is an existing compositor */
         tcase_add_test(tc, wl2_window_new);
         tcase_add_test(tc, wl2_window_surface_test);
@@ -121,7 +142,5 @@ ecore_wl2_test_window(TCase *tc)
         tcase_add_test(tc, wl2_window_output_find);
         tcase_add_test(tc, wl2_window_aux_hints_supported_get);
         tcase_add_test(tc, wl2_window_display_get);
-
-        ecore_wl2_display_disconnect(disp);
      }
 }

From a26c787e2bb5a673981b03e17b832972e2de1a29 Mon Sep 17 00:00:00 2001
From: "Carsten Haitzler (Rasterman)" <raster@rasterman.com>
Date: Mon, 22 Jul 2019 15:10:40 +0100
Subject: [PATCH 25/32] Revert "efl_ui_layout: set needs_size_calc flag at
 constructor"

This reverts commit 98b19244329725c76ba601ea66ad5161841a68b9.

This totally broke elm widget min size calcs, e dialogs... sizing is
totally broken and unusable as a result. this is a major break and
needs immediate reverting back to a working state. Sorry Woki. You
need to test this... elementary_Test out of the box is totally broken
as all hell not to mention a lot more.
---
 src/lib/elementary/efl_ui_layout.c | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/src/lib/elementary/efl_ui_layout.c b/src/lib/elementary/efl_ui_layout.c
index 4b4643c72e..1390fc774f 100644
--- a/src/lib/elementary/efl_ui_layout.c
+++ b/src/lib/elementary/efl_ui_layout.c
@@ -2445,7 +2445,7 @@ _efl_ui_layout_base_efl_object_constructor(Eo *obj, Efl_Ui_Layout_Data *sd)
 }
 
 EOLIAN static Efl_Object*
-_efl_ui_layout_base_efl_object_finalize(Eo *obj, Efl_Ui_Layout_Data *pd)
+_efl_ui_layout_base_efl_object_finalize(Eo *obj, Efl_Ui_Layout_Data *pd EINA_UNUSED)
 {
    Eo *eo, *win;
    ELM_WIDGET_DATA_GET_OR_RETURN(obj, wd, NULL);
@@ -2459,8 +2459,6 @@ _efl_ui_layout_base_efl_object_finalize(Eo *obj, Efl_Ui_Layout_Data *pd)
    if (efl_file_get(wd->resize_obj) || efl_file_mmap_get(wd->resize_obj))
      efl_file_load(wd->resize_obj);
 
-   pd->needs_size_calc = EINA_TRUE;
-
    return eo;
 }
 

From 47423ab72064309d5a8e0824ab9f3761e11666e8 Mon Sep 17 00:00:00 2001
From: Mike Blumenkrantz <zmike@samsung.com>
Date: Mon, 22 Jul 2019 15:57:39 +0200
Subject: [PATCH 26/32] efl_ui/scroll_manager: mimic feel of legacy scroller

Summary:
previously this used a hard linear scroll with a fixed animation time for
mouse wheel events, resulting in an unnatural scroll feel due to abrupt
animation termination

using the decelerate interpolator improves this, and we should be using the
config to determine animation speed
Depends on D9347

Reviewers: bu5hm4n, segfaultxavi

Reviewed By: segfaultxavi

Subscribers: cedric, #reviewers, #committers

Tags: #efl

Differential Revision: https://phab.enlightenment.org/D9354
---
 src/lib/elementary/efl_ui_scroll_manager.c | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/src/lib/elementary/efl_ui_scroll_manager.c b/src/lib/elementary/efl_ui_scroll_manager.c
index 83794319bd..63654f3eba 100644
--- a/src/lib/elementary/efl_ui_scroll_manager.c
+++ b/src/lib/elementary/efl_ui_scroll_manager.c
@@ -756,7 +756,9 @@ _scroll_wheel_post_event_go(Efl_Ui_Scroll_Manager_Data *sd, int x, int y)
    else
      {
         cur =  efl_ui_pan_position_get(sd->pan_obj);
-        _scroll_manager_scrollto_animator_add(sd, cur.x, cur.y, x, y, 0.5, 0.5, INTERP_LINEAR);
+        _scroll_manager_scrollto_animator_add(sd, cur.x, cur.y, x, y,
+          _elm_config->bring_in_scroll_friction,
+          _elm_config->bring_in_scroll_friction, INTERP_DECEL);
      }
 }
 

From 8c90deecd737cf025ce1c3162e50937639c30f09 Mon Sep 17 00:00:00 2001
From: Subodh Kumar <s7158.kumar@samsung.com>
Date: Tue, 23 Jul 2019 09:37:09 +0200
Subject: [PATCH 27/32] [elm] Add missing sizing eval hook at check

Summary:
check is not shown in our Tizen demo.
sizing eval missing.

@fix

Test Plan: NA

Reviewers: zmike, Hermet, cedric, bu5hm4n

Subscribers: bu5hm4n, #reviewers, #committers

Tags: #efl

Reviewed-by: Marcel Hollerbach <mail@marcel-hollerbach.de>
Differential Revision: https://phab.enlightenment.org/D9378
---
 src/lib/elementary/efl_ui_check.c | 16 +++++++++++++++-
 src/lib/elementary/efl_ui_radio.c | 16 +---------------
 2 files changed, 16 insertions(+), 16 deletions(-)

diff --git a/src/lib/elementary/efl_ui_check.c b/src/lib/elementary/efl_ui_check.c
index 9f575621ff..a5072728ea 100644
--- a/src/lib/elementary/efl_ui_check.c
+++ b/src/lib/elementary/efl_ui_check.c
@@ -129,6 +129,19 @@ _efl_ui_check_efl_ui_widget_on_access_activate(Eo *obj EINA_UNUSED, Efl_Ui_Check
    return EINA_TRUE;
 }
 
+EOLIAN static void
+_efl_ui_check_elm_layout_sizing_eval(Eo *obj, Efl_Ui_Check_Data *_pd EINA_UNUSED)
+{
+   Evas_Coord minw = -1, minh = -1;
+   ELM_WIDGET_DATA_GET_OR_RETURN(obj, wd);
+
+   elm_coords_finger_size_adjust(1, &minw, 1, &minh);
+   edje_object_size_min_restricted_calc
+     (wd->resize_obj, &minw, &minh, minw, minh);
+   evas_object_size_hint_min_set(obj, minw, minh);
+   evas_object_size_hint_max_set(obj, -1, -1);
+}
+
 static Eina_Bool
 _key_action_activate(Evas_Object *obj, const char *params EINA_UNUSED)
 {
@@ -396,7 +409,8 @@ ELM_LAYOUT_TEXT_ALIASES_IMPLEMENT(MY_CLASS_PFX)
 
 #define EFL_UI_CHECK_EXTRA_OPS \
    ELM_LAYOUT_CONTENT_ALIASES_OPS(MY_CLASS_PFX), \
-   ELM_LAYOUT_TEXT_ALIASES_OPS(MY_CLASS_PFX)
+   ELM_LAYOUT_TEXT_ALIASES_OPS(MY_CLASS_PFX), \
+   ELM_LAYOUT_SIZING_EVAL_OPS(efl_ui_check)
 
 
 #include "efl_ui_check.eo.c"
diff --git a/src/lib/elementary/efl_ui_radio.c b/src/lib/elementary/efl_ui_radio.c
index 099001fdb3..edbc14844f 100644
--- a/src/lib/elementary/efl_ui_radio.c
+++ b/src/lib/elementary/efl_ui_radio.c
@@ -181,19 +181,6 @@ _efl_ui_radio_efl_ui_widget_theme_apply(Eo *obj, Efl_Ui_Radio_Data *sd EINA_UNUS
    return int_ret;
 }
 
-EOLIAN static void
-_efl_ui_radio_elm_layout_sizing_eval(Eo *obj, Efl_Ui_Radio_Data *_pd EINA_UNUSED)
-{
-   Evas_Coord minw = -1, minh = -1;
-   ELM_WIDGET_DATA_GET_OR_RETURN(obj, wd);
-
-   elm_coords_finger_size_adjust(1, &minw, 1, &minh);
-   edje_object_size_min_restricted_calc
-     (wd->resize_obj, &minw, &minh, minw, minh);
-   evas_object_size_hint_min_set(obj, minw, minh);
-   evas_object_size_hint_max_set(obj, -1, -1);
-}
-
 static void
 _radio_on_cb(void *data,
              Evas_Object *obj EINA_UNUSED,
@@ -327,8 +314,7 @@ ELM_WIDGET_KEY_DOWN_DEFAULT_IMPLEMENT(efl_ui_radio, Efl_Ui_Radio_Data)
 ELM_LAYOUT_TEXT_ALIASES_IMPLEMENT(MY_CLASS_PFX)
 
 #define EFL_UI_RADIO_EXTRA_OPS \
-   ELM_LAYOUT_TEXT_ALIASES_OPS(MY_CLASS_PFX), \
-   ELM_LAYOUT_SIZING_EVAL_OPS(efl_ui_radio)
+   ELM_LAYOUT_TEXT_ALIASES_OPS(MY_CLASS_PFX)
 
 #include "efl_ui_radio.eo.c"
 #include "efl_ui_radio_group.eo.c"

From 253e18159bbc601972cad4b3b42bbbe23cbf390d Mon Sep 17 00:00:00 2001
From: Vitor Sousa <vitorsousa@expertisesolutions.com.br>
Date: Tue, 23 Jul 2019 14:09:23 +0200
Subject: [PATCH 28/32] eolian_mono: parse `binbuf` and `event` keywords, also
 re-enable binbuf tests

Summary:
Parse `binbuf` and `event` type names and generate the proper binding type.

In 288f645e3cdb tests for `Eina.Binbuf` were disabled in order to avoid the
usage of deprecated notations in eolian.

Since the new `binbuf` keyword works as a substitute for the old notation
`ptr(Eina.Binbuf)`, tests were updated and re-enabled using the new notation.

Test Plan: `meson test`

Reviewers: felipealmeida, lauromoura, q66

Reviewed By: q66

Subscribers: cedric, #reviewers, #committers

Tags: #efl

Differential Revision: https://phab.enlightenment.org/D9349
---
 .../eolian/mono/marshall_type_impl.hh         | 14 ++++++++++
 src/bin/eolian_mono/eolian/mono/type_impl.hh  |  8 ++++++
 src/tests/efl_mono/Eina.cs                    |  2 --
 src/tests/efl_mono/EinaTestData.cs            |  2 --
 src/tests/efl_mono/StructHelpers.cs           | 10 +++----
 src/tests/efl_mono/dummy_test_object.c        |  8 ++----
 src/tests/efl_mono/dummy_test_object.eo       | 28 +++++++++----------
 7 files changed, 42 insertions(+), 30 deletions(-)

diff --git a/src/bin/eolian_mono/eolian/mono/marshall_type_impl.hh b/src/bin/eolian_mono/eolian/mono/marshall_type_impl.hh
index ce16c9a374..8de109e88b 100644
--- a/src/bin/eolian_mono/eolian/mono/marshall_type_impl.hh
+++ b/src/bin/eolian_mono/eolian/mono/marshall_type_impl.hh
@@ -103,6 +103,20 @@ struct marshall_type_visitor_generate
                 r.namespaces.clear();
                 return r;
               }}
+           , {"binbuf", nullptr, [&]
+              {
+                regular_type_def r = regular;
+                r.base_type = "System.IntPtr";
+                r.namespaces.clear();
+                return r;
+              }}
+           , {"event", nullptr, [&]
+              {
+                regular_type_def r = regular;
+                r.base_type = "Efl.Event.NativeStruct";
+                r.namespaces.clear();
+                return r;
+              }}
            , {"any_value", true, [&]
                {
                 regular_type_def r = regular;
diff --git a/src/bin/eolian_mono/eolian/mono/type_impl.hh b/src/bin/eolian_mono/eolian/mono/type_impl.hh
index abfa6e9db6..7e5159fc26 100644
--- a/src/bin/eolian_mono/eolian/mono/type_impl.hh
+++ b/src/bin/eolian_mono/eolian/mono/type_impl.hh
@@ -214,6 +214,14 @@ struct visitor_generate
               {
                 return regular_type_def{"Eina.Strbuf", regular.base_qualifier, {}};
               }}
+           , {"binbuf", nullptr, [&]
+              {
+                return regular_type_def{"Eina.Binbuf", regular.base_qualifier, {}};
+              }}
+           , {"event", nullptr, [&]
+              {
+                return regular_type_def{"Efl.Event", regular.base_qualifier, {}};
+              }}
            , {"any_value", true, [&]
               { return regular_type_def{"Eina.Value", regular.base_qualifier, {}};
               }}
diff --git a/src/tests/efl_mono/Eina.cs b/src/tests/efl_mono/Eina.cs
index 2c22cdb444..d71d6c8f7f 100644
--- a/src/tests/efl_mono/Eina.cs
+++ b/src/tests/efl_mono/Eina.cs
@@ -12,7 +12,6 @@ namespace TestSuite
 
 #if EFL_BETA
 
-/*
 class TestEinaBinbuf
 {
     private static readonly byte[] test_string = System.Text.Encoding.UTF8.GetBytes("0123456789ABCDEF");
@@ -309,7 +308,6 @@ class TestEinaBinbuf
         Test.Assert(t.binbuf_return_own_no_longer_own());
     }
 }
-*/
 
 #endif
 
diff --git a/src/tests/efl_mono/EinaTestData.cs b/src/tests/efl_mono/EinaTestData.cs
index 0e5d4bb5a1..81b318ffae 100644
--- a/src/tests/efl_mono/EinaTestData.cs
+++ b/src/tests/efl_mono/EinaTestData.cs
@@ -153,7 +153,6 @@ class NativeInheritImpl : Dummy.TestObject
     // //
     //
 #if EFL_BETA
-/*
     override public bool EinaBinbufIn(Eina.Binbuf binbuf)
     {
         binbuf_in_flag = true;
@@ -282,7 +281,6 @@ class NativeInheritImpl : Dummy.TestObject
         binbuf_return_own_binbuf = null;
         return r;
     }
-*/
 #endif
 }
 
diff --git a/src/tests/efl_mono/StructHelpers.cs b/src/tests/efl_mono/StructHelpers.cs
index 088e613f73..110432f08f 100644
--- a/src/tests/efl_mono/StructHelpers.cs
+++ b/src/tests/efl_mono/StructHelpers.cs
@@ -148,8 +148,8 @@ internal class StructHelpers
         complex.Fany_value_ptr = new Eina.Value(Eina.ValueType.String);
         complex.Fany_value_ptr.Set("abc");
 
-        //complex.Fbinbuf = new Eina.Binbuf();
-        //complex.Fbinbuf.Append(126);
+        complex.Fbinbuf = new Eina.Binbuf();
+        complex.Fbinbuf.Append(126);
 
         complex.Fslice.Length = 1;
         complex.Fslice.Mem = Eina.MemoryNative.Alloc(1);
@@ -187,8 +187,8 @@ internal class StructHelpers
         Test.Assert(complex.Fany_value_ptr.Get(out str_val));
         Test.Assert(str_val == "abc");
 
-        //Test.Assert(complex.Fbinbuf.Length == 1);
-        //Test.Assert(complex.Fbinbuf.GetBytes()[0] == 126);
+        Test.Assert(complex.Fbinbuf.Length == 1);
+        Test.Assert(complex.Fbinbuf.GetBytes()[0] == 126);
 
         Test.Assert(complex.Fslice.Length == 1);
         Test.Assert(complex.Fslice.GetBytes()[0] == 125);
@@ -206,7 +206,7 @@ internal class StructHelpers
         Test.Assert(complex.Fiterator == null);
         Test.Assert(complex.Fany_value == null);
         Test.Assert(complex.Fany_value_ptr == null);
-        //Test.Assert(complex.Fbinbuf == null);
+        Test.Assert(complex.Fbinbuf == null);
 
         Test.Assert(complex.Fslice.Length == 0);
         Test.Assert(complex.Fslice.Mem == IntPtr.Zero);
diff --git a/src/tests/efl_mono/dummy_test_object.c b/src/tests/efl_mono/dummy_test_object.c
index 1a1def6ff6..e6bec29362 100644
--- a/src/tests/efl_mono/dummy_test_object.c
+++ b/src/tests/efl_mono/dummy_test_object.c
@@ -347,7 +347,6 @@ Eina_Rw_Slice _dummy_test_object_eina_rw_slice_return(EINA_UNUSED Eo *obj, EINA_
   return slc;
 }
 
-#if 0
 Eina_Bool _dummy_test_object_eina_binbuf_in(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd, Eina_Binbuf *binbuf)
 {
   Eina_Bool r = (0 == memcmp(eina_binbuf_string_get(binbuf), base_seq, eina_binbuf_length_get(binbuf)));
@@ -459,7 +458,6 @@ Eina_Binbuf *_dummy_test_object_call_eina_binbuf_return_own(Eo *obj, EINA_UNUSED
 {
   return dummy_test_object_eina_binbuf_return_own(obj);
 }
-#endif
 
 
 static const int base_seq_int[] = {0x0,0x2A,0x42};
@@ -4118,8 +4116,8 @@ void struct_complex_with_values(Dummy_StructComplex *complex)
    complex->fany_value_ptr = eina_value_new(EINA_VALUE_TYPE_STRING);
    eina_value_set(complex->fany_value_ptr, "abc");
 
-   //complex->fbinbuf = eina_binbuf_new();
-   //eina_binbuf_append_char(complex->fbinbuf, 126);
+   complex->fbinbuf = eina_binbuf_new();
+   eina_binbuf_append_char(complex->fbinbuf, 126);
 
    complex->fslice.len = 1;
    complex->fslice.mem = malloc(1);
@@ -4153,10 +4151,8 @@ Eina_Bool check_and_modify_struct_complex(Dummy_StructComplex *complex)
    if (!eina_value_get(complex->fany_value_ptr, &str_val) || strcmp(str_val, "abc") != 0)
      return EINA_FALSE;
 
-   /*
    if (eina_binbuf_length_get(complex->fbinbuf) != 1 || eina_binbuf_string_get(complex->fbinbuf)[0] != 126)
      return EINA_FALSE;
-   */
 
    if (complex->fslice.len != 1 || *(char*)complex->fslice.mem != 125)
      return EINA_FALSE;
diff --git a/src/tests/efl_mono/dummy_test_object.eo b/src/tests/efl_mono/dummy_test_object.eo
index 005431dd6e..97b7cf6641 100644
--- a/src/tests/efl_mono/dummy_test_object.eo
+++ b/src/tests/efl_mono/dummy_test_object.eo
@@ -81,7 +81,7 @@ struct @beta @free(free) Dummy.StructComplex {
    fiterator: iterator<string>;
    fany_value: any_value;
    fany_value_ptr: any_value_ptr;
-   // fbinbuf: ptr(Eina.Binbuf);
+   fbinbuf: binbuf;
    fslice: slice<ubyte>;
    // fslice: ptr(Eina.Slice); // TODO
    fobj: Dummy.Numberwrapper;
@@ -298,31 +298,30 @@ class Dummy.Test_Object extends Efl.Object implements Dummy.Test_Iface {
       }
       */
 
-      /*
       eina_binbuf_in @beta {
          params {
-            @in binbuf: ptr(Eina.Binbuf);
+            @in binbuf: binbuf;
          }
          return: bool;
       }
 
       call_eina_binbuf_in @beta {
          params {
-            @in binbuf: ptr(Eina.Binbuf);
+            @in binbuf: binbuf;
          }
          return: bool;
       }
 
       eina_binbuf_in_own @beta {
          params {
-            @in binbuf: ptr(Eina.Binbuf) @owned;
+            @in binbuf: binbuf @owned;
          }
          return: bool;
       }
 
       call_eina_binbuf_in_own @beta {
         params {
-            @in str: ptr(Eina.Binbuf) @owned;
+            @in str: binbuf @owned;
         }
         return: bool;
       }
@@ -333,13 +332,13 @@ class Dummy.Test_Object extends Efl.Object implements Dummy.Test_Iface {
 
       eina_binbuf_out @beta {
          params {
-            @out binbuf: ptr(Eina.Binbuf);
+            @out binbuf: binbuf;
          }
          return: bool;
       }
 
       call_eina_binbuf_out @beta {
-         return: ptr(Eina.Binbuf);
+         return: binbuf;
       }
 
       check_binbuf_out {
@@ -348,21 +347,21 @@ class Dummy.Test_Object extends Efl.Object implements Dummy.Test_Iface {
 
       eina_binbuf_out_own @beta {
          params {
-            @out binbuf: ptr(Eina.Binbuf) @owned;
+            @out binbuf: binbuf @owned;
          }
          return: bool;
       }
 
       call_eina_binbuf_out_own @beta {
-         return: ptr(Eina.Binbuf) @owned;
+         return: binbuf @owned;
       }
 
       eina_binbuf_return @beta {
-         return: ptr(Eina.Binbuf);
+         return: binbuf;
       }
 
       call_eina_binbuf_return @beta {
-         return: ptr(Eina.Binbuf);
+         return: binbuf;
       }
 
       check_binbuf_return {
@@ -370,13 +369,12 @@ class Dummy.Test_Object extends Efl.Object implements Dummy.Test_Iface {
       }
 
       eina_binbuf_return_own @beta {
-         return: ptr(Eina.Binbuf) @owned;
+         return: binbuf @owned;
       }
 
       call_eina_binbuf_return_own @beta {
-         return: ptr(Eina.Binbuf) @owned;
+         return: binbuf @owned;
       }
-      */
 
       /* Eina Array */
 

From 3eb7b3793b0afcc79143a74a4052cb6179334f08 Mon Sep 17 00:00:00 2001
From: Marcel Hollerbach <mail@marcel-hollerbach.de>
Date: Mon, 22 Jul 2019 11:38:00 +0200
Subject: [PATCH 29/32] eolian: start to express ownership transfere

before @owned was not even expressed in the api definitions of the
generated APIs, this adds support for it.

@owned is now expressed with EFL_TRANSFER_OWNERSHIP in a arguments. And
that preprocessor directive is documented.

Reviewed-by: Daniel Kolesa <daniel@octaforge.org>
Differential Revision: https://phab.enlightenment.org/D9369
---
 src/bin/eolian/headers.c                         |  4 ++++
 src/lib/eo/Eo.h                                  | 14 ++++++++++++++
 src/tests/eolian/data/function_as_argument_ref.h |  2 +-
 src/tests/eolian/data/function_types_ref.h       |  2 +-
 src/tests/eolian/data/struct_ref.h               |  2 +-
 src/tests/eolian/data/typedef_ref.h              |  2 +-
 6 files changed, 22 insertions(+), 4 deletions(-)

diff --git a/src/bin/eolian/headers.c b/src/bin/eolian/headers.c
index 7aab7552ef..a4a20c495c 100644
--- a/src/bin/eolian/headers.c
+++ b/src/bin/eolian/headers.c
@@ -35,6 +35,8 @@ _gen_param(Eina_Strbuf *buf, Eolian_Function_Parameter *pr,
    eina_strbuf_append(buf, _get_add_star(ftype, eolian_parameter_direction_get(pr)));
    eina_strbuf_append(buf, prn);
    eina_stringshare_del(prtn);
+   if (eolian_type_is_owned(eolian_parameter_type_get(pr)))
+     eina_strbuf_append(buf, " EFL_TRANSFER_OWNERSHIP");
    *rpid = 0;
    return 1;
 }
@@ -166,6 +168,8 @@ _gen_func(const Eolian_State *state, const Eolian_Function *fid,
           flagbuf = eina_strbuf_new();
         eina_strbuf_prepend(flagbuf, " EINA_WARN_UNUSED_RESULT");
      }
+   if (rtp && eolian_type_is_owned(rtp))
+     eina_strbuf_append(buf, " EFL_TRANSFER_OWNERSHIP");
    if (flagbuf)
      {
         eina_strbuf_append(buf, eina_strbuf_string_get(flagbuf));
diff --git a/src/lib/eo/Eo.h b/src/lib/eo/Eo.h
index 34c8a8c4b2..69fd84a560 100644
--- a/src/lib/eo/Eo.h
+++ b/src/lib/eo/Eo.h
@@ -212,6 +212,19 @@ EAPI extern unsigned int _efl_object_init_generation;
  */
 typedef void (*Efl_Del_Intercept) (Eo *obj_id);
 
+/**
+ * This is a no-operation. Its presence behind a function parameter indicates that
+ * ownership of the parameter is transferred to the callee.
+ * When present after a method, it indicates that the return value of the method is
+ * transferred to the caller.
+ * For objects, ownership transfer means that exactly one reference is transferred.
+ * If you transfer ownership without owning a reference in the first place, you will
+ * get unexpected behavior.
+ * For non-Objects, ownership transfer means that the responsibility of freeing a
+ * segment of memory is passed on.
+ */
+#define EFL_TRANSFER_OWNERSHIP
+
 #include "efl_object_override.eo.h"
 #include "efl_object.eo.h"
 
@@ -2369,6 +2382,7 @@ EAPI Eina_Iterator *eo_objects_iterator_new(void);
  * @return EINA_TRUE if the object is ownable. EINA_FALSE if not.
  */
 EAPI Eina_Bool efl_ownable_get(const Eo *obj);
+
 /**
  * @}
  */
diff --git a/src/tests/eolian/data/function_as_argument_ref.h b/src/tests/eolian/data/function_as_argument_ref.h
index 7ab0479a9f..2b677aefb3 100644
--- a/src/tests/eolian/data/function_as_argument_ref.h
+++ b/src/tests/eolian/data/function_as_argument_ref.h
@@ -19,6 +19,6 @@ EWAPI const Efl_Class *function_as_argument_class_get(void);
 
 EOAPI void function_as_argument_set_cb(Eo *obj, void *cb_data, SimpleFunc cb, Eina_Free_Cb cb_free_cb);
 
-EOAPI char *function_as_argument_call_cb(Eo *obj, int a, double b);
+EOAPI char *function_as_argument_call_cb(Eo *obj, int a, double b) EFL_TRANSFER_OWNERSHIP;
 
 #endif
diff --git a/src/tests/eolian/data/function_types_ref.h b/src/tests/eolian/data/function_types_ref.h
index a53ba715d2..45564c6893 100644
--- a/src/tests/eolian/data/function_types_ref.h
+++ b/src/tests/eolian/data/function_types_ref.h
@@ -8,7 +8,7 @@ typedef void (*VoidFunc)(void *data);
 
 typedef const char * (*SimpleFunc)(void *data, int a, double b);
 
-typedef double (*ComplexFunc)(void *data, const char *c, char **d);
+typedef double (*ComplexFunc)(void *data, const char *c, char **d EFL_TRANSFER_OWNERSHIP);
 
 typedef void (*FuncAsArgFunc)(void *data, void *cb_data, VoidFunc cb, Eina_Free_Cb cb_free_cb, void *another_cb_data, SimpleFunc another_cb, Eina_Free_Cb another_cb_free_cb);
 
diff --git a/src/tests/eolian/data/struct_ref.h b/src/tests/eolian/data/struct_ref.h
index 6e6299b3dc..ddcb20a752 100644
--- a/src/tests/eolian/data/struct_ref.h
+++ b/src/tests/eolian/data/struct_ref.h
@@ -38,7 +38,7 @@ EWAPI const Efl_Class *struct_class_get(void);
  *
  * @ingroup Struct
  */
-EOAPI char *struct_foo(Eo *obj, int idx);
+EOAPI char *struct_foo(Eo *obj, int idx) EFL_TRANSFER_OWNERSHIP;
 
 EOAPI Named *struct_bar(Eo *obj);
 
diff --git a/src/tests/eolian/data/typedef_ref.h b/src/tests/eolian/data/typedef_ref.h
index ffae7bc332..1f220b87b2 100644
--- a/src/tests/eolian/data/typedef_ref.h
+++ b/src/tests/eolian/data/typedef_ref.h
@@ -43,6 +43,6 @@ typedef enum
 
 EWAPI const Efl_Class *typedef_class_get(void);
 
-EOAPI char *typedef_foo(Eo *obj, int idx);
+EOAPI char *typedef_foo(Eo *obj, int idx) EFL_TRANSFER_OWNERSHIP;
 
 #endif

From 5585420e858bbb17ae3b7cc599b4a0f2eb178075 Mon Sep 17 00:00:00 2001
From: Xavi Artigas <xavierartigas@yahoo.es>
Date: Tue, 23 Jul 2019 16:38:04 +0200
Subject: [PATCH 30/32] mono-docs: Indicate when a class is BETA

Summary:
The mono generator adds a <remarks> section to all BETA classes with an explanatory text.
These tags are understood by DocFX and Monodevelop.
On top of this, this commit modifies the DocFX template to give the Remarks section a more
prominent place in the page.

Test Plan: Render docs, Beta classes should have a big blue box with a remark about the class being Beta and dangerous.

Reviewers: lauromoura, vitor.sousa

Subscribers: cedric, #reviewers, #committers

Tags: #efl

Differential Revision: https://phab.enlightenment.org/D9381
---
 .../default_efl/partials/class.header.tmpl.partial     | 10 ++++++----
 doc/docfx/default_efl/partials/class.tmpl.partial      |  4 ----
 doc/docfx/default_efl/styles/docfx.css                 |  6 ++++++
 src/bin/eolian_mono/eolian/mono/documentation.hh       |  6 ++++++
 4 files changed, 18 insertions(+), 8 deletions(-)

diff --git a/doc/docfx/default_efl/partials/class.header.tmpl.partial b/doc/docfx/default_efl/partials/class.header.tmpl.partial
index f6bff1af39..18c6dc7341 100644
--- a/doc/docfx/default_efl/partials/class.header.tmpl.partial
+++ b/doc/docfx/default_efl/partials/class.header.tmpl.partial
@@ -3,6 +3,12 @@
 <h1 id="{{id}}" data-uid="{{uid}}" class="text-break">{{>partials/title}}</h1>
 <div class="markdown level0 summary">{{{summary}}}</div>
 <div class="markdown level0 conceptual">{{{conceptual}}}</div>
+{{#remarks}}
+<div class="remarks">
+<h5 id="{{id}}_remarks"><strong>{{__global.remarks}}</strong></h5>
+{{{remarks}}}
+</div>
+{{/remarks}}
 {{#inClass}}
 <div class="inheritance">
   <h5>{{__global.inheritance}}</h5>
@@ -82,10 +88,6 @@
   </tbody>
 </table>
 {{/syntax.typeParameters.0}}
-{{#remarks}}
-<h5 id="{{id}}_remarks"><strong>{{__global.remarks}}</strong></h5>
-<div class="markdown level0 remarks">{{{remarks}}}</div>
-{{/remarks}}
 {{#example.0}}
 <h5 id="{{id}}_examples"><strong>{{__global.examples}}</strong></h5>
 {{/example.0}}
diff --git a/doc/docfx/default_efl/partials/class.tmpl.partial b/doc/docfx/default_efl/partials/class.tmpl.partial
index ae9de66364..75bfce0e9b 100644
--- a/doc/docfx/default_efl/partials/class.tmpl.partial
+++ b/doc/docfx/default_efl/partials/class.tmpl.partial
@@ -143,10 +143,6 @@
 <h5 class="overrides">{{__global.overrides}}</h5>
 <div><xref uid="{{uid}}" altProperty="fullName" displayProperty="nameWithType"/></div>
 {{/overridden}}
-{{#remarks}}
-<h5 id="{{id}}_remarks">{{__global.remarks}}</h5>
-<div class="markdown level1 remarks">{{{remarks}}}</div>
-{{/remarks}}
 {{#example.0}}
 <h5 id="{{id}}_examples">{{__global.examples}}</h5>
 {{/example.0}}
diff --git a/doc/docfx/default_efl/styles/docfx.css b/doc/docfx/default_efl/styles/docfx.css
index f94c4b0377..81beac718e 100644
--- a/doc/docfx/default_efl/styles/docfx.css
+++ b/doc/docfx/default_efl/styles/docfx.css
@@ -995,3 +995,9 @@ div.embeddedvideo iframe {
 
 .mainContainer[dir='rtl'] main ul[role="tablist"] {
   margin: 0; }
+
+.remarks {
+  background-color: #c0c0ff;
+  border-radius: 6px;
+  padding: 6px;
+}
diff --git a/src/bin/eolian_mono/eolian/mono/documentation.hh b/src/bin/eolian_mono/eolian/mono/documentation.hh
index a672d209b4..26e5645eb2 100644
--- a/src/bin/eolian_mono/eolian/mono/documentation.hh
+++ b/src/bin/eolian_mono/eolian/mono/documentation.hh
@@ -12,6 +12,7 @@
 #include <Eina.h>
 
 static const std::string BETA_REF_SUFFIX = " (object still in beta stage)";
+static const std::string BETA_SUMMARY_REMARKS = "This is a \\<b\\>BETA\\</b\\> class. It can be modified or removed in the future. Do not use it for product development.";
 
 namespace eolian_mono {
 
@@ -390,6 +391,11 @@ struct documentation_generator
    {
        if (!generate(sink, klass.documentation, context)) return false;
 
+       if (klass.is_beta)
+         {
+            if (!generate_tag(sink, "remarks", BETA_SUMMARY_REMARKS, context)) return false;
+         }
+
        std::string klass_name = name_helpers::klass_full_concrete_or_interface_name(klass);
        return generate_tag_example(sink, klass_name, context);
    }

From d20b8ad42adf8ce6968fc39c38960cf933218780 Mon Sep 17 00:00:00 2001
From: Xavi Artigas <xavierartigas@yahoo.es>
Date: Tue, 23 Jul 2019 12:45:17 +0200
Subject: [PATCH 31/32] mono-docs: Allow HTML codes in documentation

Summary:
All comments from EO files are HTML-escaped (i.e. "<" is turned into "&lt;"), and this is good.
However all text added by the mono code generator is HTML-escaped too, and that is a pity.
Circumventing the escaping in the generator involves serious code changes so it is simpler to
allow "escaping" characters to avoid escaping...
"<" is turned into "&lt;"
but
"\<" is turned into "<"

If you are giving these strings from C, remember that the backslash needs to be escaped too!
For example: "\\<b\\>Hello\\</b\\>"

This is intended for use in the generators, NOT in the EO docs.

Test Plan: Everything works as before, but now HTML codes can be added from the generators.

Reviewers: lauromoura, vitor.sousa, felipealmeida

Subscribers: cedric, #reviewers, #committers

Tags: #efl

Differential Revision: https://phab.enlightenment.org/D9380
---
 src/lib/eolian_cxx/grammar/html_escaped_string.hpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/lib/eolian_cxx/grammar/html_escaped_string.hpp b/src/lib/eolian_cxx/grammar/html_escaped_string.hpp
index 9a6eef1f7c..371afcda24 100644
--- a/src/lib/eolian_cxx/grammar/html_escaped_string.hpp
+++ b/src/lib/eolian_cxx/grammar/html_escaped_string.hpp
@@ -26,6 +26,7 @@ struct html_escaped_string_generator
                case '\'': out.append("&apos;"); break;
                case '<':  out.append("&lt;"); break;
                case '>':  out.append("&gt;"); break;
+               case '\\': if (pos < input.size() - 1) pos++; // Deliberate fallthrough
                default:   out.append(&input[pos], 1); break;
             }
         }

From 7c030aa57e0141bd5802b7201f31b9bd7b138a0f Mon Sep 17 00:00:00 2001
From: Xavi Artigas <xavierartigas@yahoo.es>
Date: Tue, 23 Jul 2019 20:58:42 +0200
Subject: [PATCH 32/32] mono-docs: Indicate when methods and properties are
 BETA

Summary:
Previous commit added a <remarks> section to BETA classes.
Methods (and properties) cannot have <remarks> section so a bit
of bold text is added instead to their summary.

Depends on D9380

Test Plan: Generate docs and observe beta methods and properties have a note regarding their betaness in the summary.

Reviewers: lauromoura, vitor.sousa

Subscribers: cedric, #reviewers, #committers

Tags: #efl

Differential Revision: https://phab.enlightenment.org/D9382
---
 .../eolian_mono/eolian/mono/documentation.hh  | 38 +++++++++++++++----
 1 file changed, 31 insertions(+), 7 deletions(-)

diff --git a/src/bin/eolian_mono/eolian/mono/documentation.hh b/src/bin/eolian_mono/eolian/mono/documentation.hh
index 26e5645eb2..93bc42ef4b 100644
--- a/src/bin/eolian_mono/eolian/mono/documentation.hh
+++ b/src/bin/eolian_mono/eolian/mono/documentation.hh
@@ -12,7 +12,9 @@
 #include <Eina.h>
 
 static const std::string BETA_REF_SUFFIX = " (object still in beta stage)";
-static const std::string BETA_SUMMARY_REMARKS = "This is a \\<b\\>BETA\\</b\\> class. It can be modified or removed in the future. Do not use it for product development.";
+static const std::string BETA_CLASS_REMARK = "This is a \\<b\\>BETA\\</b\\> class. It can be modified or removed in the future. Do not use it for product development.";
+static const std::string BETA_PROPERTY_REMARK = "\n\n\\<b\\>This is a BETA property\\</b\\>. It can be modified or removed in the future. Do not use it for product development.";
+static const std::string BETA_METHOD_REMARK = "\n\n\\<b\\>This is a BETA method\\</b\\>. It can be modified or removed in the future. Do not use it for product development.";
 
 namespace eolian_mono {
 
@@ -393,7 +395,7 @@ struct documentation_generator
 
        if (klass.is_beta)
          {
-            if (!generate_tag(sink, "remarks", BETA_SUMMARY_REMARKS, context)) return false;
+            if (!generate_tag(sink, "remarks", BETA_CLASS_REMARK, context)) return false;
          }
 
        std::string klass_name = name_helpers::klass_full_concrete_or_interface_name(klass);
@@ -403,7 +405,17 @@ struct documentation_generator
    template<typename OutputIterator, typename Context>
    bool generate(OutputIterator sink, attributes::property_def const& prop, Context const& context) const
    {
-       if (!generate(sink, prop.documentation, context))
+       std::string tail_text = "";
+
+       if (!prop.klass.is_beta)
+         {
+            if ((prop.setter.is_engaged() && prop.setter->is_beta) ||
+                (prop.getter.is_engaged() && prop.getter->is_beta))
+              {
+                 tail_text = BETA_PROPERTY_REMARK;
+              }
+         }
+       if (!generate(sink, prop.documentation, context, tail_text))
          return false;
 
        std::string text;
@@ -434,16 +446,21 @@ struct documentation_generator
    template<typename OutputIterator, typename Context>
    bool generate_property(OutputIterator sink, attributes::function_def const& func, Context const& context) const
    {
+       std::string tail_text = "";
+       if (!func.klass.is_beta && func.is_beta)
+         {
+            tail_text = BETA_METHOD_REMARK;
+         }
 
        // First, try the get/set specific documentation
        if (!func.documentation.summary.empty())
          {
-            if (!generate(sink, func.documentation, context))
+            if (!generate(sink, func.documentation, context, tail_text))
               return false;
          }
        else // fallback to common property documentation
          {
-            if (!generate(sink, func.property_documentation, context))
+            if (!generate(sink, func.property_documentation, context, tail_text))
               return false;
          }
 
@@ -463,7 +480,13 @@ struct documentation_generator
    template<typename OutputIterator, typename Context>
    bool generate_function(OutputIterator sink, attributes::function_def const& func, Context const& context) const
    {
-       if (!generate(sink, func.documentation, context))
+       std::string tail_text = "";
+       if (!func.klass.is_beta && func.is_beta)
+         {
+            tail_text = BETA_METHOD_REMARK;
+         }
+
+       if (!generate(sink, func.documentation, context, tail_text))
          return false;
 
        for (auto&& param : func.parameters)
@@ -486,11 +509,12 @@ struct documentation_generator
    }
 
    template<typename OutputIterator, typename Context>
-   bool generate(OutputIterator sink, attributes::documentation_def const& doc, Context const& context) const
+   bool generate(OutputIterator sink, attributes::documentation_def const& doc, Context const& context, std::string tail_text = "") const
    {
       std::string str = doc.full_text;
       if (!doc.since.empty())
         str += "\n(Since EFL " + doc.since + ")";
+      str += tail_text;
       return generate_tag_summary(sink, str, context);
    }