lib/evas/canvas/evas_3d_mesh.eo\
lib/evas/canvas/evas_3d_node.eo\
lib/evas/canvas/evas_3d_scene.eo\
- lib/evas/canvas/evas_3d_object.eo
+ lib/evas/canvas/evas_3d_object.eo \
+ lib/evas/canvas/evas_vg.eo \
+ lib/evas/canvas/evas_vg_node.eo \
+ lib/evas/canvas/evas_vg_container.eo \
+ lib/evas/canvas/evas_vg_shape.eo \
+ lib/evas/canvas/evas_vg_root_node.eo \
+ lib/evas/canvas/evas_vg_gradient.eo \
+ lib/evas/canvas/evas_vg_gradient_radial.eo \
+ lib/evas/canvas/evas_vg_gradient_linear.eo
evas_eolian_c = $(evas_eolian_files:%.eo=%.eo.c)
evas_eolian_h = $(evas_eolian_files:%.eo=%.eo.h) \
lib_evas_libevas_la_SOURCES += \
$(lib_evas_file_SOURCES)
+# Evas_3D
noinst_HEADERS += \
lib/evas/include/evas_3d_utils.h
modules/evas/model_savers/ply/evas_model_save_ply.c \
lib/evas/canvas/evas_3d_eet.c
+# Evas_VG
+lib_evas_libevas_la_SOURCES += \
+lib/evas/canvas/evas_object_vg.c \
+lib/evas/canvas/evas_vg_node.c \
+lib/evas/canvas/evas_vg_container.c \
+lib/evas/canvas/evas_vg_root_node.c \
+lib/evas/canvas/evas_vg_gradient.c \
+lib/evas/canvas/evas_vg_gradient_linear.c \
+lib/evas/canvas/evas_vg_gradient_radial.c
+
# Engine
lib_evas_libevas_la_SOURCES += \
lib/evas/common/evas_op_copy_main_.c \
#include "canvas/evas_3d_scene.eo.h"
#include "canvas/evas_3d_object.eo.h"
+
+/**
+ * Path command enum.
+ *
+ * @since 1.13
+ * @ingroup Evas_VG_Shape
+ */
+typedef enum _Evas_VG_Path_Command
+{
+ EVAS_VG_PATH_COMMAND_TYPE_END = 0, /**< End of the stream of command */
+ EVAS_VG_PATH_COMMAND_TYPE_MOVE_TO, /**< A move command type */
+ EVAS_VG_PATH_COMMAND_TYPE_LINE_TO, /**< A line command type */
+ EVAS_VG_PATH_COMMAND_TYPE_QUADRATIC_TO, /**< A quadratic command type */
+ EVAS_VG_PATH_COMMAND_TYPE_SQUADRATIC_TO, /**< A smooth quadratic command type */
+ EVAS_VG_PATH_COMMAND_TYPE_CUBIC_TO, /**< A cubic command type */
+ EVAS_VG_PATH_COMMAND_TYPE_SCUBIC_TO, /**< A smooth cubic command type */
+ EVAS_VG_PATH_COMMAND_TYPE_ARC_TO, /**< An arc command type */
+ EVAS_VG_PATH_COMMAND_TYPE_CLOSE, /**< A close command type */
+ EVAS_VG_PATH_COMMAND_TYPE_LAST, /**< Not a valid command, but last one according to this version header */
+} Evas_VG_Path_Command;
+
+/**
+ * Type of abstract VG node
+ */
+typedef Eo Evas_VG_Node;
+
+
+/**
+ * Type describing dash
+ */
+typedef struct _Evas_VG_Dash Evas_VG_Dash;
+struct _Evas_VG_Dash
+{
+ double length;
+ double gap;
+};
+
+typedef struct _Evas_VG_Gradient_Stop Evas_VG_Gradient_Stop;
+struct _Evas_VG_Gradient_Stop
+{
+ double offset;
+ int r;
+ int g;
+ int b;
+ int a;
+};
+
+typedef enum _Evas_VG_Cap
+{
+ EVAS_VG_CAP_BUTT,
+ EVAS_VG_CAP_ROUND,
+ EVAS_VG_CAP_SQUARE,
+ EVAS_VG_CAP_LAST
+} Evas_VG_Cap;
+
+typedef enum _Evas_VG_Join
+{
+ EVAS_VG_JOIN_MITER,
+ EVAS_VG_JOIN_ROUND,
+ EVAS_VG_JOIN_BEVEL,
+ EVAS_VG_JOIN_LAST
+} Evas_VG_Join;
+
+typedef enum _Evas_VG_Gradient_Spread
+{
+ EVAS_VG_GRADIENT_SPREAD_PAD,
+ EVAS_VG_GRADIENT_SPREAD_REFLECT,
+ EVAS_VG_GRADIENT_SPREAD_REPEAT,
+ EVAS_VG_GRADIENT_SPREAD_LAST
+} Evas_VG_Gradient_Spread;
+
+/**
+ * @ingroup Evas_Object_VG
+ *
+ * @{
+ */
+#include "canvas/evas_vg.eo.h"
+/**
+ * @}
+ */
+
+#include "canvas/evas_vg_node.eo.h"
+#include "canvas/evas_vg_container.eo.h"
+#include "canvas/evas_vg_shape.eo.h"
+#include "canvas/evas_vg_gradient.eo.h"
+#include "canvas/evas_vg_gradient_linear.eo.h"
+#include "canvas/evas_vg_gradient_radial.eo.h"
--- /dev/null
+#include "evas_common_private.h"
+#include "evas_private.h"
+
+#include "evas_vg_root_node.eo.h"
+
+#define MY_CLASS EVAS_VG_CLASS
+
+
+/* private magic number for rectangle objects */
+static const char o_type[] = "rectangle";
+
+const char *o_vg_type = o_type;
+
+/* private struct for rectangle object internal data */
+typedef struct _Evas_VG_Data Evas_VG_Data;
+
+struct _Evas_VG_Data
+{
+ void *engine_data;
+ Evas_VG_Node *root;
+};
+
+static void evas_object_vg_render(Evas_Object *eo_obj,
+ Evas_Object_Protected_Data *obj,
+ void *type_private_data,
+ void *output, void *context, void *surface,
+ int x, int y, Eina_Bool do_async);
+static void evas_object_vg_render_pre(Evas_Object *eo_obj,
+ Evas_Object_Protected_Data *obj,
+ void *type_private_data);
+static void evas_object_vg_render_post(Evas_Object *eo_obj,
+ Evas_Object_Protected_Data *obj,
+ void *type_private_data);
+static unsigned int evas_object_vg_id_get(Evas_Object *eo_obj);
+static unsigned int evas_object_vg_visual_id_get(Evas_Object *eo_obj);
+static void *evas_object_vg_engine_data_get(Evas_Object *eo_obj);
+static int evas_object_vg_is_opaque(Evas_Object *eo_obj,
+ Evas_Object_Protected_Data *obj,
+ void *type_private_data);
+static int evas_object_vg_was_opaque(Evas_Object *eo_obj,
+ Evas_Object_Protected_Data *obj,
+ void *type_private_data);
+
+static const Evas_Object_Func object_func =
+{
+ /* methods (compulsory) */
+ NULL,
+ evas_object_vg_render,
+ evas_object_vg_render_pre,
+ evas_object_vg_render_post,
+ evas_object_vg_id_get,
+ evas_object_vg_visual_id_get,
+ evas_object_vg_engine_data_get,
+ /* these are optional. NULL = nothing */
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ evas_object_vg_is_opaque,
+ evas_object_vg_was_opaque,
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ NULL
+};
+
+/* the actual api call to add a vector graphic object */
+EAPI Evas_Object *
+evas_object_vg_add(Evas *e)
+{
+ MAGIC_CHECK(e, Evas, MAGIC_EVAS);
+ return NULL;
+ MAGIC_CHECK_END();
+ Evas_Object *eo_obj = eo_add(MY_CLASS, e);
+ return eo_obj;
+}
+
+void
+_evas_vg_root_node_set(Eo *obj EINA_UNUSED, Evas_VG_Data *pd, Evas_VG_Node *container)
+{
+ Evas_VG_Node *tmp;
+
+ tmp = pd->root;
+ pd->root = eo_ref(container);
+ eo_unref(tmp);
+}
+
+Evas_VG_Node *
+_evas_vg_root_node_get(Eo *obj EINA_UNUSED, Evas_VG_Data *pd)
+{
+ return pd->root;
+}
+
+void
+_evas_vg_eo_base_constructor(Eo *eo_obj, Evas_VG_Data *pd EINA_UNUSED)
+{
+ Evas_Object_Protected_Data *obj = eo_data_scope_get(eo_obj, EVAS_OBJECT_CLASS);
+ Eo *parent = NULL;
+
+ eo_do_super(eo_obj, MY_CLASS, eo_constructor());
+
+ /* set up methods (compulsory) */
+ obj->func = &object_func;
+ obj->private_data = eo_data_ref(eo_obj, MY_CLASS);
+ obj->type = o_type;
+
+ eo_do(eo_obj, parent = eo_parent_get());
+ evas_object_inject(eo_obj, obj, evas_object_evas_get(parent));
+}
+
+static void
+evas_object_vg_render(Evas_Object *eo_obj EINA_UNUSED,
+ Evas_Object_Protected_Data *obj EINA_UNUSED,
+ void *type_private_data EINA_UNUSED,
+ void *output EINA_UNUSED, void *context EINA_UNUSED, void *surface EINA_UNUSED,
+ int x EINA_UNUSED, int y EINA_UNUSED, Eina_Bool do_async EINA_UNUSED)
+{
+ /* render object to surface with context, and offxet by x,y */
+ /* obj->layer->evas->engine.func->context_color_set(output, */
+ /* context, */
+ /* obj->cur->cache.clip.r, */
+ /* obj->cur->cache.clip.g, */
+ /* obj->cur->cache.clip.b, */
+ /* obj->cur->cache.clip.a); */
+ /* obj->layer->evas->engine.func->context_anti_alias_set(output, context, */
+ /* obj->cur->anti_alias); */
+ /* obj->layer->evas->engine.func->context_multiplier_unset(output, */
+ /* context); */
+ /* obj->layer->evas->engine.func->context_render_op_set(output, context, */
+ /* obj->cur->render_op); */
+ /* obj->layer->evas->engine.func->rectangle_draw(output, */
+ /* context, */
+ /* surface, */
+ /* obj->cur->geometry.x + x, */
+ /* obj->cur->geometry.y + y, */
+ /* obj->cur->geometry.w, */
+ /* obj->cur->geometry.h, */
+ /* do_async); */
+ // FIXME: I guess I should create an image, get the pixels data and
+ // start using that for Cairo.
+}
+
+static void
+evas_object_vg_render_pre(Evas_Object *eo_obj,
+ Evas_Object_Protected_Data *obj,
+ void *type_private_data EINA_UNUSED)
+{
+ int is_v, was_v;
+
+ // FIXME: Later on start doing precalc of span and stuff for all shape.
+
+ /* dont pre-render the obj twice! */
+ if (obj->pre_render_done) return;
+ obj->pre_render_done = EINA_TRUE;
+ /* pre-render phase. this does anything an object needs to do just before */
+ /* rendering. this could mean loading the image data, retrieving it from */
+ /* elsewhere, decoding video etc. */
+ /* then when this is done the object needs to figure if it changed and */
+ /* if so what and where and add the appropriate redraw rectangles */
+ /* if someone is clipping this obj - go calculate the clipper */
+ if (obj->cur->clipper)
+ {
+ if (obj->cur->cache.clip.dirty)
+ evas_object_clip_recalc(obj->cur->clipper);
+ obj->cur->clipper->func->render_pre(obj->cur->clipper->object,
+ obj->cur->clipper,
+ obj->cur->clipper->private_data);
+ }
+ /* now figure what changed and add draw rects */
+ /* if it just became visible or invisible */
+ is_v = evas_object_is_visible(eo_obj, obj);
+ was_v = evas_object_was_visible(eo_obj,obj);
+ if (!(is_v | was_v)) goto done;
+ if (is_v != was_v)
+ {
+ evas_object_render_pre_visible_change(&obj->layer->evas->clip_changes, eo_obj, is_v, was_v);
+ goto done;
+ }
+ if (obj->changed_map || obj->changed_src_visible)
+ {
+ evas_object_render_pre_prev_cur_add(&obj->layer->evas->clip_changes, eo_obj, obj);
+ goto done;
+ }
+ /* it's not visible - we accounted for it appearing or not so just abort */
+ if (!is_v) goto done;
+ /* clipper changed this is in addition to anything else for obj */
+ evas_object_render_pre_clipper_change(&obj->layer->evas->clip_changes, eo_obj);
+ /* if we restacked (layer or just within a layer) and don't clip anyone */
+ if ((obj->restack) && (!obj->clip.clipees))
+ {
+ evas_object_render_pre_prev_cur_add(&obj->layer->evas->clip_changes, eo_obj, obj);
+ goto done;
+ }
+ /* if it changed render op */
+ if (obj->cur->render_op != obj->prev->render_op)
+ {
+ evas_object_render_pre_prev_cur_add(&obj->layer->evas->clip_changes, eo_obj, obj);
+ goto done;
+ }
+ /* if it changed color */
+ if ((obj->cur->color.r != obj->prev->color.r) ||
+ (obj->cur->color.g != obj->prev->color.g) ||
+ (obj->cur->color.b != obj->prev->color.b) ||
+ (obj->cur->color.a != obj->prev->color.a))
+ {
+ evas_object_render_pre_prev_cur_add(&obj->layer->evas->clip_changes, eo_obj, obj);
+ goto done;
+ }
+ /* if it changed geometry - and obviously not visibility or color */
+ /* calculate differences since we have a constant color fill */
+ /* we really only need to update the differences */
+ if ((obj->cur->geometry.x != obj->prev->geometry.x) ||
+ (obj->cur->geometry.y != obj->prev->geometry.y) ||
+ (obj->cur->geometry.w != obj->prev->geometry.w) ||
+ (obj->cur->geometry.h != obj->prev->geometry.h))
+ {
+ evas_rects_return_difference_rects(&obj->layer->evas->clip_changes,
+ obj->cur->geometry.x,
+ obj->cur->geometry.y,
+ obj->cur->geometry.w,
+ obj->cur->geometry.h,
+ obj->prev->geometry.x,
+ obj->prev->geometry.y,
+ obj->prev->geometry.w,
+ obj->prev->geometry.h);
+ goto done;
+ }
+ /* it obviously didn't change - add a NO obscure - this "unupdates" this */
+ /* area so if there were updates for it they get wiped. don't do it if we */
+ /* arent fully opaque and we are visible */
+ if (evas_object_is_visible(eo_obj, obj) &&
+ evas_object_is_opaque(eo_obj, obj) &&
+ (!obj->clip.clipees))
+ {
+ Evas_Coord x, y, w, h;
+
+ x = obj->cur->cache.clip.x;
+ y = obj->cur->cache.clip.y;
+ w = obj->cur->cache.clip.w;
+ h = obj->cur->cache.clip.h;
+ if (obj->cur->clipper)
+ {
+ RECTS_CLIP_TO_RECT(x, y, w, h,
+ obj->cur->clipper->cur->cache.clip.x,
+ obj->cur->clipper->cur->cache.clip.y,
+ obj->cur->clipper->cur->cache.clip.w,
+ obj->cur->clipper->cur->cache.clip.h);
+ }
+ obj->layer->evas->engine.func->output_redraws_rect_del
+ (obj->layer->evas->engine.data.output,
+ x + obj->layer->evas->framespace.x,
+ y + obj->layer->evas->framespace.y,
+ w, h);
+ }
+ done:
+ evas_object_render_pre_effect_updates(&obj->layer->evas->clip_changes, eo_obj, is_v, was_v);
+}
+
+static void
+evas_object_vg_render_post(Evas_Object *eo_obj,
+ Evas_Object_Protected_Data *obj EINA_UNUSED,
+ void *type_private_data EINA_UNUSED)
+{
+ /* this moves the current data to the previous state parts of the object */
+ /* in whatever way is safest for the object. also if we don't need object */
+ /* data anymore we can free it if the object deems this is a good idea */
+ /* remove those pesky changes */
+ evas_object_clip_changes_clean(eo_obj);
+ /* move cur to prev safely for object data */
+ evas_object_cur_prev(eo_obj);
+}
+
+static unsigned int
+evas_object_vg_id_get(Evas_Object *eo_obj)
+{
+ Evas_VG_Data *o = eo_data_scope_get(eo_obj, MY_CLASS);
+ if (!o) return 0;
+ return MAGIC_OBJ_VG;
+}
+
+static unsigned int
+evas_object_vg_visual_id_get(Evas_Object *eo_obj)
+{
+ Evas_VG_Data *o = eo_data_scope_get(eo_obj, MY_CLASS);
+ if (!o) return 0;
+ return MAGIC_OBJ_SHAPE;
+}
+
+static void *
+evas_object_vg_engine_data_get(Evas_Object *eo_obj)
+{
+ Evas_VG_Data *o = eo_data_scope_get(eo_obj, MY_CLASS);
+ return o->engine_data;
+}
+
+static int
+evas_object_vg_is_opaque(Evas_Object *eo_obj EINA_UNUSED,
+ Evas_Object_Protected_Data *obj EINA_UNUSED,
+ void *type_private_data EINA_UNUSED)
+{
+ return 0;
+}
+
+static int
+evas_object_vg_was_opaque(Evas_Object *eo_obj EINA_UNUSED,
+ Evas_Object_Protected_Data *obj EINA_UNUSED,
+ void *type_private_data EINA_UNUSED)
+{
+ return 0;
+}
+
+#include "evas_vg.eo.c"
--- /dev/null
+class Evas.VG (Evas.Object)
+{
+ legacy_prefix: evas_object_vg;
+ eo_prefix: evas_obj_vg;
+ properties {
+ root_node {
+ get {
+ }
+ values {
+ Evas_VG_Node *container;
+ }
+ }
+ }
+ implements {
+ Eo.Base.constructor;
+ }
+}
\ No newline at end of file
--- /dev/null
+#include "evas_common_private.h"
+#include "evas_private.h"
+
+#include "evas_vg_private.h"
+
+#define MY_CLASS EVAS_VG_CONTAINER_CLASS
+
+void
+_evas_vg_container_eo_base_constructor(Eo *obj, Evas_VG_Container_Data *pd)
+{
+ Eo *parent;
+
+ eo_do_super(obj, MY_CLASS, eo_constructor());
+
+ eo_do(obj, parent = eo_parent_get());
+ if (!eo_isa(obj, EVAS_VG_CONTAINER_CLASS) &&
+ !eo_isa(obj, EVAS_VG_CLASS))
+ {
+ ERR("Parent must be either an Evas_Object_VG or an Evas_VG_Container.");
+ eo_error_set(obj);
+ }
+}
+
+Eina_Bool
+_evas_vg_container_evas_vg_node_bound_get(Eo *obj,
+ Evas_VG_Container_Data *pd,
+ Eina_Rectangle *r)
+{
+ // FIXME: iterate children and get their boundary to
+}
+
+
+#include "evas_vg_container.eo.c"
--- /dev/null
+class Evas.VG_Container (Evas.VG_Node)
+{
+ eo_prefix: evas_vg_container;
+ implements {
+ Eo.Base.constructor;
+ Evas.VG_Node.bound_get;
+ }
+}
--- /dev/null
+#include "evas_common_private.h"
+#include "evas_private.h"
+
+#include <strings.h>
+
+typedef struct _Evas_VG_Gradient_Data Evas_VG_Gradient_Data;
+struct _Evas_VG_Gradient_Data
+{
+ // FIXME: Later on we should deduplicate it somehow.
+ Evas_VG_Gradient_Stop *colors;
+ unsigned int colors_count;
+
+ Evas_VG_Gradient_Spread s;
+};
+
+void
+_evas_vg_gradient_stop_set(Eo *obj EINA_UNUSED,
+ Evas_VG_Gradient_Data *pd,
+ const Evas_VG_Gradient_Stop *colors,
+ unsigned int length)
+{
+ pd->colors = realloc(pd->colors, length * sizeof(Evas_VG_Gradient_Stop));
+ if (!pd->colors)
+ {
+ pd->colors_count = 0;
+ return ;
+ }
+
+ memcpy(pd->colors, colors, length * sizeof(Evas_VG_Gradient_Stop));
+ pd->colors_count = length;
+}
+
+void
+_evas_vg_gradient_stop_get(Eo *obj EINA_UNUSED,
+ Evas_VG_Gradient_Data *pd,
+ const Evas_VG_Gradient_Stop **colors,
+ unsigned int *length)
+{
+ if (colors) *colors = pd->colors;
+ if (length) *length = pd->colors_count;
+}
+
+void
+_evas_vg_gradient_spread_set(Eo *obj EINA_UNUSED,
+ Evas_VG_Gradient_Data *pd,
+ Evas_VG_Gradient_Spread s)
+{
+ pd->s = s;
+}
+
+Evas_VG_Gradient_Spread
+_evas_vg_gradient_spread_get(Eo *obj EINA_UNUSED,
+ Evas_VG_Gradient_Data *pd)
+{
+ return pd->s;
+}
+
+#include "evas_vg_gradient.eo.c"
--- /dev/null
+abstract Evas.VG_Gradient (Evas.VG_Node)
+{
+ eo_prefix: evas_vg_gradient;
+ legacy_prefix: null;
+ properties {
+ stop {
+ set {
+ }
+ get {
+ }
+ values {
+ const(Evas_VG_Gradient_Stop) *colors;
+ uint length;
+ }
+ }
+ spread {
+ set {
+ }
+ get {
+ }
+ values {
+ Evas_VG_Gradient_Spread s;
+ }
+ }
+ }
+}
--- /dev/null
+#include "evas_common_private.h"
+#include "evas_private.h"
+
+#include <strings.h>
+
+typedef struct _Evas_VG_Gradient_Linear_Data Evas_VG_Gradient_Linear_Data;
+struct _Evas_VG_Gradient_Linear_Data
+{
+ struct {
+ double x, y;
+ } start, end;
+};
+
+void
+_evas_vg_gradient_linear_start_set(Eo *obj EINA_UNUSED,
+ Evas_VG_Gradient_Linear_Data *pd,
+ double x, double y)
+{
+ pd->start.x = x;
+ pd->start.y = y;
+}
+
+void
+_evas_vg_gradient_linear_start_get(Eo *obj EINA_UNUSED,
+ Evas_VG_Gradient_Linear_Data *pd,
+ double *x, double *y)
+{
+ if (x) *x = pd->start.x;
+ if (y) *y = pd->start.y;
+}
+
+void
+_evas_vg_gradient_linear_end_set(Eo *obj EINA_UNUSED,
+ Evas_VG_Gradient_Linear_Data *pd,
+ double x, double y)
+{
+ pd->end.x = x;
+ pd->end.y = y;
+}
+
+void
+_evas_vg_gradient_linear_end_get(Eo *obj EINA_UNUSED,
+ Evas_VG_Gradient_Linear_Data *pd,
+ double *x, double *y)
+{
+ if (x) *x = pd->end.x;
+ if (y) *y = pd->end.y;
+}
+
+#include "evas_vg_gradient_linear.eo.c"
--- /dev/null
+class Evas.VG_Gradient_Linear (Evas.VG_Gradient)
+{
+ eo_prefix: evas_vg_gradient_linear;
+ legacy_prefix: null;
+ properties {
+ start {
+ set {
+ }
+ get {
+ }
+ values {
+ double x;
+ double y;
+ }
+ }
+ end {
+ set {
+ }
+ get {
+ }
+ values {
+ double x;
+ double y;
+ }
+ }
+ }
+}
--- /dev/null
+#include "evas_common_private.h"
+#include "evas_private.h"
+
+typedef struct _Evas_VG_Gradient_Radial_Data Evas_VG_Gradient_Radial_Data;
+struct _Evas_VG_Gradient_Radial_Data
+{
+ struct {
+ double x, y;
+ } center, focal;
+ double radius;
+};
+
+void
+_evas_vg_gradient_radial_center_set(Eo *obj EINA_UNUSED,
+ Evas_VG_Gradient_Radial_Data *pd,
+ double x, double y)
+{
+ pd->center.x = x;
+ pd->center.y = y;
+}
+
+void
+_evas_vg_gradient_radial_center_get(Eo *obj EINA_UNUSED,
+ Evas_VG_Gradient_Radial_Data *pd,
+ double *x, double *y)
+{
+ if (x) *x = pd->center.x;
+ if (y) *y = pd->center.y;
+}
+
+void
+_evas_vg_gradient_radial_radius_set(Eo *obj EINA_UNUSED,
+ Evas_VG_Gradient_Radial_Data *pd,
+ double r)
+{
+ pd->radius = r;
+}
+
+double
+_evas_vg_gradient_radial_radius_get(Eo *obj EINA_UNUSED,
+ Evas_VG_Gradient_Radial_Data *pd)
+{
+ return pd->radius;
+}
+
+void
+_evas_vg_gradient_radial_focal_set(Eo *obj EINA_UNUSED,
+ Evas_VG_Gradient_Radial_Data *pd,
+ double x, double y)
+{
+ pd->focal.x = x;
+ pd->focal.y = y;
+}
+
+void
+_evas_vg_gradient_radial_focal_get(Eo *obj EINA_UNUSED,
+ Evas_VG_Gradient_Radial_Data *pd,
+ double *x, double *y)
+{
+ if (x) *x = pd->focal.x;
+ if (y) *y = pd->focal.y;
+}
+
+#include "evas_vg_gradient_radial.eo.c"
--- /dev/null
+class Evas.VG_Gradient_Radial (Evas.VG_Gradient)
+{
+ eo_prefix: evas_vg_gradient_radial;
+ legacy_prefix: null;
+ properties {
+ center {
+ set {
+ }
+ get {
+ }
+ values {
+ double x;
+ double y;
+ }
+ }
+ radius {
+ set {
+ }
+ get {
+ }
+ values {
+ double r;
+ }
+ }
+ focal {
+ set {
+ }
+ get {
+ }
+ values {
+ double x;
+ double y;
+ }
+ }
+ }
+}
--- /dev/null
+#include "evas_common_private.h"
+#include "evas_private.h"
+
+#include <string.h>
+
+#define MY_CLASS EVAS_VG_NODE_CLASS
+
+typedef struct _Evas_VG_Node_Data Evas_VG_Node_Data;
+struct _Evas_VG_Node_Data
+{
+ Eina_Matrix3 *m;
+ Evas_VG_Node *mask;
+
+ double x, y;
+ int r, g, b, a;
+ Eina_Bool visibility;
+};
+
+// FIXME:
+// - share private structure with evas_object_vg
+// - mark parent canvas evas_object dirty after any change on the object
+// - add a virtual render function as part of the private data field
+
+void
+_evas_vg_node_transformation_set(Eo *obj EINA_UNUSED,
+ Evas_VG_Node_Data *pd,
+ const Eina_Matrix3 *m)
+{
+ if (!pd->m)
+ {
+ pd->m = malloc(sizeof (Eina_Matrix3));
+ if (!pd->m) return ;
+ }
+ memcpy(pd->m, m, sizeof (Eina_Matrix3));
+}
+
+const Eina_Matrix3 *
+_evas_vg_node_transformation_get(Eo *obj EINA_UNUSED, Evas_VG_Node_Data *pd)
+{
+ return pd->m;
+}
+
+void
+_evas_vg_node_origin_set(Eo *obj EINA_UNUSED,
+ Evas_VG_Node_Data *pd,
+ double x, double y)
+{
+ pd->x = x;
+ pd->y = y;
+}
+
+void
+_evas_vg_node_origin_get(Eo *obj EINA_UNUSED,
+ Evas_VG_Node_Data *pd,
+ double *x, double *y)
+{
+ if (x) *x = pd->x;
+ if (y) *y = pd->y;
+}
+
+void
+_evas_vg_node_visibility_set(Eo *obj EINA_UNUSED,
+ Evas_VG_Node_Data *pd,
+ Eina_Bool v)
+{
+ pd->visibility = v;
+}
+
+Eina_Bool
+_evas_vg_node_visibility_get(Eo *obj EINA_UNUSED, Evas_VG_Node_Data *pd)
+{
+ return pd->visibility;
+}
+
+void
+_evas_vg_node_color_set(Eo *obj EINA_UNUSED,
+ Evas_VG_Node_Data *pd,
+ int r, int g, int b, int a)
+{
+ pd->r = r;
+ pd->g = g;
+ pd->b = b;
+ pd->a = a;
+}
+
+void
+_evas_vg_node_color_get(Eo *obj EINA_UNUSED,
+ Evas_VG_Node_Data *pd,
+ int *r, int *g, int *b, int *a)
+{
+ if (r) *r = pd->r;
+ if (g) *g = pd->g;
+ if (b) *b = pd->b;
+ if (a) *a = pd->a;
+}
+
+void
+_evas_vg_node_mask_set(Eo *obj EINA_UNUSED,
+ Evas_VG_Node_Data *pd,
+ Evas_VG_Node *r)
+{
+ Evas_VG_Node *tmp = pd->mask;
+
+ pd->mask = eo_ref(r);
+ eo_unref(tmp);
+}
+
+Evas_VG_Node*
+_evas_vg_node_mask_get(Eo *obj EINA_UNUSED, Evas_VG_Node_Data *pd)
+{
+ return pd->mask;
+}
+
+// Parent should be a container otherwise dismissing the stacking operation
+void
+_evas_vg_node_eo_base_constructor(Eo *obj, Evas_VG_Node_Data *pd)
+{
+ Eo *parent;
+
+ eo_do_super(obj, MY_CLASS, eo_constructor());
+ eo_do(obj, parent = eo_parent_get());
+ if (!eo_isa(parent, EVAS_VG_CONTAINER_CLASS))
+ eo_error_set(obj);
+}
+
+void
+_evas_vg_node_eo_base_parent_set(Eo *obj, Evas_VG_Node_Data *pd, Eo *parent)
+{
+}
+
+void
+_evas_vg_node_raise(Eo *obj, Evas_VG_Node_Data *pd EINA_UNUSED)
+{
+ Eo *parent;
+
+ eo_do(obj, parent = eo_parent_get());
+}
+
+void
+_evas_vg_node_stack_above(Eo *obj,
+ Evas_VG_Node_Data *pd EINA_UNUSED,
+ Evas_VG_Node *above)
+{
+ Eo *parent;
+
+ eo_do(obj, parent = eo_parent_get());
+}
+
+void
+_evas_vg_node_stack_below(Eo *obj,
+ Evas_VG_Node_Data *pd EINA_UNUSED,
+ Evas_Object *below)
+{
+ Eo *parent;
+
+ eo_do(obj, parent = eo_parent_get());
+}
+
+void
+_evas_vg_node_lower(Eo *obj, Evas_VG_Node_Data *pd EINA_UNUSED)
+{
+ Eo *parent;
+
+ eo_do(obj, parent = eo_parent_get());
+}
+
+#include "evas_vg_node.eo.c"
--- /dev/null
+abstract Evas.VG_Node (Eo.Base)
+{
+ eo_prefix: evas_vg_node;
+ legacy_prefix: null;
+ properties {
+ transformation {
+ set {
+ }
+ get {
+ }
+ values {
+ const(Eina_Matrix3) *m;
+ }
+ }
+ origin {
+ set {
+ }
+ get {
+ }
+ values {
+ double x;
+ double y;
+ }
+ }
+ visibility {
+ set {
+ /*@ Makes the given Evas_VG node visible or invisible. */
+ }
+ get {
+ /*@ Retrieves whether or not the given Evas_VG node is visible. */
+ }
+ values {
+ Eina_Bool v; /*@ @c EINA_TRUE if to make the object visible, @c EINA_FALSE otherwise */
+ }
+ }
+ color {
+ set {
+ /*@
+ Sets the general/main color of the given Evas_VG node to the given
+ one.
+
+ @note These color values are expected to be premultiplied by @p a.
+
+ @ingroup Evas_VG_Node_Group */
+ }
+ get {
+ /*@
+ Retrieves the general/main color of the given Evas_VG node.
+
+ Retrieves the “main” color's RGB component (and alpha channel)
+ values, <b>which range from 0 to 255</b>. For the alpha channel,
+ which defines the object's transparency level, 0 means totally
+ transparent, while 255 means opaque. These color values are
+ premultiplied by the alpha value.
+
+ @note Use @c NULL pointers on the components you're not interested
+ in: they'll be ignored by the function.
+
+ @ingroup Evas_VG_Node_Group */
+ }
+ values {
+ int r; /*@ The red component of the given color. */
+ int g; /*@ The green component of the given color. */
+ int b; /*@ The blue component of the given color. */
+ int a; /*@ The alpha component of the given color. */
+ }
+ }
+ mask {
+ set {
+ }
+ get {
+ }
+ values {
+ Evas_VG_Node *m;
+ }
+ }
+/* quality {
+ set {
+ }
+ get {
+ }
+ values {
+ Evas_VG_Quality q;
+ }
+ } */
+ }
+ methods {
+ bound_get {
+ return: bool @warn_unused;
+ params {
+ @out Eina_Rectangle r;
+ }
+ }
+ raise {
+ /*@
+ Raise @p obj to the top of its layer.
+
+ @p obj will, then, be the highest one in the layer it belongs
+ to. Object on other layers won't get touched.
+
+ @see evas_vg_node_stack_above()
+ @see evas_vg_node_stack_below()
+ @see evas_vg_node_lower() */
+ }
+ stack_above {
+ /*@
+ Stack @p obj immediately above @p above
+
+ Objects, in a given Evas_VG_Container, are stacked in the order they get added
+ to it. This means that, if they overlap, the highest ones will
+ cover the lowest ones, in that order. This function is a way to
+ change the stacking order for the objects.
+
+ This function is intended to be used with <b>objects belonging to
+ the same container</b>, otherwise it will fail (and
+ accomplish nothing).
+
+ @see evas_vg_node_stack_below() */
+
+ params {
+ @in Evas_VG_Node *above @nonull; /*@ the object above which to stack */
+ }
+ }
+ stack_below {
+ /*@
+ Stack @p obj immediately below @p below
+
+ Objects, in a given container, are stacked in the order they get added
+ to it. This means that, if they overlap, the highest ones will
+ cover the lowest ones, in that order. This function is a way to
+ change the stacking order for the objects.
+
+ This function is intended to be used with <b>objects belonging to
+ the same container</b>, otherwise it will fail (and
+ accomplish nothing).
+
+ @see evas_vg_node_layer_get()
+ @see evas_vg_node_layer_set()
+ @see evas_vg_node_stack_below() */
+
+ params {
+ @in Evas_Object *below @nonull; /*@ the object below which to stack */
+ }
+ }
+ lower {
+ /*@
+ Lower @p obj to the bottom of its layer.
+
+ @p obj will, then, be the lowest one in the layer it belongs
+ to. Objects on other layers won't get touched.
+
+ @see evas_vg_node_stack_above()
+ @see evas_vg_node_stack_below()
+ @see evas_vg_node_raise() */
+ }
+ }
+ implements {
+ Eo.Base.parent.set;
+ Eo.Base.constructor;
+ @virtual .bound_get;
+ }
+}
\ No newline at end of file
--- /dev/null
+#ifndef EVAS_VG_PRIVATE_H_
+# define EVAS_VG_PRIVATE_H_
+
+typedef struct _Evas_VG_Container_Data Evas_VG_Container_Data;
+struct _Evas_VG_Container_Data
+{
+ Eina_List *children;
+};
+
+#endif
--- /dev/null
+#include "evas_common_private.h"
+#include "evas_private.h"
+
+#include "evas_vg_root_node.eo.h"
+
+#include <string.h>
+
+#define MY_CLASS EVAS_VG_ROOT_NODE_CLASS
+
+typedef struct _Evas_VG_Root_Node_Data Evas_VG_Root_Node_Data;
+struct _Evas_VG_Root_Node_Data
+{
+};
+
+void
+_evas_vg_root_node_eo_base_parent_set(Eo *obj,
+ Evas_VG_Root_Node_Data *pd EINA_UNUSED,
+ Eo *parent)
+{
+ // Nice little hack, jump over parent parent_set in Evas_VG_Root
+ eo_do_super(obj, EVAS_VG_NODE_CLASS, eo_constructor());
+ if (!eo_isa(parent, EVAS_VG_CLASS) &&
+ !eo_isa(parent, EVAS_VG_CONTAINER_CLASS))
+ eo_error_set(obj);
+}
+
+void
+_evas_vg_root_node_eo_base_constructor(Eo *obj,
+ Evas_VG_Root_Node_Data *pd EINA_UNUSED)
+{
+ Eo *parent;
+
+ // Nice little hack, jump over parent constructor in Evas_VG_Root
+ eo_do_super(obj, EVAS_VG_NODE_CLASS, eo_constructor());
+ eo_do(obj, parent = eo_parent_get());
+ if (!eo_isa(parent, EVAS_VG_CLASS) &&
+ !eo_isa(parent, EVAS_VG_CONTAINER_CLASS))
+ eo_error_set(obj);
+}
+
+#include "evas_vg_root_node.eo.c"
--- /dev/null
+class Evas.VG_Root_Node (Evas.VG_Node)
+{
+ eo_prefix: evas_vg_root_node;
+ implements {
+ Eo.Base.parent.set;
+ Eo.Base.constructor;
+ }
+}
--- /dev/null
+#include "evas_common_private.h"
+#include "evas_private.h"
+
+#define MY_CLASS EVAS_VG_SHAPE_CLASS
+
+typedef struct _Evas_VG_Shape_Data Evas_VG_Shape_Data;
+struct _Evas_VG_Shape_Data
+{
+ Evas_VG_Path_Command *op;
+ double *points;
+ unsigned int op_count;
+ unsigned int pts_counts;
+};
+
+Eina_Bool
+_evas_vg_shape_path_set(Eo *obj, Evas_VG_Shape_Data *pd, Evas_VG_Path_Command *op, double *points)
+{
+}
+
+Eina_Bool
+_evas_vg_shape_bounds_get(Eo *obj, Evas_VG_Shape_Data *pd, Eina_Rectangle *r)
+{
+}
+
+void
+_evas_vg_shape_eo_base_constructor(Eo *obj, Evas_VG_Shape_Data *pd)
+{
+ Eo *parent;
+
+ eo_super_do(obj, MY_CLASS, eo_constructor());
+
+ eo_do(obj, parent = eo_parent_get());
+ if (!eo_isa(obj, EVAS_VG_CONTAINER_CLASS) &&
+ !eo_isa(obj, EVAS_VG_CLASS))
+ {
+ ERR("Parent must be either an Evas_Object_VG or an Evas_VG_Container.");
+ eo_error_set(obj);
+ }
+}
--- /dev/null
+class Evas.VG_Shape (Evas.VG_Node)
+{
+ eo_prefix: evas_vg_shape;
+ properties {
+ fill {
+ set {
+ }
+ get {
+ }
+ values {
+ Evas_VG_Node *f;
+ }
+ }
+ stroke_scale {
+ set {
+ }
+ get {
+ }
+ values {
+ double s;
+ }
+ }
+ stroke_color {
+ set {
+ }
+ get {
+ }
+ values {
+ int r;
+ int g;
+ int b;
+ int a;
+ }
+ }
+ stroke_fill {
+ set {
+ }
+ get {
+ }
+ values {
+ Evas_VG_Node *f;
+ }
+ }
+ stroke_width {
+ set {
+ }
+ get {
+ }
+ values {
+ double w;
+ }
+ }
+ stroke_location {
+ set {
+ }
+ get {
+ }
+ values {
+ double centered;
+ }
+ }
+ stroke_dash {
+ set {
+ }
+ get {
+ }
+ values {
+ const(Evas_VG_Dash) *dash;
+ uint length;
+ }
+ }
+ stroke_marker {
+ set {
+ }
+ get {
+ }
+ values {
+ Evas_VG_Shape *m;
+ }
+ }
+ stroke_cap {
+ set {
+ }
+ get {
+ }
+ values {
+ Evas_VG_Cap c;
+ }
+ }
+ stroke_join {
+ set {
+ }
+ get {
+ }
+ values {
+ Evas_VG_Join j;
+ }
+ }
+ }
+ methods {
+ path_set {
+ return: bool;
+ params {
+ @in const(Evas_VG_Path_Command) *op;
+ @in const(double) *points;
+ }
+ }
+ }
+ implements {
+ Eo.Base.constructor;
+ Eo.Base.destructor;
+ }
+}
#define MAGIC_SMART 0x7c6977c5
#define MAGIC_OBJ_SHAPE 0x747297f7
#define MAGIC_OBJ_CONTAINER 0x71877776
+#define MAGIC_OBJ_VG 0x77817EE7
#define MAGIC_OBJ_CUSTOM 0x7b7857ab
#define MAGIC_EVAS_GL 0x77976718
#define MAGIC_MAP 0x7575177d
projects / platform / upstream / efl.git / commitdiff