# HG changeset patch # User Thinker K.F. Li # Date 1258273401 -28800 # Node ID d38aca825822900c7046748cd29b0a67adb8c57f # Parent 273307d061b7d685bcc249f0835fd7297e580c03 Import more functions for Skia graphic engine. diff -r 273307d061b7 -r d38aca825822 include/mb_graph_engine_skia.h --- a/include/mb_graph_engine_skia.h Sun Nov 15 16:21:09 2009 +0800 +++ b/include/mb_graph_engine_skia.h Sun Nov 15 16:23:21 2009 +0800 @@ -2,6 +2,7 @@ #define __MB_GE_SKIA_H_ #include +#include "mb_basic_types.h" #include "mb_img_ldr.h" /*! \defgroup mb_ge_skia MadButterfly Graphic Engine with Skia @@ -11,8 +12,6 @@ #define MBE_OPERATOR_SOURCE 1 #define MBE_STATUS_SUCCESS 0 -typedef float co_aix; - struct _mbe_text_extents_t { co_aix x_bearing; co_aix y_bearing; @@ -34,20 +33,20 @@ typedef struct _mbe_pattern_t mbe_pattern_t; typedef struct _mbe_t mbe_t; -extern void mbe_pattern_add_color_stop_rgba(mbe_pattern_t *ptn, - co_aix offset, - co_aix r, co_aix g, co_aix b, - co_aix a); extern mbe_pattern_t *mbe_pattern_create_for_surface(mbe_surface_t *surface); extern mbe_pattern_t *mbe_pattern_create_radial(co_aix cx0, co_aix cy0, co_aix radius0, co_aix cx1, co_aix cy1, - co_aix radius1); + co_aix radius1, + grad_stop_t *stops, + int stop_cnt); extern mbe_pattern_t *mbe_pattern_create_linear(co_aix x0, co_aix y0, - co_aix x1, co_aix y1); + co_aix x1, co_aix y1, + grad_stop_t *stops, + int stop_cnt); extern void mbe_pattern_set_matrix(mbe_pattern_t *ptn, const co_aix matrix[6]); -extern void mbe_pattern_destroy(mbe_pattern_t *canvas); +extern void mbe_pattern_destroy(mbe_pattern_t *ptn); extern int mbe_image_surface_get_stride(mbe_surface_t *surface); extern int mbe_image_surface_get_height(mbe_surface_t *surface); diff -r 273307d061b7 -r d38aca825822 src/graph_engine_skia.cpp --- a/src/graph_engine_skia.cpp Sun Nov 15 16:21:09 2009 +0800 +++ b/src/graph_engine_skia.cpp Sun Nov 15 16:23:21 2009 +0800 @@ -1,7 +1,45 @@ +/*! \page ge_layer Graphic Engine Layer + * + * Graphic Engine Layer is an abstract of graphic engine; likes Cairo + * and Skia. It provides portability for the rest of MadButterfly. + * + * The basic stratage of interface of graphic engine layer is defined + * according purpose of MadButterfly. For example, MadButterfly wants + * a function that can clear a canvas, we define a clear function. + * Never define a indirectly way to finish the function. Never define + * a way to finish the function for the reason that some engine + * require you to finish the task in that procedure. It avoids + * binding graphic engine layer with any behavior of a graphic engine, + * and provides more compatible with other engines, to define + * interface of graphic engine layer according purpose of + * MadButterfly. + * + * \section ge_mem Graphic Engine Layer Memory Management + * + * MadButterfly is responsible for management of objects and memory + * blocks returned by graphic engine layer, even for graphic engines + * that have management model. MadButterfly supposes memory blocks + * only be released when they are no more used. MadBufferfly is + * responsible for release them. So, even a graphic engine has + * reference count with objects, MadButterfly still keep a reference + * for every object returned by the engine until no one will use it. + * + * \section ge_transform Transformation of Coordination System + * + * Points of pathes are transformed when it is added to the canvas + * with the transformation matrix at the time. So, changes of + * transformation matrix of an canvas will not affect points that had + * been added. It only affects points been added when the matrix is + * setted. + */ #include #include #include #include +#include +#include +#include +#include #define C_START extern "C" { #define C_END } @@ -10,6 +48,21 @@ #include "mb_graph_engine_skia.h" #include "mb_shapes.h" +#include "mb_img_ldr.h" + +/*! \brief Source pattern + * + * For Skia, source pattern is SkShader with some decoration. Since + * SkShade will repeative tiling or extenting edge color, it can not + * stop tiling and extenting for fixed size bitmap. So, we need to + * translate mbe_paint() into a drawing of a rectangle. + */ +struct _mbe_pattern_t { + SkShader *shader; + int w, h; + int has_size; + co_aix matrix[6]; +}; struct _mbe_scaled_font_t { struct _mb_font_face_t *face; @@ -17,46 +70,409 @@ co_aix ctm[6]; }; struct _mbe_font_face_t {}; +/*! \brief MadButterfly Graphic Engine Context. + * + * A context comprises source pattern, target surface, path, + * line-width, and transform matrix. + */ struct _mbe_t { SkCanvas *canvas; - SkShader *shader; - int shader_owned; + SkPath *path, *subpath; + SkPaint *paint; + SkRegion *saved_region; + + struct _mbe_states_t *states; +}; + +struct _mbe_states_t { + mbe_pattern_t *ptn; + int ptn_owned; + co_aix line_width; + co_aix matrix[6]; + struct _mbe_states_t *next; }; #ifndef ASSERT #define ASSERT(x) #endif -void mbe_pattern_add_color_stop_rgba(mbe_pattern_t *ptn, - co_aix offset, - co_aix r, co_aix g, co_aix b, - co_aix a) {} -mbe_pattern_t *mbe_pattern_create_for_surface(mbe_surface_t *surface) {} -mbe_pattern_t *mbe_pattern_create_radial(co_aix cx0, co_aix cy0, - co_aix radius0, - co_aix cx1, co_aix cy1, - co_aix radius1) {} -mbe_pattern_t *mbe_pattern_create_linear(co_aix x0, co_aix y0, - co_aix x1, co_aix y1) {} -void mbe_pattern_set_matrix(mbe_pattern_t *ptn, - const co_aix matrix[6]) {} -void mbe_pattern_destroy(mbe_pattern_t *canvas) {} +#define PI 3.1415926535897931 + +#define CO_AIX_2_SKSCALAR(a) ((a) * 65536) +#define SKSCALAR_2_CO_AIX(a) ((co_aix)(a) / 65536) +#define MB_MATRIX_2_SKMATRIX(sk, mb) { \ + (sk).setScaleX(CO_AIX_2_SKSCALAR((mb)[0])); \ + (sk).setSkewX(CO_AIX_2_SKSCALAR((mb)[1])); \ + (sk).setTranslateX(CO_AIX_2_SKSCALAR((mb)[2])); \ + (sk).setSkewY(CO_AIX_2_SKSCALAR((mb)[3])); \ + (sk).setScaleY(CO_AIX_2_SKSCALAR((mb)[4])); \ + (sk).setTranslateY(CO_AIX_2_SKSCALAR((mb)[5])); \ + } +#define SKMATRIX_2_MB_MATRIX(mb, sk) { \ + (mb)[0] = SKSCALAR_2_CO_AIX((sk).getScaleX()); \ + (mb)[1] = SKSCALAR_2_CO_AIX((sk).getSkewX()); \ + (mb)[2] = SKSCALAR_2_CO_AIX((sk).getTranslateX()); \ + (mb)[3] = SKSCALAR_2_CO_AIX((sk).getSkewY()); \ + (mb)[4] = SKSCALAR_2_CO_AIX((sk).getScaleY()); \ + (mb)[5] = SKSCALAR_2_CO_AIX((sk).getTranslateY()); \ + } +#define MBSTOP_2_SKCOLOR(c) \ + ((((int)((c)->a * 255)) << 24) | \ + (((int)((c)->r * 255)) << 16) | \ + (((int)((c)->g * 255)) << 8) | \ + (((int)((c)->b * 255)))) + +static const co_aix id_matrix[6] = { 1, 0, 0, 0, 1, 0 }; + +static void +_prepare_sized_pattern(mbe_t *mbe, mbe_pattern_t *ptn) { + SkCanvas *canvas = mbe->canvas; + SkPath path; + co_aix x, y; + co_aix reverse[6]; + + *mbe->saved_region = canvas->getTotalClip(); + + compute_reverse(ptn->matrix, reverse); + x = 0; y = 0; + matrix_trans_pos(reverse, &x, &y); + path.moveTo(CO_AIX_2_SKSCALAR(x), CO_AIX_2_SKSCALAR(y)); + x = 0; y = ptn->h; + matrix_trans_pos(reverse, &x, &y); + path.moveTo(CO_AIX_2_SKSCALAR(x), CO_AIX_2_SKSCALAR(y)); + x = ptn->w; y = ptn->h; + matrix_trans_pos(reverse, &x, &y); + path.moveTo(CO_AIX_2_SKSCALAR(x), CO_AIX_2_SKSCALAR(y)); + path.close(); + + canvas->clipPath(path, SkRegion::kIntersect_Op); +} + +static void +_finish_sized_pattern(mbe_t *mbe) { + SkCanvas *canvas = mbe->canvas; + + canvas->setClipRegion(*mbe->saved_region); +} + +static void +_canvas_device_region(SkCanvas *canvas, SkRegion *region) { + SkDevice *device; + int w, h; + + device = canvas->getDevice(); + w = device->width(); + h = device->height(); + region->setRect(0, 0, w, h); +} + +static void +_update_path(mbe_t *mbe) { + SkPath *path = mbe->path; + SkPath *subpath = mbe->subpath; + SkMatrix canvas_matrix; + SkPoint point; + + MB_MATRIX_2_SKMATRIX(canvas_matrix, mbe->states->matrix); + path->addPath(*subpath, canvas_matrix); + + subpath->getLastPt(&point); + subpath->rewind(); + subpath->moveTo(point); +} + +/* + * When a function want to use the paint associated with a canvas to + * draw, it should call _prepare_paint() can make the paint ready. + * And, call _finish_paint() when the paint is no more used. + */ +static void +_prepare_paint(mbe_t *mbe, SkPaint::Style style) { + SkPaint *paint = mbe->paint; + mbe_pattern_t *ptn = mbe->states->ptn; + SkShader *shader = ptn->shader; + co_aix matrix[6]; + SkMatrix skmatrix; + + paint->setStyle(style); + + /* Local matrix of SkShader is a mapping from source pattern to + * user space. Unlikely, for Cairo is a mapping from user space + * to source pattern. + */ + matrix_mul(mbe->states->matrix, ptn->matrix, matrix); + MB_MATRIX_2_SKMATRIX(skmatrix, matrix); + shader->setLocalMatrix(skmatrix); + paint->setShader(shader); + + if(style == SkPaint::kStroke_Style) + paint->setStrokeWidth(CO_AIX_2_SKSCALAR(mbe->states->line_width)); + + if(ptn->has_size) + _prepare_sized_pattern(mbe, ptn); +} + +static void +_finish_paint(mbe_t *mbe) { + mbe_pattern_t *ptn = mbe->states->ptn; + + mbe->paint->reset(); + if(ptn->has_size) + _finish_sized_pattern(mbe); +} + +mbe_pattern_t *mbe_pattern_create_for_surface(mbe_surface_t *surface) { + mbe_pattern_t *ptn; + SkBitmap *bitmap = (SkBitmap *)surface; -int mbe_image_surface_get_stride(mbe_surface_t *surface) {} -int mbe_image_surface_get_height(mbe_surface_t *surface) {} -int mbe_image_surface_get_width(mbe_surface_t *surface) {} -unsigned char *mbe_image_surface_get_data(mbe_surface_t *surface) {} + ptn = (mbe_pattern_t *)malloc(sizeof(mbe_pattern_t)); + ptn->shader = SkShader::CreateBitmapShader(*bitmap, + SkShader::kClamp_TileMode, + SkShader::kClamp_TileMode); + if(ptn->shader == NULL) { + free(ptn); + return NULL; + } + + ptn->has_size = 1; + ptn->w = bitmap->width(); + ptn->h = bitmap->height(); + + memcpy(ptn->matrix, id_matrix, sizeof(co_aix) * 6); + + return ptn; +} + +mbe_pattern_t * +mbe_pattern_create_radial(co_aix cx0, co_aix cy0, co_aix radius0, + co_aix cx1, co_aix cy1, co_aix radius1, + grad_stop_t *stops, int stop_cnt) { + mbe_pattern_t *ptn; + SkColor *colors; + SkScalar *poses; + grad_stop_t *stop; + SkPoint center; + int i; + + ptn = (mbe_pattern_t *)malloc(sizeof(mbe_pattern_t)); + colors = new SkColor[stop_cnt]; + poses = new SkScalar[stop_cnt]; + if(ptn == NULL || colors == NULL || poses == NULL) + goto fail; + + center.set(CO_AIX_2_SKSCALAR(cx1), CO_AIX_2_SKSCALAR(cy1)); + + stop = stops; + for(i = 0; i < stop_cnt; i++) { + colors[i] = MBSTOP_2_SKCOLOR(stop); + poses[i] = CO_AIX_2_SKSCALAR(stop->offset); + } + + /* + * cx0, cy0 and radius0 is not used. Since Skia is still not + * support two circles radial. And, SVG 1.2 is also not support + * two circles. + */ + ptn->shader = + SkGradientShader::CreateRadial(center, CO_AIX_2_SKSCALAR(radius1), + colors, poses, stop_cnt, + SkShader::kClamp_TileMode); + if(ptn->shader == NULL) + goto fail; + + memcpy(ptn->matrix, id_matrix, sizeof(co_aix) * 6); + + delete colors; + delete poses; + return ptn; + + fail: + if(ptn) free(ptn); + if(colors) delete colors; + if(poses) delete poses; + return NULL; +} + +mbe_pattern_t * +mbe_pattern_create_linear(co_aix x0, co_aix y0, + co_aix x1, co_aix y1, + grad_stop_t *stops, int stop_cnt) { + mbe_pattern_t *ptn; + SkColor *colors; + SkScalar *poses; + grad_stop_t *stop; + SkPoint points[2]; + int i; + + ptn = (mbe_pattern_t *)malloc(sizeof(mbe_pattern_t)); + colors = new SkColor[stop_cnt]; + poses = new SkScalar[stop_cnt]; + if(ptn == NULL || colors == NULL || poses == NULL) + goto fail; + + points[0].set(CO_AIX_2_SKSCALAR(x0), CO_AIX_2_SKSCALAR(y0)); + points[1].set(CO_AIX_2_SKSCALAR(x1), CO_AIX_2_SKSCALAR(y1)); + + stop = stops; + for(i = 0; i < stop_cnt; i++) { + colors[i] = MBSTOP_2_SKCOLOR(stop); + poses[i] = CO_AIX_2_SKSCALAR(stop->offset); + } + + /* + * cx0, cy0 and radius0 is not used. Since Skia is still not + * support two circles radial. And, SVG 1.2 is also not support + * two circles. + */ + ptn->shader = + SkGradientShader::CreateLinear(points, colors, poses, stop_cnt, + SkShader::kClamp_TileMode); + if(ptn->shader == NULL) + goto fail; + + memcpy(ptn->matrix, id_matrix, sizeof(co_aix) * 6); + + delete colors; + delete poses; + return ptn; + + fail: + if(ptn) free(ptn); + if(colors) delete colors; + if(poses) delete poses; + return NULL; +} + +void mbe_pattern_set_matrix(mbe_pattern_t *ptn, const co_aix matrix[6]) { + SkMatrix skmatrix; + + MB_MATRIX_2_SKMATRIX(skmatrix, matrix); + + ptn->shader->setLocalMatrix(skmatrix); +} + +void mbe_pattern_destroy(mbe_pattern_t *ptn) { + if(ptn->shader) + delete ptn->shader; + free(ptn); +} + +int mbe_image_surface_get_stride(mbe_surface_t *surface) { + return ((SkBitmap *)surface)->rowBytes(); +} + +int mbe_image_surface_get_height(mbe_surface_t *surface) { + return ((SkBitmap *)surface)->height(); +} + +int mbe_image_surface_get_width(mbe_surface_t *surface) { + return ((SkBitmap *)surface)->width(); +} + +unsigned char *mbe_image_surface_get_data(mbe_surface_t *surface) { + return (unsigned char *)((SkBitmap *)surface)->getPixels(); +} + mbe_surface_t *mbe_image_surface_create_from_png(const char *filename) {} + mbe_surface_t * mbe_image_surface_create_for_data(unsigned char *data, mb_img_fmt_t fmt, int width, int height, - int stride) {} -mb_img_fmt_t mbe_image_surface_get_format(mbe_surface_t *surface) {} + int stride) { + SkBitmap *bitmap; + SkBitmap::Config cfg; + + switch(fmt) { + case MB_IFMT_ARGB32: + cfg = SkBitmap::kARGB_8888_Config; break; + + case MB_IFMT_A8: + cfg = SkBitmap::kA8_Config; break; + + case MB_IFMT_A1: + cfg = SkBitmap::kA1_Config; break; + + case MB_IFMT_RGB16_565: + cfg = SkBitmap::kRGB_565_Config; break; + + case MB_IFMT_RGB24: + default: + return NULL; + } + + bitmap = new SkBitmap(); + if(bitmap == NULL) + return NULL; + + bitmap->setConfig(cfg, width, height, stride); + bitmap->setPixels(data); + + return (mbe_surface_t *)bitmap; +} + +mb_img_fmt_t mbe_image_surface_get_format(mbe_surface_t *surface) { + SkBitmap *bitmap = (SkBitmap *)surface; + mb_img_fmt_t fmt; + SkBitmap::Config cfg; + + cfg = bitmap->getConfig(); + switch(cfg) { + case SkBitmap::kARGB_8888_Config: + fmt = MB_IFMT_ARGB32; break; + + case SkBitmap::kA8_Config: + fmt = MB_IFMT_A8; break; + + case SkBitmap::kA1_Config: + fmt = MB_IFMT_A1; break; + + case SkBitmap::kRGB_565_Config: + fmt = MB_IFMT_RGB16_565; break; + + default: + fmt = MB_IFMT_DUMMY; + } + + return fmt; +} + mbe_surface_t * -mbe_image_surface_create(mb_img_fmt_t fmt, int width, int height) {} +mbe_image_surface_create(mb_img_fmt_t fmt, int width, int height) { + SkBitmap *bitmap; + SkBitmap::Config cfg; -mbe_scaled_font_t *mbe_scaled_font_reference(mbe_scaled_font_t *scaled) {} + switch(fmt) { + case MB_IFMT_ARGB32: + cfg = SkBitmap::kARGB_8888_Config; break; + + case MB_IFMT_A8: + cfg = SkBitmap::kA8_Config; break; + + case MB_IFMT_A1: + cfg = SkBitmap::kA1_Config; break; + + case MB_IFMT_RGB16_565: + cfg = SkBitmap::kRGB_565_Config; break; + + case MB_IFMT_RGB24: + default: + return NULL; + } + + bitmap = new SkBitmap(); + if(bitmap == NULL) + return NULL; + + bitmap->setConfig(cfg, width, height); + bitmap->allocPixels(); + + return (mbe_surface_t *)bitmap; +} + +mbe_scaled_font_t *mbe_scaled_font_reference(mbe_scaled_font_t *scaled) { +} + void mbe_scaled_font_destroy(mbe_scaled_font_t *scaled) {} mbe_font_face_t *mbe_font_face_reference(mbe_font_face_t *face) {} mbe_scaled_font_t * @@ -68,75 +484,333 @@ mbe_text_extents_t *extents) {} void mbe_font_face_destroy(mbe_font_face_t *face) {} -void mbe_paint_with_alpha(mbe_t *canvas, co_aix alpha) {} + +void mbe_paint_with_alpha(mbe_t *canvas, co_aix alpha) { + SkPaint *paint = canvas->paint; + SkColorFilter *filter; + SkColor color; + + color = ((uint32_t)(alpha * 255)) << 24; + filter = + SkColorFilter::CreatePorterDuffFilter(color, + SkPorterDuff::kSrcOver_Mode); + mbe_paint(canvas); + +} + void mbe_surface_destroy(mbe_surface_t *surface) {} void mbe_set_source_rgba(mbe_t *canvas, co_aix r, co_aix g, co_aix b, co_aix a) {} void mbe_set_scaled_font(mbe_t *canvas, const mbe_scaled_font_t *scaled) {} void mbe_set_source_rgb(mbe_t *canvas, co_aix r, co_aix g, co_aix b) {} -void mbe_set_line_width(mbe_t *canvas, co_aix width) {} + +void mbe_set_line_width(mbe_t *canvas, co_aix width) { + canvas->states->line_width = width; +} + mbe_font_face_t *mbe_get_font_face(mbe_t *canvas) {} -void mbe_fill_preserve(mbe_t *canvas) {} -void mbe_set_source(mbe_t *canvas, mbe_pattern_t *source) {} -void mbe_reset_clip(mbe_t *canvas) {} -mbe_surface_t *mbe_get_target(mbe_t *canvas) {} -void mbe_close_path(mbe_t *canvas) {} + +void mbe_fill_preserve(mbe_t *canvas) { + mbe_pattern_t *ptn = canvas->states->ptn; + SkPaint *paint = canvas->paint; + SkPath *path = canvas->path; + SkRegion *saved_clip = NULL; + co_aix x, y; + + ASSERT(paint); + ASSERT(ptn); + ASSERT(path); + + if(!canvas->subpath->isEmpty()) + _update_path(canvas); + + _prepare_paint(canvas, SkPaint::kFill_Style); + + canvas->canvas->drawPath(*path, *paint); + + _finish_paint(canvas); +} + +void mbe_set_source(mbe_t *canvas, mbe_pattern_t *source) { + canvas->states->ptn = source; +} + +void mbe_reset_clip(mbe_t *canvas) { + SkRegion clip; + + _canvas_device_region(canvas->canvas, &clip); + canvas->canvas->setClipRegion(clip); +} + +mbe_surface_t *mbe_get_target(mbe_t *canvas) { + return (mbe_surface_t *)&canvas->canvas->getDevice()->accessBitmap(false); +} + +void mbe_close_path(mbe_t *canvas) { + canvas->subpath->close(); +} + void mbe_text_path(mbe_t *canvas, const char *txt) {} + void mbe_rectangle(mbe_t *canvas, co_aix x, co_aix y, - co_aix width, co_aix height) {} -int mbe_in_stroke(mbe_t *canvas, co_aix x, co_aix y) {} -void mbe_new_path(mbe_t *canvas) {} + co_aix width, co_aix height) { + SkPath *subpath = canvas->subpath; + + subpath->addRect(CO_AIX_2_SKSCALAR(x), CO_AIX_2_SKSCALAR(y), + CO_AIX_2_SKSCALAR(x + width), + CO_AIX_2_SKSCALAR(y + height)); +} + +int mbe_in_stroke(mbe_t *canvas, co_aix x, co_aix y) { + return 0; +} + +void mbe_new_path(mbe_t *canvas) { + canvas->subpath->reset(); +} + void mbe_curve_to(mbe_t *canvas, co_aix x1, co_aix y1, co_aix x2, co_aix y2, - co_aix x3, co_aix y3) {} -void mbe_restore(mbe_t *canvas) {} -void mbe_move_to(mbe_t *canvas, co_aix x, co_aix y) {} -void mbe_line_to(mbe_t *canvas, co_aix x, co_aix y) {} -int mbe_in_fill(mbe_t *canvas, co_aix x, co_aix y) {} -void mbe_stroke(mbe_t *canvas) {} + co_aix x3, co_aix y3) { + SkPath *subpath = canvas->subpath; + + subpath->cubicTo(CO_AIX_2_SKSCALAR(x1), CO_AIX_2_SKSCALAR(y1), + CO_AIX_2_SKSCALAR(x2), CO_AIX_2_SKSCALAR(y2), + CO_AIX_2_SKSCALAR(x3), CO_AIX_2_SKSCALAR(y3)); +} + +void mbe_restore(mbe_t *canvas) { + struct _mbe_states_t *states; + + _update_path(canvas); + + states = canvas->states; + ASSERT(states->next); + canvas->states = states->next; + free(states); +} + +void mbe_move_to(mbe_t *canvas, co_aix x, co_aix y) { + canvas->subpath->moveTo(CO_AIX_2_SKSCALAR(x), + CO_AIX_2_SKSCALAR(y)); +} + +void mbe_line_to(mbe_t *canvas, co_aix x, co_aix y) { + canvas->subpath->lineTo(CO_AIX_2_SKSCALAR(x), + CO_AIX_2_SKSCALAR(y)); +} + +int mbe_in_fill(mbe_t *canvas, co_aix x, co_aix y) { + SkRegion region, dev_region; + bool in_fill; + + if(!canvas->subpath->isEmpty()) + _update_path(canvas); + + _canvas_device_region(canvas->canvas, &dev_region); + region.setPath(*canvas->path, dev_region); + + in_fill = region.contains(x, y); + + return in_fill; +} + +void mbe_stroke(mbe_t *canvas) { + SkPath *path = canvas->path; + SkPaint *paint = canvas->paint; + + ASSERT(ptn); + ASSERT(path); + ASSERT(paint); + + if(!canvas->subpath->isEmpty()) + _update_path(canvas); + + _prepare_paint(canvas, SkPaint::kStroke_Style); + + canvas->canvas->drawPath(*path, *paint); + + _finish_paint(canvas); + + path->reset(); +} mbe_t *mbe_create(mbe_surface_t *target) { mbe_t *mbe; + struct _mbe_states_t *states; SkBitmap *bitmap = (SkBitmap *)target; mbe = (mbe_t *)malloc(sizeof(mbe_t)); if(mbe == NULL) return NULL; - mbe->canvas = new SkCanvas(*bitmap); - if(mbe->canvas == NULL) { + mbe->states = (struct _mbe_states_t *) + malloc(sizeof(struct _mbe_states_t)); + states = mbe->states; + if(states == NULL) { free(mbe); return NULL; } - mbe->shader = NULL; - mbe->shader_owned = 0; + mbe->canvas = new SkCanvas(*bitmap); + mbe->path = new SkPath(); + mbe->subpath = new SkPath(); + mbe->saved_region = new SkRegion(); + mbe->paint = new SkPaint(); + states->ptn = NULL; + states->ptn_owned = 0; + states->line_width = 0; + states->next = NULL; + + if(mbe->canvas == NULL || mbe->path == NULL || + mbe->subpath == NULL || mbe->paint == NULL || + mbe->saved_region == NULL) + goto fail; + memcpy(states->matrix, id_matrix, sizeof(co_aix) * 6); + return mbe; + + fail: + if(mbe->canvas) delete mbe->canvas; + if(mbe->path) delete mbe->path; + if(mbe->subpath) delete mbe->subpath; + if(mbe->paint) delete mbe->paint; + if(mbe->saved_region) delete mbe->saved_region; + free(states); + free(mbe); + + return NULL; } void mbe_destroy(mbe_t *canvas) { + struct _mbe_states_t *states; + delete canvas->canvas; - if(canvas->shader && canvas->shader_owned) - delete canvas->shader; + delete canvas->path; + delete canvas->subpath; + delete canvas->paint; + delete canvas->saved_region; + while(canvas->states) { + states = canvas->states; + canvas->states = states->next; + + if(states->ptn && states->ptn_owned) + mbe_pattern_destroy(states->ptn); + free(states); + } free(canvas); } -void mbe_paint(mbe_t *canvas) {} -void mbe_save(mbe_t *canvas) {} -void mbe_fill(mbe_t *canvas) {} -void mbe_clip(mbe_t *canvas) {} +void mbe_paint(mbe_t *canvas) { + SkPaint *paint = canvas->paint; + + ASSERT(paint); + + _prepare_paint(canvas, SkPaint::kFill_Style); + + canvas->canvas->drawPaint(*paint); + + _finish_paint(canvas); +} + +void mbe_save(mbe_t *canvas) { + struct _mbe_states_t *states; + + states = (struct _mbe_states_t *)malloc(sizeof(struct _mbe_states_t)); + ASSERT(states); + + memcpy(states, canvas->states, sizeof(struct _mbe_states_t)); + states->next = canvas->states; + canvas->states = states; +} + +void mbe_fill(mbe_t *canvas) { + mbe_fill_preserve(canvas); + canvas->path->reset(); +} + +void mbe_clip(mbe_t *canvas) { + if(!canvas->subpath->isEmpty()) + _update_path(canvas); + + canvas->canvas->clipPath(*canvas->path, SkRegion::kIntersect_Op); + canvas->path->reset(); +} mbe_font_face_t * mbe_query_font_face(const char *family, int slant, int weight) {} void mbe_free_font_face(mbe_font_face_t *face) {} -void mbe_clear(mbe_t *canvas) {} -void mbe_copy_source(mbe_t *canvas) {} -void mbe_transform(mbe_t *mbe, co_aix matrix[6]) {} +void mbe_clear(mbe_t *canvas) { + SkColor color = 0; + + canvas->canvas->drawColor(color, SkPorterDuff::kClear_Mode); +} + +void mbe_copy_source(mbe_t *canvas) { + SkPaint *paint = canvas->paint; + SkXfermode *mode; + + _prepare_paint(canvas, SkPaint::kFill_Style); + mode = SkPorterDuff::CreateXfermode(SkPorterDuff::kSrc_Mode); + paint->setXfermode(mode); + mode->unref(); + + canvas->canvas->drawPaint(*paint); + + _finish_paint(canvas); +} + +void mbe_transform(mbe_t *mbe, co_aix matrix[6]) { + _update_path(mbe); + + matrix_mul(matrix, mbe->states->matrix, mbe->states->matrix); +} + void mbe_arc(mbe_t *mbe, co_aix x, co_aix y, co_aix radius, - co_aix angle_start, co_aix angle_stop) {} + co_aix angle_start, co_aix angle_stop) { + SkPoint point; + SkPath *subpath = mbe->subpath; + SkRect rect; + SkScalar x0, y0; + SkScalar ang_start, ang_stop; + SkScalar sweep; + SkScalar r; /* radius */ + + subpath->getLastPt(&point); + x0 = point.fX; + y0 = point.fX; + r = CO_AIX_2_SKSCALAR(radius); + ang_start = CO_AIX_2_SKSCALAR(angle_start * 180 / PI); + ang_stop = CO_AIX_2_SKSCALAR(angle_stop * 180 / PI); + + /* Skia can only draw an arc in clockwise directly. We negative + * start and stop point to draw the arc in the mirror along x-axis + * in a sub-path. Then, the sub-path are reflected along x-axis, + * again. We get a right path, and add it to the path of mbe_t. + */ + if(ang_start > ang_stop) { + SkPath tmppath; + SkMatrix matrix; + co_aix reflect[6] = { 1, 0, 0, + 0, -1, 0}; + + rect.set(-r, -r, r, r); + sweep = ang_start - ang_stop; + tmppath.arcTo(rect, -ang_start, sweep, false); + + reflect[2] = x; + reflect[5] = y; + MB_MATRIX_2_SKMATRIX(matrix, reflect); + subpath->addPath(tmppath, matrix); + } else { + rect.set(x0 - r, y0 - r, x0 + r, y0 + r); + sweep = ang_stop - ang_start; + subpath->arcTo(rect, ang_start, sweep, false); + } +} C_END