ector: add initial interface for a shape object.

src/Makefile_Ector.am

@@ -2,7 +2,8 @@
 ### Library
 ector_eolian_files = \
 	lib/ector/ector_surface.eo \
-	lib/ector/ector_renderer.eo
+	lib/ector/ector_renderer_base.eo \
+	lib/ector/ector_renderer_shape.eo
 
 ector_eolian_c = $(ector_eolian_files:%.eo=%.eo.c)
 ector_eolian_h = $(ector_eolian_files:%.eo=%.eo.h)
@@ -22,7 +23,9 @@ dist_installed_ectormainheaders_DATA = \
 lib/ector/Ector.h
 
 lib_ector_libector_la_SOURCES = \
-lib/ector/ector_main.c
+lib/ector/ector_main.c \
+lib/ector/ector_renderer_shape.c \
+lib/ector/ector_renderer_base.c
 
 lib_ector_libector_la_CPPFLAGS = -I$(top_builddir)/src/lib/efl \
 @ECTOR_CFLAGS@ \

src/lib/ector/ector_private.h

@@ -36,4 +36,13 @@ extern int _ector_log_dom_global;
 #endif /* ifdef CRI */
 #define CRI(...) EINA_LOG_DOM_CRIT(_ector_log_dom_global, __VA_ARGS__)
 
+static inline void
+_ector_renderer_replace(Ector_Renderer **d, const Ector_Renderer *s)
+{
+   Ector_Renderer *tmp = *d;
+
+   *d = eo_ref(s);
+   eo_unref(tmp);
+}
+
 #endif

src/lib/ector/ector_renderer.h

@@ -1,6 +1,7 @@
 #ifndef ECTOR_RENDERER_H
 #define ECTOR_RENDERER_H
 
-#include "ector_renderer.eo.h"
+#include "ector_renderer_base.eo.h"
+#include "ector_renderer_shape.eo.h"
 
 #endif

src/lib/ector/ector_renderer_base.c

@@ -0,0 +1,170 @@
+#ifdef HAVE_CONFIG_H
+# include "config.h"
+#endif
+
+#include <Eina.h>
+#include <Ector.h>
+
+#include "ector_private.h"
+
+typedef struct _Ector_Renderer_Base_Data Ector_Renderer_Base_Data;
+struct _Ector_Renderer_Base_Data
+{
+   Eina_Matrix3 *m;
+
+   struct {
+      double x;
+      double y;
+   } origin;
+
+   struct {
+      int r, g, b, a;
+   } color;
+
+   Ector_Renderer *mask;
+
+   Ector_Quality q;
+   Eina_Bool visibility;
+};
+
+void
+_ector_renderer_base_transformation_set(Eo *obj EINA_UNUSED,
+                                        Ector_Renderer_Base_Data *pd,
+                                        const Eina_Matrix3 *m)
+{
+   Eina_Matrix3 *tmp = pd->m;
+
+   pd->m = NULL;
+   if (!m)
+     {
+        free(tmp);
+        tmp = NULL;
+     }
+   else
+     {
+        if (!tmp) tmp = malloc(sizeof (Eina_Matrix3));
+        if (!tmp) return ;
+
+        memcpy(tmp, m, sizeof (Eina_Matrix3));
+     }
+
+   pd->m = tmp;
+}
+
+const Eina_Matrix3 *
+_ector_renderer_base_transformation_get(Eo *obj EINA_UNUSED,
+                                        Ector_Renderer_Base_Data *pd)
+{
+   return pd->m;
+}
+
+void
+_ector_renderer_base_origin_set(Eo *obj EINA_UNUSED,
+                                Ector_Renderer_Base_Data *pd,
+                                double x, double y)
+{
+   pd->origin.x = x;
+   pd->origin.y = y;
+}
+
+void
+_ector_renderer_base_origin_get(Eo *obj EINA_UNUSED,
+                                Ector_Renderer_Base_Data *pd,
+                                double *x, double *y)
+{
+   if (x) *x = pd->origin.x;
+   if (y) *y = pd->origin.y;
+}
+
+void
+_ector_renderer_base_visibility_set(Eo *obj EINA_UNUSED,
+                                    Ector_Renderer_Base_Data *pd,
+                                    Eina_Bool v)
+{
+   pd->visibility = v;
+}
+
+Eina_Bool
+_ector_renderer_base_visibility_get(Eo *obj EINA_UNUSED,
+                                    Ector_Renderer_Base_Data *pd)
+{
+   return pd->visibility;
+}
+
+void
+_ector_renderer_base_color_set(Eo *obj EINA_UNUSED,
+                               Ector_Renderer_Base_Data *pd,
+                               int r, int g, int b, int a)
+{
+   pd->color.r = r;
+   pd->color.g = g;
+   pd->color.b = b;
+   pd->color.a = a;
+}
+
+void
+_ector_renderer_base_color_get(Eo *obj EINA_UNUSED,
+                               Ector_Renderer_Base_Data *pd,
+                               int *r, int *g, int *b, int *a)
+{
+   if (r) *r = pd->color.r;
+   if (g) *g = pd->color.g;
+   if (b) *b = pd->color.b;
+   if (a) *a = pd->color.a;
+}
+
+void
+_ector_renderer_base_mask_set(Eo *obj EINA_UNUSED,
+                              Ector_Renderer_Base_Data *pd,
+                              Ector_Renderer *r)
+{
+   _ector_renderer_replace(&pd->mask, r);
+}
+
+Ector_Renderer *
+_ector_renderer_base_mask_get(Eo *obj EINA_UNUSED,
+                              Ector_Renderer_Base_Data *pd)
+{
+   return pd->mask;
+}
+
+void
+_ector_renderer_base_quality_set(Eo *obj EINA_UNUSED,
+                                 Ector_Renderer_Base_Data *pd,
+                                 Ector_Quality q)
+{
+   pd->q = q;
+}
+
+Ector_Quality
+_ector_renderer_base_quality_get(Eo *obj EINA_UNUSED,
+                                 Ector_Renderer_Base_Data *pd)
+{
+   return pd->q;
+}
+
+Eina_Bool
+_ector_renderer_base_bounds_get(Eo *obj, Ector_Renderer_Base_Data *pd,
+                                Eina_Rectangle **r)
+{
+}
+
+Eina_Bool
+_ector_renderer_base_draw(Eo *obj, Ector_Renderer_Base_Data *pd,
+                          Ector_Surface *s, Ector_Rop op, Eina_Array *clips,
+                          int x, int y)
+{
+}
+
+Eina_Bool
+_ector_renderer_base_prepare(Eo *obj, Ector_Renderer_Base_Data *pd,
+                             Ector_Surface *s)
+{
+}
+
+Eina_Bool
+_ector_renderer_base_done(Eo *obj, Ector_Renderer_Base_Data *pd)
+{
+}
+
+#include "ector_renderer_base.eo.c"

src/lib/ector/ector_renderer_base.eo

@@ -1,4 +1,4 @@
-abstract Ector.Renderer (Eo.Base)
+abstract Ector.Renderer.Base (Eo.Base)
 {
    eo_prefix: ector_renderer;
    legacy_prefix: null;
@@ -9,7 +9,7 @@ abstract Ector.Renderer (Eo.Base)
 	 get {
 	 }
 	 values {
-	    Eina_Matrix3 m;
+	    const(Eina_Matrix3) *m;
 	 }
       }
       origin {

src/lib/ector/ector_renderer_shape.c

@@ -0,0 +1,237 @@
+#ifdef HAVE_CONFIG_H
+# include "config.h"
+#endif
+
+#include <Eina.h>
+#include <Ector.h>
+
+#include "ector_private.h"
+
+typedef struct _Ector_Renderer_Shape_Data Ector_Renderer_Shape_Data;
+struct _Ector_Renderer_Shape_Data
+{
+   Ector_Renderer *fill;
+   struct {
+      Ector_Renderer *fill;
+      Ector_Renderer *marker;
+
+      double scale;
+      double width;
+      double centered;
+
+      struct {
+         int r, g, b, a;
+      } color;
+
+      Efl_Geometry_Dash *dash;
+      unsigned int dash_length;
+
+      Efl_Geometry_Cap cap;
+      Efl_Geometry_Cap join;
+   } stroke;
+};
+
+void
+_ector_renderer_shape_fill_set(Eo *obj EINA_UNUSED,
+                               Ector_Renderer_Shape_Data *pd,
+                               const Ector_Renderer *r)
+{
+   _ector_renderer_replace(&pd->fill, r);
+}
+
+const Ector_Renderer *
+_ector_renderer_shape_fill_get(Eo *obj EINA_UNUSED,
+                               Ector_Renderer_Shape_Data *pd)
+{
+   return pd->fill;
+}
+
+void
+_ector_renderer_shape_stroke_fill_set(Eo *obj EINA_UNUSED,
+                                      Ector_Renderer_Shape_Data *pd,
+                                      const Ector_Renderer *r)
+{
+   _ector_renderer_replace(&pd->stroke.fill, r);
+}
+
+const Ector_Renderer *
+_ector_renderer_shape_stroke_fill_get(Eo *obj EINA_UNUSED,
+                                      Ector_Renderer_Shape_Data *pd)
+{
+   return pd->stroke.fill;
+}
+
+void
+_ector_renderer_shape_stroke_marker_set(Eo *obj EINA_UNUSED,
+                                        Ector_Renderer_Shape_Data *pd,
+                                        const Ector_Renderer *r)
+{
+   _ector_renderer_replace(&pd->stroke.marker, r);
+}
+
+const Ector_Renderer *
+_ector_renderer_shape_stroke_marker_get(Eo *obj EINA_UNUSED,
+                                        Ector_Renderer_Shape_Data *pd)
+{
+   return pd->stroke.marker;
+}
+
+void
+_ector_renderer_shape_efl_geometry_shape_stroke_scale_set(Eo *obj EINA_UNUSED,
+                                                          Ector_Renderer_Shape_Data *pd,
+                                                          double s)
+{
+   pd->stroke.scale = s;
+}
+
+double
+_ector_renderer_shape_efl_geometry_shape_stroke_scale_get(Eo *obj EINA_UNUSED,
+                                                          Ector_Renderer_Shape_Data *pd)
+{
+   return pd->stroke.scale;
+}
+
+void
+_ector_renderer_shape_efl_geometry_shape_stroke_color_set(Eo *obj EINA_UNUSED,
+                                                          Ector_Renderer_Shape_Data *pd,
+                                                          int r, int g, int b, int a)
+{
+   pd->stroke.color.r = r;
+   pd->stroke.color.g = g;
+   pd->stroke.color.b = b;
+   pd->stroke.color.a = a;
+}
+
+
+void
+_ector_renderer_shape_efl_geometry_shape_stroke_color_get(Eo *obj EINA_UNUSED,
+                                                          Ector_Renderer_Shape_Data *pd,
+                                                          int *r, int *g, int *b, int *a)
+{
+   if (r) *r = pd->stroke.color.r;
+   if (g) *g = pd->stroke.color.g;
+   if (b) *b = pd->stroke.color.b;
+   if (a) *a = pd->stroke.color.a;
+}
+
+void
+_ector_renderer_shape_efl_geometry_shape_stroke_width_set(Eo *obj EINA_UNUSED,
+                                                          Ector_Renderer_Shape_Data *pd,
+                                                          double w)
+{
+   pd->stroke.width = w;
+}
+
+double
+_ector_renderer_shape_efl_geometry_shape_stroke_width_get(Eo *obj EINA_UNUSED,
+                                                          Ector_Renderer_Shape_Data *pd)
+{
+   return pd->stroke.width;
+}
+
+void
+_ector_renderer_shape_efl_geometry_shape_stroke_location_set(Eo *obj EINA_UNUSED,
+                                                             Ector_Renderer_Shape_Data *pd,
+                                                             double centered)
+{
+   pd->stroke.centered = centered;
+}
+
+double
+_ector_renderer_shape_efl_geometry_shape_stroke_location_get(Eo *obj EINA_UNUSED,
+                                                             Ector_Renderer_Shape_Data *pd)
+{
+   return pd->stroke.centered;
+}
+
+void
+_ector_renderer_shape_efl_geometry_shape_stroke_dash_set(Eo *obj EINA_UNUSED,
+                                                         Ector_Renderer_Shape_Data *pd,
+                                                         const Efl_Geometry_Dash *dash,
+                                                         unsigned int length)
+{
+   Efl_Geometry_Dash *tmp;
+
+   if (!dash)
+     {
+        free(pd->stroke.dash);
+        pd->stroke.dash = NULL;
+        pd->stroke.dash_length = 0;
+        return ;
+     }
+
+   tmp = realloc(pd->stroke.dash, length * sizeof (Efl_Geometry_Dash));
+   if (!tmp) return ;
+   memcpy(tmp, dash, length * sizeof (Efl_Geometry_Dash));
+
+   pd->stroke.dash = tmp;
+   pd->stroke.dash_length = length;
+}
+
+void
+_ector_renderer_shape_efl_geometry_shape_stroke_dash_get(Eo *obj EINA_UNUSED,
+                                                         Ector_Renderer_Shape_Data *pd,
+                                                         const Efl_Geometry_Dash **dash,
+                                                         unsigned int *length)
+{
+   if (dash) *dash = pd->stroke.dash;
+   if (length) *length = pd->stroke.dash_length;
+}
+
+void
+_ector_renderer_shape_efl_geometry_shape_stroke_cap_set(Eo *obj EINA_UNUSED,
+                                                        Ector_Renderer_Shape_Data *pd,
+                                                        Efl_Geometry_Cap c)
+{
+   pd->stroke.cap = c;
+}
+
+Efl_Geometry_Cap
+_ector_renderer_shape_efl_geometry_shape_stroke_cap_get(Eo *obj EINA_UNUSED,
+                                                        Ector_Renderer_Shape_Data *pd)
+{
+   return pd->stroke.cap;
+}
+
+void
+_ector_renderer_shape_efl_geometry_shape_stroke_join_set(Eo *obj EINA_UNUSED,
+                                                         Ector_Renderer_Shape_Data *pd,
+                                                         Efl_Geometry_Join j)
+{
+   pd->stroke.join = j;
+}
+
+Efl_Geometry_Join
+_ector_renderer_shape_efl_geometry_shape_stroke_join_get(Eo *obj EINA_UNUSED,
+                                                         Ector_Renderer_Shape_Data *pd)
+{
+   return pd->stroke.join;
+}
+
+Eina_Bool
+_ector_renderer_shape_efl_geometry_shape_path_set(Eo *obj,
+                                                  Ector_Renderer_Shape_Data *pd,
+                                                  const Efl_Geometry_Path_Command *op,
+                                                  const double *points)
+{
+}
+
+Eina_Bool
+_ector_renderer_shape_ector_renderer_base_prepare(Eo *obj,
+                                                  Ector_Renderer_Shape_Data *pd,
+                                                  Ector_Surface *s)
+{
+}
+
+void
+_ector_renderer_shape_eo_base_constructor(Eo *obj,
+                                          Ector_Renderer_Shape_Data *pd)
+{
+}
+
+void
+_ector_renderer_shape_eo_base_destructor(Eo *obj, Ector_Renderer_Shape_Data *pd)
+{
+}
+
+#include "ector_renderer_shape.eo.c"

src/lib/ector/ector_renderer_shape.eo

@@ -0,0 +1,47 @@
+class Ector.Renderer.Shape (Ector.Renderer.Base, Efl.Geometry.Shape)
+{
+   eo_prefix: ector_renderer_shape;
+   legacy_prefix: null;
+   properties {
+      fill {
+         set {
+	 }
+	 get {
+	 }
+	 values {
+	    const(Ector_Renderer) *r;
+	 }
+      }
+      stroke_fill {
+         set {
+	 }
+	 get {
+	 }
+	 values {
+	    const(Ector_Renderer) *r;
+	 }
+      }
+      stroke_marker {
+         set {
+	 }
+	 get {
+	 }
+	 values {
+	    const(Ector_Renderer) *r;
+	 }
+      }
+   }
+   implements {
+      Efl.Geometry.Shape.stroke_scale;
+      Efl.Geometry.Shape.stroke_color;
+      Efl.Geometry.Shape.stroke_width;
+      Efl.Geometry.Shape.stroke_location;
+      Efl.Geometry.Shape.stroke_dash;
+      Efl.Geometry.Shape.stroke_cap;
+      Efl.Geometry.Shape.stroke_join;
+      Efl.Geometry.Shape.path_set;
+      Ector.Renderer.Base.prepare;
+      Eo.Base.constructor;
+      Eo.Base.destructor;
+   }
+}