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

@@ -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"

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"

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;
+   }
+}

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',