From c6742e9590ba243cd7f2eefed511e4adf72d68e4 Mon Sep 17 00:00:00 2001 From: Hermet Park Date: Mon, 22 Jun 2020 20:53:52 +0900 Subject: [PATCH] common transform: support matrix transform interface. this interface is designed for user-defined arbitrary affine-transform paints. required by svg loader. Change-Id: I7f08023605d224e36cef3770098d3757aee81848 --- .gitignore | 1 + inc/tizenvg.h | 33 ++++---- src/lib/sw_engine/tvgSwFill.cpp | 14 ++-- src/lib/sw_engine/tvgSwShape.cpp | 4 +- src/lib/tvgRender.cpp | 70 +++++++++------- src/lib/tvgRender.h | 8 +- src/lib/tvgScene.cpp | 11 +++ src/lib/tvgSceneImpl.h | 64 ++++++++------ src/lib/tvgShape.cpp | 13 ++- src/lib/tvgShapeImpl.h | 68 +++++++++------ test/makefile | 1 + test/testCustomTransform.cpp | 140 +++++++++++++++++++++++++++++++ 12 files changed, 317 insertions(+), 110 deletions(-) create mode 100644 test/testCustomTransform.cpp diff --git a/.gitignore b/.gitignore index 7aa8bd7f..c2b9a6c0 100644 --- a/.gitignore +++ b/.gitignore @@ -11,6 +11,7 @@ testUpdate testDirectUpdate testScene testTransform +testCustomTransform testSceneTransform testStroke testStrokeLine diff --git a/inc/tizenvg.h b/inc/tizenvg.h index bc541b31..a7eede4c 100644 --- a/inc/tizenvg.h +++ b/inc/tizenvg.h @@ -78,6 +78,14 @@ struct Point }; +struct Matrix +{ + float e11, e12, e13; + float e21, e22, e23; + float e31, e32, e33; +}; + + /** * @class Paint * @@ -91,12 +99,6 @@ class TVG_EXPORT Paint public: virtual ~Paint() {} - virtual Result rotate(float degree) = 0; - virtual Result scale(float factor) = 0; - virtual Result translate(float x, float y) = 0; - - virtual Result bounds(float* x, float* y, float* w, float* h) const = 0; - _TVG_DECALRE_IDENTIFIER(); }; @@ -242,16 +244,17 @@ public: Result fill(std::unique_ptr f) noexcept; //Transform - Result rotate(float degree) noexcept override; - Result scale(float factor) noexcept override; - Result translate(float x, float y) noexcept override; + Result rotate(float degree) noexcept; + Result scale(float factor) noexcept; + Result translate(float x, float y) noexcept; + Result transform(const Matrix& m) noexcept; //Getters uint32_t pathCommands(const PathCommand** cmds) const noexcept; uint32_t pathCoords(const Point** pts) const noexcept; Result fill(uint8_t* r, uint8_t* g, uint8_t* b, uint8_t* a) const noexcept; const Fill* fill() const noexcept; - Result bounds(float* x, float* y, float* w, float* h) const noexcept override; + Result bounds(float* x, float* y, float* w, float* h) const noexcept; float strokeWidth() const noexcept; Result strokeColor(uint8_t* r, uint8_t* g, uint8_t* b, uint8_t* a) const noexcept; @@ -282,14 +285,14 @@ public: Result push(std::unique_ptr paint) noexcept; Result reserve(uint32_t size) noexcept; - Result load(const std::string& path) noexcept; - Result rotate(float degree) noexcept override; - Result scale(float factor) noexcept override; - Result translate(float x, float y) noexcept override; + Result rotate(float degree) noexcept; + Result scale(float factor) noexcept; + Result translate(float x, float y) noexcept; + Result transform(const Matrix& m) noexcept; - Result bounds(float* x, float* y, float* w, float* h) const noexcept override; + Result bounds(float* x, float* y, float* w, float* h) const noexcept; static std::unique_ptr gen() noexcept; diff --git a/src/lib/sw_engine/tvgSwFill.cpp b/src/lib/sw_engine/tvgSwFill.cpp index f6091837..0bf30248 100644 --- a/src/lib/sw_engine/tvgSwFill.cpp +++ b/src/lib/sw_engine/tvgSwFill.cpp @@ -100,12 +100,12 @@ bool _prepareLinear(SwFill* fill, const LinearGradient* linear, const RenderTran auto cy = (y2 - y1) * 0.5f + y1; auto dx = x1 - cx; auto dy = y1 - cy; - x1 = dx * transform->e11 + dy * transform->e12 + transform->e31; - y1 = dx * transform->e21 + dy * transform->e22 + transform->e32; + x1 = dx * transform->m.e11 + dy * transform->m.e12 + transform->m.e31; + y1 = dx * transform->m.e21 + dy * transform->m.e22 + transform->m.e32; dx = x2 - cx; dy = y2 - cy; - x2 = dx * transform->e11 + dy * transform->e12 + transform->e31; - y2 = dx * transform->e21 + dy * transform->e22 + transform->e32; + x2 = dx * transform->m.e11 + dy * transform->m.e12 + transform->m.e31; + y2 = dx * transform->m.e21 + dy * transform->m.e22 + transform->m.e32; } fill->linear.dx = x2 - x1; @@ -131,11 +131,11 @@ bool _prepareRadial(SwFill* fill, const RadialGradient* radial, const RenderTran if (radius < FLT_EPSILON) return true; if (transform) { - auto tx = fill->radial.cx * transform->e11 + fill->radial.cy * transform->e12 + transform->e31; - auto ty = fill->radial.cx * transform->e21 + fill->radial.cy * transform->e22 + transform->e32; + auto tx = fill->radial.cx * transform->m.e11 + fill->radial.cy * transform->m.e12 + transform->m.e31; + auto ty = fill->radial.cx * transform->m.e21 + fill->radial.cy * transform->m.e22 + transform->m.e32; fill->radial.cx = tx; fill->radial.cy = ty; - radius *= transform->e33; + radius *= transform->m.e33; } fill->radial.a = radius * radius; diff --git a/src/lib/sw_engine/tvgSwShape.cpp b/src/lib/sw_engine/tvgSwShape.cpp index 4d3c44ec..6d8c9f2d 100644 --- a/src/lib/sw_engine/tvgSwShape.cpp +++ b/src/lib/sw_engine/tvgSwShape.cpp @@ -347,8 +347,8 @@ static void _transformOutline(SwOutline* outline, const RenderTransform* transfo for(uint32_t i = 0; i < outline->ptsCnt; ++i) { auto dx = static_cast(outline->pts[i].x >> 6); auto dy = static_cast(outline->pts[i].y >> 6); - auto tx = dx * transform->e11 + dy * transform->e12 + transform->e31; - auto ty = dx * transform->e21 + dy * transform->e22 + transform->e32; + auto tx = dx * transform->m.e11 + dy * transform->m.e12 + transform->m.e31; + auto ty = dx * transform->m.e21 + dy * transform->m.e22 + transform->m.e32; auto pt = Point{tx, ty}; outline->pts[i] = TO_SWPOINT(&pt); } diff --git a/src/lib/tvgRender.cpp b/src/lib/tvgRender.cpp index 4b4afc3b..cd9dff26 100644 --- a/src/lib/tvgRender.cpp +++ b/src/lib/tvgRender.cpp @@ -30,10 +30,24 @@ /* External Class Implementation */ /************************************************************************/ +void RenderTransform::override(const Matrix& m) +{ + this->m = m; + + if (m.e11 == 0.0f && m.e12 == 0.0f && m.e13 == 0.0f && + m.e21 == 0.0f && m.e22 == 0.0f && m.e23 == 0.0f && + m.e31 == 0.0f && m.e32 == 0.0f && m.e33 == 0.0f) { + overriding = false; + } else overriding = true; +} + + bool RenderTransform::update() { constexpr auto PI = 3.141592f; + if (overriding) return true; + //Init Status if (fabsf(x) <= FLT_EPSILON && fabsf(y) <= FLT_EPSILON && fabsf(degree) <= FLT_EPSILON && fabsf(factor - 1) <= FLT_EPSILON) { @@ -41,20 +55,20 @@ bool RenderTransform::update() } //identity - e11 = 1.0f; - e12 = 0.0f; - e13 = 0.0f; - e21 = 0.0f; - e22 = 1.0f; - e23 = 0.0f; - e31 = 0.0f; - e32 = 0.0f; - e33 = 1.0f; + m.e11 = 1.0f; + m.e12 = 0.0f; + m.e13 = 0.0f; + m.e21 = 0.0f; + m.e22 = 1.0f; + m.e23 = 0.0f; + m.e31 = 0.0f; + m.e32 = 0.0f; + m.e33 = 1.0f; //scale - e11 *= factor; - e22 *= factor; - e33 *= factor; + m.e11 *= factor; + m.e22 *= factor; + m.e33 *= factor; //rotation if (fabsf(degree) > FLT_EPSILON) { @@ -62,23 +76,23 @@ bool RenderTransform::update() auto cosVal = cosf(radian); auto sinVal = sinf(radian); - auto t11 = e11 * cosVal + e12 * sinVal; - auto t12 = e11 * -sinVal + e12 * cosVal; - auto t21 = e21 * cosVal + e22 * sinVal; - auto t22 = e21 * -sinVal + e22 * cosVal; - auto t31 = e31 * cosVal + e32 * sinVal; - auto t32 = e31 * -sinVal + e32 * cosVal; + auto t11 = m.e11 * cosVal + m.e12 * sinVal; + auto t12 = m.e11 * -sinVal + m.e12 * cosVal; + auto t21 = m.e21 * cosVal + m.e22 * sinVal; + auto t22 = m.e21 * -sinVal + m.e22 * cosVal; + auto t31 = m.e31 * cosVal + m.e32 * sinVal; + auto t32 = m.e31 * -sinVal + m.e32 * cosVal; - e11 = t11; - e12 = t12; - e21 = t21; - e22 = t22; - e31 = t31; - e32 = t32; + m.e11 = t11; + m.e12 = t12; + m.e21 = t21; + m.e22 = t22; + m.e31 = t31; + m.e32 = t32; } - e31 += x; - e32 += y; + m.e31 += x; + m.e32 += y; return true; } @@ -95,8 +109,8 @@ RenderTransform::RenderTransform(const RenderTransform* lhs, const RenderTransfo auto dx = rhs->x * lhs->factor; auto dy = rhs->y * lhs->factor; - auto tx = dx * lhs->e11 + dy * lhs->e12 + lhs->e13; - auto ty = dx * lhs->e21 + dy * lhs->e22 + lhs->e23; + auto tx = dx * lhs->m.e11 + dy * lhs->m.e12 + lhs->m.e13; + auto ty = dx * lhs->m.e21 + dy * lhs->m.e22 + lhs->m.e23; x = lhs->x + tx; y = lhs->y + ty; diff --git a/src/lib/tvgRender.h b/src/lib/tvgRender.h index 74feb778..8e9a50f3 100644 --- a/src/lib/tvgRender.h +++ b/src/lib/tvgRender.h @@ -32,17 +32,15 @@ enum RenderUpdateFlag {None = 0, Path = 1, Color = 2, Gradient = 4, Stroke = 8, struct RenderTransform { - //3x3 Matrix Elements - float e11, e12, e13; - float e21, e22, e23; - float e31, e32, e33; - + Matrix m; //3x3 Matrix Elements float x = 0.0f; float y = 0.0f; float degree = 0.0f; //rotation degree float factor = 1.0f; //scale factor + bool overriding = false; //user transform? bool update(); + void override(const Matrix& m); RenderTransform(); RenderTransform(const RenderTransform* lhs, const RenderTransform* rhs); diff --git a/src/lib/tvgScene.cpp b/src/lib/tvgScene.cpp index 41620a0b..1980d96a 100644 --- a/src/lib/tvgScene.cpp +++ b/src/lib/tvgScene.cpp @@ -97,6 +97,17 @@ Result Scene::translate(float x, float y) noexcept } +Result Scene::transform(const Matrix& m) noexcept +{ + auto impl = pImpl.get(); + if (!impl) return Result::MemoryCorruption; + + if (!impl->transform(m)) return Result::FailedAllocation; + + return Result::Success; +} + + Result Scene::bounds(float* x, float* y, float* w, float* h) const noexcept { auto impl = pImpl.get(); diff --git a/src/lib/tvgSceneImpl.h b/src/lib/tvgSceneImpl.h index 5e67a666..4e412d47 100644 --- a/src/lib/tvgSceneImpl.h +++ b/src/lib/tvgSceneImpl.h @@ -26,7 +26,7 @@ struct Scene::Impl { vector paints; - RenderTransform *transform = nullptr; + RenderTransform *rTransform = nullptr; uint32_t flag = RenderUpdateFlag::None; unique_ptr loader = nullptr; @@ -34,7 +34,7 @@ struct Scene::Impl { //Are you sure clear() prior to this? assert(paints.empty()); - if (transform) delete(transform); + if (rTransform) delete(rTransform); } bool clear(RenderMethod& renderer) @@ -82,20 +82,20 @@ struct Scene::Impl } if (flag & RenderUpdateFlag::Transform) { - if (!transform) return false; - if (!transform->update()) { - delete(transform); - transform = nullptr; + if (!rTransform) return false; + if (!rTransform->update()) { + delete(rTransform); + rTransform = nullptr; } } auto ret = true; - if (transform && pTransform) { - RenderTransform outTransform(pTransform, transform); + if (rTransform && pTransform) { + RenderTransform outTransform(pTransform, rTransform); ret = updateInternal(renderer, &outTransform, pFlag | flag); } else { - auto outTransform = pTransform ? pTransform : transform; + auto outTransform = pTransform ? pTransform : rTransform; ret = updateInternal(renderer, outTransform, pFlag | flag); } @@ -158,14 +158,14 @@ struct Scene::Impl bool scale(float factor) { - if (transform) { - if (fabsf(factor - transform->factor) <= FLT_EPSILON) return true; + if (rTransform) { + if (fabsf(factor - rTransform->factor) <= FLT_EPSILON) return true; } else { if (fabsf(factor) <= FLT_EPSILON) return true; - transform = new RenderTransform(); - if (!transform) return false; + rTransform = new RenderTransform(); + if (!rTransform) return false; } - transform->factor = factor; + rTransform->factor = factor; flag |= RenderUpdateFlag::Transform; return true; @@ -173,14 +173,14 @@ struct Scene::Impl bool rotate(float degree) { - if (transform) { - if (fabsf(degree - transform->degree) <= FLT_EPSILON) return true; + if (rTransform) { + if (fabsf(degree - rTransform->degree) <= FLT_EPSILON) return true; } else { if (fabsf(degree) <= FLT_EPSILON) return true; - transform = new RenderTransform(); - if (!transform) return false; + rTransform = new RenderTransform(); + if (!rTransform) return false; } - transform->degree = degree; + rTransform->degree = degree; flag |= RenderUpdateFlag::Transform; return true; @@ -188,20 +188,34 @@ struct Scene::Impl bool translate(float x, float y) { - if (transform) { - if (fabsf(x - transform->x) <= FLT_EPSILON && fabsf(y - transform->y) <= FLT_EPSILON) return true; + if (rTransform) { + if (fabsf(x - rTransform->x) <= FLT_EPSILON && fabsf(y - rTransform->y) <= FLT_EPSILON) return true; } else { if (fabsf(x) <= FLT_EPSILON && fabsf(y) <= FLT_EPSILON) return true; - transform = new RenderTransform(); - if (!transform) return false; + rTransform = new RenderTransform(); + if (!rTransform) return false; } - transform->x = x; - transform->y = y; + rTransform->x = x; + rTransform->y = y; flag |= RenderUpdateFlag::Transform; return true; } + + bool transform(const Matrix& m) + { + if (!rTransform) { + rTransform = new RenderTransform(); + if (!rTransform) return false; + } + rTransform->override(m); + flag |= RenderUpdateFlag::Transform; + + return true; + } + + Result load(const string& path) { if (loader) loader->close(); diff --git a/src/lib/tvgShape.cpp b/src/lib/tvgShape.cpp index aabd5bd2..f7699b4b 100644 --- a/src/lib/tvgShape.cpp +++ b/src/lib/tvgShape.cpp @@ -303,7 +303,18 @@ Result Shape::translate(float x, float y) noexcept auto impl = pImpl.get(); if (!impl) return Result::MemoryCorruption; - impl->translate(x, y); + if (!impl->translate(x, y)) return Result::FailedAllocation; + + return Result::Success; +} + + +Result Shape::transform(const Matrix& m) noexcept +{ + auto impl = pImpl.get(); + if (!impl) return Result::MemoryCorruption; + + if (!impl->transform(m)) return Result::FailedAllocation; return Result::Success; } diff --git a/src/lib/tvgShapeImpl.h b/src/lib/tvgShapeImpl.h index 4cce022d..fa670f01 100644 --- a/src/lib/tvgShapeImpl.h +++ b/src/lib/tvgShapeImpl.h @@ -44,7 +44,7 @@ struct Shape::Impl ShapePath *path = nullptr; Fill *fill = nullptr; ShapeStroke *stroke = nullptr; - RenderTransform *transform = nullptr; + RenderTransform *rTransform = nullptr; uint8_t color[4] = {0, 0, 0, 0}; //r, g, b, a uint32_t flag = RenderUpdateFlag::None; void *edata = nullptr; //engine data @@ -59,7 +59,7 @@ struct Shape::Impl if (path) delete(path); if (fill) delete(fill); if (stroke) delete(stroke); - if (transform) delete(transform); + if (rTransform) delete(rTransform); } bool dispose(Shape& shape, RenderMethod& renderer) @@ -75,18 +75,18 @@ struct Shape::Impl bool update(Shape& shape, RenderMethod& renderer, const RenderTransform* pTransform = nullptr, uint32_t pFlag = 0) { if (flag & RenderUpdateFlag::Transform) { - if (!transform) return false; - if (!transform->update()) { - delete(transform); - transform = nullptr; + if (!rTransform) return false; + if (!rTransform->update()) { + delete(rTransform); + rTransform = nullptr; } } - if (transform && pTransform) { - RenderTransform outTransform(pTransform, transform); + if (rTransform && pTransform) { + RenderTransform outTransform(pTransform, rTransform); edata = renderer.prepare(shape, edata, &outTransform, static_cast(pFlag | flag)); } else { - auto outTransform = pTransform ? pTransform : transform; + auto outTransform = pTransform ? pTransform : rTransform; edata = renderer.prepare(shape, edata, outTransform, static_cast(pFlag | flag)); } @@ -104,50 +104,64 @@ struct Shape::Impl bool scale(float factor) { - if (transform) { - if (fabsf(factor - transform->factor) <= FLT_EPSILON) return true; + if (rTransform) { + if (fabsf(factor - rTransform->factor) <= FLT_EPSILON) return true; } else { if (fabsf(factor) <= FLT_EPSILON) return true; - transform = new RenderTransform(); - if (!transform) return false; + rTransform = new RenderTransform(); + if (!rTransform) return false; } - transform->factor = factor; - flag |= RenderUpdateFlag::Transform; + rTransform->factor = factor; + if (!rTransform->overriding) flag |= RenderUpdateFlag::Transform; return true; } bool rotate(float degree) { - if (transform) { - if (fabsf(degree - transform->degree) <= FLT_EPSILON) return true; + if (rTransform) { + if (fabsf(degree - rTransform->degree) <= FLT_EPSILON) return true; } else { if (fabsf(degree) <= FLT_EPSILON) return true; - transform = new RenderTransform(); - if (!transform) return false; + rTransform = new RenderTransform(); + if (!rTransform) return false; } - transform->degree = degree; - flag |= RenderUpdateFlag::Transform; + rTransform->degree = degree; + if (!rTransform->overriding) flag |= RenderUpdateFlag::Transform; return true; } bool translate(float x, float y) { - if (transform) { - if (fabsf(x - transform->x) <= FLT_EPSILON && fabsf(y - transform->y) <= FLT_EPSILON) return true; + if (rTransform) { + if (fabsf(x - rTransform->x) <= FLT_EPSILON && fabsf(y - rTransform->y) <= FLT_EPSILON) return true; } else { if (fabsf(x) <= FLT_EPSILON && fabsf(y) <= FLT_EPSILON) return true; - transform = new RenderTransform(); - if (!transform) return false; + rTransform = new RenderTransform(); + if (!rTransform) return false; } - transform->x = x; - transform->y = y; + rTransform->x = x; + rTransform->y = y; + if (!rTransform->overriding) flag |= RenderUpdateFlag::Transform; + + return true; + } + + + bool transform(const Matrix& m) + { + if (!rTransform) { + rTransform = new RenderTransform(); + if (!rTransform) return false; + } + rTransform->override(m); flag |= RenderUpdateFlag::Transform; return true; } + bool strokeWidth(float width) { //TODO: Size Exception? diff --git a/test/makefile b/test/makefile index 501eef58..f6624fc8 100755 --- a/test/makefile +++ b/test/makefile @@ -9,6 +9,7 @@ all: gcc -o testDirectUpdate testDirectUpdate.cpp -g -lstdc++ `pkg-config --cflags --libs elementary tizenvg` gcc -o testScene testScene.cpp -g -lstdc++ `pkg-config --cflags --libs elementary tizenvg` gcc -o testTransform testTransform.cpp -g -lstdc++ `pkg-config --cflags --libs elementary tizenvg` + gcc -o testCustomTransform testCustomTransform.cpp -g -lstdc++ `pkg-config --cflags --libs elementary tizenvg` gcc -o testSceneTransform testSceneTransform.cpp -g -lstdc++ `pkg-config --cflags --libs elementary tizenvg` gcc -o testStroke testStroke.cpp -g -lstdc++ `pkg-config --cflags --libs elementary tizenvg` gcc -o testStrokeLine testStrokeLine.cpp -g -lstdc++ `pkg-config --cflags --libs elementary tizenvg` diff --git a/test/testCustomTransform.cpp b/test/testCustomTransform.cpp new file mode 100644 index 00000000..ae3d7c83 --- /dev/null +++ b/test/testCustomTransform.cpp @@ -0,0 +1,140 @@ +#include +#include + +using namespace std; + +#define WIDTH 800 +#define HEIGHT 800 + +static uint32_t buffer[WIDTH * HEIGHT]; +unique_ptr canvas = nullptr; +tvg::Shape* pShape = nullptr; + +void tvgtest() +{ + //Create a Canvas + canvas = tvg::SwCanvas::gen(); + canvas->target(buffer, WIDTH, WIDTH, HEIGHT); + + //Shape1 + auto shape = tvg::Shape::gen(); + + /* Acquire shape pointer to access it again. + instead, you should consider not to interrupt this pointer life-cycle. */ + pShape = shape.get(); + + shape->moveTo(0, -114.5); + shape->lineTo(54, -5.5); + shape->lineTo(175, 11.5); + shape->lineTo(88, 95.5); + shape->lineTo(108, 216.5); + shape->lineTo(0, 160.5); + shape->lineTo(-102, 216.5); + shape->lineTo(-87, 96.5); + shape->lineTo(-173, 12.5); + shape->lineTo(-53, -5.5); + shape->close(); + shape->fill(0, 0, 255, 255); + canvas->push(move(shape)); + + //Draw first frame + canvas->draw(); + canvas->sync(); +} + +void transit_cb(Elm_Transit_Effect *effect, Elm_Transit* transit, double progress) +{ + /* Update shape directly. + You can update only necessary properties of this shape, + while retaining other properties. */ + + //Transform Matrix + tvg::Matrix m = {1, 0, 0, 0, 1, 0, 0, 0, 1}; + + //scale x + m.e11 = 1 - (progress * 0.5f); + + //scale y + m.e22 = 1 + (progress * 2.0f); + + //rotation + constexpr auto PI = 3.141592f; + auto degree = 45.0f; + auto radian = degree / 180.0f * PI; + auto cosVal = cosf(radian); + auto sinVal = sinf(radian); + + auto t11 = m.e11 * cosVal + m.e12 * sinVal; + auto t12 = m.e11 * -sinVal + m.e12 * cosVal; + auto t21 = m.e21 * cosVal + m.e22 * sinVal; + auto t22 = m.e21 * -sinVal + m.e22 * cosVal; + auto t31 = m.e31 * cosVal + m.e32 * sinVal; + auto t32 = m.e31 * -sinVal + m.e32 * cosVal; + + m.e11 = t11; + m.e12 = t12; + m.e21 = t21; + m.e22 = t22; + m.e31 = t31; + m.e32 = t32; + + //translate + m.e31 = progress * 300.0f + 300.0f; + m.e32 = progress * -100.0f + 300.0f; + + pShape->transform(m); + + //Update shape for drawing (this may work asynchronously) + canvas->update(pShape); + + //Draw Next frames + canvas->draw(); + canvas->sync(); + + //Update Efl Canvas + Eo* img = (Eo*) effect; + evas_object_image_data_update_add(img, 0, 0, WIDTH, HEIGHT); +} + +void +win_del(void *data, Evas_Object *o, void *ev) +{ + elm_exit(); +} + +int main(int argc, char **argv) +{ + //Initialize TizenVG Engine + tvg::Initializer::init(tvg::CanvasEngine::Sw); + + tvgtest(); + + //Show the result using EFL... + elm_init(argc, argv); + + Eo* win = elm_win_util_standard_add(NULL, "TizenVG Test"); + evas_object_smart_callback_add(win, "delete,request", win_del, 0); + + Eo* img = evas_object_image_filled_add(evas_object_evas_get(win)); + evas_object_image_size_set(img, WIDTH, HEIGHT); + evas_object_image_data_set(img, buffer); + evas_object_size_hint_weight_set(img, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND); + evas_object_show(img); + + elm_win_resize_object_add(win, img); + evas_object_geometry_set(win, 0, 0, WIDTH, HEIGHT); + evas_object_show(win); + + Elm_Transit *transit = elm_transit_add(); + elm_transit_effect_add(transit, transit_cb, img, nullptr); + elm_transit_duration_set(transit, 2); + elm_transit_repeat_times_set(transit, -1); + elm_transit_auto_reverse_set(transit, EINA_TRUE); + elm_transit_go(transit); + + elm_run(); + elm_shutdown(); + + //Terminate TizenVG Engine + tvg::Initializer::term(tvg::CanvasEngine::Sw); +}