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
            #define PEXPORT __declspec(dllexport)
        #else
            #define PICAPI
            #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 <stdint.h>
 
#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */
 
typedef int32_t 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 int32_t 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_A8,
    COLOR_FORMAT_UNKNOWN,
} ps_color_format;
 
PEXPORT ps_canvas* PICAPI ps_canvas_create(ps_color_format fmt, int32_t width, int32_t height);
 
PEXPORT ps_canvas* PICAPI ps_canvas_create_with_data(ps_byte* data, ps_color_format fmt,
                                                     int32_t width, int32_t height, int32_t pitch);
 
PEXPORT ps_canvas* PICAPI ps_canvas_create_compatible(const ps_canvas* canvas,
                                                      int32_t width, int32_t 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);
 
PEXPORT ps_canvas* PICAPI ps_canvas_create_from_mask(ps_mask* mask, const ps_rect* rect);
 
PEXPORT ps_canvas* PICAPI ps_canvas_replace_data(ps_canvas* canvas, ps_byte* data,
                                                 ps_color_format fmt, int32_t width, int32_t height, int32_t 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, int32_t width, int32_t height);
 
PEXPORT ps_image* PICAPI ps_image_create_with_data(ps_byte* data, ps_color_format fmt,
                                                   int32_t width, int32_t height, int32_t pitch);
PEXPORT ps_image* PICAPI ps_image_create_from_data(ps_byte* data, ps_color_format fmt,
                                                   int32_t width, int32_t height, int32_t pitch);
PEXPORT ps_image* PICAPI ps_image_create_compatible(const ps_canvas* canvas, int32_t width, int32_t 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(int32_t width, int32_t height);
 
PEXPORT ps_mask* PICAPI ps_mask_create_with_data(ps_byte* data, int32_t width, int32_t 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, uint32_t 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_BICUBIC,
    FILTER_QUADRIC,
    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_scissor_rect(ps_context* ctx, const ps_rect* rect);
 
PEXPORT void PICAPI ps_clip_rects(ps_context* ctx, const ps_rect* rects, uint32_t 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, int32_t 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, int32_t 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;
    uint32_t 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, uint32_t 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, uint32_t length);
 
PEXPORT void PICAPI ps_wide_text_out_length(ps_context* ctx, float x, float y,
                                            const ps_uchar16* text, uint32_t 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,
                                 uint32_t length, ps_draw_text_type type, ps_text_align align);
 
PEXPORT ps_bool PICAPI ps_get_glyph(ps_context* ctx, int32_t ch, ps_glyph* glyph);
 
PEXPORT void PICAPI ps_show_glyphs(ps_context* ctx, float x, float y,
                                   ps_glyph* glyphs, uint32_t 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_identity(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 uint32_t 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,
                                              uint32_t 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_*/