picasso.h

Go to the documentation of this file.

#ifndef _PICASSO_H_
#define _PICASSO_H_

#ifdef DLL_EXPORT
    #if defined(WIN32) || defined(WINCE)
        #ifdef EXPORT
            #define PICAPI  __stdcall
            #define PEXPORT __declspec(dllexport)
        #else
            #define PICAPI  __stdcall
            #define PEXPORT __declspec(dllimport)
        #endif
    #else
        #define PICAPI
        #if (defined(__GNUC__) && ((__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 3))) || (defined(__clang__))
            #define PEXPORT __attribute__((visibility("default")))
        #else
            #define PEXPORT
        #endif
    #endif
#else
#define PICAPI
#define PEXPORT
#endif

#include "pconfig.h"
#include <stdint.h>

#if defined(ENABLE_GLES1)
#include <EGL/egl.h>
#include <GLES/gl.h>
#elif defined(ENABLE_GLES2)
#include <EGL/egl.h>
#include <GLES2/gl2.h>
#endif

#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */

typedef int ps_bool;

#define True    1

#define False   0

typedef uint16_t ps_uchar16;

typedef int16_t ps_schar16;

typedef uint8_t ps_byte;

typedef struct _ps_context ps_context;

typedef struct _ps_canvas ps_canvas;

typedef struct _ps_image ps_image;

typedef struct _ps_pattern ps_pattern;

typedef struct _ps_gradient ps_gradient;

typedef struct _ps_matrix ps_matrix;

typedef struct _ps_path ps_path;

typedef struct _ps_mask ps_mask;

typedef struct _ps_font ps_font;

typedef struct _ps_glyph {
    void* glyph;
}ps_glyph;

typedef struct _ps_size {
    float w;
    float h;
}ps_size;

typedef struct _ps_rect {
    float x;
    float y;
    float w;
    float h;
}ps_rect;

typedef struct _ps_point {
    float x;
    float y;
}ps_point;

typedef struct _ps_color {
    float r;
    float g;
    float b;
    float a;
}ps_color;

PEXPORT int PICAPI ps_version(void);

PEXPORT ps_bool PICAPI ps_initialize(void);

PEXPORT void PICAPI ps_shutdown(void);

typedef enum _ps_status {
    STATUS_SUCCEED,
    STATUS_OUT_OF_MEMORY,
    STATUS_INVALID_ARGUMENT,
    STATUS_NOT_SUPPORT,
    STATUS_DEVICE_ERROR,
    STATUS_MISMATCHING_FORMAT,
    STATUS_UNKNOWN_ERROR,
}ps_status;

PEXPORT ps_status PICAPI ps_last_status(void);
PEXPORT ps_context* PICAPI ps_context_create(ps_canvas* canvas, ps_context* shared_context);

PEXPORT ps_context* PICAPI ps_context_ref(ps_context* ctx);

PEXPORT void PICAPI ps_context_unref(ps_context* ctx);

PEXPORT ps_canvas* PICAPI ps_context_set_canvas(ps_context* ctx, ps_canvas* canvas);

PEXPORT ps_canvas* PICAPI ps_context_get_canvas(ps_context* ctx);

typedef enum _ps_color_format {
    COLOR_FORMAT_RGBA,
    COLOR_FORMAT_ARGB,
    COLOR_FORMAT_ABGR,
    COLOR_FORMAT_BGRA,
    COLOR_FORMAT_RGB,
    COLOR_FORMAT_BGR,
    COLOR_FORMAT_RGB565,
    COLOR_FORMAT_RGB555,
    COLOR_FORMAT_UNKNOWN,
}ps_color_format;

PEXPORT ps_canvas* PICAPI ps_canvas_create(ps_color_format fmt, int width, int height);

PEXPORT ps_canvas* PICAPI ps_canvas_create_with_data(ps_byte* data, ps_color_format fmt,
                                                            int width, int height, int pitch);

PEXPORT ps_canvas* PICAPI ps_canvas_create_compatible(const ps_canvas* canvas,
                                                                int width, int height);

PEXPORT ps_canvas* PICAPI ps_canvas_create_from_canvas(ps_canvas* canvas, const ps_rect* rect);

PEXPORT ps_canvas* PICAPI ps_canvas_create_from_image(ps_image* img, const ps_rect* rect);

#if defined(ENABLE_GLES1) || defined(ENABLE_GLES2)

PEXPORT ps_canvas* PICAPI ps_canvas_create_with_egl(EGLSurface surface, EGLContext context);
#endif

PEXPORT ps_canvas* PICAPI ps_canvas_replace_data(ps_canvas* canvas, ps_byte* data,
                                                 ps_color_format fmt, int width, int height, int pitch);

PEXPORT ps_canvas* PICAPI ps_canvas_ref(ps_canvas* canvas);

PEXPORT void PICAPI ps_canvas_unref(ps_canvas* canvas);

PEXPORT ps_bool PICAPI ps_canvas_get_size(const ps_canvas* canvas, ps_size* rsize);

PEXPORT ps_color_format PICAPI ps_canvas_get_format(const ps_canvas* canvas);

PEXPORT void PICAPI ps_canvas_set_mask(ps_canvas* canvas, const ps_mask* mask);

PEXPORT void PICAPI ps_canvas_reset_mask(ps_canvas* canvas);

PEXPORT void PICAPI ps_canvas_bitblt(ps_canvas* src, const ps_rect* rect,
                                                ps_canvas* dst, const ps_point* location);
PEXPORT ps_image* PICAPI ps_image_create(ps_color_format fmt, int width, int height);

PEXPORT ps_image* PICAPI ps_image_create_with_data(ps_byte* data, ps_color_format fmt,
                                int width, int height, int pitch);
PEXPORT ps_image* PICAPI ps_image_create_from_data(ps_byte* data, ps_color_format fmt,
                                int width, int height, int pitch);
PEXPORT ps_image* PICAPI ps_image_create_compatible(const ps_canvas* canvas, int width, int height);

PEXPORT ps_image* PICAPI ps_image_create_from_canvas(ps_canvas* canvas, const ps_rect* rect);

PEXPORT ps_image* PICAPI ps_image_create_from_image(ps_image* img, const ps_rect* rect);

PEXPORT ps_image* PICAPI ps_image_ref(ps_image* img);

PEXPORT void PICAPI ps_image_unref(ps_image* img);

PEXPORT void PICAPI ps_image_set_allow_transparent(ps_image* img, ps_bool allow);

PEXPORT void PICAPI ps_image_set_transparent_color(ps_image* img, const ps_color* color);

PEXPORT ps_bool PICAPI ps_image_get_size(const ps_image* img, ps_size* rsize);

PEXPORT ps_color_format PICAPI ps_image_get_format(const ps_image* img);

typedef enum _ps_wrap_type {
    WRAP_TYPE_REPEAT,
    WRAP_TYPE_REFLECT,
}ps_wrap_type;

PEXPORT ps_pattern* PICAPI ps_pattern_create_image(const ps_image* img, ps_wrap_type x_wrap,
                                                ps_wrap_type y_wrap, const ps_matrix* transform);

PEXPORT void PICAPI ps_pattern_transform(ps_pattern* pattern, const ps_matrix* matrix);

PEXPORT ps_pattern* PICAPI ps_pattern_ref(ps_pattern* pattern);

PEXPORT void PICAPI ps_pattern_unref(ps_pattern* pattern);

typedef enum _ps_gradient_spread {
    GRADIENT_SPREAD_PAD,
    GRADIENT_SPREAD_REPEAT,
    GRADIENT_SPREAD_REFLECT,
}ps_gradient_spread;

PEXPORT ps_gradient* PICAPI ps_gradient_create_linear(ps_gradient_spread spread,
                                                    const ps_point* start, const ps_point* end);

PEXPORT ps_gradient* PICAPI ps_gradient_create_radial(ps_gradient_spread spread,
                        const ps_point* start, float sradius, const ps_point* end, float eradius);

PEXPORT ps_gradient* PICAPI ps_gradient_create_conic(ps_gradient_spread spread,
                                    const ps_point* origin, float sangle);

PEXPORT void PICAPI ps_gradient_transform(ps_gradient* gradient, const ps_matrix* matrix);

PEXPORT ps_gradient* PICAPI ps_gradient_ref(ps_gradient* gradient);

PEXPORT void PICAPI ps_gradient_unref(ps_gradient* gradient);

PEXPORT void PICAPI ps_gradient_add_color_stop(ps_gradient* gradient,
                                                float offset, const ps_color* color);

PEXPORT void PICAPI ps_gradient_clear_color_stops(ps_gradient* gradient);

PEXPORT ps_mask* PICAPI ps_mask_create_with_data(ps_byte* data, int width, int height);

PEXPORT ps_mask* PICAPI ps_mask_ref(ps_mask* mask);

PEXPORT void PICAPI ps_mask_unref(ps_mask* mask);

PEXPORT void PICAPI ps_mask_add_color_filter(ps_mask* mask, const ps_color* color);

PEXPORT void PICAPI ps_mask_clear_color_filters(ps_mask* mask);

PEXPORT void PICAPI ps_set_source_color(ps_context* ctx, const ps_color* color);

PEXPORT void PICAPI ps_set_source_image(ps_context* ctx, const ps_image* image);

PEXPORT void PICAPI ps_set_source_pattern(ps_context* ctx, const ps_pattern* pattern);

PEXPORT void PICAPI ps_set_source_gradient(ps_context* ctx, const ps_gradient* gradient);

PEXPORT void PICAPI ps_set_source_canvas(ps_context* ctx, const ps_canvas* canvas);

typedef enum _ps_line_cap {
    LINE_CAP_BUTT,
    LINE_CAP_ROUND,
    LINE_CAP_SQUARE,
}ps_line_cap;

PEXPORT void PICAPI ps_set_line_cap(ps_context* ctx, ps_line_cap line_cap);

typedef enum _ps_line_join {
    LINE_JOIN_MITER,
    LINE_JOIN_MITER_REVERT,
    LINE_JOIN_MITER_ROUND,
    LINE_JOIN_ROUND,
    LINE_JOIN_BEVEL,
}ps_line_join;

PEXPORT void PICAPI ps_set_line_join(ps_context* ctx, ps_line_join line_join);

typedef enum _ps_line_inner_join {
    LINE_INNER_MITER,
    LINE_INNER_BEVEL,
    LINE_INNER_JAG,
    LINE_INNER_ROUND,
}ps_line_inner_join;

PEXPORT void PICAPI ps_set_line_inner_join(ps_context* ctx, ps_line_inner_join line_inner_join);

PEXPORT float PICAPI ps_set_line_width(ps_context* ctx, float width);

PEXPORT float PICAPI ps_set_miter_limit(ps_context* ctx, float limit);

PEXPORT void PICAPI ps_set_stroke_color(ps_context* ctx, const ps_color* color);

PEXPORT void PICAPI ps_set_stroke_image(ps_context* ctx, const ps_image* image);

PEXPORT void PICAPI ps_set_stroke_pattern(ps_context* ctx, const ps_pattern* pattern);

PEXPORT void PICAPI ps_set_stroke_gradient(ps_context* ctx, const ps_gradient* gradient);

PEXPORT void PICAPI ps_set_stroke_canvas(ps_context* ctx, const ps_canvas* canvas);

PEXPORT void PICAPI ps_set_line_dash(ps_context* ctx, float start,
                                        const float* dashes, unsigned int num_dashes);

PEXPORT void PICAPI ps_reset_line_dash(ps_context* ctx);

PEXPORT void PICAPI ps_set_shadow(ps_context* ctx, float x_offset, float y_offset, float blur);

PEXPORT void PICAPI ps_set_shadow_color(ps_context* ctx, const ps_color* color);

PEXPORT void PICAPI ps_reset_shadow(ps_context* ctx);

typedef enum _ps_composite {
    COMPOSITE_CLEAR,
    COMPOSITE_SRC,
    COMPOSITE_SRC_OVER,
    COMPOSITE_SRC_IN,
    COMPOSITE_SRC_OUT,
    COMPOSITE_SRC_ATOP,
    COMPOSITE_DST,
    COMPOSITE_DST_OVER,
    COMPOSITE_DST_IN,
    COMPOSITE_DST_OUT,
    COMPOSITE_DST_ATOP,
    COMPOSITE_XOR,
    COMPOSITE_DARKEN,
    COMPOSITE_LIGHTEN,
    COMPOSITE_OVERLAY,
    COMPOSITE_SCREEN,
    COMPOSITE_MULTIPLY,
    COMPOSITE_PLUS,
    COMPOSITE_MINUS,
    COMPOSITE_EXCLUSION,
    COMPOSITE_DIFFERENCE,
    COMPOSITE_SOFTLIGHT,
    COMPOSITE_HARDLIGHT,
    COMPOSITE_BURN,
    COMPOSITE_DODGE,
    COMPOSITE_CONTRAST,
    COMPOSITE_INVERT,
    COMPOSITE_INVERT_BLEND,
    COMPOSITE_HUE,
    COMPOSITE_SATURATION,
    COMPOSITE_COLOR,
    COMPOSITE_LUMINOSITY,
    COMPOSITE_ERROR,
}ps_composite;

PEXPORT ps_composite PICAPI ps_set_composite_operator(ps_context* ctx, ps_composite composite);

typedef enum _ps_filter {
    FILTER_NEAREST,
    FILTER_BILINEAR,
    FILTER_GAUSSIAN,
    FILTER_UNKNOWN,
}ps_filter;

PEXPORT ps_filter PICAPI ps_set_filter(ps_context* ctx, ps_filter filter);

typedef enum _ps_fill_rule {
    FILL_RULE_WINDING,
    FILL_RULE_EVEN_ODD,
    FILL_RULE_ERROR,
}ps_fill_rule;

PEXPORT ps_fill_rule PICAPI ps_set_fill_rule(ps_context* ctx, ps_fill_rule rule);

PEXPORT float PICAPI ps_set_alpha(ps_context* ctx, float alpha);

PEXPORT float PICAPI ps_set_gamma(ps_context* ctx, float gamma);

PEXPORT void PICAPI ps_set_antialias(ps_context* ctx, ps_bool antialias);

PEXPORT float PICAPI ps_set_blur(ps_context* ctx, float blur);

PEXPORT void PICAPI ps_stroke(ps_context* ctx);

PEXPORT void PICAPI ps_fill(ps_context* ctx);

PEXPORT void PICAPI ps_paint(ps_context* ctx);

PEXPORT void PICAPI ps_clear(ps_context* ctx);

PEXPORT void PICAPI ps_clip(ps_context* ctx);

PEXPORT void PICAPI ps_clip_path(ps_context* ctx, const ps_path* path, ps_fill_rule rule);

PEXPORT void PICAPI ps_clip_rect(ps_context* ctx, const ps_rect* rect);

PEXPORT void PICAPI ps_clip_device_rect(ps_context* ctx, const ps_rect* rect);

PEXPORT void PICAPI ps_clip_rects(ps_context* ctx, const ps_rect* rects, unsigned int num_rects);

PEXPORT void PICAPI ps_reset_clip(ps_context* ctx);

PEXPORT void PICAPI ps_save(ps_context* ctx);

PEXPORT void PICAPI ps_restore(ps_context* ctx);

typedef enum _ps_charset {
    CHARSET_ANSI,
    CHARSET_UNICODE,
}ps_charset;

typedef enum _ps_font_weight {
    FONT_WEIGHT_REGULAR = 400,
    FONT_WEIGHT_MEDIUM = 500,
    FONT_WEIGHT_BOLD = 700,
    FONT_WEIGHT_HEAVY = 900,
}ps_font_weight;

PEXPORT ps_font* PICAPI ps_font_create(const char* name, ps_charset charset,
                                                    float size, int weight, ps_bool italic);

PEXPORT ps_font* PICAPI ps_font_create_copy(const ps_font* font);

PEXPORT ps_font* PICAPI ps_font_ref(ps_font* font);

PEXPORT void PICAPI ps_font_unref(ps_font* font);

PEXPORT void PICAPI ps_font_set_size(ps_font* font, float size);

PEXPORT void PICAPI ps_font_set_weight(ps_font* font, int weight);

PEXPORT void PICAPI ps_font_set_italic(ps_font* font, ps_bool italic);

PEXPORT void PICAPI ps_font_set_charset(ps_font* font, ps_charset charset);

PEXPORT void PICAPI ps_font_set_hint(ps_font* font, ps_bool hint);

PEXPORT void PICAPI ps_font_set_flip(ps_font* font, ps_bool flip);

typedef struct _ps_font_info {
    float size;
    float ascent;
    float descent;
    float leading;
    unsigned int unitsEM;
}ps_font_info;

PEXPORT ps_bool PICAPI ps_get_font_info(ps_context* ctx, ps_font_info* info);

PEXPORT ps_font* PICAPI ps_set_font(ps_context* ctx, const ps_font* font);

typedef enum _ps_text_type {
    TEXT_TYPE_SMOOTH,
    TEXT_TYPE_MONO,
    TEXT_TYPE_STROKE,
}ps_text_type;

PEXPORT ps_bool PICAPI ps_get_text_extent(ps_context* ctx, const void* text, unsigned int length, ps_size* rsize);

PEXPORT void PICAPI ps_set_text_color(ps_context* ctx, const ps_color * color);

PEXPORT void PICAPI ps_set_text_stroke_color(ps_context* ctx, const ps_color * color);

PEXPORT void PICAPI ps_text_transform(ps_context* ctx, const ps_matrix* matrix);

PEXPORT void PICAPI ps_set_text_matrix(ps_context* ctx, const ps_matrix* matrix);

PEXPORT void PICAPI ps_set_text_render_type(ps_context* ctx, ps_text_type type);

PEXPORT void PICAPI ps_set_text_antialias(ps_context* ctx, ps_bool antialias);

PEXPORT void PICAPI ps_set_text_kerning(ps_context* ctx, ps_bool kerning);

PEXPORT void PICAPI ps_text_out_length(ps_context* ctx, float x, float y,
                                                const char* text, unsigned int length);

PEXPORT void PICAPI ps_wide_text_out_length(ps_context* ctx, float x, float y,
                                                const ps_uchar16* text, unsigned int length);
typedef enum _ps_draw_text_type {
    DRAW_TEXT_FILL,
    DRAW_TEXT_STROKE,
    DRAW_TEXT_BOTH,
}ps_draw_text_type;

typedef enum _ps_text_align {
    TEXT_ALIGN_CENTER = 0,
    TEXT_ALIGN_TOP       = 1,
    TEXT_ALIGN_BOTTOM = 2,
    TEXT_ALIGN_LEFT   = 4,
    TEXT_ALIGN_RIGHT  = 8,
}ps_text_align;

PEXPORT void PICAPI ps_draw_text(ps_context* ctx, const ps_rect* area, const void* text,
                                unsigned int length, ps_draw_text_type type, ps_text_align align);

PEXPORT ps_bool PICAPI ps_get_glyph(ps_context* ctx, int ch, ps_glyph* glyph);

PEXPORT void PICAPI ps_show_glyphs(ps_context* ctx, float x, float y,
                                                    ps_glyph* glyphs, unsigned int length);

PEXPORT ps_bool PICAPI ps_get_path_from_glyph(ps_context* ctx,
                                        const ps_glyph* glyph, ps_path* path);

PEXPORT ps_bool PICAPI ps_glyph_get_extent(const ps_glyph* glyph, ps_size* rsize);

PEXPORT void PICAPI ps_translate(ps_context* ctx, float tx, float ty);

PEXPORT void PICAPI ps_scale(ps_context* ctx, float sx, float sy);

PEXPORT void PICAPI ps_shear(ps_context* ctx, float shx, float shy);

PEXPORT void PICAPI ps_rotate(ps_context* ctx, float angle);

PEXPORT void PICAPI ps_identity(ps_context* ctx);

PEXPORT void PICAPI ps_transform(ps_context* ctx, const ps_matrix* matrix);

PEXPORT void PICAPI ps_set_matrix(ps_context* ctx, const ps_matrix* matrix);

PEXPORT ps_bool PICAPI ps_get_matrix(ps_context* ctx, ps_matrix* matrix);

PEXPORT void PICAPI ps_world_to_viewport(ps_context* ctx, ps_point* point);

PEXPORT void PICAPI ps_viewport_to_world(ps_context* ctx, ps_point* point);

PEXPORT ps_matrix* PICAPI ps_matrix_create(void);

PEXPORT ps_matrix* PICAPI ps_matrix_create_init(float sx, float shy, float shx,
                                                            float sy, float tx, float ty);

PEXPORT ps_matrix* PICAPI ps_matrix_create_copy(const ps_matrix* matrix);

PEXPORT ps_matrix* PICAPI ps_matrix_ref(ps_matrix* matrix);

PEXPORT void PICAPI ps_matrix_unref(ps_matrix* matrix);

PEXPORT void PICAPI ps_matrix_init(ps_matrix* matrix, float sx, float shy,
                                            float shx, float sy, float tx, float ty);

PEXPORT void PICAPI ps_matrix_translate(ps_matrix* matrix, float tx, float ty);

PEXPORT void PICAPI ps_matrix_scale(ps_matrix* matrix, float sx, float sy);

PEXPORT void PICAPI ps_matrix_rotate(ps_matrix* matrix, float angle);

PEXPORT void PICAPI ps_matrix_shear(ps_matrix* matrix, float shx, float shy);

PEXPORT void PICAPI ps_matrix_invert(ps_matrix* matrix);

PEXPORT void PICAPI ps_matrix_reset(ps_matrix* matrix);

PEXPORT void PICAPI ps_matrix_flip_x(ps_matrix* matrix);

PEXPORT void PICAPI ps_matrix_flip_y(ps_matrix* matrix);

PEXPORT void PICAPI ps_matrix_multiply(ps_matrix* result, const ps_matrix* a, const ps_matrix* b);

PEXPORT ps_bool PICAPI ps_matrix_is_identity(const ps_matrix* matrix);

PEXPORT ps_bool PICAPI ps_matrix_is_equal(const ps_matrix* a, const ps_matrix* b);

PEXPORT float PICAPI ps_matrix_get_determinant(const ps_matrix* matrix);

PEXPORT void PICAPI ps_matrix_set_translate_factor(ps_matrix* matrix, float tx, float ty);

PEXPORT ps_bool PICAPI ps_matrix_get_translate_factor(ps_matrix* matrix, float *tx, float *ty);

PEXPORT void PICAPI ps_matrix_set_scale_factor(ps_matrix* matrix, float sx, float sy);

PEXPORT ps_bool PICAPI ps_matrix_get_scale_factor(ps_matrix* matrix, float *sx, float *sy);

PEXPORT void PICAPI ps_matrix_set_shear_factor(ps_matrix* matrix, float shx, float shy);

PEXPORT ps_bool PICAPI ps_matrix_get_shear_factor(ps_matrix* matrix, float *shx, float *shy);

PEXPORT void PICAPI ps_matrix_transform_point(const ps_matrix* matrix, ps_point* point);

PEXPORT void PICAPI ps_matrix_transform_rect(const ps_matrix* matrix, ps_rect* rect);

PEXPORT void PICAPI ps_matrix_transform_path(const ps_matrix* matrix, ps_path* path);

PEXPORT void PICAPI ps_new_path(ps_context* ctx);

PEXPORT void PICAPI ps_new_sub_path(ps_context* ctx);

PEXPORT void PICAPI ps_add_sub_path(ps_context* ctx, const ps_path* path);

PEXPORT void PICAPI ps_set_path(ps_context* ctx, const ps_path* path);

PEXPORT ps_bool PICAPI ps_get_path(ps_context* ctx, ps_path* path);

PEXPORT void PICAPI ps_close_path(ps_context* ctx);

PEXPORT void PICAPI ps_move_to(ps_context* ctx, const ps_point* point);

PEXPORT void PICAPI ps_line_to(ps_context* ctx, const ps_point* point);

PEXPORT void PICAPI ps_bezier_curve_to(ps_context* ctx, const ps_point* fcp,
                                           const ps_point* scp, const ps_point* ep);

PEXPORT void PICAPI ps_quad_curve_to(ps_context* ctx, const ps_point* cp, const ps_point* ep);

PEXPORT void PICAPI ps_arc(ps_context* ctx, const ps_point* cp, float radius,
                                           float sangle, float eangle, ps_bool clockwise);

PEXPORT void PICAPI ps_tangent_arc(ps_context* ctx, const ps_rect* rect, float sangle, float sweep);

PEXPORT void PICAPI ps_rectangle(ps_context* ctx, const ps_rect* rect);

PEXPORT void PICAPI ps_rounded_rect(ps_context* ctx, const ps_rect* rect, float ltx,
                      float lty, float rtx, float rty, float lbx, float lby, float rbx, float rby);

PEXPORT void PICAPI ps_ellipse(ps_context* ctx, const ps_rect* rect);

PEXPORT ps_path* PICAPI ps_path_create(void);

PEXPORT ps_path* PICAPI ps_path_create_copy(const ps_path* path);

PEXPORT ps_path* PICAPI ps_path_ref(ps_path* path);

PEXPORT void PICAPI ps_path_unref(ps_path* path);

PEXPORT void PICAPI ps_path_move_to(ps_path* path, const ps_point* point);

PEXPORT void PICAPI ps_path_line_to(ps_path* path, const ps_point* point);

PEXPORT void PICAPI ps_path_tangent_arc_to(ps_path* path, float radius,
                                            const ps_point* tp, const ps_point* ep);

PEXPORT void PICAPI ps_path_arc_to(ps_path* path, float radiusX, float radiusY, float angle,
                                        ps_bool large_arc, ps_bool clockwise, const ps_point* ep);

PEXPORT void PICAPI ps_path_bezier_to(ps_path* path, const ps_point* fcp,
                                                 const ps_point* scp, const ps_point* ep);

PEXPORT void PICAPI ps_path_quad_to(ps_path* path, const ps_point* cp, const ps_point* ep);

PEXPORT void PICAPI ps_path_sub_close(ps_path* path);

PEXPORT float PICAPI ps_path_get_length(const ps_path* path);

PEXPORT void PICAPI ps_path_clear(ps_path* path);

PEXPORT ps_bool PICAPI ps_path_is_empty(const ps_path* path);

PEXPORT unsigned int PICAPI ps_path_get_vertex_count(const ps_path* path);

typedef enum _ps_path_cmd {
    PATH_CMD_STOP     = 0,
    PATH_CMD_MOVE_TO  = 1,
    PATH_CMD_LINE_TO  = 2,
    PATH_CMD_CURVE3   = 3,
    PATH_CMD_CURVE4   = 4,
    PATH_CMD_END_POLY = 0x0F,
}ps_path_cmd;

PEXPORT ps_path_cmd PICAPI ps_path_get_vertex(const ps_path* path,
                                                unsigned int index, ps_point * point);

PEXPORT ps_bool PICAPI ps_path_bounding_rect(const ps_path* path, ps_rect* rect);

PEXPORT ps_bool PICAPI ps_path_contains(const ps_path* path,
                                        const ps_point* point, ps_fill_rule rule);

PEXPORT ps_bool PICAPI ps_path_stroke_contains(const ps_path* path,
                                        const ps_point* point, float width);

PEXPORT void PICAPI ps_path_add_line(ps_path* path, const ps_point* p1, const ps_point* p2);

PEXPORT void PICAPI ps_path_add_arc(ps_path* path, const ps_point* cp, float radius,
                                            float sangle, float eangle, ps_bool clockwise);

PEXPORT void PICAPI ps_path_add_rect(ps_path* path, const ps_rect* rect);

PEXPORT void PICAPI ps_path_add_ellipse(ps_path* path, const ps_rect* rect);

PEXPORT void PICAPI ps_path_add_rounded_rect(ps_path* path, const ps_rect* rect, float ltx,
                      float lty, float rtx, float rty, float lbx, float lby, float rbx, float rby);

PEXPORT void PICAPI ps_path_add_sub_path(ps_path* path, const ps_path* spath);

typedef enum _ps_path_op {
    PATH_OP_UNION,
    PATH_OP_INTERSECT,
    PATH_OP_XOR,
    PATH_OP_DIFF,
}ps_path_operation;

PEXPORT void PICAPI ps_path_clipping(ps_path* result, ps_path_operation op,
                                                const ps_path* a, const ps_path* b);

#ifdef __cplusplus
}
#endif /* __cplusplus */

#endif /*_PICASSO_H_*/