src/bindings/capi/tvgCapi.cpp

   1 /*
   2  * Copyright (c) 2020 Samsung Electronics Co., Ltd. All rights reserved.
   3
   4  * Permission is hereby granted, free of charge, to any person obtaining a copy
   5  * of this software and associated documentation files (the "Software"), to deal
   6  * in the Software without restriction, including without limitation the rights
   7  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
   8  * copies of the Software, and to permit persons to whom the Software is
   9  * furnished to do so, subject to the following conditions:
  10
  11  * The above copyright notice and this permission notice shall be included in all
  12  * copies or substantial portions of the Software.
  13
  14  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  15  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  16  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  17  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  18  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  19  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  20  * SOFTWARE.
  21  */
  22
  23 #include <thorvg.h>
  24 #include "thorvg_capi.h"
  25
  26 using namespace std;
  27 using namespace tvg;
  28
  29 #ifdef __cplusplus
  30 extern "C" {
  31 #endif
  32
  33 struct _Tvg_Canvas
  34 {
  35     //Dummy for Direct Casting
  36 };
  37
  38 struct _Tvg_Paint
  39 {
  40     //Dummy for Direct Casting
  41 };
  42
  43 struct _Tvg_Gradient
  44 {
  45     //Dummy for Direct Casting
  46 };
  47
  48
  49 /************************************************************************/
  50 /* Engine API                                                           */
  51 /************************************************************************/
  52
  53 TVG_EXPORT Tvg_Result tvg_engine_init(unsigned engine_method, unsigned threads) {
  54     Result ret = Result::Success;
  55
  56     if (engine_method & TVG_ENGINE_SW) ret = tvg::Initializer::init(tvg::CanvasEngine::Sw, threads);
  57     if (ret != Result::Success) return (Tvg_Result) ret;
  58
  59     if (engine_method & TVG_ENGINE_GL) ret = tvg::Initializer::init(tvg::CanvasEngine::Gl, threads);
  60     return (Tvg_Result) ret;
  61 }
  62
  63
  64 TVG_EXPORT Tvg_Result tvg_engine_term(unsigned engine_method) {
  65     Result ret = Result::Success;
  66
  67     if (engine_method & TVG_ENGINE_SW) ret = tvg::Initializer::term(tvg::CanvasEngine::Sw);
  68     if (ret != Result::Success) return (Tvg_Result) ret;
  69
  70     if (engine_method & TVG_ENGINE_GL) ret = tvg::Initializer::term(tvg::CanvasEngine::Gl);
  71     return (Tvg_Result) ret;
  72 }
  73
  74 /************************************************************************/
  75 /* Canvas API                                                           */
  76 /************************************************************************/
  77
  78 TVG_EXPORT Tvg_Canvas* tvg_swcanvas_create()
  79 {
  80     return (Tvg_Canvas*) SwCanvas::gen().release();
  81 }
  82
  83
  84 TVG_EXPORT Tvg_Result tvg_canvas_destroy(Tvg_Canvas* canvas)
  85 {
  86     delete(canvas);
  87     return TVG_RESULT_SUCCESS;
  88 }
  89
  90
  91 TVG_EXPORT Tvg_Result tvg_swcanvas_set_target(Tvg_Canvas* canvas, uint32_t* buffer, uint32_t stride, uint32_t w, uint32_t h, uint32_t cs)
  92 {
  93     return (Tvg_Result) reinterpret_cast<SwCanvas*>(canvas)->target(buffer, stride, w, h, static_cast<SwCanvas::Colorspace>(cs));
  94 }
  95
  96
  97 TVG_EXPORT Tvg_Result tvg_canvas_push(Tvg_Canvas* canvas, Tvg_Paint* paint)
  98 {
  99     return (Tvg_Result) reinterpret_cast<Canvas*>(canvas)->push(unique_ptr<Paint>((Paint*)paint));
 100 }
 101
 102
 103 TVG_EXPORT Tvg_Result tvg_canvas_reserve(Tvg_Canvas* canvas, uint32_t n)
 104 {
 105     return (Tvg_Result) reinterpret_cast<Canvas*>(canvas)->reserve(n);
 106 }
 107
 108
 109 TVG_EXPORT Tvg_Result tvg_canvas_clear(Tvg_Canvas* canvas)
 110 {
 111     return (Tvg_Result) reinterpret_cast<Canvas*>(canvas)->clear();
 112 }
 113
 114
 115 TVG_EXPORT Tvg_Result tvg_canvas_update(Tvg_Canvas* canvas)
 116 {
 117      return (Tvg_Result) reinterpret_cast<Canvas*>(canvas)->update(nullptr);
 118 }
 119
 120
 121 TVG_EXPORT Tvg_Result tvg_canvas_update_paint(Tvg_Canvas* canvas, Tvg_Paint* paint)
 122 {
 123     return (Tvg_Result) reinterpret_cast<Canvas*>(canvas)->update((Paint*) paint);
 124 }
 125
 126
 127 TVG_EXPORT Tvg_Result tvg_canvas_draw(Tvg_Canvas* canvas)
 128 {
 129     return (Tvg_Result) reinterpret_cast<Canvas*>(canvas)->draw();
 130 }
 131
 132
 133 TVG_EXPORT Tvg_Result tvg_canvas_sync(Tvg_Canvas* canvas)
 134 {
 135     return (Tvg_Result) reinterpret_cast<Canvas*>(canvas)->sync();
 136 }
 137
 138
 139 /************************************************************************/
 140 /* Paint API                                                            */
 141 /************************************************************************/
 142
 143 TVG_EXPORT Tvg_Result tvg_paint_del(Tvg_Paint* paint)
 144 {
 145     delete(paint);
 146     return TVG_RESULT_SUCCESS;
 147 }
 148
 149
 150 TVG_EXPORT Tvg_Result tvg_paint_scale(Tvg_Paint* paint, float factor)
 151 {
 152     return (Tvg_Result) reinterpret_cast<Paint*>(paint)->scale(factor);
 153 }
 154
 155
 156 TVG_EXPORT Tvg_Result tvg_paint_rotate(Tvg_Paint* paint, float degree)
 157 {
 158     return (Tvg_Result) reinterpret_cast<Paint*>(paint)->rotate(degree);
 159 }
 160
 161
 162 TVG_EXPORT Tvg_Result tvg_paint_translate(Tvg_Paint* paint, float x, float y)
 163 {
 164     return (Tvg_Result) reinterpret_cast<Paint*>(paint)->translate(x, y);
 165 }
 166
 167
 168 TVG_EXPORT Tvg_Result tvg_paint_transform(Tvg_Paint* paint, const Tvg_Matrix* m)
 169 {
 170     return (Tvg_Result) reinterpret_cast<Paint*>(paint)->transform(*(reinterpret_cast<const Matrix*>(m)));
 171 }
 172
 173
 174 /************************************************************************/
 175 /* Shape API                                                            */
 176 /************************************************************************/
 177
 178 TVG_EXPORT Tvg_Paint* tvg_shape_new()
 179 {
 180     return (Tvg_Paint*) Shape::gen().release();
 181 }
 182
 183
 184 TVG_EXPORT Tvg_Result tvg_shape_reset(Tvg_Paint* paint)
 185 {
 186     return (Tvg_Result) reinterpret_cast<Shape*>(paint)->reset();
 187 }
 188
 189
 190 TVG_EXPORT Tvg_Result tvg_shape_move_to(Tvg_Paint* paint, float x, float y)
 191 {
 192     return (Tvg_Result) reinterpret_cast<Shape*>(paint)->moveTo(x, y);
 193 }
 194
 195
 196 TVG_EXPORT Tvg_Result tvg_shape_line_to(Tvg_Paint* paint, float x, float y)
 197 {
 198     return (Tvg_Result) reinterpret_cast<Shape*>(paint)->lineTo(x, y);
 199 }
 200
 201
 202 TVG_EXPORT Tvg_Result tvg_shape_cubic_to(Tvg_Paint* paint, float cx1, float cy1, float cx2, float cy2, float x, float y)
 203 {
 204     return (Tvg_Result) reinterpret_cast<Shape*>(paint)->cubicTo(cx1, cy1, cx2, cy2, x, y);
 205 }
 206
 207
 208 TVG_EXPORT Tvg_Result tvg_shape_close(Tvg_Paint* paint)
 209 {
 210     return (Tvg_Result) reinterpret_cast<Shape*>(paint)->close();
 211 }
 212
 213
 214 TVG_EXPORT Tvg_Result tvg_shape_append_rect(Tvg_Paint* paint, float x, float y, float w, float h, float rx, float ry)
 215 {
 216     return (Tvg_Result) reinterpret_cast<Shape*>(paint)->appendRect(x, y, w, h, rx, ry);
 217 }
 218
 219 TVG_EXPORT Tvg_Result tvg_shape_append_arc(Tvg_Paint* paint, float cx, float cy, float radius, float startAngle, float sweep, uint8_t pie)
 220 {
 221     return (Tvg_Result) reinterpret_cast<Shape*>(paint)->appendArc(cx, cy, radius, startAngle, sweep, pie);
 222 }
 223
 224 TVG_EXPORT Tvg_Result tvg_shape_append_circle(Tvg_Paint* paint, float cx, float cy, float rx, float ry)
 225 {
 226     return (Tvg_Result) reinterpret_cast<Shape*>(paint)->appendCircle(cx, cy, rx, ry);
 227 }
 228
 229
 230 TVG_EXPORT Tvg_Result tvg_shape_append_path(Tvg_Paint* paint, const Tvg_Path_Command* cmds, uint32_t cmdCnt, const Tvg_Point* pts, uint32_t ptsCnt)
 231 {
 232     return (Tvg_Result) reinterpret_cast<Shape*>(paint)->appendPath((PathCommand*)cmds, cmdCnt, (Point*)pts, ptsCnt);
 233 }
 234
 235
 236 TVG_EXPORT Tvg_Result tvg_shape_set_stroke_width(Tvg_Paint* paint, float width)
 237 {
 238     return (Tvg_Result) reinterpret_cast<Shape*>(paint)->stroke(width);
 239 }
 240
 241
 242 TVG_EXPORT Tvg_Result tvg_shape_set_stroke_color(Tvg_Paint* paint, uint8_t r, uint8_t g, uint8_t b, uint8_t a)
 243 {
 244     return (Tvg_Result) reinterpret_cast<Shape*>(paint)->stroke(r, g, b, a);
 245 }
 246
 247
 248 TVG_EXPORT Tvg_Result tvg_shape_set_stroke_dash(Tvg_Paint* paint, const float* dashPattern, uint32_t cnt)
 249 {
 250     return (Tvg_Result) reinterpret_cast<Shape*>(paint)->stroke(dashPattern, cnt);
 251 }
 252
 253
 254 TVG_EXPORT Tvg_Result tvg_shape_set_stroke_cap(Tvg_Paint* paint, Tvg_Stroke_Cap cap)
 255 {
 256     return (Tvg_Result) reinterpret_cast<Shape*>(paint)->stroke((StrokeCap)cap);
 257 }
 258
 259
 260 TVG_EXPORT Tvg_Result tvg_shape_set_stroke_join(Tvg_Paint* paint, Tvg_Stroke_Join join)
 261 {
 262     return (Tvg_Result) reinterpret_cast<Shape*>(paint)->stroke((StrokeJoin)join);
 263 }
 264
 265
 266 TVG_EXPORT Tvg_Result tvg_shape_fill_color(Tvg_Paint* paint, uint8_t r, uint8_t g, uint8_t b, uint8_t a)
 267 {
 268     return (Tvg_Result) reinterpret_cast<Shape*>(paint)->fill(r, g, b, a);
 269 }
 270
 271
 272 TVG_EXPORT Tvg_Result tvg_shape_linear_gradient_set(Tvg_Paint* paint, Tvg_Gradient *gradient)
 273 {
 274     return (Tvg_Result) reinterpret_cast<Shape*>(paint)->fill(unique_ptr<LinearGradient>((LinearGradient*)(gradient)));
 275 }
 276
 277
 278 TVG_EXPORT Tvg_Result tvg_shape_radial_gradient_set(Tvg_Paint* paint, Tvg_Gradient *gradient)
 279 {
 280     return (Tvg_Result) reinterpret_cast<Shape*>(paint)->fill(unique_ptr<RadialGradient>((RadialGradient*)(gradient)));
 281 }
 282
 283
 284 /************************************************************************/
 285 /* Picture API                                                          */
 286 /************************************************************************/
 287
 288 TVG_EXPORT Tvg_Paint* tvg_picture_new()
 289 {
 290     return (Tvg_Paint*) Picture::gen().release();
 291 }
 292
 293
 294 TVG_EXPORT Tvg_Result tvg_picture_load(Tvg_Paint* paint, const char* path)
 295 {
 296     return (Tvg_Result) reinterpret_cast<Picture*>(paint)->load(path);
 297 }
 298
 299
 300 TVG_EXPORT Tvg_Result tvg_picture_get_viewbox(Tvg_Paint* paint, float* x, float* y, float* w, float* h)
 301 {
 302     return (Tvg_Result) reinterpret_cast<Picture*>(paint)->viewbox(x, y, w, h);
 303 }
 304
 305
 306 /************************************************************************/
 307 /* Gradient API                                                         */
 308 /************************************************************************/
 309 TVG_EXPORT Tvg_Gradient* tvg_linear_gradient_new()
 310 {
 311     return (Tvg_Gradient*)LinearGradient::gen().release();
 312 }
 313
 314 TVG_EXPORT Tvg_Gradient* tvg_radial_gradient_new()
 315 {
 316     return (Tvg_Gradient*)RadialGradient::gen().release();
 317
 318 }
 319
 320 TVG_EXPORT Tvg_Result tvg_gradient_del(Tvg_Gradient* grad)
 321 {
 322     delete(grad);
 323     return TVG_RESULT_SUCCESS;
 324 }
 325
 326 TVG_EXPORT Tvg_Result tvg_linear_gradient_set(Tvg_Gradient* grad, float x1, float y1, float x2, float y2)
 327 {
 328     return (Tvg_Result) reinterpret_cast<LinearGradient*>(grad)->linear(x1, y1, x2, y2);
 329 }
 330
 331 TVG_EXPORT Tvg_Result tvg_radial_gradient_set(Tvg_Gradient* grad, float cx, float cy, float radius)
 332 {
 333     return (Tvg_Result) reinterpret_cast<RadialGradient*>(grad)->radial(cx, cy, radius);
 334 }
 335
 336 TVG_EXPORT Tvg_Result tvg_gradient_color_stops(Tvg_Gradient* grad, const Tvg_Color_Stop* color_stop, uint32_t cnt)
 337 {
 338     return (Tvg_Result) reinterpret_cast<Fill*>(grad)->colorStops(reinterpret_cast<const Fill::ColorStop*>(color_stop), cnt);
 339 }
 340
 341 TVG_EXPORT Tvg_Result tvg_gradient_spread(Tvg_Gradient* grad, const Tvg_Stroke_Fill spread)
 342 {
 343     return (Tvg_Result) reinterpret_cast<Fill*>(grad)->spread((FillSpread)spread);
 344 }
 345
 346
 347 #ifdef __cplusplus
 348 }
 349 #endif