config_h = configuration_data()
+if get_option('engines').contains('sw') == true
+ config_h.set10('THORVG_SW_RASTER_SUPPORT', true)
+endif
+
+if get_option('engines').contains('gl') == true
+ config_h.set10('THORVG_GL_RASTER_SUPPORT', true)
+endif
+
+if get_option('loaders').contains('svg') == true
+ config_h.set10('THORVG_SVG_LOADER_SUPPORT', true)
+endif
+
configure_file(
- output: 'config.h',
- configuration: config_h
+ output: 'config.h',
+ configuration: config_h
)
-headers = [include_directories('inc')]
+headers = [include_directories('inc'), include_directories('.')]
subdir('inc')
subdir('src')
--- /dev/null
+option('engines',
+ type: 'array',
+ choices: ['sw', 'gl'],
+ value: ['sw', 'gl'],
+ description: 'Enable Rasterizer Engine in thorvg')
+
+option('loaders',
+ type: 'array',
+ choices: ['svg'],
+ value: ['svg'],
+ description: 'Enable Vector File Loader in thorvg')
gles_dep = meson.get_compiler('cpp').find_library('GLESv2')
external_dep = [egl_dep, gles_dep]
-glengine_dep = declare_dependency(
- dependencies : external_dep,
- include_directories : include_directories('.'),
- sources : source_file,
-)
+engine_dep += [declare_dependency(
+ dependencies : external_dep,
+ include_directories : include_directories('.'),
+ sources : source_file,
+)]
-subdir('sw_engine')
-subdir('gl_engine')
+engine_dep = []
+
+if get_option('engines').contains('sw') == true
+ subdir('sw_engine')
+endif
+
+if get_option('engines').contains('gl') == true
+ subdir('gl_engine')
+endif
source_file = [
'tvgCanvasImpl.h',
'tvgSwCanvas.cpp',
]
-engine_dep = [swengine_dep, glengine_dep]
-
common_dep = declare_dependency(
dependencies : engine_dep,
include_directories : include_directories('.'),
'tvgSwStroke.cpp',
]
-swengine_dep = declare_dependency(
- include_directories : include_directories('.'),
- sources : source_file
-)
+engine_dep += [declare_dependency(
+ include_directories : include_directories('.'),
+ sources : source_file
+)]
#ifndef _TVG_COMMON_H_
#define _TVG_COMMON_H_
+#include "config.h"
+
#include <iostream>
#include <cassert>
#include <vector>
#define _TVG_GLCANVAS_CPP_
#include "tvgCommon.h"
-#include "tvgGlRenderer.h"
#include "tvgCanvasImpl.h"
+#ifdef THORVG_GL_RASTER_SUPPORT
+ #include "tvgGlRenderer.h"
+#else
+ class GlRenderer : public RenderMethod
+ {
+ //Non Supported. Dummy Class */
+ };
+#endif
+
/************************************************************************/
/* Internal Class Implementation */
/************************************************************************/
/* External Class Implementation */
/************************************************************************/
+#ifdef THORVG_GL_RASTER_SUPPORT
GlCanvas::GlCanvas() : Canvas(GlRenderer::inst()), pImpl(make_unique<Impl>())
+#else
+GlCanvas::GlCanvas() : Canvas(nullptr), pImpl(make_unique<Impl>())
+#endif
{
}
+
GlCanvas::~GlCanvas()
{
}
Result GlCanvas::target(uint32_t* buffer, uint32_t stride, uint32_t w, uint32_t h) noexcept
{
+#ifdef THORVG_GL_RASTER_SUPPORT
//We know renderer type, avoid dynamic_cast for performance.
auto renderer = static_cast<GlRenderer*>(Canvas::pImpl.get()->renderer);
if (!renderer) return Result::MemoryCorruption;
if (!renderer->target(buffer, stride, w, h)) return Result::Unknown;
return Result::Success;
+#endif
+ return Result::NonSupport;
}
unique_ptr<GlCanvas> GlCanvas::gen() noexcept
{
+#ifdef THORVG_GL_RASTER_SUPPORT
auto canvas = unique_ptr<GlCanvas>(new GlCanvas);
assert(canvas);
return canvas;
+#endif
+ return unique_ptr<GlCanvas>(nullptr);
}
#define _TVG_INITIALIZER_CPP_
#include "tvgCommon.h"
-#include "tvgSwRenderer.h"
-#include "tvgGlRenderer.h"
#include "tvgLoaderMgr.h"
+#ifdef THORVG_SW_RASTER_SUPPORT
+ #include "tvgSwRenderer.h"
+#endif
+
+#ifdef THORVG_GL_RASTER_SUPPORT
+ #include "tvgGlRenderer.h"
+#endif
+
+
/************************************************************************/
/* Internal Class Implementation */
/************************************************************************/
Result Initializer::init(CanvasEngine engine) noexcept
{
+ auto nonSupport = true;
+
if (engine == CanvasEngine::Sw) {
- if (!SwRenderer::init()) return Result::InsufficientCondition;
+ #ifdef THORVG_SW_RASTER_SUPPORT
+ if (!SwRenderer::init()) return Result::InsufficientCondition;
+ nonSupport = false;
+ #endif
} else if (engine == CanvasEngine::Gl) {
- if (!GlRenderer::init()) return Result::InsufficientCondition;
+ #ifdef THORVG_GL_RASTER_SUPPORT
+ if (!GlRenderer::init()) return Result::InsufficientCondition;
+ nonSupport = false;
+ #endif
} else {
return Result::InvalidArguments;
}
+ if (nonSupport) return Result::NonSupport;
+
if (!LoaderMgr::init()) return Result::Unknown;
return Result::Success;
Result Initializer::term(CanvasEngine engine) noexcept
{
- //TODO: deinitialize modules
+ auto nonSupport = true;
if (engine == CanvasEngine::Sw) {
- if (!SwRenderer::term()) return Result::InsufficientCondition;
+ #ifdef THORVG_SW_RASTER_SUPPORT
+ if (!SwRenderer::term()) return Result::InsufficientCondition;
+ nonSupport = false;
+ #endif
} else if (engine == CanvasEngine::Gl) {
- if (!GlRenderer::term()) return Result::InsufficientCondition;
+ #ifdef THORVG_GL_RASTER_SUPPORT
+ if (!GlRenderer::term()) return Result::InsufficientCondition;
+ nonSupport = false;
+ #endif
} else {
return Result::InvalidArguments;
}
+ if (nonSupport) return Result::NonSupport;
+
if (!LoaderMgr::term()) return Result::Unknown;
return Result::Success;
#define _TVG_LOADER_MGR_CPP_
#include "tvgCommon.h"
-#include "tvgSvgLoader.h"
+#ifdef THORVG_SVG_LOADER_SUPPORT
+ #include "tvgSvgLoader.h"
+#endif
static int initCnt = 0;
unique_ptr<Loader> LoaderMgr::loader(const char* path)
{
- //TODO:
+#ifdef THORVG_SVG_LOADER_SUPPORT
return unique_ptr<SvgLoader>(new SvgLoader);
+#endif
+ cout << "Non supported format: " << path << endl;
+ return unique_ptr<Loader>(nullptr);
}
#endif //_TVG_LOADER_MGR_CPP_
\ No newline at end of file
{
public:
virtual ~RenderMethod() {}
- virtual void* prepare(const Shape& shape, void* data, const RenderTransform* transform, RenderUpdateFlag flags) = 0;
- virtual bool dispose(const Shape& shape, void *data) = 0;
- virtual bool preRender() = 0;
- virtual bool render(const Shape& shape, void *data) = 0;
- virtual bool postRender() = 0;
- virtual bool clear() = 0;
- virtual bool flush() = 0;
- virtual uint32_t ref() = 0;
- virtual uint32_t unref() = 0;
+ virtual void* prepare(const Shape& shape, void* data, const RenderTransform* transform, RenderUpdateFlag flags) { return nullptr; }
+ virtual bool dispose(const Shape& shape, void *data) { return false; }
+ virtual bool preRender() { return false; }
+ virtual bool render(const Shape& shape, void *data) { return false; }
+ virtual bool postRender() { return false; }
+ virtual bool clear() { return false; }
+ virtual bool flush() { return false; }
+ virtual uint32_t ref() { return 0; }
+ virtual uint32_t unref() { return 0; }
};
struct RenderInitializer
#define _TVG_SWCANVAS_CPP_
#include "tvgCommon.h"
-#include "tvgSwRenderer.h"
#include "tvgCanvasImpl.h"
+#ifdef THORVG_SW_RASTER_SUPPORT
+ #include "tvgSwRenderer.h"
+#else
+ class SwRenderer : public RenderMethod
+ {
+ //Non Supported. Dummy Class */
+ };
+#endif
/************************************************************************/
/* Internal Class Implementation */
/* External Class Implementation */
/************************************************************************/
+#ifdef THORVG_SW_RASTER_SUPPORT
SwCanvas::SwCanvas() : Canvas(SwRenderer::inst()), pImpl(make_unique<Impl>())
+#else
+SwCanvas::SwCanvas() : Canvas(nullptr), pImpl(make_unique<Impl>())
+#endif
{
}
Result SwCanvas::target(uint32_t* buffer, uint32_t stride, uint32_t w, uint32_t h) noexcept
{
+#ifdef THORVG_SW_RASTER_SUPPORT
//We know renderer type, avoid dynamic_cast for performance.
auto renderer = static_cast<SwRenderer*>(Canvas::pImpl.get()->renderer);
if (!renderer) return Result::MemoryCorruption;
if (!renderer->target(buffer, stride, w, h)) return Result::InvalidArguments;
return Result::Success;
+#endif
+ return Result::NonSupport;
}
unique_ptr<SwCanvas> SwCanvas::gen() noexcept
{
+#ifdef THORVG_SW_RASTER_SUPPORT
auto canvas = unique_ptr<SwCanvas>(new SwCanvas);
assert(canvas);
- return canvas;
+ return canvas;
+#endif
+ return unique_ptr<SwCanvas>(nullptr);
}
#endif /* _TVG_SWCANVAS_CPP_ */
-subdir('svg_loader')
+subloader_dep = []
+
+if get_option('loaders').contains('svg') == true
+ subdir('svg_loader')
+endif
loader_dep = declare_dependency(
- dependencies : svgloader_dep,
+ dependencies: subloader_dep,
include_directories : include_directories('.'),
)
'tvgSvgSceneBuilder.cpp',
]
-svgloader_dep = declare_dependency(
- include_directories : include_directories('.'),
- sources : source_file
-)
+subloader_dep += [declare_dependency(
+ include_directories : include_directories('.'),
+ sources : source_file
+)]
tmp = { c, -s, 0, s, c, 0, 0, 0, 1 };
_matrixCompose(matrix, &tmp, matrix);
} else if (ptCount == 3) {
- tmp = { 1, 0, points[0], 0, 1, points[1], 0, 0, 1 };
+ tmp = { 1, 0, points[1], 0, 1, points[2], 0, 0, 1 };
_matrixCompose(matrix, &tmp, matrix);
tmp = { c, -s, 0, s, c, 0, 0, 0, 1 };
_matrixCompose(matrix, &tmp, matrix);
- tmp = { 1, 0, points[0], 0, 1, points[1], 0, 0, 1 };
+ tmp = { 1, 0, -points[1], 0, 1, -points[2], 0, 0, 1 };
_matrixCompose(matrix, &tmp, matrix);
} else {
goto error;
case 's':
case 'S': {
Point p[3], ctrl;
- if ((cmds->size() > 1) && (cmds->at(cmds->size() - 2) == PathCommand::CubicTo)) {
+ if ((cmds->size() > 1) && (cmds->at(cmds->size() - 1) == PathCommand::CubicTo)) {
ctrl.x = 2 * cur->x - curCtl->x;
- ctrl.y = 2 * cur->x - curCtl->y;
+ ctrl.y = 2 * cur->y - curCtl->y;
} else {
ctrl = *cur;
}
subdir('examples')
thread_dep = meson.get_compiler('cpp').find_library('pthread')
-thorvg_lib_dep = [ common_dep, loader_dep, thread_dep]
+thorvg_lib_dep = [common_dep, loader_dep, thread_dep]
thorvg_lib = library(
'thorvg',
}
//Initialize ThorVG Engine
- tvg::Initializer::init(tvgEngine);
+ if (tvg::Initializer::init(tvgEngine) == tvg::Result::Success) {
- elm_init(argc, argv);
+ elm_init(argc, argv);
- if (tvgEngine == tvg::CanvasEngine::Sw) {
- auto view = createSwView();
- evas_object_image_pixels_get_callback_set(view, drawSwView, nullptr);
- ecore_animator_add(animSwCb, view);
- } else {
- auto view = createGlView();
- ecore_animator_add(animGlCb, view);
- }
+ if (tvgEngine == tvg::CanvasEngine::Sw) {
+ auto view = createSwView();
+ evas_object_image_pixels_get_callback_set(view, drawSwView, nullptr);
+ ecore_animator_add(animSwCb, view);
+ } else {
+ auto view = createGlView();
+ ecore_animator_add(animGlCb, view);
+ }
- elm_run();
- elm_shutdown();
+ elm_run();
+ elm_shutdown();
- //Terminate ThorVG Engine
- tvg::Initializer::term(tvgEngine);
+ //Terminate ThorVG Engine
+ tvg::Initializer::term(tvgEngine);
+
+ } else {
+ cout << "engine is not supported" << endl;
+ }
+ return 0;
}
}
//Initialize ThorVG Engine
- tvg::Initializer::init(tvgEngine);
+ if (tvg::Initializer::init(tvgEngine) == tvg::Result::Success) {
- elm_init(argc, argv);
+ elm_init(argc, argv);
- if (tvgEngine == tvg::CanvasEngine::Sw) {
- createSwView();
- } else {
- createGlView();
- }
+ if (tvgEngine == tvg::CanvasEngine::Sw) {
+ createSwView();
+ } else {
+ createGlView();
+ }
- elm_run();
- elm_shutdown();
+ elm_run();
+ elm_shutdown();
- //Terminate ThorVG Engine
- tvg::Initializer::term(tvgEngine);
+ //Terminate ThorVG Engine
+ tvg::Initializer::term(tvgEngine);
+
+ } else {
+ cout << "engine is not supported" << endl;
+ }
+ return 0;
}
}
//Initialize ThorVG Engine
- tvg::Initializer::init(tvgEngine);
+ if (tvg::Initializer::init(tvgEngine) == tvg::Result::Success) {
- elm_init(argc, argv);
+ elm_init(argc, argv);
- if (tvgEngine == tvg::CanvasEngine::Sw) {
- createSwView();
- } else {
- createGlView();
- }
+ if (tvgEngine == tvg::CanvasEngine::Sw) {
+ createSwView();
+ } else {
+ createGlView();
+ }
- elm_run();
- elm_shutdown();
+ elm_run();
+ elm_shutdown();
- //Terminate ThorVG Engine
- tvg::Initializer::term(tvgEngine);
+ //Terminate ThorVG Engine
+ tvg::Initializer::term(tvgEngine);
+
+ } else {
+ cout << "engine is not supported" << endl;
+ }
+ return 0;
}
}
//Initialize ThorVG Engine
- tvg::Initializer::init(tvgEngine);
+ if (tvg::Initializer::init(tvgEngine) == tvg::Result::Success) {
- elm_init(argc, argv);
+ elm_init(argc, argv);
- Elm_Transit *transit = elm_transit_add();
+ Elm_Transit *transit = elm_transit_add();
- if (tvgEngine == tvg::CanvasEngine::Sw) {
- auto view = createSwView();
- elm_transit_effect_add(transit, transitSwCb, view, nullptr);
- } else {
- auto view = createGlView();
- elm_transit_effect_add(transit, transitGlCb, view, nullptr);
- }
+ if (tvgEngine == tvg::CanvasEngine::Sw) {
+ auto view = createSwView();
+ elm_transit_effect_add(transit, transitSwCb, view, nullptr);
+ } else {
+ auto view = createGlView();
+ elm_transit_effect_add(transit, transitGlCb, view, 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_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();
+ elm_run();
+ elm_shutdown();
- //Terminate ThorVG Engine
- tvg::Initializer::term(tvgEngine);
-}
+ //Terminate ThorVG Engine
+ tvg::Initializer::term(tvgEngine);
+
+ } else {
+ cout << "engine is not supported" << endl;
+ }
+ return 0;
+}
\ No newline at end of file
}
//Initialize ThorVG Engine
- tvg::Initializer::init(tvgEngine);
+ if (tvg::Initializer::init(tvgEngine) == tvg::Result::Success) {
- elm_init(argc, argv);
+ elm_init(argc, argv);
- Elm_Transit *transit = elm_transit_add();
+ Elm_Transit *transit = elm_transit_add();
- if (tvgEngine == tvg::CanvasEngine::Sw) {
- auto view = createSwView();
- elm_transit_effect_add(transit, transitSwCb, view, nullptr);
- } else {
- auto view = createGlView();
- elm_transit_effect_add(transit, transitGlCb, view, nullptr);
- }
+ if (tvgEngine == tvg::CanvasEngine::Sw) {
+ auto view = createSwView();
+ elm_transit_effect_add(transit, transitSwCb, view, nullptr);
+ } else {
+ auto view = createGlView();
+ elm_transit_effect_add(transit, transitGlCb, view, 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_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();
+ elm_run();
+ elm_shutdown();
- //Terminate ThorVG Engine
- tvg::Initializer::term(tvgEngine);
+ //Terminate ThorVG Engine
+ tvg::Initializer::term(tvgEngine);
+
+ } else {
+ cout << "engine is not supported" << endl;
+ }
+ return 0;
}
}
//Initialize ThorVG Engine
- tvg::Initializer::init(tvgEngine);
+ if (tvg::Initializer::init(tvgEngine) == tvg::Result::Success) {
elm_init(argc, argv);
//Terminate ThorVG Engine
tvg::Initializer::term(tvgEngine);
-}
+
+ } else {
+ cout << "engine is not supported" << endl;
+ }
+ return 0;
+}
\ No newline at end of file
}
//Initialize ThorVG Engine
- tvg::Initializer::init(tvgEngine);
+ if (tvg::Initializer::init(tvgEngine) == tvg::Result::Success) {
- elm_init(argc, argv);
+ elm_init(argc, argv);
- if (tvgEngine == tvg::CanvasEngine::Sw) {
- createSwView();
- } else {
- createGlView();
- }
+ if (tvgEngine == tvg::CanvasEngine::Sw) {
+ createSwView();
+ } else {
+ createGlView();
+ }
- elm_run();
- elm_shutdown();
+ elm_run();
+ elm_shutdown();
- //Terminate ThorVG Engine
- tvg::Initializer::term(tvgEngine);
+ //Terminate ThorVG Engine
+ tvg::Initializer::term(tvgEngine);
+
+ } else {
+ cout << "engine is not supported" << endl;
+ }
+ return 0;
}
}
//Initialize ThorVG Engine
- tvg::Initializer::init(tvgEngine);
+ if (tvg::Initializer::init(tvgEngine) == tvg::Result::Success) {
- elm_init(argc, argv);
+ elm_init(argc, argv);
- if (tvgEngine == tvg::CanvasEngine::Sw) {
- createSwView();
- } else {
- createGlView();
- }
+ if (tvgEngine == tvg::CanvasEngine::Sw) {
+ createSwView();
+ } else {
+ createGlView();
+ }
- elm_run();
- elm_shutdown();
+ elm_run();
+ elm_shutdown();
- //Terminate ThorVG Engine
- tvg::Initializer::term(tvgEngine);
+ //Terminate ThorVG Engine
+ tvg::Initializer::term(tvgEngine);
+
+ } else {
+ cout << "engine is not supported" << endl;
+ }
+ return 0;
}
}
//Initialize ThorVG Engine
- tvg::Initializer::init(tvgEngine);
+ if (tvg::Initializer::init(tvgEngine) == tvg::Result::Success) {
- elm_init(argc, argv);
+ elm_init(argc, argv);
- if (tvgEngine == tvg::CanvasEngine::Sw) {
- createSwView();
- } else {
- createGlView();
- }
+ if (tvgEngine == tvg::CanvasEngine::Sw) {
+ createSwView();
+ } else {
+ createGlView();
+ }
- elm_run();
- elm_shutdown();
+ elm_run();
+ elm_shutdown();
- //Terminate ThorVG Engine
- tvg::Initializer::term(tvgEngine);
-}
+ //Terminate ThorVG Engine
+ tvg::Initializer::term(tvgEngine);
+
+ } else {
+ cout << "engine is not supported" << endl;
+ }
+ return 0;
+}
\ No newline at end of file
}
//Initialize ThorVG Engine
- tvg::Initializer::init(tvgEngine);
+ if (tvg::Initializer::init(tvgEngine) == tvg::Result::Success) {
- elm_init(argc, argv);
+ elm_init(argc, argv);
- if (tvgEngine == tvg::CanvasEngine::Sw) {
- createSwView();
- } else {
- createGlView();
- }
+ if (tvgEngine == tvg::CanvasEngine::Sw) {
+ createSwView();
+ } else {
+ createGlView();
+ }
- elm_run();
- elm_shutdown();
+ elm_run();
+ elm_shutdown();
- //Terminate ThorVG Engine
- tvg::Initializer::term(tvgEngine);
+ //Terminate ThorVG Engine
+ tvg::Initializer::term(tvgEngine);
+
+ } else {
+ cout << "engine is not supported" << endl;
+ }
+ return 0;
}
\ No newline at end of file
}
//Initialize ThorVG Engine
- tvg::Initializer::init(tvgEngine);
+ if (tvg::Initializer::init(tvgEngine) == tvg::Result::Success) {
- elm_init(argc, argv);
+ elm_init(argc, argv);
- if (tvgEngine == tvg::CanvasEngine::Sw) {
- createSwView();
- } else {
- createGlView();
- }
+ if (tvgEngine == tvg::CanvasEngine::Sw) {
+ createSwView();
+ } else {
+ createGlView();
+ }
- elm_run();
- elm_shutdown();
+ elm_run();
+ elm_shutdown();
- //Terminate ThorVG Engine
- tvg::Initializer::term(tvgEngine);
-}
+ //Terminate ThorVG Engine
+ tvg::Initializer::term(tvgEngine);
+
+ } else {
+ cout << "engine is not supported" << endl;
+ }
+ return 0;
+}
\ No newline at end of file
}
//Initialize ThorVG Engine
- tvg::Initializer::init(tvgEngine);
+ if (tvg::Initializer::init(tvgEngine) == tvg::Result::Success) {
- elm_init(argc, argv);
+ elm_init(argc, argv);
- if (tvgEngine == tvg::CanvasEngine::Sw) {
- createSwView();
- } else {
- createGlView();
- }
+ if (tvgEngine == tvg::CanvasEngine::Sw) {
+ createSwView();
+ } else {
+ createGlView();
+ }
- elm_run();
- elm_shutdown();
+ elm_run();
+ elm_shutdown();
- //Terminate ThorVG Engine
- tvg::Initializer::term(tvgEngine);
-}
+ //Terminate ThorVG Engine
+ tvg::Initializer::term(tvgEngine);
+
+ } else {
+ cout << "engine is not supported" << endl;
+ }
+ return 0;
+}
\ No newline at end of file
}
//Initialize ThorVG Engine
- tvg::Initializer::init(tvgEngine);
+ if (tvg::Initializer::init(tvgEngine) == tvg::Result::Success) {
- elm_init(argc, argv);
+ elm_init(argc, argv);
- Elm_Transit *transit = elm_transit_add();
+ Elm_Transit *transit = elm_transit_add();
- if (tvgEngine == tvg::CanvasEngine::Sw) {
- auto view = createSwView();
- elm_transit_effect_add(transit, transitSwCb, view, nullptr);
- } else {
- auto view = createGlView();
- elm_transit_effect_add(transit, transitGlCb, view, nullptr);
- }
+ if (tvgEngine == tvg::CanvasEngine::Sw) {
+ auto view = createSwView();
+ elm_transit_effect_add(transit, transitSwCb, view, nullptr);
+ } else {
+ auto view = createGlView();
+ elm_transit_effect_add(transit, transitGlCb, view, 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_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();
+ elm_run();
+ elm_shutdown();
- //Terminate ThorVG Engine
- tvg::Initializer::term(tvgEngine);
-}
+ //Terminate ThorVG Engine
+ tvg::Initializer::term(tvgEngine);
+
+ } else {
+ cout << "engine is not supported" << endl;
+ }
+ return 0;
+}
\ No newline at end of file
}
//Initialize ThorVG Engine
- tvg::Initializer::init(tvgEngine);
+ if (tvg::Initializer::init(tvgEngine) == tvg::Result::Success) {
- elm_init(argc, argv);
+ elm_init(argc, argv);
- if (tvgEngine == tvg::CanvasEngine::Sw) {
- createSwView();
- } else {
- createGlView();
- }
+ if (tvgEngine == tvg::CanvasEngine::Sw) {
+ createSwView();
+ } else {
+ createGlView();
+ }
- elm_run();
- elm_shutdown();
+ elm_run();
+ elm_shutdown();
- //Terminate ThorVG Engine
- tvg::Initializer::term(tvgEngine);
-}
+ //Terminate ThorVG Engine
+ tvg::Initializer::term(tvgEngine);
+
+ } else {
+ cout << "engine is not supported" << endl;
+ }
+ return 0;
+}
\ No newline at end of file
}
//Initialize ThorVG Engine
- tvg::Initializer::init(tvgEngine);
+ if (tvg::Initializer::init(tvgEngine) == tvg::Result::Success) {
- elm_init(argc, argv);
+ elm_init(argc, argv);
- if (tvgEngine == tvg::CanvasEngine::Sw) {
- createSwView();
- } else {
- createGlView();
- }
+ if (tvgEngine == tvg::CanvasEngine::Sw) {
+ createSwView();
+ } else {
+ createGlView();
+ }
- elm_run();
- elm_shutdown();
+ elm_run();
+ elm_shutdown();
- //Terminate ThorVG Engine
- tvg::Initializer::term(tvgEngine);
-}
+ //Terminate ThorVG Engine
+ tvg::Initializer::term(tvgEngine);
+
+ } else {
+ cout << "engine is not supported" << endl;
+ }
+ return 0;
+}
\ No newline at end of file
}
//Initialize ThorVG Engine
- tvg::Initializer::init(tvgEngine);
+ if (tvg::Initializer::init(tvgEngine) == tvg::Result::Success) {
- elm_init(argc, argv);
+ elm_init(argc, argv);
- if (tvgEngine == tvg::CanvasEngine::Sw) {
- createSwView();
- } else {
- createGlView();
- }
+ if (tvgEngine == tvg::CanvasEngine::Sw) {
+ createSwView();
+ } else {
+ createGlView();
+ }
- elm_run();
- elm_shutdown();
+ elm_run();
+ elm_shutdown();
- //Terminate ThorVG Engine
- tvg::Initializer::term(tvgEngine);
+ //Terminate ThorVG Engine
+ tvg::Initializer::term(tvgEngine);
+
+ } else {
+ cout << "engine is not supported" << endl;
+ }
+ return 0;
}
\ No newline at end of file
}
//Initialize ThorVG Engine
- tvg::Initializer::init(tvgEngine);
+ if (tvg::Initializer::init(tvgEngine) == tvg::Result::Success) {
- elm_init(argc, argv);
+ elm_init(argc, argv);
- if (tvgEngine == tvg::CanvasEngine::Sw) {
- createSwView();
- } else {
- createGlView();
- }
+ if (tvgEngine == tvg::CanvasEngine::Sw) {
+ createSwView();
+ } else {
+ createGlView();
+ }
- elm_run();
- elm_shutdown();
+ elm_run();
+ elm_shutdown();
- //Terminate ThorVG Engine
- tvg::Initializer::term(tvg::CanvasEngine::Sw);
-}
+ //Terminate ThorVG Engine
+ tvg::Initializer::term(tvg::CanvasEngine::Sw);
+
+ } else {
+ cout << "engine is not supported" << endl;
+ }
+ return 0;
+}
\ No newline at end of file
}
//Initialize ThorVG Engine
- tvg::Initializer::init(tvgEngine);
+ if (tvg::Initializer::init(tvgEngine) == tvg::Result::Success) {
- elm_init(argc, argv);
+ elm_init(argc, argv);
- Elm_Transit *transit = elm_transit_add();
+ Elm_Transit *transit = elm_transit_add();
- if (tvgEngine == tvg::CanvasEngine::Sw) {
- auto view = createSwView();
- elm_transit_effect_add(transit, transitSwCb, view, nullptr);
- } else {
- auto view = createGlView();
- elm_transit_effect_add(transit, transitGlCb, view, nullptr);
- }
+ if (tvgEngine == tvg::CanvasEngine::Sw) {
+ auto view = createSwView();
+ elm_transit_effect_add(transit, transitSwCb, view, nullptr);
+ } else {
+ auto view = createGlView();
+ elm_transit_effect_add(transit, transitGlCb, view, 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_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();
+ elm_run();
+ elm_shutdown();
- //Terminate ThorVG Engine
- tvg::Initializer::term(tvgEngine);
-}
+ //Terminate ThorVG Engine
+ tvg::Initializer::term(tvgEngine);
+
+ } else {
+ cout << "engine is not supported" << endl;
+ }
+ return 0;
+}
\ No newline at end of file
}
//Initialize ThorVG Engine
- tvg::Initializer::init(tvgEngine);
+ if (tvg::Initializer::init(tvgEngine) == tvg::Result::Success) {
- elm_init(argc, argv);
+ elm_init(argc, argv);
- Elm_Transit *transit = elm_transit_add();
+ Elm_Transit *transit = elm_transit_add();
- if (tvgEngine == tvg::CanvasEngine::Sw) {
- auto view = createSwView();
- elm_transit_effect_add(transit, transitSwCb, view, nullptr);
- } else {
- auto view = createGlView();
- elm_transit_effect_add(transit, transitGlCb, view, nullptr);
- }
+ if (tvgEngine == tvg::CanvasEngine::Sw) {
+ auto view = createSwView();
+ elm_transit_effect_add(transit, transitSwCb, view, nullptr);
+ } else {
+ auto view = createGlView();
+ elm_transit_effect_add(transit, transitGlCb, view, 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_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();
+ elm_run();
+ elm_shutdown();
- //Terminate ThorVG Engine
- tvg::Initializer::term(tvgEngine);
-}
+ //Terminate ThorVG Engine
+ tvg::Initializer::term(tvgEngine);
+
+ } else {
+ cout << "engine is not supported" << endl;
+ }
+ return 0;
+}
\ No newline at end of file