svg text and tspan support with coordinate lists, lists not yet disposed

14 files changed, 202 insertions, 82 deletions

diff --git a/gunit_tests/context.cpp b/gunit_tests/context.cpp
index cc068a1..4b3a438 100644
--- a/gunit_tests/context.cpp
+++ b/gunit_tests/context.cpp
@@ -174,7 +174,7 @@ TEST_F(ContextTest, CtxDrawBasicNullContext) {
     vkvg_text_run_create_with_length(ctx, NULL, 10);
 
     // vkvg_text_run_destroy(NULL);
-    vkvg_show_text_run(ctx, NULL);
+    vkvg_text_run_render(ctx, NULL);
 }
 
 
diff --git a/include/vkvg.h b/include/vkvg.h
index e6f2b52..1ca2522 100644
--- a/include/vkvg.h
+++ b/include/vkvg.h
@@ -1802,7 +1802,7 @@ vkvg_public void vkvg_text_run_destroy(VkvgText textRun);
  * @param ctx a valid vkvg @ref context
  * @param textRun
  */
-vkvg_public void vkvg_show_text_run(VkvgContext ctx, VkvgText textRun);
+vkvg_public void vkvg_text_run_render(VkvgContext ctx, VkvgText textRun);
 /**
  * @brief
  *
@@ -1817,10 +1817,12 @@ vkvg_public void vkvg_text_run_get_extents(VkvgText textRun, vkvg_text_extents_t
  */
 vkvg_public uint32_t vkvg_text_run_get_glyph_count(VkvgText textRun);
 /**
- * @brief retrieve glyph positions.
- *
+ * @brief Get glyph position at the provided index
+ * @param textRun A valid @ref VkvgText
+ * @param index index of the glyph to get position for.
+ * @return the glyph structure with position and glyph index.
  */
-vkvg_public void vkvg_text_run_get_glyph_position(VkvgText textRun, uint32_t index, vkvg_glyph_info_t* pGlyphInfo);
+vkvg_public vkvg_glyph_info_t vkvg_text_run_get_glyph_position(VkvgText textRun, uint32_t index);
 /** @}*/
 
 /**
diff --git a/src/msdf/CMakeLists.txt b/src/msdf/CMakeLists.txt
new file mode 100644
index 0000000..4962282
--- /dev/null
+++ b/src/msdf/CMakeLists.txt
@@ -0,0 +1,16 @@
+cmake_minimum_required(VERSION 3.14)
+project(msdf)
+
+# GoogleTest requires at least C++14
+set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+
+include(FetchContent)
+
+FetchContent_Declare(
+  msdfgen
+  GIT_REPOSITORY https://github.com/Chlumsky/msdfgen.git
+  GIT_TAG        1874bcf7d9624ccc85b4bc9a85d78116f690f35b #v1.13
+)
+
+FetchContent_MakeAvailable(msdfgen)
diff --git a/src/svg/svg-parse.c b/src/svg/svg-parse.c
index 6f91b55..9761050 100644
--- a/src/svg/svg-parse.c
+++ b/src/svg/svg-parse.c
@@ -120,10 +120,24 @@
 
 #define PROCESS_TEXT    process_element(svg, &attribs, parentData, false);
 #define POSTPROC_TEXT   vkvg_restore(svg->ctx);
-#define SVG_ATT_TEXT_X  parse_coordinate_list(svg->value, svg->value + svg->value_len, &(CAST(text)->x));
-#define SVG_ATT_TEXT_Y  parse_coordinate_list(svg->value, svg->value + svg->value_len, &(CAST(text)->y));
-#define SVG_ATT_TEXT_DX parse_coordinate_list(svg->value, svg->value + svg->value_len, &(CAST(text)->dx));
-#define SVG_ATT_TEXT_DY parse_coordinate_list(svg->value, svg->value + svg->value_len, &(CAST(text)->dy));
+#define SVG_ATT_TEXT_X  parse_coordinate_list(svg->value, svg->value + svg->value_len, &(CAST(text)->coords.x));
+#define SVG_ATT_TEXT_Y  parse_coordinate_list(svg->value, svg->value + svg->value_len, &(CAST(text)->coords.y));
+#define SVG_ATT_TEXT_DX parse_coordinate_list(svg->value, svg->value + svg->value_len, &(CAST(text)->coords.dx));
+#define SVG_ATT_TEXT_DY parse_coordinate_list(svg->value, svg->value + svg->value_len, &(CAST(text)->coords.dy));
+//============
+//== TSPAN ===
+#define PREPROC_TSPAN                   \
+    vkvg_save(svg->ctx);                \
+    void* tspanParent = parentData;     \
+    parentData = _new_tspan();          \
+    CAST(tspan)->parent = tspanParent;
+
+#define PROCESS_TSPAN    process_element(svg, &attribs, parentData, false);
+#define POSTPROC_TSPAN   vkvg_restore(svg->ctx);
+#define SVG_ATT_TSPAN_X  parse_coordinate_list(svg->value, svg->value + svg->value_len, &(CAST(tspan)->coords.x));
+#define SVG_ATT_TSPAN_Y  parse_coordinate_list(svg->value, svg->value + svg->value_len, &(CAST(tspan)->coords.y));
+#define SVG_ATT_TSPAN_DX parse_coordinate_list(svg->value, svg->value + svg->value_len, &(CAST(tspan)->coords.dx));
+#define SVG_ATT_TSPAN_DY parse_coordinate_list(svg->value, svg->value + svg->value_len, &(CAST(tspan)->coords.dy));
 //============
 
 //= LINEAR GRADIENT =
@@ -288,6 +302,13 @@
 #define SVG_ATT_SVG_VIEWBOX svg->hasViewBox = try_parse_viewbox(svg);
 #define SVG_ATT_TRANSFORM   apply_transform(svg);
 
+#define SVG_ATT_XML_SPACE                                                   \
+    if (!strncasecmp ((char*)svg->value, "default", svg->value_len))        \
+        attribs->space = XML_SPACE_DEFAULT;                                 \
+    else if (!strncasecmp ((char*)svg->value, "preserve", svg->value_len))  \
+        attribs->space = XML_SPACE_PRESERVE;
+
+
 #include "parser_gen.h"
 
 svg_element_linear_gradient *_new_linear_gradient() {
@@ -1508,8 +1529,8 @@ void process_element(svg_context *const svg, SvgPresentationAttributes *const at
                 vkvg_close_path(svg->ctx);
             draw(svg, attribs);
         } break;
-        case svg_element_type_text: {
-            CASTELT(txt, text, elt);
+        case svg_element_type_text:
+        case svg_element_type_tspan: {
             VkvgFont font = NULL;
             if (attribs->font_family_len > 0) {
                 char fam[1024];
@@ -1518,6 +1539,7 @@ void process_element(svg_context *const svg, SvgPresentationAttributes *const at
                 vkvg_set_font(svg->ctx, font);
                 vkvg_font_destroy(font);
             }
+            return;
         } break;
         default:
             LOG("Unprocessed element type: %d\n", _get_element_type(elt));
@@ -1604,32 +1626,86 @@ void process_svg(svg_context *const svg) {
         vkvg_scale(svg->ctx, xScale, yScale);
 }
 
-void process_innerText(SVG_COMMON_SIG, const uint8_t * innerText, size_t txt_len) {
+void draw_text(SVG_COMMON_SIG, svg_text_coords* coords, const uint8_t *buff, const uint8_t *const buff_end) {
+    if (attribs->fill_type) {
+        vkvg_set_opacity(svg->ctx, attribs->opacity * attribs->fill_opacity);
+        if (attribs->fill_type == svg_paint_type_pattern)
+            set_pattern(svg, attribs->fill);
+        else
+            vkvg_set_source_color(svg->ctx, attribs->fill);
+    }
+    VkvgText tr = NULL;
+
+    int charI = coords->charIndex;
+    int len = 0;
+    while (buff < buff_end) {
+        float x  = 0,
+            y  = 0,
+            dx = 0,
+            dy = 0;
+        bool singleChar = false;
+        int r = coords->x.count - charI;
+        if (r > 0) {
+            vkvg_get_current_point(svg->ctx, &x, &y);
+            x = coords->x.elements[charI];
+            vkvg_move_to(svg->ctx, x, y);
+            singleChar |= (r > 1);
+        }
+        r = coords->y.count - charI;
+        if (r > 0) {
+            vkvg_get_current_point(svg->ctx, &x, &y);
+            y = coords->y.elements[charI];
+            vkvg_move_to(svg->ctx, x, y);
+            singleChar |= (r > 1);
+        }
+        r = coords->dx.count - charI;
+        if (r > 0) {
+            vkvg_rel_move_to(svg->ctx, coords->dx.elements[charI], 0);
+            singleChar |= (r > 1);
+        }
+        r = coords->dy.count - charI;
+        if (r > 0) {
+            vkvg_rel_move_to(svg->ctx, 0, coords->dy.elements[charI]);
+            singleChar |= (r > 1);
+        }
+        if (singleChar)
+            len = get_utf8_char_length(buff[0]);
+        else
+            len = buff_end - buff;
+
+        tr = vkvg_text_run_create_with_length(svg->ctx, (char*)buff, len);
+        vkvg_text_run_render(svg->ctx, tr);
+        charI += vkvg_text_run_get_glyph_count(tr);
+        vkvg_text_run_destroy(tr);
+
+        buff += len;
+    }
+    coords->charIndex = charI;
+}
+
+
+void process_innerText(SVG_COMMON_SIG, const uint8_t *innerText, size_t txt_len) {
     if (!parentData)
         return;
     const uint8_t *const buff_end = innerText + txt_len;
 
-    innerText = skip_whitespaces(innerText, buff_end);
+    if (attribs->space == XML_SPACE_DEFAULT) {
+        innerText = skip_whitespaces(innerText, buff_end);
+        //should trim trailing white space
+    }
 
     svg_element_type eltType = _get_element_type(parentData);
     if (eltType == svg_element_type_text) {
+        LOG("text innerText: %.*s\n", (int)(buff_end - innerText), innerText);
         CASTELT(txt, text, parentData);
-        VkvgText tr = vkvg_text_run_create_with_length(svg->ctx, attribs->font_family, attribs->font_family_len);
 
-        if (txt->x.count && txt->y.count) {
-            vkvg_move_to(svg->ctx, txt->x.elements[0], txt->y.elements[0]);
-        }
-        if (attribs->fill_type) {
-            vkvg_set_opacity(svg->ctx, attribs->opacity * attribs->fill_opacity);
-            if (attribs->fill_type == svg_paint_type_pattern)
-                set_pattern(svg, attribs->fill);
-            else
-                vkvg_set_source_color(svg->ctx, attribs->fill);
-        }
+        draw_text(svg, attribs, parentData, &txt->coords, innerText, buff_end);
 
-        vkvg_show_text_run(svg->ctx, tr);
-        vkvg_text_run_destroy(tr);
-        LOG("Text innerText: %.*s\n", (int)(buff_end - innerText), innerText);
+    } else if (eltType == svg_element_type_tspan) {
+        LOG("tspan innerText: %.*s\n", (int)(buff_end - innerText), innerText);
+        CASTELT(txt, tspan, parentData);
+
+        draw_text(svg, attribs, parentData, &txt->coords, innerText, buff_end);
     }
 }
 
diff --git a/src/svg/vkvg_svg_internal.h b/src/svg/vkvg_svg_internal.h
index f33fc09..bf2af9c 100644
--- a/src/svg/vkvg_svg_internal.h
+++ b/src/svg/vkvg_svg_internal.h
@@ -63,7 +63,7 @@ typedef enum {
     svg_element_type_polygon,
     svg_element_type_path,
     svg_element_type_text,
-    svg_element_type_span,
+    svg_element_type_tspan,
     svg_element_type_linear_gradient,
     svg_element_type_radial_gradient,
     svg_element_type_gradient_stop
@@ -171,16 +171,23 @@ typedef struct {
 CTOR_ARRAY(float)
 
 typedef struct {
-    svg_element_header id;
     array_float         x;
     array_float         y;
     array_float         dx;
     array_float         dy;
+    int                 charIndex;
+} svg_text_coords;
+
+typedef struct {
+    svg_element_header  id;
+    svg_text_coords     coords;
 } svg_element_text;
 
 typedef struct {
-    svg_element_header id;
-} svg_element_span;
+    svg_element_header  id;
+    svg_text_coords     coords;
+    svg_element_header *parent;
+} svg_element_tspan;
 
 typedef struct {
     svg_element_header       id;
@@ -243,6 +250,7 @@ typedef enum { SVG_IMG_REND_AUTO = 0, SVG_IMG_REND_SPEED, SVG_IMG_REND_QUALITY }
 typedef enum { SVG_SHAPE_REND_AUTO = 0, SVG_SHAPE_REND_SPEED, SVG_SHAPE_REND_CRISP, SVG_SHAPE_REND_GEOMETRIC } SvgShapeRendering;
 typedef enum { SVG_OVERFLOW_VISIBLE = 0, SVG_OVERFLOW_HIDDEN, SVG_OVERFLOW_SCROLL, SVG_OVERFLOW_AUTO } SvgOverflow;
 typedef enum { SVG_BUFFER_AUTO = 0, SVG_BUFFER_STATIC, SVG_BUFFER_DYNAMIC } SvgBufferedRendering;
+typedef enum { XML_SPACE_DEFAULT = 0, XML_SPACE_PRESERVE } XmlSpace;
 
 typedef struct {
     uint8_t r;
@@ -299,6 +307,7 @@ typedef struct {
     SvgVectorEffect      vector_effect     : 1;
     SvgDisplay           display           : 1;
     SvgVisibility        visibility        : 1;
+    XmlSpace             space             : 1;
     SvgImageRendering    image_rendering   : 2;
     SvgShapeRendering    shape_rendering   : 2;
 
@@ -413,7 +422,7 @@ CREATE_CTOR_ELT(line)
 CREATE_CTOR_ELT(ellipse)
 CREATE_CTOR_ELT(path)
 CREATE_CTOR_ELT(text)
-CREATE_CTOR_ELT(span)
+CREATE_CTOR_ELT(tspan)
 CREATE_CTOR_ELT(polygon)
 CREATE_CTOR_ELT(gradient_stop)
 
diff --git a/src/vkvg_context.c b/src/vkvg_context.c
index a2958fd..0c49c8d 100644
--- a/src/vkvg_context.c
+++ b/src/vkvg_context.c
@@ -1257,32 +1257,34 @@ VkvgText vkvg_text_run_create(VkvgContext ctx, const char* text) {
     return tr;
 }
 VkvgText vkvg_text_run_create_with_length(VkvgContext ctx, const char* text, uint32_t length) {
-    if (vkvg_status(ctx))
+    if (vkvg_status(ctx) || vkvg_font_status(ctx->currentFont))
         return NULL;
     VkvgText tr = (vkvg_text_run_t*)calloc(1, sizeof(vkvg_text_run_t));
     text_run_init(ctx->currentFont, ctx->textDirection, text, length, tr);
     return tr;
 }
-uint32_t vkvg_text_run_get_glyph_count(VkvgText textRun) { return textRun->glyph_count; }
-void vkvg_text_run_get_glyph_position(VkvgText textRun, uint32_t index, vkvg_glyph_info_t* pGlyphInfo) {
+uint32_t vkvg_text_run_get_glyph_count(VkvgText textRun) { return textRun ? textRun->glyph_count : 0; }
+vkvg_glyph_info_t vkvg_text_run_get_glyph_position(VkvgText textRun, uint32_t index) {
     if (index >= textRun->glyph_count) {
-        *pGlyphInfo = (vkvg_glyph_info_t){0};
-        return;
+        return (vkvg_glyph_info_t){0};
     }
 #if VKVG_USE_HARFBUZZ
-    memcpy(pGlyphInfo, &textRun->glyphs[index], sizeof(vkvg_glyph_info_t));
+    vkvg_glyph_info_t* tmp = (vkvg_glyph_info_t*)&textRun->glyphs[index];
+    return *tmp;
 #else
-    *pGlyphInfo = textRun->glyphs[index];
+    return textRun->glyphs[index];
 #endif
 }
 void vkvg_text_run_destroy(VkvgText textRun) {
+    if (!textRun)
+        return;
     text_run_term(textRun);
     free(textRun);
 }
-void vkvg_show_text_run(VkvgContext ctx, VkvgText textRun) {
-    if (vkvg_status(ctx))
+void vkvg_text_run_render(VkvgContext ctx, VkvgText textRun) {
+    if (vkvg_status(ctx) || !textRun)
         return;
-    text_run_show_text(ctx, textRun);
+    text_run_render(ctx, textRun);
 }
 void vkvg_text_run_get_extents(VkvgText textRun, vkvg_text_extents_t* extents) { *extents = textRun->extents; }
 
diff --git a/src/vkvg_fonts.c b/src/vkvg_fonts.c
index 484b70c..8098a28 100644
--- a/src/vkvg_fonts.c
+++ b/src/vkvg_fonts.c
@@ -83,7 +83,6 @@ static inline uint32_t get_face_glyph_count (FontFace face) {
 #endif
 }
 
-
 void _fonts_cache_create(VkvgDevice dev, const char* fontDirs) {
     _font_cache_t* cache = (_font_cache_t*)calloc(1, sizeof(_font_cache_t));
 
@@ -820,7 +819,7 @@ void _font_cache_show_text(VkvgContext ctx, const char* text) {
     if (ctx->status)
         return;
 
-    text_run_show_text(ctx, &tr);
+    text_run_render(ctx, &tr);
     text_run_term(&tr);
     //_show_texture(ctx); return;
 }
@@ -869,9 +868,9 @@ void text_run_init(VkvgFont font, vkvg_direction_t textDirection, const char* te
         mtx_unlock(&textRun->font->face->mutex);
 #endif
 
-    unsigned int string_width_in_pixels = 0;
+    float string_width_in_pixels = 0;
     for (uint32_t i = 0; i < textRun->glyph_count; ++i)
-        string_width_in_pixels += textRun->glyphs[i].x_advance >> 6;
+        string_width_in_pixels += (float)textRun->glyphs[i].x_advance / 64.f;
 #ifdef VKVG_USE_FREETYPE
     FT_Size_Metrics* metrics = &textRun->font->ftSize->metrics;
     textRun->extents.height  = (float)(FT_MulFix(textRun->font->face->face->height, metrics->y_scale) >>
@@ -879,11 +878,11 @@ void text_run_init(VkvgFont font, vkvg_direction_t textDirection, const char* te
 #else
     textRun->extents.height = textRun->font->ascent - textRun->font->descent + textRun->font->lineGap;
 #endif
-    textRun->extents.x_advance = (float)string_width_in_pixels;
+    textRun->extents.x_advance = string_width_in_pixels;
     if (textRun->glyph_count > 0) {
-        textRun->extents.y_advance = (float)(textRun->glyphs[textRun->glyph_count - 1].y_advance >> 6);
-        textRun->extents.x_bearing = -(float)(textRun->glyphs[0].x_offset >> 6);
-        textRun->extents.y_bearing = -(float)(textRun->glyphs[0].y_offset >> 6);
+        textRun->extents.y_advance = (float)textRun->glyphs[textRun->glyph_count - 1].y_advance / 64.f;
+        textRun->extents.x_bearing = -(float)textRun->glyphs[0].x_offset / 64.f;
+        textRun->extents.y_bearing = -(float)textRun->glyphs[0].y_offset / 64.f;
     }
 
     textRun->extents.width = textRun->extents.x_advance;
@@ -897,7 +896,8 @@ void text_run_term(VkvgText textRun) {
 #endif
     vkvg_font_destroy(textRun->font);
 }
-void text_run_show_text(VkvgContext ctx, VkvgText tr) {
+
+void text_run_render(VkvgContext ctx, VkvgText tr) {
     unsigned int glyph_count;
 #ifdef VKVG_USE_HARFBUZZ
     hb_glyph_info_t* glyph_info = hb_buffer_get_glyph_infos(tr->hbBuf, &glyph_count);
@@ -930,10 +930,10 @@ void text_run_show_text(VkvgContext ctx, VkvgText tr) {
         VKVG_IBO_INDEX_TYPE firstIdx = (VKVG_IBO_INDEX_TYPE)(ctx->vertCount - ctx->curVertOffset);
 
         TexRef l = cr.texRef;
-        float yOffset = (float)l->penY / (float)FONT_PAGE_SIZE;
+        float uvY = (float)l->penY / (float)FONT_PAGE_SIZE;
 
         v.uv.x = cr.bounds.x;
-        v.uv.y = yOffset; // + cr.bounds.y
+        v.uv.y = uvY; // + cr.bounds.y
         v.uv.z = l->pageIdx;
         _add_vertex(ctx, v);
 
@@ -944,7 +944,7 @@ void text_run_show_text(VkvgContext ctx, VkvgText tr) {
         v.pos.x += cr.bounds.width;
         v.pos.y = p0.y;
         v.uv.x += uvWidth;
-        v.uv.y = yOffset; // + cr.bounds.y;
+        v.uv.y = uvY; // + cr.bounds.y;
         _add_vertex(ctx, v);
 
         v.pos.y += cr.bounds.height;
@@ -957,7 +957,6 @@ void text_run_show_text(VkvgContext ctx, VkvgText tr) {
         pen.y -= (tr->glyphs[i].y_advance >> 6);
     }
 
-           // equivalent to a moveto
     _finish_path(ctx);
     _add_point(ctx, pen.x, pen.y);
     _flush_chars_to_tex(tr->font);
@@ -1033,6 +1032,11 @@ VkvgFont _create_font_from_face (VkvgDevice dev, FontFace face, float pointSize,
         FT_Set_Var_Design_Coordinates(face->face, font->face->numAxis, font->coords);
         font->face->coords = font->coords;
     }
+#ifdef VKVG_USE_HARFBUZZ
+    hb_font_t* hbf = font->face->hb_font;
+    hb_ft_font_changed(hbf);
+    hb_font_set_ppem(hbf, font->ftSize->metrics.x_ppem, font->ftSize->metrics.y_ppem);
+#endif
 
     font->charLookup = (glyph_ref*)calloc(face->face->num_glyphs, sizeof(glyph_ref));
 
diff --git a/src/vkvg_fonts.h b/src/vkvg_fonts.h
index 00c1edc..09a57d0 100644
--- a/src/vkvg_fonts.h
+++ b/src/vkvg_fonts.h
@@ -314,5 +314,5 @@ void _font_cache_update_context_descset(VkvgContext ctx);
 
 void text_run_init(VkvgFont font, vkvg_direction_t textDirection, const char* text, int length, VkvgText textRun);
 void text_run_term(VkvgText textRun);
-void text_run_show_text(VkvgContext ctx, VkvgText tr); // Draw text run
+void text_run_render(VkvgContext ctx, VkvgText tr); // Draw text run
 #endif
diff --git a/src/vkvg_internal.h b/src/vkvg_internal.h
index cdffdb5..c7f5c0e 100644
--- a/src/vkvg_internal.h
+++ b/src/vkvg_internal.h
@@ -160,8 +160,6 @@ static inline uint64_t fnv1a_64_str(const char *const restrict str) {
 #define VKVG_FENCE_TIMEOUT 30000000000
 // #define VKVG_FENCE_TIMEOUT 10000
 
-
-
 #include "vectors.h"
 
 /*typedef struct {
diff --git a/tests/fonts/allfont.c b/tests/fonts/allfont.c
index 5278b37..00eb19d 100644
--- a/tests/fonts/allfont.c
+++ b/tests/fonts/allfont.c
@@ -199,8 +199,15 @@ void draw(VkvgSurface surfFont) {
         FcPatternGetString(font_entry, FC_FILE, 0, &file_path);
         sprintf(tmp, "%s", family_name);
 
+        if (!variable) {
+            FcChar8* axes_blueprint = NULL;
+            if (FcPatternGetString(font_entry, FC_FONT_VARIATIONS, 0, &axes_blueprint) == FcResultMatch) {
+                variable = true;
+            }
+        }
+
         if (onlyVariable && !variable)
-                continue;
+            continue;
 
         VkvgFont font = vkvg_font_create (device, tmp, fontSize);
         if (vkvg_font_status(font)) {
@@ -208,7 +215,7 @@ void draw(VkvgSurface surfFont) {
             fflush(stdout);
             continue;
         }
-        sprintf(tmp, "%s : %s", family_name, style_variant);
+        sprintf(tmp, "%s : %s var:%d", family_name, style_variant,variable);
         vkvg_set_font (ctx, mono);
         vkvg_move_to (ctx, penX, penY);
         vkvg_set_source_rgb(ctx,0.8f,0.8f,0.8f);
@@ -242,7 +249,7 @@ void draw(VkvgSurface surfFont) {
 
         vkvg_move_to (ctx, penX, penY);
         vkvg_set_source_rgb(ctx,1,1,1);
-        vkvg_show_text_run(ctx,tr);
+        vkvg_text_run_render(ctx,tr);
 
         vkvg_flush(ctx);
 
@@ -340,9 +347,10 @@ int main(int argc, char* argv[]) {
                                       vkh_app_get_inst(e->app),
                                       vkh_device_get_phy(e->dev),
                                       vkh_device_get_vkdev(e->dev),
-                                      e->gQFamIdx, 0, false};
+                                      e->gQFamIdx, 0, false };//, TESTS_DATA_ROOT "/fonts"};
 
     device = vkvg_device_create(&info);
+    vkvg_device_set_dpy(device, 140,140);
     surf = vkvg_surface_create(device, test_width, test_height);
     VkvgSurface surfFont = vkvg_surface_create(device, test_width, test_height);
 
@@ -356,10 +364,11 @@ int main(int argc, char* argv[]) {
     }
     FcConfig* config = FcConfigGetCurrent();
     FcPattern* request = FcPatternCreate();
-    FcObjectSet* requested_elements = FcObjectSetBuild(FC_FAMILY, FC_STYLE, FC_FILE, FC_LANG, FC_VARIABLE, (char *)0);
+    FcObjectSet* requested_elements = FcObjectSetBuild(FC_FAMILY, FC_STYLE, FC_FILE, FC_LANG, FC_VARIABLE, FC_FONT_VARIATIONS,(char *)0);
     //FcPatternAddBool(request, FC_VARIABLE, FcTrue);
     //FcPatternAddBool(request, FC_SCALABLE, FcTrue);
     //FcPatternAddString(request, FC_FONTFORMAT, (const FcChar8 *)"TrueType");
+    //FcPatternAddBool(request, FC_VARIABLE, FcDontCare);
 
     font_database = FcFontList(config, request, requested_elements);
 #endif
diff --git a/tests/fonts/fontquery.c b/tests/fonts/fontquery.c
index 7f8e988..bf979ab 100644
--- a/tests/fonts/fontquery.c
+++ b/tests/fonts/fontquery.c
@@ -14,7 +14,7 @@
 
 #include <string.h>
 
-float fontSize = 24.0f;
+float fontSize = 50.0f;
 int   curFontStartIdx = 0;
 bool  redraw = true;
 
@@ -257,8 +257,8 @@ void draw(VkvgSurface surfFont) {
     //FcPatternAddBool(request, FC_SCALABLE, FcTrue);
     //FcPatternAddString(request, FC_FONTFORMAT, (const FcChar8 *)"TrueType");
 
-    FcConfigSubstitute(config, request, FcMatchPattern);
-    FcDefaultSubstitute(request);
+    //FcConfigSubstitute(config, request, FcMatchPattern);
+    //FcDefaultSubstitute(request);
 
     FcFontSet* fonts = FcFontList(config, request, requested_elements);
 
@@ -313,7 +313,7 @@ void draw(VkvgSurface surfFont) {
 
         vkvg_move_to (ctx, penX, penY);
         vkvg_set_source_rgb(ctx,1,1,1);
-        vkvg_show_text_run(ctx,tr);
+        vkvg_text_run_render(ctx,tr);
 
         penX = 50;
         penY = 150;
@@ -434,11 +434,14 @@ static void key_callback(GLFWwindow* window, int key, int scancode, int action,
         txtBuffer[txtBuffPtr]='\0';
         break;
     case GLFW_KEY_PAGE_DOWN:
-        curFontStartIdx += 0xff;
+        //curFontStartIdx += 0xff;
+        if (fontSize > 5.f)
+            fontSize--;
         break;
     case GLFW_KEY_PAGE_UP:
-        curFontStartIdx -= 0xff;
-        curFontStartIdx = MAX(curFontStartIdx, 0);
+        //curFontStartIdx -= 0xff;
+        //curFontStartIdx = MAX(curFontStartIdx, 0);
+        fontSize++;
         break;
     case GLFW_KEY_F3:
         variable = !variable;
@@ -500,7 +503,7 @@ int main(int argc, char* argv[]) {
                                       vkh_app_get_inst(e->app),
                                       vkh_device_get_phy(e->dev),
                                       vkh_device_get_vkdev(e->dev),
-                                      e->gQFamIdx, 0};
+                                      e->gQFamIdx, 0, false};//, TESTS_DATA_ROOT "/fonts"};
 
     device = vkvg_device_create(&info);
     surf = vkvg_surface_create(device, test_width, test_height);
@@ -517,8 +520,8 @@ int main(int argc, char* argv[]) {
     config = FcConfigGetCurrent();
     FcPattern* request = FcPatternCreate();
     FcObjectSet* requested_elements = FcObjectSetBuild(FC_FAMILY, FC_STYLE, FC_FILE, FC_LANG, FC_VARIABLE, (char *)0);
-    FcPatternAddBool(request, FC_SCALABLE, FcTrue);
-    FcPatternAddString(request, FC_FONTFORMAT, (const FcChar8 *)"TrueType");
+    //FcPatternAddBool(request, FC_SCALABLE, FcTrue);
+    //FcPatternAddString(request, FC_FONTFORMAT, (const FcChar8 *)"TrueType");
 
     font_database = FcFontList(config, request, requested_elements);
 #endif
diff --git a/tests/paint_surf.c b/tests/paint_surf.c
index a48006d..f7fb4ca 100644
--- a/tests/paint_surf.c
+++ b/tests/paint_surf.c
@@ -21,7 +21,7 @@ VkvgSurface createSurf(uint32_t width, uint32_t height) {
 
 void paint() {
     VkvgSurface src = createSurf(256, 256);
-    VkvgContext ctx = _initCtx(surf);
+    VkvgContext ctx = _initCtx();
     vkvg_set_source_surface(ctx, src, 0, 0);
     vkvg_paint(ctx);
     vkvg_destroy(ctx);
@@ -29,7 +29,7 @@ void paint() {
 }
 void paint_with_offset() {
     VkvgSurface src = createSurf(256, 256);
-    VkvgContext ctx = _initCtx(surf);
+    VkvgContext ctx = _initCtx();
     vkvg_set_source_rgba(ctx, 0, 1, 0, 0.5);
     vkvg_paint(ctx);
     vkvg_set_source_surface(ctx, src, 100, 100);
@@ -39,7 +39,7 @@ void paint_with_offset() {
 }
 void paint_multiple() {
     VkvgSurface src = createSurf(256, 256);
-    VkvgContext ctx = _initCtx(surf);
+    VkvgContext ctx = _initCtx();
     for (int i = 0; i < 10; i++) {
         vkvg_set_source_surface(ctx, src, i * 20, i * 20);
         vkvg_paint(ctx);
@@ -49,7 +49,7 @@ void paint_multiple() {
 }
 void paint_with_rotation() {
     VkvgSurface src = createSurf(256, 256);
-    VkvgContext ctx = _initCtx(surf);
+    VkvgContext ctx = _initCtx();
     vkvg_set_source_surface(ctx, src, 0, 0);
     vkvg_rotate(ctx, 45);
     vkvg_paint(ctx);
@@ -58,7 +58,7 @@ void paint_with_rotation() {
 }
 void paint_with_scale() {
     VkvgSurface src = createSurf(256, 256);
-    VkvgContext ctx = _initCtx(surf);
+    VkvgContext ctx = _initCtx();
     vkvg_set_source_surface(ctx, src, 0, 0);
     vkvg_scale(ctx, 0.2f, 0.2f);
     vkvg_paint(ctx);
@@ -67,7 +67,7 @@ void paint_with_scale() {
 }
 void paint_rect() {
     VkvgSurface src = createSurf(256, 256);
-    VkvgContext ctx = _initCtx(surf);
+    VkvgContext ctx = _initCtx();
     vkvg_set_source_surface(ctx, src, 0, 0);
     vkvg_rectangle(ctx, 100, 100, 300, 200);
     vkvg_paint(ctx);
@@ -76,7 +76,7 @@ void paint_rect() {
 }
 // TODO:test failed: full screen paint instead of rotated rect
 void paint_rect_with_rotation() {
-    VkvgContext ctx = _initCtx(surf);
+    VkvgContext ctx = _initCtx();
     vkvg_rotate(ctx, 45);
     vkvg_set_source_rgba(ctx, 1, 0, 0, 1);
     vkvg_rectangle(ctx, 100, 100, 300, 200);
@@ -84,7 +84,7 @@ void paint_rect_with_rotation() {
     vkvg_destroy(ctx);
 }
 void paint_rect_with_scale() {
-    VkvgContext ctx = _initCtx(surf);
+    VkvgContext ctx = _initCtx();
     vkvg_scale(ctx, 0.2f, 0.2f);
     vkvg_set_source_rgba(ctx, 1, 0, 0, 1);
     vkvg_rectangle(ctx, 100, 100, 300, 200);
diff --git a/tests/vkvg-svg/svg-viewer.c b/tests/vkvg-svg/svg-viewer.c
index 450157b..27a5029 100644
--- a/tests/vkvg-svg/svg-viewer.c
+++ b/tests/vkvg-svg/svg-viewer.c
@@ -342,6 +342,7 @@ int main(int argc, char* argv[]) {
                     nextSvgFile = false;
                 }
                 sprintf(tmp, "%s/%s", path, de->d_name);
+                vkengine_set_title(e,tmp);
             } else {
                 sprintf(tmp, "%s", path);
             }
diff --git a/tests/vkvg-svg/svg.c b/tests/vkvg-svg/svg.c
index d9e4b59..d8e88b7 100644
--- a/tests/vkvg-svg/svg.c
+++ b/tests/vkvg-svg/svg.c
@@ -59,7 +59,7 @@ void svg_text() {
     vkvg_surface_destroy(svgSurf);
 }
 void svg_text_frag() {
-    const char* txt = {"<svg><text id='txt' font-size='50' font-family='sans' x='50' y='50'>The crow jumed on the fox</text></svg>"};
+    const char* txt = {"<svg><text id='txt' font-size='20' font-family='sans' x='50' y='50 60 70'>The crow jumed on the fox</text></svg>"};
     VkvgSurface svgSurf = vkvg_surface_create_from_svg_fragment(device, test_width, test_height, txt);
     VkvgContext ctx = _initCtx();