evas vg: Linear gradients code cleanup

Removed ector dependency. Removed redundant code.

Change-Id: I1f9744ad354ee75feb63da7727bfdefb3e834b12

diff --git a/src/examples/evas/efl-canvas-vg-simple.c b/src/examples/evas/efl-canvas-vg-simple.c
index 15d74ae..4d8f310 100644 (file)
--- a/src/examples/evas/efl-canvas-vg-simple.c
+++ b/src/examples/evas/efl-canvas-vg-simple.c
@@ -505,8 +505,8 @@ _3_gradient_test()
 
   //Make Linear gradient for fill
   grad_stroke = efl_add(EFL_CANVAS_VG_GRADIENT_LINEAR_CLASS, container,
-     efl_gfx_gradient_linear_start_set(efl_added, 0, 0),
-     efl_gfx_gradient_linear_end_set(efl_added, 100, 100),
+     evas_vg_gradient_linear_start_set(efl_added, 0, 0),
+     evas_vg_gradient_linear_end_set(efl_added, 100, 100),
      efl_gfx_entity_visible_set(efl_added, EINA_TRUE));
   //Make Stops
   float pa;

diff --git a/src/lib/evas/canvas/efl_canvas_vg_gradient_linear.c b/src/lib/evas/canvas/efl_canvas_vg_gradient_linear.c
index 8712b86..52fb188 100644 (file)
--- a/src/lib/evas/canvas/efl_canvas_vg_gradient_linear.c
+++ b/src/lib/evas/canvas/efl_canvas_vg_gradient_linear.c
@@ -8,6 +8,7 @@
 #define MY_CLASS EFL_CANVAS_VG_GRADIENT_LINEAR_CLASS
 
 typedef struct _Efl_Canvas_Vg_Gradient_Linear_Data Efl_Canvas_Vg_Gradient_Linear_Data;
+
 struct _Efl_Canvas_Vg_Gradient_Linear_Data
 {
    struct {
@@ -16,89 +17,6 @@ struct _Efl_Canvas_Vg_Gradient_Linear_Data
 };
 
 static void
-_efl_canvas_vg_gradient_linear_efl_gfx_gradient_linear_start_set(Eo *obj EINA_UNUSED,
-                                                          Efl_Canvas_Vg_Gradient_Linear_Data *pd,
-                                                          double x, double y)
-{
-   pd->start.x = x;
-   pd->start.y = y;
-
-   efl_canvas_vg_node_change(obj);
-}
-
-static void
-_efl_canvas_vg_gradient_linear_efl_gfx_gradient_linear_start_get(const Eo *obj EINA_UNUSED,
-                                                          Efl_Canvas_Vg_Gradient_Linear_Data *pd,
-                                                          double *x, double *y)
-{
-   if (x) *x = pd->start.x;
-   if (y) *y = pd->start.y;
-}
-
-static void
-_efl_canvas_vg_gradient_linear_efl_gfx_gradient_linear_end_set(Eo *obj EINA_UNUSED,
-                                                        Efl_Canvas_Vg_Gradient_Linear_Data *pd,
-                                                        double x, double y)
-{
-   pd->end.x = x;
-   pd->end.y = y;
-
-   efl_canvas_vg_node_change(obj);
-}
-
-static void
-_efl_canvas_vg_gradient_linear_efl_gfx_gradient_linear_end_get(const Eo *obj EINA_UNUSED,
-                                                        Efl_Canvas_Vg_Gradient_Linear_Data *pd,
-                                                        double *x, double *y)
-{
-   if (x) *x = pd->end.x;
-   if (y) *y = pd->end.y;
-}
-
-#ifndef HAVE_THORVG
-static void
-_efl_canvas_vg_gradient_linear_render_pre(Evas_Object_Protected_Data *vg_pd EINA_UNUSED,
-                                          Efl_VG *obj,
-                                          Efl_Canvas_Vg_Node_Data *nd,
-                                          void *engine EINA_UNUSED,
-                                          void *output EINA_UNUSED,
-                                          void *context EINA_UNUSED,
-                                          Ector_Surface *surface,
-                                          Eina_Matrix3 *ptransform,
-                                          int p_opacity EINA_UNUSED,
-                                          Ector_Buffer *comp,
-                                          Efl_Gfx_Vg_Composite_Method comp_method,
-                                          void *data)
-{
-   Efl_Canvas_Vg_Gradient_Linear_Data *pd = data;
-   Efl_Canvas_Vg_Gradient_Data *gd;
-
-   if (nd->flags == EFL_GFX_CHANGE_FLAG_NONE) return;
-
-   nd->flags = EFL_GFX_CHANGE_FLAG_NONE;
-
-   gd = efl_data_scope_get(obj, EFL_CANVAS_VG_GRADIENT_CLASS);
-   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_GRADIENT_LINEAR_MIXIN);
-        efl_domain_current_pop();
-     }
-
-   ector_renderer_transformation_set(nd->renderer, ctransform);
-   ector_renderer_origin_set(nd->renderer, nd->x, nd->y);
-   ector_renderer_visibility_set(nd->renderer, nd->visibility);
-   efl_gfx_gradient_stop_set(nd->renderer, gd->colors, gd->colors_count);
-   efl_gfx_gradient_spread_set(nd->renderer, gd->spread);
-   efl_gfx_gradient_linear_start_set(nd->renderer, pd->start.x, pd->start.y);
-   efl_gfx_gradient_linear_end_set(nd->renderer, pd->end.x, pd->end.y);
-   ector_renderer_prepare(nd->renderer);
-   ector_renderer_comp_method_set(nd->renderer, comp, comp_method);
-}
-#else
-static void
 _gradient_linear_render_pre_tvg(Efl_Canvas_Vg_Gradient_Data *gd,
                                 Tvg_Paint *shape,
                                 Evas_Vg_Gradient_Owner_Type owner)
@@ -111,24 +29,26 @@ _gradient_linear_render_pre_tvg(Efl_Canvas_Vg_Gradient_Data *gd,
    else if (owner == EVAS_VG_GRADIENT_OWNER_TYPE_STROKE)
      tvg_shape_set_stroke_linear_gradient(shape, gd->gradient);
 }
-#endif
 
 static Eo *
 _efl_canvas_vg_gradient_linear_efl_object_constructor(Eo *obj,
                                                       Efl_Canvas_Vg_Gradient_Linear_Data *pd)
 {
-   Efl_Canvas_Vg_Node_Data *nd;
-   Efl_Canvas_Vg_Gradient_Data *gd;
+   Efl_Canvas_Vg_Node_Data *nd = NULL;
+   Efl_Canvas_Vg_Gradient_Data *gd = NULL;
+
    obj = efl_constructor(efl_super(obj, MY_CLASS));
+   if (!obj) return NULL;
+
    gd = efl_data_scope_get(obj, EFL_CANVAS_VG_GRADIENT_CLASS);
+   if (!gd) return NULL;
+
    nd = efl_data_scope_get(obj, EFL_CANVAS_VG_NODE_CLASS);
-#ifndef HAVE_THORVG
-   nd->render_pre = _efl_canvas_vg_gradient_linear_render_pre;
-#else
+   if (!nd) return NULL;
+
    gd->gradient_render_pre_tvg = _gradient_linear_render_pre_tvg;
    gd->spread = EFL_GFX_GRADIENT_SPREAD_PAD;
    gd->gradient = tvg_linear_gradient_new();
-#endif
    nd->data = pd;
 
    return obj;
@@ -141,36 +61,38 @@ _efl_canvas_vg_gradient_linear_efl_object_destructor(Eo *obj, Efl_Canvas_Vg_Grad
 }
 
 static void
-_efl_canvas_vg_gradient_linear_efl_gfx_path_bounds_get(const Eo *obj, Efl_Canvas_Vg_Gradient_Linear_Data *pd, Eina_Rect *r)
+_efl_canvas_vg_gradient_linear_efl_gfx_path_bounds_get(const Eo *obj,
+                                                       Efl_Canvas_Vg_Gradient_Linear_Data *pd EINA_UNUSED,
+                                                       Eina_Rect *r)
 {
-   Efl_Canvas_Vg_Node_Data *nd;
-   nd = efl_data_scope_get(obj, EFL_CANVAS_VG_NODE_CLASS);
-#ifdef HAVE_THORVG
-   if (!obj) return;
+   Efl_Canvas_Vg_Node_Data *nd = NULL;
+   Efl_Canvas_Vg_Gradient_Data *gd = NULL;
    float x1 = 0.f, y1 = 0.f, x2 = 0.f, y2 = 0.f;
-   Efl_Canvas_Vg_Gradient_Data *gd = efl_data_scope_get(obj, EFL_CANVAS_VG_GRADIENT_CLASS);
+
+   if (!obj) return;
+
+   nd = efl_data_scope_get(obj, EFL_CANVAS_VG_NODE_CLASS);
+   gd = efl_data_scope_get(obj, EFL_CANVAS_VG_GRADIENT_CLASS);
+
+   if (!nd || !gd || !gd->gradient)
+
    if (gd && tvg_linear_gradient_get(gd->gradient, &x1, &y1, &x2, &y2) == TVG_RESULT_SUCCESS)
      {
         EINA_RECTANGLE_SET(r, nd->x + x1, nd->y + y1, x2 - x1, y2 - y1);
      }
-#else
-   EINA_RECTANGLE_SET(r,
-                      nd->x + pd->start.x, nd->y + pd->start.y,
-                      pd->end.x - pd->start.x, pd->end.y - pd->start.y);
-#endif
 }
 
 static Eina_Bool
 _efl_canvas_vg_gradient_linear_efl_gfx_path_interpolate(Eo *obj,
-                                                Efl_Canvas_Vg_Gradient_Linear_Data *pd,
-                                                const Efl_VG *from, const Efl_VG *to,
-                                                double pos_map)
+                                                        Efl_Canvas_Vg_Gradient_Linear_Data *pd,
+                                                        const Efl_VG *from, const Efl_VG *to,
+                                                        double pos_map)
 {
    Efl_Canvas_Vg_Gradient_Linear_Data *fromd, *tod;
    Efl_Canvas_Vg_Gradient_Data *gd;
 
    double from_map;
-   Eina_Bool r;
+   Eina_Bool r = EINA_FALSE;
 
    r = efl_gfx_path_interpolate(efl_super(obj, EFL_CANVAS_VG_GRADIENT_LINEAR_CLASS), from, to, pos_map);
 
@@ -205,17 +127,19 @@ _efl_canvas_vg_gradient_linear_efl_duplicate_duplicate(const Eo *obj, Efl_Canvas
    Efl_VG *cn = NULL;
 
    cn = efl_duplicate(efl_super(obj, MY_CLASS));
-   efl_gfx_gradient_linear_start_set(cn, pd->start.x, pd->start.y);
-   efl_gfx_gradient_linear_end_set(cn, pd->end.x, pd->end.y);
+   if (!cn) return NULL;
+
+   evas_vg_gradient_linear_start_set(cn, pd->start.x, pd->start.y);
+   evas_vg_gradient_linear_end_set(cn, pd->end.x, pd->end.y);
    return cn;
 }
 
 EAPI void
 evas_vg_gradient_linear_start_set(Evas_Vg_Gradient_Linear *obj, double x, double y)
 {
-#ifdef HAVE_THORVG
    Efl_Canvas_Vg_Gradient_Linear_Data *lgd = NULL;
    Efl_Canvas_Vg_Gradient_Data *gd = NULL;
+   float x2 = 0.f, y2 = 0.f;
 
    if (!obj) return;
 
@@ -226,43 +150,36 @@ evas_vg_gradient_linear_start_set(Evas_Vg_Gradient_Linear *obj, double x, double
    lgd->start.y = y;
 
    gd = efl_data_scope_get(obj, EFL_CANVAS_VG_GRADIENT_CLASS);
-   if (!gd) return;
+   if (!gd || !gd->gradient) return;
 
-   float x2 = 0.f, y2 = 0.f;
    tvg_linear_gradient_get(gd->gradient, NULL, NULL, &x2, &y2);
    tvg_linear_gradient_set(gd->gradient, x, y, x2, y2);
 
    if (gd->shape) efl_canvas_vg_node_change(gd->shape);
-#else
-   efl_gfx_gradient_linear_start_set(obj, x, y);
-#endif
 }
 
 EAPI void
 evas_vg_gradient_linear_start_get(Evas_Vg_Gradient_Linear *obj, double *x, double *y)
 {
-#ifdef HAVE_THORVG
+   Efl_Canvas_Vg_Gradient_Data *gd = NULL;
+   float x1 = 0.f, y1 = 0.f;
+
    if (!obj) return;
 
-   Efl_Canvas_Vg_Gradient_Data *gd = efl_data_scope_get(obj, EFL_CANVAS_VG_GRADIENT_CLASS);
-   if (!gd) return;
+   gd = efl_data_scope_get(obj, EFL_CANVAS_VG_GRADIENT_CLASS);
+   if (!gd || !gd->gradient) return;
 
-   float x1 = 0.f, y1 = 0.f;
    tvg_linear_gradient_get(gd->gradient, &x1, &y1, NULL, NULL);
    if (x) *x = x1;
    if (y) *y = y1;
-
-#else
-   efl_gfx_gradient_linear_start_get(obj, x, y);
-#endif
 }
 
 EAPI void
 evas_vg_gradient_linear_end_set(Evas_Vg_Gradient_Linear *obj, double x, double y)
 {
-#ifdef HAVE_THORVG
    Efl_Canvas_Vg_Gradient_Linear_Data *lgd = NULL;
    Efl_Canvas_Vg_Gradient_Data *gd = NULL;
+   float x1 = 0.f, y1 = 0.f;
 
    if (!obj) return;
 
@@ -273,34 +190,28 @@ evas_vg_gradient_linear_end_set(Evas_Vg_Gradient_Linear *obj, double x, double y
    lgd->end.y = y;
 
    gd = efl_data_scope_get(obj, EFL_CANVAS_VG_GRADIENT_CLASS);
-   if (!gd) return;
+   if (!gd || !gd->gradient) return;
 
-   float x1 = 0.f, y1 = 0.f;
    tvg_linear_gradient_get(gd->gradient, &x1, &y1, NULL, NULL);
    tvg_linear_gradient_set(gd->gradient, x1, y1, x, y);
 
    if (gd->shape) efl_canvas_vg_node_change(gd->shape);
-#else
-   efl_gfx_gradient_linear_end_set(obj, x, y);
-#endif
 }
 
 EAPI void
 evas_vg_gradient_linear_end_get(Evas_Vg_Gradient_Linear *obj, double *x, double *y)
 {
-#ifdef HAVE_THORVG
+   Efl_Canvas_Vg_Gradient_Data *gd = NULL;
+   float x2 = 0.f, y2 = 0.f;
+
    if (!obj) return;
 
-   Efl_Canvas_Vg_Gradient_Data *gd = efl_data_scope_get(obj, EFL_CANVAS_VG_GRADIENT_CLASS);
-   if (!gd) return;
+   gd = efl_data_scope_get(obj, EFL_CANVAS_VG_GRADIENT_CLASS);
+   if (!gd || !gd->gradient) return;
 
-   float x2 = 0.f, y2 = 0.f;
    tvg_linear_gradient_get(gd->gradient, NULL, NULL, &x2, &y2);
    if (x) *x = x2;
    if (y) *y = y2;
-#else
-   efl_gfx_gradient_linear_end_get(obj, x, y);
-#endif
 }
 
 EAPI Evas_Vg_Gradient_Linear *

diff --git a/src/lib/evas/canvas/efl_canvas_vg_gradient_linear.eo b/src/lib/evas/canvas/efl_canvas_vg_gradient_linear.eo
index 21d3be7..8c6ba6a 100644 (file)
--- a/src/lib/evas/canvas/efl_canvas_vg_gradient_linear.eo
+++ b/src/lib/evas/canvas/efl_canvas_vg_gradient_linear.eo
@@ -2,8 +2,6 @@ class @beta Efl.Canvas.Vg.Gradient_Linear extends Efl.Canvas.Vg.Gradient impleme
 {
    [[Efl vector graphics gradient linear class]]
    implements {
-      Efl.Gfx.Gradient_Linear.start { get; set; }
-      Efl.Gfx.Gradient_Linear.end { get; set; }
       Efl.Gfx.Path.interpolate;
       Efl.Duplicate.duplicate;
       Efl.Gfx.Path.bounds_get;