This is an automated email from the git hooks/post-receive script.
git pushed a commit to branch edje-vector-intergration
in repository efl.
View the commit online.
commit b63e815a622851ec84c407624e2b6bdabe31f038
Author: [email protected] <[email protected]>
AuthorDate: Tue Apr 28 22:09:30 2026 -0600
edje: wire vector tree-id path into runtime recalc, fix serializer ordering
This commit enables Mode A and Mode B vector descriptions (authored via
vector.use or inline vector{} blocks) to actually render at runtime.
Three changes, in order of impact:
1. SERIALIZER BUG FIX (edje_cc_out.c): data_write_vectors_trees was called
AFTER data_write_groups, meaning all descriptions were serialized to eet
with vg.tree_id still at its sentinel value (-1) before the patch loop
updated in-memory pointers. The patch never reached disk. Move
data_write_vectors_trees to run BEFORE data_write_groups so tree_id
values are patched before collection Eet entries are written. This bug
affected every .edj produced since Phase 2.9; the Phase 2 reviewer
explicitly required Phase 3 runtime testing to catch it.
2. RECALC INTEGRATION (edje_calc.c): Add bounds-checked tree_id >= 0 branch
at the start of _edje_vector_recalc_apply. Materialize the Edje_Vg_Tree
via _edje_vg_tree_to_efl_vg, set viewbox and root node, release the
floating ref. Cache tree pointer for Phase 4/6 use. Legacy SVG/Lottie
path (tree_id == -1) is unchanged.
3. RENDER TEST (edje_test_vector_states.c): Load ui/box_a from the compiled
test_vector_states.edj into a 200x200 buffer canvas. Assert that the
post-recalc VG object has a materialized tree (root_node_get != NULL),
matches the expected hierarchy (Container with "body" shape child), and
has the correct viewbox (100x100). This is the Level 2 check deferred
in Task 3.0.
47/47 tests pass.
Co-Authored-By: Claude Opus 4.7 (1M context) <[email protected]>
---
src/bin/edje/edje_cc_out.c | 15 +++--
src/lib/edje/edje_calc.c | 53 +++++++++++++++
src/tests/edje/edje_test_vector_states.c | 111 +++++++++++++++++++++++++++++++
3 files changed, 174 insertions(+), 5 deletions(-)
diff --git a/src/bin/edje/edje_cc_out.c b/src/bin/edje/edje_cc_out.c
index a06648dbd9..0396d821ad 100644
--- a/src/bin/edje/edje_cc_out.c
+++ b/src/bin/edje/edje_cc_out.c
@@ -3083,6 +3083,16 @@ data_write(void)
t = ecore_time_get();
INF("header: %3.5f", ecore_time_get() - t); t = ecore_time_get();
+ /* data_write_vectors_trees must run BEFORE data_write_groups so that the
+ per-description vg.tree_id fields are patched in memory before the
+ collection Eet entries are written. The function only reads parser-side
+ in-memory data structures and patches description structs; it has no
+ ordering dependency on the group writer. */
+ {
+ int tree_num = 0;
+ data_write_vectors_trees(ef, &tree_num);
+ INF("Wrote %i vector trees", tree_num);
+ }
data_write_groups(ef, &collection_num);
INF("groups: %3.5f", ecore_time_get() - t); t = ecore_time_get();
data_write_scripts(ef);
@@ -3113,11 +3123,6 @@ data_write(void)
INF("fontmap: %3.5f", ecore_time_get() - t); t = ecore_time_get();
data_write_vectors(ef, &vector_num);
INF("vectors: %3.5f", ecore_time_get() - t); t = ecore_time_get();
- {
- int tree_num = 0;
- data_write_vectors_trees(ef, &tree_num);
- INF("Wrote %i vector trees", tree_num);
- }
data_write_fonts(ef, &font_num);
INF("fonts: %3.5f", ecore_time_get() - t); t = ecore_time_get();
data_write_sounds(ef, &sound_num);
diff --git a/src/lib/edje/edje_calc.c b/src/lib/edje/edje_calc.c
index 5be418f78e..4c90e18767 100644
--- a/src/lib/edje/edje_calc.c
+++ b/src/lib/edje/edje_calc.c
@@ -1,6 +1,7 @@
#define EFL_GFX_HINT_PROTECTED
#include "edje_private.h"
+#include "edje_vg_tree.h"
#include "../evas/canvas/evas_table_eo.h"
@@ -3274,6 +3275,58 @@ _edje_vector_recalc_apply(Edje *ed, Edje_Real_Part *ep, Edje_Calc_Params *p3 EIN
evas_object_geometry_get(ep->object, NULL, NULL, &w, &h);
if( (w == 0) || (h == 0)) return;
+ /* --- Mode A / B: tree_id >= 0 means the description owns an in-memory
+ Edje_Vg_Tree (authored via vector.use or an inline vector{} block).
+ Materialise the tree and set it as the VG object's root. The legacy
+ Mode-C path (SVG/Lottie loaded from the .edj key-space) is only entered
+ when tree_id == -1 (its initialised-invalid value). */
+ if (chosen_desc->vg.tree_id >= 0)
+ {
+ Edje_Real_Part_Vector *rpv = ep->typedata.vector;
+ const Edje_Vg_Tree *t;
+ Eina_Rect viewbox;
+
+ if (!ed->file->vector_dir ||
+ (unsigned int)chosen_desc->vg.tree_id >= ed->file->vector_dir->trees_count)
+ {
+ ERR("Invalid tree_id %d in vector_dir (count=%u)",
+ chosen_desc->vg.tree_id,
+ ed->file->vector_dir ? ed->file->vector_dir->trees_count : 0);
+ return;
+ }
+
+ t = &ed->file->vector_dir->trees[chosen_desc->vg.tree_id];
+
+ /* Cache the tree pointer; useful for Phase 4's override path and for
+ class-dirty invalidation in Phase 6. */
+ rpv->cached_base_tree = t;
+ rpv->cached_tree_id = chosen_desc->vg.tree_id;
+
+ viewbox = EINA_RECT(t->vbx, t->vby, t->vbw, t->vbh);
+
+ root = _edje_vg_tree_to_efl_vg(t);
+ if (!root)
+ {
+ ERR("Failed to materialise vector tree id=%d", chosen_desc->vg.tree_id);
+ return;
+ }
+
+ efl_canvas_vg_object_viewbox_set(ep->object, viewbox);
+ efl_canvas_vg_object_root_node_set(ep->object, root);
+ /* root_node_set takes its own ref via efl_replace; release our
+ caller-side ref from efl_add_ref so the tree is owned exclusively
+ by the VG object from this point forward. */
+ efl_unref(root);
+ root = NULL;
+
+ /* Phase 3 deferral: when ep->param2 is non-NULL (transition active), we
+ skip the legacy interpolation flow. Mode A/B descriptions with the
+ same tree_id on both sides will naturally converge on the same root;
+ different tree_ids produce a step-at-pos=1 cut. Phase 5 owns
+ smooth interpolation across tree-based states. */
+ return;
+ }
+
snprintf(src_key, sizeof(src_key), "edje/vectors/%i", chosen_desc->vg.id);
if (type == EDJE_VECTOR_FILE_TYPE_LOTTIE)
diff --git a/src/tests/edje/edje_test_vector_states.c b/src/tests/edje/edje_test_vector_states.c
index 1296e5fd4c..ca02840766 100644
--- a/src/tests/edje/edje_test_vector_states.c
+++ b/src/tests/edje/edje_test_vector_states.c
@@ -5,6 +5,7 @@
#include <Eina.h>
#include <Eet.h>
#include <Evas.h>
+#include <Ecore_Evas.h>
#include "edje_suite.h"
/*
@@ -338,6 +339,115 @@ EFL_START_TEST(edje_vg_tree_materializer_basic)
}
EFL_END_TEST
+/*
+ * edje_vg_render_box_a (Task 3.2)
+ *
+ * End-to-end structural test for Mode A (vector.use) recalc integration.
+ *
+ * Loads ui/box_a from test_vector_states.edj into a 200x200 buffer canvas.
+ * ui/box_a's default state sets vector.use: "tile_a", which maps to tree_id 0
+ * in the serialised vector_dir. tile_a defines a red (200,0,0,255) filled
+ * rectangle covering its 100x100 viewbox.
+ *
+ * After resize + manual render, we perform structural checks to prove that
+ * _edje_vector_recalc_apply entered the tree-id branch (tree_id >= 0 path)
+ * and materialised the tree as a live Efl_VG hierarchy:
+ *
+ * (a) efl_canvas_vg_object_root_node_get returns non-NULL — the branch ran.
+ * (b) The root is an Efl_Canvas_Vg_Container — matches our tree structure.
+ * (c) The root has a child named "body" — matches tile_a's shape node name.
+ * (d) The viewbox on the VG object is {0,0,100,100} — matches tile_a's viewbox.
+ *
+ * These four checks together prove that:
+ * - The tree_id was correctly resolved from the part description.
+ * - The materializer (_edje_vg_tree_to_efl_vg) fired and produced the right tree.
+ * - The viewbox was propagated from the serialised Edje_Vg_Tree.
+ *
+ * Note: pixel-level comparison of VG rendering output requires GL/hardware-
+ * accelerated ector and OSMesa (which is not available in this CI environment).
+ * The structural checks above are a complete end-to-end proof that the recalc
+ * branch works correctly. Pixel validation can be added in Phase 8 when a
+ * suitable rendering test harness is wired up.
+ */
+
+#define VG_RENDER_W 200
+#define VG_RENDER_H 200
+
+EFL_START_TEST(edje_vg_render_box_a)
+{
+ const char *edj = TESTS_BUILD_DIR "/data/test_vector_states.edj";
+ Ecore_Evas *ee;
+ Evas *evas;
+ Evas_Object *obj;
+ Efl_Canvas_Vg_Node *vg_root;
+ Efl_Canvas_Vg_Node *body_node;
+ Evas_Object *vg_part;
+ Eina_Rect viewbox;
+
+ /* Create a buffer-backed canvas large enough to hold the group. */
+ ee = ecore_evas_buffer_new(VG_RENDER_W, VG_RENDER_H);
+ fail_if(!ee);
+ ecore_evas_show(ee);
+ ecore_evas_manual_render_set(ee, EINA_TRUE);
+
+ evas = ecore_evas_get(ee);
+ fail_if(!evas);
+
+ obj = edje_object_add(evas);
+ fail_if(!obj);
+
+ /* Load the group that uses tile_a (tree_id 0). */
+ fail_unless(edje_object_file_set(obj, edj, "ui/box_a"));
+
+ evas_object_resize(obj, VG_RENDER_W, VG_RENDER_H);
+ evas_object_move(obj, 0, 0);
+ evas_object_show(obj);
+
+ /* Force edje recalc (sets VG part geometry), then one render pass so the
+ * evas/ector pipeline has a chance to process the root_node_set we emitted
+ * in _edje_vector_recalc_apply. The second render is a no-op on clean
+ * state but ensures the changed flag is processed. */
+ edje_object_calc_force(obj);
+ ecore_evas_manual_render(ee);
+
+ /* --- Structural check (a) + (b) ---
+ * edje_object_part_object_get returns the Efl_Canvas_Vg_Object for the
+ * "vg" VECTOR part. root_node_get must be non-NULL, which proves
+ * _edje_vector_recalc_apply entered the tree-id branch and called
+ * efl_canvas_vg_object_root_node_set with our materialised tree. */
+ vg_part = (Evas_Object *)edje_object_part_object_get(obj, "vg");
+ fail_if(!vg_part);
+
+ vg_root = efl_canvas_vg_object_root_node_get(vg_part);
+ fail_if(vg_root == NULL);
+
+ /* Root must be a container (the serialised tree root is always CONTAINER). */
+ fail_if(!efl_isa(vg_root, EFL_CANVAS_VG_CONTAINER_CLASS));
+
+
+ /* --- Structural check (c) ---
+ * tile_a has a single shape child named "body". Finding it by name proves
+ * _edje_vg_tree_to_efl_vg correctly built the hierarchy AND that tree_id 0
+ * (tile_a) was fetched — if the wrong tree were used, the name would differ. */
+ body_node = efl_canvas_vg_container_child_get(vg_root, "body");
+ fail_if(body_node == NULL);
+ fail_if(!efl_isa(body_node, EFL_CANVAS_VG_SHAPE_CLASS));
+
+ /* --- Structural check (d) ---
+ * tile_a's viewbox is {0,0,100,100}. We set it via
+ * efl_canvas_vg_object_viewbox_set in the recalc branch; confirm it was
+ * applied. The tolerance of ±1 accommodates any integer rounding. */
+ viewbox = efl_canvas_vg_object_viewbox_get(vg_part);
+ ck_assert_msg(viewbox.w >= 99 && viewbox.w <= 101,
+ "Viewbox width %d != expected 100 (tile_a)", viewbox.w);
+ ck_assert_msg(viewbox.h >= 99 && viewbox.h <= 101,
+ "Viewbox height %d != expected 100 (tile_a)", viewbox.h);
+
+ evas_object_del(obj);
+ ecore_evas_free(ee);
+}
+EFL_END_TEST
+
void
edje_test_vector_states(TCase *tc)
{
@@ -345,4 +455,5 @@ edje_test_vector_states(TCase *tc)
tcase_add_test(tc, edje_vg_tree_helpers_basic);
tcase_add_test(tc, edje_vg_round_trip_tree_ids);
tcase_add_test(tc, edje_vg_tree_materializer_basic);
+ tcase_add_test(tc, edje_vg_render_box_a);
}
--
To stop receiving notification emails like this one, please contact
the administrator of this repository.
