diff options
Diffstat (limited to 'source/fitz/draw-device.c')
| -rw-r--r-- | source/fitz/draw-device.c | 538 |
1 files changed, 264 insertions, 274 deletions
diff --git a/source/fitz/draw-device.c b/source/fitz/draw-device.c index 8701cd31..18ea53d9 100644 --- a/source/fitz/draw-device.c +++ b/source/fitz/draw-device.c @@ -38,7 +38,6 @@ struct fz_draw_state_s { struct fz_draw_device_s { fz_gel *gel; - fz_context *ctx; int flags; int top; fz_scale_cache *cache_x; @@ -77,11 +76,11 @@ static void dump_spaces(int x, const char *s) #endif #ifdef DUMP_STACK_CHANGES -#define STACK_PUSHED(A) stack_change(dev, ">" ## A) -#define STACK_POPPED(A) stack_change(dev, "<" ## A) -#define STACK_CONVERT(A) stack_change(dev, A) +#define STACK_PUSHED(A) stack_change(ctx, dev, ">" ## A) +#define STACK_POPPED(A) stack_change(ctx, dev, "<" ## A) +#define STACK_CONVERT(A) stack_change(ctx, dev, A) -static void stack_change(fz_draw_device *dev, char *s) +static void stack_change(fz_context *ctx, fz_draw_device *dev, char *s) { int depth = dev->top; int n; @@ -100,19 +99,19 @@ static void stack_change(fz_draw_device *dev, char *s) #endif -static void fz_grow_stack(fz_draw_device *dev) +static void fz_grow_stack(fz_context *ctx, fz_draw_device *dev) { int max = dev->stack_cap * 2; fz_draw_state *stack; if (dev->stack == &dev->init_stack[0]) { - stack = Memento_label(fz_malloc(dev->ctx, sizeof(*stack) * max), "draw device stack"); + stack = Memento_label(fz_malloc_array(ctx, max, sizeof *stack), "draw device stack"); memcpy(stack, dev->stack, sizeof(*stack) * dev->stack_cap); } else { - stack = fz_resize_array(dev->ctx, dev->stack, max, sizeof(*stack)); + stack = fz_resize_array(ctx, dev->stack, max, sizeof(*stack)); } dev->stack = stack; dev->stack_cap = max; @@ -122,22 +121,20 @@ static void fz_grow_stack(fz_draw_device *dev) * already having been initialised to contain the same thing. Simply * change any contents of state[1] that you want to and continue. */ static fz_draw_state * -push_stack(fz_draw_device *dev) +push_stack(fz_context *ctx, fz_draw_device *dev) { fz_draw_state *state; if (dev->top == dev->stack_cap-1) - fz_grow_stack(dev); + fz_grow_stack(ctx, dev); state = &dev->stack[dev->top]; dev->top++; memcpy(&state[1], state, sizeof(*state)); return state; } -static void emergency_pop_stack(fz_draw_device *dev, fz_draw_state *state) +static void emergency_pop_stack(fz_context *ctx, fz_draw_device *dev, fz_draw_state *state) { - fz_context *ctx = dev->ctx; - if (state[1].mask != state[0].mask) fz_drop_pixmap(ctx, state[1].mask); if (state[1].dest != state[0].dest) @@ -150,9 +147,8 @@ static void emergency_pop_stack(fz_draw_device *dev, fz_draw_state *state) } static fz_draw_state * -fz_knockout_begin(fz_draw_device *dev) +fz_knockout_begin(fz_context *ctx, fz_draw_device *dev) { - fz_context *ctx = dev->ctx; fz_irect bbox; fz_pixmap *dest, *shape; fz_draw_state *state = &dev->stack[dev->top]; @@ -161,12 +157,12 @@ fz_knockout_begin(fz_draw_device *dev) if ((state->blendmode & FZ_BLEND_KNOCKOUT) == 0) return state; - state = push_stack(dev); + state = push_stack(ctx, dev); STACK_PUSHED("knockout"); - fz_pixmap_bbox(dev->ctx, state->dest, &bbox); + fz_pixmap_bbox(ctx, state->dest, &bbox); fz_intersect_irect(&bbox, &state->scissor); - dest = fz_new_pixmap_with_bbox(dev->ctx, state->dest->colorspace, &bbox); + dest = fz_new_pixmap_with_bbox(ctx, state->dest->colorspace, &bbox); if (isolated) { @@ -197,8 +193,8 @@ fz_knockout_begin(fz_draw_device *dev) } else { - shape = fz_new_pixmap_with_bbox(dev->ctx, NULL, &bbox); - fz_clear_pixmap(dev->ctx, shape); + shape = fz_new_pixmap_with_bbox(ctx, NULL, &bbox); + fz_clear_pixmap(ctx, shape); } #ifdef DUMP_GROUP_BLENDS dump_spaces(dev->top-1, "Knockout begin\n"); @@ -211,12 +207,11 @@ fz_knockout_begin(fz_draw_device *dev) return &state[1]; } -static void fz_knockout_end(fz_draw_device *dev) +static void fz_knockout_end(fz_context *ctx, fz_draw_device *dev) { fz_draw_state *state; int blendmode; int isolated; - fz_context *ctx = dev->ctx; if (dev->top == 0) { @@ -233,12 +228,12 @@ static void fz_knockout_end(fz_draw_device *dev) #ifdef DUMP_GROUP_BLENDS dump_spaces(dev->top, ""); - fz_dump_blend(dev->ctx, state[1].dest, "Knockout end: blending "); + fz_dump_blend(ctx, state[1].dest, "Knockout end: blending "); if (state[1].shape) - fz_dump_blend(dev->ctx, state[1].shape, "/"); - fz_dump_blend(dev->ctx, state[0].dest, " onto "); + fz_dump_blend(ctx, state[1].shape, "/"); + fz_dump_blend(ctx, state[0].dest, " onto "); if (state[0].shape) - fz_dump_blend(dev->ctx, state[0].shape, "/"); + fz_dump_blend(ctx, state[0].shape, "/"); if (blendmode != 0) printf(" (blend %d)", blendmode); if (isolated != 0) @@ -254,26 +249,28 @@ static void fz_knockout_end(fz_draw_device *dev) * errors can cause the stack to get out of sync, and this saves our * bacon. */ if (state[0].dest != state[1].dest) - fz_drop_pixmap(dev->ctx, state[1].dest); + fz_drop_pixmap(ctx, state[1].dest); if (state[0].shape != state[1].shape) { if (state[0].shape) fz_paint_pixmap(state[0].shape, state[1].shape, 255); - fz_drop_pixmap(dev->ctx, state[1].shape); + fz_drop_pixmap(ctx, state[1].shape); } #ifdef DUMP_GROUP_BLENDS - fz_dump_blend(dev->ctx, state[0].dest, " to get "); + fz_dump_blend(ctx, state[0].dest, " to get "); if (state[0].shape) - fz_dump_blend(dev->ctx, state[0].shape, "/"); + fz_dump_blend(ctx, state[0].shape, "/"); printf("\n"); #endif } static void -fz_draw_fill_path(fz_device *devp, fz_path *path, int even_odd, const fz_matrix *ctm, +fz_draw_fill_path(fz_context *ctx, fz_device *devp, fz_path *path, int even_odd, const fz_matrix *ctm, fz_colorspace *colorspace, float *color, float alpha) { fz_draw_device *dev = devp->user; + fz_gel *gel = dev->gel; + float expansion = fz_matrix_expansion(ctm); float flatness = 0.3f / expansion; unsigned char colorbv[FZ_MAX_COLORS + 1]; @@ -284,48 +281,50 @@ fz_draw_fill_path(fz_device *devp, fz_path *path, int even_odd, const fz_matrix fz_colorspace *model = state->dest->colorspace; if (model == NULL) - model = fz_device_gray(dev->ctx); + model = fz_device_gray(ctx); if (flatness < 0.001f) flatness = 0.001f; - fz_reset_gel(dev->gel, &state->scissor); - fz_flatten_fill_path(dev->gel, path, ctm, flatness); - fz_sort_gel(dev->gel); + fz_reset_gel(ctx, gel, &state->scissor); + fz_flatten_fill_path(ctx, gel, path, ctm, flatness); + fz_sort_gel(ctx, gel); - fz_intersect_irect(fz_bound_gel(dev->gel, &bbox), &state->scissor); + fz_intersect_irect(fz_bound_gel(ctx, gel, &bbox), &state->scissor); if (fz_is_empty_irect(&bbox)) return; if (state->blendmode & FZ_BLEND_KNOCKOUT) - state = fz_knockout_begin(dev); + state = fz_knockout_begin(ctx, dev); - fz_convert_color(dev->ctx, model, colorfv, colorspace, color); + fz_convert_color(ctx, model, colorfv, colorspace, color); for (i = 0; i < model->n; i++) colorbv[i] = colorfv[i] * 255; colorbv[i] = alpha * 255; - fz_scan_convert(dev->gel, even_odd, &bbox, state->dest, colorbv); + fz_scan_convert(ctx, gel, even_odd, &bbox, state->dest, colorbv); if (state->shape) { - fz_reset_gel(dev->gel, &state->scissor); - fz_flatten_fill_path(dev->gel, path, ctm, flatness); - fz_sort_gel(dev->gel); + fz_reset_gel(ctx, gel, &state->scissor); + fz_flatten_fill_path(ctx, gel, path, ctm, flatness); + fz_sort_gel(ctx, gel); colorbv[0] = alpha * 255; - fz_scan_convert(dev->gel, even_odd, &bbox, state->shape, colorbv); + fz_scan_convert(ctx, gel, even_odd, &bbox, state->shape, colorbv); } if (state->blendmode & FZ_BLEND_KNOCKOUT) - fz_knockout_end(dev); + fz_knockout_end(ctx, dev); } static void -fz_draw_stroke_path(fz_device *devp, fz_path *path, fz_stroke_state *stroke, const fz_matrix *ctm, +fz_draw_stroke_path(fz_context *ctx, fz_device *devp, fz_path *path, fz_stroke_state *stroke, const fz_matrix *ctm, fz_colorspace *colorspace, float *color, float alpha) { fz_draw_device *dev = devp->user; + fz_gel *gel = dev->gel; + float expansion = fz_matrix_expansion(ctm); float flatness = 0.3f / expansion; float linewidth = stroke->linewidth; @@ -337,81 +336,82 @@ fz_draw_stroke_path(fz_device *devp, fz_path *path, fz_stroke_state *stroke, con fz_colorspace *model = state->dest->colorspace; if (model == NULL) - model = fz_device_gray(dev->ctx); + model = fz_device_gray(ctx); if (linewidth * expansion < 0.1f) linewidth = 1 / expansion; if (flatness < 0.001f) flatness = 0.001f; - fz_reset_gel(dev->gel, &state->scissor); + fz_reset_gel(ctx, gel, &state->scissor); if (stroke->dash_len > 0) - fz_flatten_dash_path(dev->gel, path, stroke, ctm, flatness, linewidth); + fz_flatten_dash_path(ctx, gel, path, stroke, ctm, flatness, linewidth); else - fz_flatten_stroke_path(dev->gel, path, stroke, ctm, flatness, linewidth); - fz_sort_gel(dev->gel); + fz_flatten_stroke_path(ctx, gel, path, stroke, ctm, flatness, linewidth); + fz_sort_gel(ctx, gel); - fz_intersect_irect(fz_bound_gel(dev->gel, &bbox), &state->scissor); + fz_intersect_irect(fz_bound_gel(ctx, gel, &bbox), &state->scissor); if (fz_is_empty_irect(&bbox)) return; if (state->blendmode & FZ_BLEND_KNOCKOUT) - state = fz_knockout_begin(dev); + state = fz_knockout_begin(ctx, dev); - fz_convert_color(dev->ctx, model, colorfv, colorspace, color); + fz_convert_color(ctx, model, colorfv, colorspace, color); for (i = 0; i < model->n; i++) colorbv[i] = colorfv[i] * 255; colorbv[i] = alpha * 255; - fz_scan_convert(dev->gel, 0, &bbox, state->dest, colorbv); + fz_scan_convert(ctx, gel, 0, &bbox, state->dest, colorbv); if (state->shape) { - fz_reset_gel(dev->gel, &state->scissor); + fz_reset_gel(ctx, gel, &state->scissor); if (stroke->dash_len > 0) - fz_flatten_dash_path(dev->gel, path, stroke, ctm, flatness, linewidth); + fz_flatten_dash_path(ctx, gel, path, stroke, ctm, flatness, linewidth); else - fz_flatten_stroke_path(dev->gel, path, stroke, ctm, flatness, linewidth); - fz_sort_gel(dev->gel); + fz_flatten_stroke_path(ctx, gel, path, stroke, ctm, flatness, linewidth); + fz_sort_gel(ctx, gel); colorbv[0] = 255; - fz_scan_convert(dev->gel, 0, &bbox, state->shape, colorbv); + fz_scan_convert(ctx, gel, 0, &bbox, state->shape, colorbv); } if (state->blendmode & FZ_BLEND_KNOCKOUT) - fz_knockout_end(dev); + fz_knockout_end(ctx, dev); } static void -fz_draw_clip_path(fz_device *devp, fz_path *path, const fz_rect *rect, int even_odd, const fz_matrix *ctm) +fz_draw_clip_path(fz_context *ctx, fz_device *devp, fz_path *path, const fz_rect *rect, int even_odd, const fz_matrix *ctm) { fz_draw_device *dev = devp->user; + fz_gel *gel = dev->gel; + float expansion = fz_matrix_expansion(ctm); float flatness = 0.3f / expansion; fz_irect bbox; fz_draw_state *state = &dev->stack[dev->top]; fz_colorspace *model; - fz_context *ctx = dev->ctx; if (flatness < 0.001f) flatness = 0.001f; - fz_reset_gel(dev->gel, &state->scissor); - fz_flatten_fill_path(dev->gel, path, ctm, flatness); - fz_sort_gel(dev->gel); + fz_reset_gel(ctx, gel, &state->scissor); + fz_flatten_fill_path(ctx, gel, path, ctm, flatness); + fz_sort_gel(ctx, gel); - state = push_stack(dev); + state = push_stack(ctx, dev); STACK_PUSHED("clip path"); model = state->dest->colorspace; - fz_intersect_irect(fz_bound_gel(dev->gel, &bbox), &state->scissor); + fz_intersect_irect(fz_bound_gel(ctx, gel, &bbox), &state->scissor); if (rect) { fz_irect bbox2; fz_intersect_irect(&bbox, fz_irect_from_rect(&bbox2, rect)); } - if (fz_is_empty_irect(&bbox) || fz_is_rect_gel(dev->gel)) + if (fz_is_empty_irect(&bbox) || fz_is_rect_gel(ctx, gel)) { state[1].scissor = bbox; state[1].mask = NULL; @@ -423,17 +423,17 @@ fz_draw_clip_path(fz_device *devp, fz_path *path, const fz_rect *rect, int even_ fz_try(ctx) { - state[1].mask = fz_new_pixmap_with_bbox(dev->ctx, NULL, &bbox); - fz_clear_pixmap(dev->ctx, state[1].mask); - state[1].dest = fz_new_pixmap_with_bbox(dev->ctx, model, &bbox); - fz_clear_pixmap(dev->ctx, state[1].dest); + state[1].mask = fz_new_pixmap_with_bbox(ctx, NULL, &bbox); + fz_clear_pixmap(ctx, state[1].mask); + state[1].dest = fz_new_pixmap_with_bbox(ctx, model, &bbox); + fz_clear_pixmap(ctx, state[1].dest); if (state[1].shape) { - state[1].shape = fz_new_pixmap_with_bbox(dev->ctx, NULL, &bbox); - fz_clear_pixmap(dev->ctx, state[1].shape); + state[1].shape = fz_new_pixmap_with_bbox(ctx, NULL, &bbox); + fz_clear_pixmap(ctx, state[1].shape); } - fz_scan_convert(dev->gel, even_odd, &bbox, state[1].mask, NULL); + fz_scan_convert(ctx, gel, even_odd, &bbox, state[1].mask, NULL); state[1].blendmode |= FZ_BLEND_ISOLATED; state[1].scissor = bbox; @@ -443,39 +443,40 @@ fz_draw_clip_path(fz_device *devp, fz_path *path, const fz_rect *rect, int even_ } fz_catch(ctx) { - emergency_pop_stack(dev, state); + emergency_pop_stack(ctx, dev, state); } } static void -fz_draw_clip_stroke_path(fz_device *devp, fz_path *path, const fz_rect *rect, fz_stroke_state *stroke, const fz_matrix *ctm) +fz_draw_clip_stroke_path(fz_context *ctx, fz_device *devp, fz_path *path, const fz_rect *rect, fz_stroke_state *stroke, const fz_matrix *ctm) { fz_draw_device *dev = devp->user; + fz_gel *gel = dev->gel; + float expansion = fz_matrix_expansion(ctm); float flatness = 0.3f / expansion; float linewidth = stroke->linewidth; fz_irect bbox; fz_draw_state *state = &dev->stack[dev->top]; fz_colorspace *model; - fz_context *ctx = dev->ctx; if (linewidth * expansion < 0.1f) linewidth = 1 / expansion; if (flatness < 0.001f) flatness = 0.001f; - fz_reset_gel(dev->gel, &state->scissor); + fz_reset_gel(ctx, gel, &state->scissor); if (stroke->dash_len > 0) - fz_flatten_dash_path(dev->gel, path, stroke, ctm, flatness, linewidth); + fz_flatten_dash_path(ctx, gel, path, stroke, ctm, flatness, linewidth); else - fz_flatten_stroke_path(dev->gel, path, stroke, ctm, flatness, linewidth); - fz_sort_gel(dev->gel); + fz_flatten_stroke_path(ctx, gel, path, stroke, ctm, flatness, linewidth); + fz_sort_gel(ctx, gel); - state = push_stack(dev); + state = push_stack(ctx, dev); STACK_PUSHED("clip stroke"); model = state->dest->colorspace; - fz_intersect_irect(fz_bound_gel(dev->gel, &bbox), &state->scissor); + fz_intersect_irect(fz_bound_gel(ctx, gel, &bbox), &state->scissor); if (rect) { fz_irect bbox2; @@ -484,18 +485,18 @@ fz_draw_clip_stroke_path(fz_device *devp, fz_path *path, const fz_rect *rect, fz fz_try(ctx) { - state[1].mask = fz_new_pixmap_with_bbox(dev->ctx, NULL, &bbox); - fz_clear_pixmap(dev->ctx, state[1].mask); - state[1].dest = fz_new_pixmap_with_bbox(dev->ctx, model, &bbox); - fz_clear_pixmap(dev->ctx, state[1].dest); + state[1].mask = fz_new_pixmap_with_bbox(ctx, NULL, &bbox); + fz_clear_pixmap(ctx, state[1].mask); + state[1].dest = fz_new_pixmap_with_bbox(ctx, model, &bbox); + fz_clear_pixmap(ctx, state[1].dest); if (state->shape) { - state[1].shape = fz_new_pixmap_with_bbox(dev->ctx, NULL, &bbox); - fz_clear_pixmap(dev->ctx, state[1].shape); + state[1].shape = fz_new_pixmap_with_bbox(ctx, NULL, &bbox); + fz_clear_pixmap(ctx, state[1].shape); } if (!fz_is_empty_irect(&bbox)) - fz_scan_convert(dev->gel, 0, &bbox, state[1].mask, NULL); + fz_scan_convert(ctx, gel, 0, &bbox, state[1].mask, NULL); state[1].blendmode |= FZ_BLEND_ISOLATED; state[1].scissor = bbox; @@ -505,7 +506,7 @@ fz_draw_clip_stroke_path(fz_device *devp, fz_path *path, const fz_rect *rect, fz } fz_catch(ctx) { - emergency_pop_stack(dev, state); + emergency_pop_stack(ctx, dev, state); } } @@ -558,10 +559,11 @@ draw_glyph(unsigned char *colorbv, fz_pixmap *dst, fz_glyph *glyph, } static void -fz_draw_fill_text(fz_device *devp, fz_text *text, const fz_matrix *ctm, +fz_draw_fill_text(fz_context *ctx, fz_device *devp, fz_text *text, const fz_matrix *ctm, fz_colorspace *colorspace, float *color, float alpha) { fz_draw_device *dev = devp->user; + unsigned char colorbv[FZ_MAX_COLORS + 1]; unsigned char shapebv; float colorfv[FZ_MAX_COLORS]; @@ -572,9 +574,9 @@ fz_draw_fill_text(fz_device *devp, fz_text *text, const fz_matrix *ctm, fz_colorspace *model = state->dest->colorspace; if (state->blendmode & FZ_BLEND_KNOCKOUT) - state = fz_knockout_begin(dev); + state = fz_knockout_begin(ctx, dev); - fz_convert_color(dev->ctx, model, colorfv, colorspace, color); + fz_convert_color(ctx, model, colorfv, colorspace, color); for (i = 0; i < model->n; i++) colorbv[i] = colorfv[i] * 255; colorbv[i] = alpha * 255; @@ -592,7 +594,7 @@ fz_draw_fill_text(fz_device *devp, fz_text *text, const fz_matrix *ctm, tm.f = text->items[i].y; fz_concat(&trm, &tm, ctm); - glyph = fz_render_glyph(dev->ctx, text->font, gid, &trm, model, &state->scissor); + glyph = fz_render_glyph(ctx, text->font, gid, &trm, model, &state->scissor); if (glyph) { fz_pixmap *pixmap = glyph->pixmap; @@ -611,33 +613,34 @@ fz_draw_fill_text(fz_device *devp, fz_text *text, const fz_matrix *ctm, mat.e = x + pixmap->x; mat.f = y + pixmap->y; fz_paint_image(state->dest, &state->scissor, state->shape, pixmap, &mat, alpha * 255, !(devp->hints & FZ_DONT_INTERPOLATE_IMAGES)); } - fz_drop_glyph(dev->ctx, glyph); + fz_drop_glyph(ctx, glyph); } else { - fz_path *path = fz_outline_glyph(dev->ctx, text->font, gid, &tm); + fz_path *path = fz_outline_glyph(ctx, text->font, gid, &tm); if (path) { - fz_draw_fill_path(devp, path, 0, ctm, colorspace, color, alpha); - fz_drop_path(dev->ctx, path); + fz_draw_fill_path(ctx, devp, path, 0, ctm, colorspace, color, alpha); + fz_drop_path(ctx, path); } else { - fz_warn(dev->ctx, "cannot render glyph"); + fz_warn(ctx, "cannot render glyph"); } } } if (state->blendmode & FZ_BLEND_KNOCKOUT) - fz_knockout_end(dev); + fz_knockout_end(ctx, dev); } static void -fz_draw_stroke_text(fz_device *devp, fz_text *text, fz_stroke_state *stroke, +fz_draw_stroke_text(fz_context *ctx, fz_device *devp, fz_text *text, fz_stroke_state *stroke, const fz_matrix *ctm, fz_colorspace *colorspace, float *color, float alpha) { fz_draw_device *dev = devp->user; + unsigned char colorbv[FZ_MAX_COLORS + 1]; float colorfv[FZ_MAX_COLORS]; fz_matrix tm, trm; @@ -647,9 +650,9 @@ fz_draw_stroke_text(fz_device *devp, fz_text *text, fz_stroke_state *stroke, fz_colorspace *model = state->dest->colorspace; if (state->blendmode & FZ_BLEND_KNOCKOUT) - state = fz_knockout_begin(dev); + state = fz_knockout_begin(ctx, dev); - fz_convert_color(dev->ctx, model, colorfv, colorspace, color); + fz_convert_color(ctx, model, colorfv, colorspace, color); for (i = 0; i < model->n; i++) colorbv[i] = colorfv[i] * 255; colorbv[i] = alpha * 255; @@ -666,7 +669,7 @@ fz_draw_stroke_text(fz_device *devp, fz_text *text, fz_stroke_state *stroke, tm.f = text->items[i].y; fz_concat(&trm, &tm, ctm); - glyph = fz_render_stroked_glyph(dev->ctx, text->font, gid, &trm, ctm, stroke, &state->scissor); + glyph = fz_render_stroked_glyph(ctx, text->font, gid, &trm, ctm, stroke, &state->scissor); if (glyph) { int x = (int)trm.e; @@ -674,32 +677,31 @@ fz_draw_stroke_text(fz_device *devp, fz_text *text, fz_stroke_state *stroke, draw_glyph(colorbv, state->dest, glyph, x, y, &state->scissor); if (state->shape) draw_glyph(colorbv, state->shape, glyph, x, y, &state->scissor); - fz_drop_glyph(dev->ctx, glyph); + fz_drop_glyph(ctx, glyph); } else { - fz_path *path = fz_outline_glyph(dev->ctx, text->font, gid, &tm); + fz_path *path = fz_outline_glyph(ctx, text->font, gid, &tm); if (path) { - fz_draw_stroke_path(devp, path, stroke, ctm, colorspace, color, alpha); - fz_drop_path(dev->ctx, path); + fz_draw_stroke_path(ctx, devp, path, stroke, ctm, colorspace, color, alpha); + fz_drop_path(ctx, path); } else { - fz_warn(dev->ctx, "cannot render glyph"); + fz_warn(ctx, "cannot render glyph"); } } } if (state->blendmode & FZ_BLEND_KNOCKOUT) - fz_knockout_end(dev); + fz_knockout_end(ctx, dev); } static void -fz_draw_clip_text(fz_device *devp, fz_text *text, const fz_matrix *ctm, int accumulate) +fz_draw_clip_text(fz_context *ctx, fz_device *devp, fz_text *text, const fz_matrix *ctm, int accumulate) { fz_draw_device *dev = devp->user; - fz_context *ctx = dev->ctx; fz_irect bbox; fz_pixmap *mask, *dest, *shape; fz_matrix tm, trm; @@ -712,7 +714,7 @@ fz_draw_clip_text(fz_device *devp, fz_text *text, const fz_matrix *ctm, int accu /* If accumulate == 1 then this text object is the first (or only) in a sequence */ /* If accumulate == 2 then this text object is a continuation */ - state = push_stack(dev); + state = push_stack(ctx, dev); STACK_PUSHED("clip text"); model = state->dest->colorspace; @@ -721,7 +723,7 @@ fz_draw_clip_text(fz_device *devp, fz_text *text, const fz_matrix *ctm, int accu /* make the mask the exact size needed */ fz_rect rect; - fz_irect_from_rect(&bbox, fz_bound_text(dev->ctx, text, NULL, ctm, &rect)); + fz_irect_from_rect(&bbox, fz_bound_text(ctx, text, NULL, ctm, &rect)); fz_intersect_irect(&bbox, &state->scissor); } else @@ -734,14 +736,14 @@ fz_draw_clip_text(fz_device *devp, fz_text *text, const fz_matrix *ctm, int accu { if (accumulate == 0 || accumulate == 1) { - mask = fz_new_pixmap_with_bbox(dev->ctx, NULL, &bbox); - fz_clear_pixmap(dev->ctx, mask); - dest = fz_new_pixmap_with_bbox(dev->ctx, model, &bbox); - fz_clear_pixmap(dev->ctx, dest); + mask = fz_new_pixmap_with_bbox(ctx, NULL, &bbox); + fz_clear_pixmap(ctx, mask); + dest = fz_new_pixmap_with_bbox(ctx, model, &bbox); + fz_clear_pixmap(ctx, dest); if (state->shape) { - shape = fz_new_pixmap_with_bbox(dev->ctx, NULL, &bbox); - fz_clear_pixmap(dev->ctx, shape); + shape = fz_new_pixmap_with_bbox(ctx, NULL, &bbox); + fz_clear_pixmap(ctx, shape); } else shape = NULL; @@ -776,7 +778,7 @@ fz_draw_clip_text(fz_device *devp, fz_text *text, const fz_matrix *ctm, int accu tm.f = text->items[i].y; fz_concat(&trm, &tm, ctm); - glyph = fz_render_glyph(dev->ctx, text->font, gid, &trm, model, &state->scissor); + glyph = fz_render_glyph(ctx, text->font, gid, &trm, model, &state->scissor); if (glyph) { int x = (int)trm.e; @@ -784,11 +786,11 @@ fz_draw_clip_text(fz_device *devp, fz_text *text, const fz_matrix *ctm, int accu draw_glyph(NULL, mask, glyph, x, y, &bbox); if (state[1].shape) draw_glyph(NULL, state[1].shape, glyph, x, y, &bbox); - fz_drop_glyph(dev->ctx, glyph); + fz_drop_glyph(ctx, glyph); } else { - fz_path *path = fz_outline_glyph(dev->ctx, text->font, gid, &tm); + fz_path *path = fz_outline_glyph(ctx, text->font, gid, &tm); if (path) { fz_pixmap *old_dest; @@ -799,13 +801,13 @@ fz_draw_clip_text(fz_device *devp, fz_text *text, const fz_matrix *ctm, int accu state[1].mask = NULL; fz_try(ctx) { - fz_draw_fill_path(devp, path, 0, ctm, fz_device_gray(ctx), &white, 1); + fz_draw_fill_path(ctx, devp, path, 0, ctm, fz_device_gray(ctx), &white, 1); } fz_always(ctx) { state[1].mask = state[1].dest; state[1].dest = old_dest; - fz_drop_path(dev->ctx, path); + fz_drop_path(ctx, path); } fz_catch(ctx) { @@ -814,7 +816,7 @@ fz_draw_clip_text(fz_device *devp, fz_text *text, const fz_matrix *ctm, int accu } else { - fz_warn(dev->ctx, "cannot render glyph for clipping"); + fz_warn(ctx, "cannot render glyph for clipping"); } } } @@ -823,40 +825,39 @@ fz_draw_clip_text(fz_device *devp, fz_text *text, const fz_matrix *ctm, int accu fz_catch(ctx) { if (accumulate == 0 || accumulate == 1) - emergency_pop_stack(dev, state); + emergency_pop_stack(ctx, dev, state); fz_rethrow(ctx); } } static void -fz_draw_clip_stroke_text(fz_device *devp, fz_text *text, fz_stroke_state *stroke, const fz_matrix *ctm) +fz_draw_clip_stroke_text(fz_context *ctx, fz_device *devp, fz_text *text, fz_stroke_state *stroke, const fz_matrix *ctm) { fz_draw_device *dev = devp->user; - fz_context *ctx = dev->ctx; fz_irect bbox; fz_pixmap *mask, *dest, *shape; fz_matrix tm, trm; fz_glyph *glyph; int i, gid; - fz_draw_state *state = push_stack(dev); + fz_draw_state *state = push_stack(ctx, dev); fz_colorspace *model = state->dest->colorspace; fz_rect rect; STACK_PUSHED("clip stroke text"); /* make the mask the exact size needed */ - fz_irect_from_rect(&bbox, fz_bound_text(dev->ctx, text, stroke, ctm, &rect)); + fz_irect_from_rect(&bbox, fz_bound_text(ctx, text, stroke, ctm, &rect)); fz_intersect_irect(&bbox, &state->scissor); fz_try(ctx) { - state[1].mask = mask = fz_new_pixmap_with_bbox(dev->ctx, NULL, &bbox); - fz_clear_pixmap(dev->ctx, mask); - state[1].dest = dest = fz_new_pixmap_with_bbox(dev->ctx, model, &bbox); - fz_clear_pixmap(dev->ctx, dest); + state[1].mask = mask = fz_new_pixmap_with_bbox(ctx, NULL, &bbox); + fz_clear_pixmap(ctx, mask); + state[1].dest = dest = fz_new_pixmap_with_bbox(ctx, model, &bbox); + fz_clear_pixmap(ctx, dest); if (state->shape) { - state[1].shape = shape = fz_new_pixmap_with_bbox(dev->ctx, NULL, &bbox); - fz_clear_pixmap(dev->ctx, shape); + state[1].shape = shape = fz_new_pixmap_with_bbox(ctx, NULL, &bbox); + fz_clear_pixmap(ctx, shape); } else shape = state->shape; @@ -881,7 +882,7 @@ fz_draw_clip_stroke_text(fz_device *devp, fz_text *text, fz_stroke_state *stroke tm.f = text->items[i].y; fz_concat(&trm, &tm, ctm); - glyph = fz_render_stroked_glyph(dev->ctx, text->font, gid, &trm, ctm, stroke, &state->scissor); + glyph = fz_render_stroked_glyph(ctx, text->font, gid, &trm, ctm, stroke, &state->scissor); if (glyph) { int x = (int)trm.e; @@ -889,11 +890,11 @@ fz_draw_clip_stroke_text(fz_device *devp, fz_text *text, fz_stroke_state *stroke draw_glyph(NULL, mask, glyph, x, y, &bbox); if (shape) draw_glyph(NULL, shape, glyph, x, y, &bbox); - fz_drop_glyph(dev->ctx, glyph); + fz_drop_glyph(ctx, glyph); } else { - fz_path *path = fz_outline_glyph(dev->ctx, text->font, gid, &tm); + fz_path *path = fz_outline_glyph(ctx, text->font, gid, &tm); if (path) { fz_pixmap *old_dest; @@ -905,13 +906,13 @@ fz_draw_clip_stroke_text(fz_device *devp, fz_text *text, fz_stroke_state *stroke state[0].mask = NULL; fz_try(ctx) { - fz_draw_stroke_path(devp, path, stroke, ctm, fz_device_gray(ctx), &white, 1); + fz_draw_stroke_path(ctx, devp, path, stroke, ctm, fz_device_gray(ctx), &white, 1); } fz_always(ctx) { state[0].mask = state[0].dest; state[0].dest = old_dest; - fz_drop_path(dev->ctx, path); + fz_drop_path(ctx, path); } fz_catch(ctx) { @@ -920,7 +921,7 @@ fz_draw_clip_stroke_text(fz_device *devp, fz_text *text, fz_stroke_state *stroke } else { - fz_warn(dev->ctx, "cannot render glyph for stroked clipping"); + fz_warn(ctx, "cannot render glyph for stroked clipping"); } } } @@ -928,17 +929,17 @@ fz_draw_clip_stroke_text(fz_device *devp, fz_text *text, fz_stroke_state *stroke } fz_catch(ctx) { - emergency_pop_stack(dev, state); + emergency_pop_stack(ctx, dev, state); } } static void -fz_draw_ignore_text(fz_device *dev, fz_text *text, const fz_matrix *ctm) +fz_draw_ignore_text(fz_context *ctx, fz_device *dev, fz_text *text, const fz_matrix *ctm) { } static void -fz_draw_fill_shade(fz_device *devp, fz_shade *shade, const fz_matrix *ctm, float alpha) +fz_draw_fill_shade(fz_context *ctx, fz_device *devp, fz_shade *shade, const fz_matrix *ctm, float alpha) { fz_draw_device *dev = devp->user; fz_rect bounds; @@ -949,7 +950,7 @@ fz_draw_fill_shade(fz_device *devp, fz_shade *shade, const fz_matrix *ctm, float fz_draw_state *state = &dev->stack[dev->top]; fz_colorspace *model = state->dest->colorspace; - fz_bound_shade(dev->ctx, shade, ctm, &bounds); + fz_bound_shade(ctx, shade, ctm, &bounds); scissor = state->scissor; fz_intersect_irect(fz_irect_from_rect(&bbox, &bounds), &scissor); @@ -958,24 +959,24 @@ fz_draw_fill_shade(fz_device *devp, fz_shade *shade, const fz_matrix *ctm, float if (!model) { - fz_warn(dev->ctx, "cannot render shading directly to an alpha mask"); + fz_warn(ctx, "cannot render shading directly to an alpha mask"); return; } if (state->blendmode & FZ_BLEND_KNOCKOUT) - state = fz_knockout_begin(dev); + state = fz_knockout_begin(ctx, dev); dest = state->dest; shape = state->shape; if (alpha < 1) { - dest = fz_new_pixmap_with_bbox(dev->ctx, state->dest->colorspace, &bbox); - fz_clear_pixmap(dev->ctx, dest); + dest = fz_new_pixmap_with_bbox(ctx, state->dest->colorspace, &bbox); + fz_clear_pixmap(ctx, dest); if (shape) { - shape = fz_new_pixmap_with_bbox(dev->ctx, NULL, &bbox); - fz_clear_pixmap(dev->ctx, shape); + shape = fz_new_pixmap_with_bbox(ctx, NULL, &bbox); + fz_clear_pixmap(ctx, shape); } } @@ -983,7 +984,7 @@ fz_draw_fill_shade(fz_device *devp, fz_shade *shade, const fz_matrix *ctm, float { unsigned char *s; int x, y, n, i; - fz_convert_color(dev->ctx, model, colorfv, shade->colorspace, shade->background); + fz_convert_color(ctx, model, colorfv, shade->colorspace, shade->background); for (i = 0; i < model->n; i++) colorbv[i] = colorfv[i] * 255; colorbv[i] = 255; @@ -1011,30 +1012,29 @@ fz_draw_fill_shade(fz_device *devp, fz_shade *shade, const fz_matrix *ctm, float } } - fz_paint_shade(dev->ctx, shade, ctm, dest, &bbox); + fz_paint_shade(ctx, shade, ctm, dest, &bbox); if (shape) - fz_clear_pixmap_rect_with_value(dev->ctx, shape, 255, &bbox); + fz_clear_pixmap_rect_with_value(ctx, shape, 255, &bbox); if (alpha < 1) { fz_paint_pixmap(state->dest, dest, alpha * 255); - fz_drop_pixmap(dev->ctx, dest); + fz_drop_pixmap(ctx, dest); if (shape) { fz_paint_pixmap(state->shape, shape, alpha * 255); - fz_drop_pixmap(dev->ctx, shape); + fz_drop_pixmap(ctx, shape); } } if (state->blendmode & FZ_BLEND_KNOCKOUT) - fz_knockout_end(dev); + fz_knockout_end(ctx, dev); } static fz_pixmap * -fz_transform_pixmap(fz_draw_device *dev, fz_pixmap *image, fz_matrix *ctm, int x, int y, int dx, int dy, int gridfit, const fz_irect *clip) +fz_transform_pixmap(fz_context *ctx, fz_draw_device *dev, fz_pixmap *image, fz_matrix *ctm, int x, int y, int dx, int dy, int gridfit, const fz_irect *clip) { fz_pixmap *scaled; - fz_context *ctx = dev->ctx; if (ctm->a != 0 && ctm->b == 0 && ctm->c == 0 && ctm->d != 0) { @@ -1087,7 +1087,7 @@ fz_transform_pixmap(fz_draw_device *dev, fz_pixmap *image, fz_matrix *ctm, int x } static void -fz_draw_fill_image(fz_device *devp, fz_image *image, const fz_matrix *ctm, float alpha) +fz_draw_fill_image(fz_context *ctx, fz_device *devp, fz_image *image, const fz_matrix *ctm, float alpha) { fz_draw_device *dev = devp->user; fz_pixmap *converted = NULL; @@ -1096,7 +1096,6 @@ fz_draw_fill_image(fz_device *devp, fz_image *image, const fz_matrix *ctm, float fz_pixmap *orig_pixmap; int after; int dx, dy; - fz_context *ctx = dev->ctx; fz_draw_state *state = &dev->stack[dev->top]; fz_colorspace *model = state->dest->colorspace; fz_irect clip; @@ -1108,7 +1107,7 @@ fz_draw_fill_image(fz_device *devp, fz_image *image, const fz_matrix *ctm, float if (!model) { - fz_warn(dev->ctx, "cannot render image directly to an alpha mask"); + fz_warn(ctx, "cannot render image directly to an alpha mask"); return; } @@ -1128,7 +1127,7 @@ fz_draw_fill_image(fz_device *devp, fz_image *image, const fz_matrix *ctm, float fz_try(ctx) { if (state->blendmode & FZ_BLEND_KNOCKOUT) - state = fz_knockout_begin(dev); + state = fz_knockout_begin(ctx, dev); after = 0; if (pixmap->colorspace == fz_device_gray(ctx)) @@ -1146,7 +1145,7 @@ fz_draw_fill_image(fz_device *devp, fz_image *image, const fz_matrix *ctm, float if (dx < pixmap->w && dy < pixmap->h && !(devp->hints & FZ_DONT_INTERPOLATE_IMAGES)) { int gridfit = alpha == 1.0f && !(dev->flags & FZ_DRAWDEV_FLAGS_TYPE3); - scaled = fz_transform_pixmap(dev, pixmap, &local_ctm, state->dest->x, state->dest->y, dx, dy, gridfit, &clip); + scaled = fz_transform_pixmap(ctx, dev, pixmap, &local_ctm, state->dest->x, state->dest->y, dx, dy, gridfit, &clip); if (!scaled) { if (dx < 1) @@ -1179,7 +1178,7 @@ fz_draw_fill_image(fz_device *devp, fz_image *image, const fz_matrix *ctm, float fz_paint_image(state->dest, &state->scissor, state->shape, pixmap, &local_ctm, alpha * 255, !(devp->hints & FZ_DONT_INTERPOLATE_IMAGES)); if (state->blendmode & FZ_BLEND_KNOCKOUT) - fz_knockout_end(dev); + fz_knockout_end(ctx, dev); } fz_always(ctx) { @@ -1194,7 +1193,7 @@ fz_draw_fill_image(fz_device *devp, fz_image *image, const fz_matrix *ctm, float } static void -fz_draw_fill_image_mask(fz_device *devp, fz_image *image, const fz_matrix *ctm, +fz_draw_fill_image_mask(fz_context *ctx, fz_device *devp, fz_image *image, const fz_matrix *ctm, fz_colorspace *colorspace, float *color, float alpha) { fz_draw_device *dev = devp->user; @@ -1205,7 +1204,6 @@ fz_draw_fill_image_mask(fz_device *devp, fz_image *image, const fz_matrix *ctm, fz_pixmap *orig_pixmap; int dx, dy; int i; - fz_context *ctx = dev->ctx; fz_draw_state *state = &dev->stack[dev->top]; fz_colorspace *model = state->dest->colorspace; fz_irect clip; @@ -1225,25 +1223,25 @@ fz_draw_fill_image_mask(fz_device *devp, fz_image *image, const fz_matrix *ctm, fz_try(ctx) { if (state->blendmode & FZ_BLEND_KNOCKOUT) - state = fz_knockout_begin(dev); + state = fz_knockout_begin(ctx, dev); if (dx < pixmap->w && dy < pixmap->h) { int gridfit = alpha == 1.0f && !(dev->flags & FZ_DRAWDEV_FLAGS_TYPE3); - scaled = fz_transform_pixmap(dev, pixmap, &local_ctm, state->dest->x, state->dest->y, dx, dy, gridfit, &clip); + scaled = fz_transform_pixmap(ctx, dev, pixmap, &local_ctm, state->dest->x, state->dest->y, dx, dy, gridfit, &clip); if (!scaled) { if (dx < 1) dx = 1; if (dy < 1) dy = 1; - scaled = fz_scale_pixmap_cached(dev->ctx, pixmap, pixmap->x, pixmap->y, dx, dy, NULL, dev->cache_x, dev->cache_y); + scaled = fz_scale_pixmap_cached(ctx, pixmap, pixmap->x, pixmap->y, dx, dy, NULL, dev->cache_x, dev->cache_y); } if (scaled) pixmap = scaled; } - fz_convert_color(dev->ctx, model, colorfv, colorspace, color); + fz_convert_color(ctx, model, colorfv, colorspace, color); for (i = 0; i < model->n; i++) colorbv[i] = colorfv[i] * 255; colorbv[i] = alpha * 255; @@ -1251,14 +1249,14 @@ fz_draw_fill_image_mask(fz_device *devp, fz_image *image, const fz_matrix *ctm, fz_paint_image_with_color(state->dest, &state->scissor, state->shape, pixmap, &local_ctm, colorbv, !(devp->hints & FZ_DONT_INTERPOLATE_IMAGES)); if (scaled) - fz_drop_pixmap(dev->ctx, scaled); + fz_drop_pixmap(ctx, scaled); if (state->blendmode & FZ_BLEND_KNOCKOUT) - fz_knockout_end(dev); + fz_knockout_end(ctx, dev); } fz_always(ctx) { - fz_drop_pixmap(dev->ctx, orig_pixmap); + fz_drop_pixmap(ctx, orig_pixmap); } fz_catch(ctx) { @@ -1267,10 +1265,9 @@ fz_draw_fill_image_mask(fz_device *devp, fz_image *image, const fz_matrix *ctm, } static void -fz_draw_clip_image_mask(fz_device *devp, fz_image *image, const fz_rect *rect, const fz_matrix *ctm) +fz_draw_clip_image_mask(fz_context *ctx, fz_device *devp, fz_image *image, const fz_rect *rect, const fz_matrix *ctm) { fz_draw_device *dev = devp->user; - fz_context *ctx = dev->ctx; fz_irect bbox; fz_pixmap *mask = NULL; fz_pixmap *dest = NULL; @@ -1279,7 +1276,7 @@ fz_draw_clip_image_mask(fz_device *devp, fz_image *image, const fz_rect *rect, c fz_pixmap *pixmap = NULL; fz_pixmap *orig_pixmap = NULL; int dx, dy; - fz_draw_state *state = push_stack(dev); + fz_draw_state *state = push_stack(ctx, dev); fz_colorspace *model = state->dest->colorspace; fz_irect clip; fz_matrix local_ctm = *ctm; @@ -1326,15 +1323,15 @@ fz_draw_clip_image_mask(fz_device *devp, fz_image *image, const fz_rect *rect, c pixmap = fz_new_pixmap_from_image(ctx, image, dx, dy); orig_pixmap = pixmap; - state[1].mask = mask = fz_new_pixmap_with_bbox(dev->ctx, NULL, &bbox); - fz_clear_pixmap(dev->ctx, mask); + state[1].mask = mask = fz_new_pixmap_with_bbox(ctx, NULL, &bbox); + fz_clear_pixmap(ctx, mask); - state[1].dest = dest = fz_new_pixmap_with_bbox(dev->ctx, model, &bbox); - fz_clear_pixmap(dev->ctx, dest); + state[1].dest = dest = fz_new_pixmap_with_bbox(ctx, model, &bbox); + fz_clear_pixmap(ctx, dest); if (state->shape) { - state[1].shape = shape = fz_new_pixmap_with_bbox(dev->ctx, NULL, &bbox); - fz_clear_pixmap(dev->ctx, shape); + state[1].shape = shape = fz_new_pixmap_with_bbox(ctx, NULL, &bbox); + fz_clear_pixmap(ctx, shape); } state[1].blendmode |= FZ_BLEND_ISOLATED; @@ -1343,14 +1340,14 @@ fz_draw_clip_image_mask(fz_device *devp, fz_image *image, const fz_rect *rect, c if (dx < pixmap->w && dy < pixmap->h) { int gridfit = !(dev->flags & FZ_DRAWDEV_FLAGS_TYPE3); - scaled = fz_transform_pixmap(dev, pixmap, &local_ctm, state->dest->x, state->dest->y, dx, dy, gridfit, &clip); + scaled = fz_transform_pixmap(ctx, dev, pixmap, &local_ctm, state->dest->x, state->dest->y, dx, dy, gridfit, &clip); if (!scaled) { if (dx < 1) dx = 1; if (dy < 1) dy = 1; - scaled = fz_scale_pixmap_cached(dev->ctx, pixmap, pixmap->x, pixmap->y, dx, dy, NULL, dev->cache_x, dev->cache_y); + scaled = fz_scale_pixmap_cached(ctx, pixmap, pixmap->x, pixmap->y, dx, dy, NULL, dev->cache_x, dev->cache_y); } if (scaled) pixmap = scaled; @@ -1364,15 +1361,14 @@ fz_draw_clip_image_mask(fz_device *devp, fz_image *image, const fz_rect *rect, c } fz_catch(ctx) { - emergency_pop_stack(dev, state); + emergency_pop_stack(ctx, dev, state); } } static void -fz_draw_pop_clip(fz_device *devp) +fz_draw_pop_clip(fz_context *ctx, fz_device *devp) { fz_draw_device *dev = devp->user; - fz_context *ctx = dev->ctx; fz_draw_state *state; if (dev->top == 0) @@ -1390,31 +1386,31 @@ fz_draw_pop_clip(fz_device *devp) { #ifdef DUMP_GROUP_BLENDS dump_spaces(dev->top, ""); - fz_dump_blend(dev->ctx, state[1].dest, "Clipping "); + fz_dump_blend(ctx, state[1].dest, "Clipping "); if (state[1].shape) - fz_dump_blend(dev->ctx, state[1].shape, "/"); - fz_dump_blend(dev->ctx, state[0].dest, " onto "); + fz_dump_blend(ctx, state[1].shape, "/"); + fz_dump_blend(ctx, state[0].dest, " onto "); if (state[0].shape) - fz_dump_blend(dev->ctx, state[0].shape, "/"); - fz_dump_blend(dev->ctx, state[1].mask, " with "); + fz_dump_blend(ctx, state[0].shape, "/"); + fz_dump_blend(ctx, state[1].mask, " with "); #endif fz_paint_pixmap_with_mask(state[0].dest, state[1].dest, state[1].mask); if (state[0].shape != state[1].shape) { fz_paint_pixmap_with_mask(state[0].shape, state[1].shape, state[1].mask); - fz_drop_pixmap(dev->ctx, state[1].shape); + fz_drop_pixmap(ctx, state[1].shape); } /* The following tests should not be required, but just occasionally * errors can cause the stack to get out of sync, and this might save * our bacon. */ if (state[0].mask != state[1].mask) - fz_drop_pixmap(dev->ctx, state[1].mask); + fz_drop_pixmap(ctx, state[1].mask); if (state[0].dest != state[1].dest) - fz_drop_pixmap(dev->ctx, state[1].dest); + fz_drop_pixmap(ctx, state[1].dest); #ifdef DUMP_GROUP_BLENDS - fz_dump_blend(dev->ctx, state[0].dest, " to get "); + fz_dump_blend(ctx, state[0].dest, " to get "); if (state[0].shape) - fz_dump_blend(dev->ctx, state[0].shape, "/"); + fz_dump_blend(ctx, state[0].shape, "/"); printf("\n"); #endif } @@ -1427,21 +1423,20 @@ fz_draw_pop_clip(fz_device *devp) } static void -fz_draw_begin_mask(fz_device *devp, const fz_rect *rect, int luminosity, fz_colorspace *colorspace, float *colorfv) +fz_draw_begin_mask(fz_context *ctx, fz_device *devp, const fz_rect *rect, int luminosity, fz_colorspace *colorspace, float *colorfv) { fz_draw_device *dev = devp->user; fz_pixmap *dest; fz_irect bbox; - fz_draw_state *state = push_stack(dev); + fz_draw_state *state = push_stack(ctx, dev); fz_pixmap *shape = state->shape; - fz_context *ctx = dev->ctx; STACK_PUSHED("mask"); fz_intersect_irect(fz_irect_from_rect(&bbox, rect), &state->scissor); fz_try(ctx) { - state[1].dest = dest = fz_new_pixmap_with_bbox(dev->ctx, fz_device_gray(ctx), &bbox); + state[1].dest = dest = fz_new_pixmap_with_bbox(ctx, fz_device_gray(ctx), &bbox); if (state->shape) { /* FIXME: If we ever want to support AIS true, then @@ -1458,16 +1453,16 @@ fz_draw_begin_mask(fz_device *devp, const fz_rect *rect, int luminosity, fz_colo float bc; if (!colorspace) colorspace = fz_device_gray(ctx); - fz_convert_color(dev->ctx, fz_device_gray(ctx), &bc, colorspace, colorfv); - fz_clear_pixmap_with_value(dev->ctx, dest, bc * 255); + fz_convert_color(ctx, fz_device_gray(ctx), &bc, colorspace, colorfv); + fz_clear_pixmap_with_value(ctx, dest, bc * 255); if (shape) - fz_clear_pixmap_with_value(dev->ctx, shape, 255); + fz_clear_pixmap_with_value(ctx, shape, 255); } else { - fz_clear_pixmap(dev->ctx, dest); + fz_clear_pixmap(ctx, dest); if (shape) - fz_clear_pixmap(dev->ctx, shape); + fz_clear_pixmap(ctx, shape); } #ifdef DUMP_GROUP_BLENDS @@ -1478,18 +1473,17 @@ fz_draw_begin_mask(fz_device *devp, const fz_rect *rect, int luminosity, fz_colo } fz_catch(ctx) { - emergency_pop_stack(dev, state); + emergency_pop_stack(ctx, dev, state); } } static void -fz_draw_end_mask(fz_device *devp) +fz_draw_end_mask(fz_context *ctx, fz_device *devp) { fz_draw_device *dev = devp->user; fz_pixmap *temp, *dest; fz_irect bbox; int luminosity; - fz_context *ctx = dev->ctx; fz_draw_state *state; if (dev->top == 0) @@ -1508,21 +1502,21 @@ fz_draw_end_mask(fz_device *devp) fz_try(ctx) { /* convert to alpha mask */ - temp = fz_alpha_from_gray(dev->ctx, state[1].dest, luminosity); + temp = fz_alpha_from_gray(ctx, state[1].dest, luminosity); if (state[1].mask != state[0].mask) - fz_drop_pixmap(dev->ctx, state[1].mask); + fz_drop_pixmap(ctx, state[1].mask); state[1].mask = temp; if (state[1].dest != state[0].dest) - fz_drop_pixmap(dev->ctx, state[1].dest); + fz_drop_pixmap(ctx, state[1].dest); state[1].dest = NULL; if (state[1].shape != state[0].shape) - fz_drop_pixmap(dev->ctx, state[1].shape); + fz_drop_pixmap(ctx, state[1].shape); state[1].shape = NULL; /* create new dest scratch buffer */ fz_pixmap_bbox(ctx, temp, &bbox); - dest = fz_new_pixmap_with_bbox(dev->ctx, state->dest->colorspace, &bbox); - fz_clear_pixmap(dev->ctx, dest); + dest = fz_new_pixmap_with_bbox(ctx, state->dest->colorspace, &bbox); + fz_clear_pixmap(ctx, dest); /* push soft mask as clip mask */ state[1].dest = dest; @@ -1531,31 +1525,30 @@ fz_draw_end_mask(fz_device *devp) * clip mask when we pop. So create a new shape now. */ if (state[0].shape) { - state[1].shape = fz_new_pixmap_with_bbox(dev->ctx, NULL, &bbox); - fz_clear_pixmap(dev->ctx, state[1].shape); + state[1].shape = fz_new_pixmap_with_bbox(ctx, NULL, &bbox); + fz_clear_pixmap(ctx, state[1].shape); } state[1].scissor = bbox; } fz_catch(ctx) { - emergency_pop_stack(dev, state); + emergency_pop_stack(ctx, dev, state); } } static void -fz_draw_begin_group(fz_device *devp, const fz_rect *rect, int isolated, int knockout, int blendmode, float alpha) +fz_draw_begin_group(fz_context *ctx, fz_device *devp, const fz_rect *rect, int isolated, int knockout, int blendmode, float alpha) { fz_draw_device *dev = devp->user; fz_irect bbox; fz_pixmap *dest; - fz_context *ctx = dev->ctx; fz_draw_state *state = &dev->stack[dev->top]; fz_colorspace *model = state->dest->colorspace; if (state->blendmode & FZ_BLEND_KNOCKOUT) - fz_knockout_begin(dev); + fz_knockout_begin(ctx, dev); - state = push_stack(dev); + state = push_stack(ctx, dev); STACK_PUSHED("group"); fz_intersect_irect(fz_irect_from_rect(&bbox, rect), &state->scissor); @@ -1570,11 +1563,11 @@ fz_draw_begin_group(fz_device *devp, const fz_rect *rect, int isolated, int knoc if (isolated) { - fz_clear_pixmap(dev->ctx, dest); + fz_clear_pixmap(ctx, dest); } else { - fz_copy_pixmap_rect(dev->ctx, dest, state[0].dest, &bbox); + fz_copy_pixmap_rect(ctx, dest, state[0].dest, &bbox); } if (blendmode == 0 && alpha == 1.0 && isolated) @@ -1586,7 +1579,7 @@ fz_draw_begin_group(fz_device *devp, const fz_rect *rect, int isolated, int knoc else { state[1].shape = fz_new_pixmap_with_bbox(ctx, NULL, &bbox); - fz_clear_pixmap(dev->ctx, state[1].shape); + fz_clear_pixmap(ctx, state[1].shape); } state[1].alpha = alpha; @@ -1599,18 +1592,17 @@ fz_draw_begin_group(fz_device *devp, const fz_rect *rect, int isolated, int knoc } fz_catch(ctx) { - emergency_pop_stack(dev, state); + emergency_pop_stack(ctx, dev, state); } } static void -fz_draw_end_group(fz_device *devp) +fz_draw_end_group(fz_context *ctx, fz_device *devp) { fz_draw_device *dev = devp->user; int blendmode; int isolated; float alpha; - fz_context *ctx = dev->ctx; fz_draw_state *state; if (dev->top == 0) @@ -1626,12 +1618,12 @@ fz_draw_end_group(fz_device *devp) isolated = state[1].blendmode & FZ_BLEND_ISOLATED; #ifdef DUMP_GROUP_BLENDS dump_spaces(dev->top, ""); - fz_dump_blend(dev->ctx, state[1].dest, "Group end: blending "); + fz_dump_blend(ctx, state[1].dest, "Group end: blending "); if (state[1].shape) - fz_dump_blend(dev->ctx, state[1].shape, "/"); - fz_dump_blend(dev->ctx, state[0].dest, " onto "); + fz_dump_blend(ctx, state[1].shape, "/"); + fz_dump_blend(ctx, state[0].dest, " onto "); if (state[0].shape) - fz_dump_blend(dev->ctx, state[0].shape, "/"); + fz_dump_blend(ctx, state[0].shape, "/"); if (alpha != 1.0f) printf(" (alpha %g)", alpha); if (blendmode != 0) @@ -1650,22 +1642,22 @@ fz_draw_end_group(fz_device *devp) * errors can cause the stack to get out of sync, and this might save * our bacon. */ if (state[0].dest != state[1].dest) - fz_drop_pixmap(dev->ctx, state[1].dest); + fz_drop_pixmap(ctx, state[1].dest); if (state[0].shape != state[1].shape) { if (state[0].shape) fz_paint_pixmap(state[0].shape, state[1].shape, alpha * 255); - fz_drop_pixmap(dev->ctx, state[1].shape); + fz_drop_pixmap(ctx, state[1].shape); } #ifdef DUMP_GROUP_BLENDS - fz_dump_blend(dev->ctx, state[0].dest, " to get "); + fz_dump_blend(ctx, state[0].dest, " to get "); if (state[0].shape) - fz_dump_blend(dev->ctx, state[0].shape, "/"); + fz_dump_blend(ctx, state[0].shape, "/"); printf("\n"); #endif if (state[0].blendmode & FZ_BLEND_KNOCKOUT) - fz_knockout_end(dev); + fz_knockout_end(ctx, dev); } typedef struct @@ -1683,7 +1675,7 @@ typedef struct } tile_record; static int -fz_make_hash_tile_key(fz_store_hash *hash, void *key_) +fz_make_hash_tile_key(fz_context *ctx, fz_store_hash *hash, void *key_) { tile_key *key = (tile_key *)key_; @@ -1723,7 +1715,7 @@ fz_drop_tile_key(fz_context *ctx, void *key_) } static int -fz_cmp_tile_key(void *k0_, void *k1_) +fz_cmp_tile_key(fz_context *ctx, void *k0_, void *k1_) { tile_key *k0 = (tile_key *)k0_; tile_key *k1 = (tile_key *)k1_; @@ -1733,7 +1725,7 @@ fz_cmp_tile_key(void *k0_, void *k1_) #ifndef NDEBUG static void -fz_debug_tile(FILE *out, void *key_) +fz_debug_tile(fz_context *ctx, FILE *out, void *key_) { tile_key *key = (tile_key *)key_; @@ -1789,13 +1781,12 @@ fz_tile_size(fz_context *ctx, tile_record *tile) } static int -fz_draw_begin_tile(fz_device *devp, const fz_rect *area, const fz_rect *view, float xstep, float ystep, const fz_matrix *ctm, int id) +fz_draw_begin_tile(fz_context *ctx, fz_device *devp, const fz_rect *area, const fz_rect *view, float xstep, float ystep, const fz_matrix *ctm, int id) { fz_draw_device *dev = devp->user; fz_pixmap *dest = NULL; fz_pixmap *shape; fz_irect bbox; - fz_context *ctx = dev->ctx; fz_draw_state *state = &dev->stack[dev->top]; fz_colorspace *model = state->dest->colorspace; fz_rect local_view = *view; @@ -1804,9 +1795,9 @@ fz_draw_begin_tile(fz_device *devp, const fz_rect *area, const fz_rect *view, fl /* ctm maps from pattern space to device space */ if (state->blendmode & FZ_BLEND_KNOCKOUT) - fz_knockout_begin(dev); + fz_knockout_begin(ctx, dev); - state = push_stack(dev); + state = push_stack(ctx, dev); STACK_PUSHED("tile"); fz_irect_from_rect(&bbox, fz_transform_rect(&local_view, ctm)); /* We should never have a bbox that entirely covers our destination. @@ -1851,12 +1842,12 @@ fz_draw_begin_tile(fz_device *devp, const fz_rect *area, const fz_rect *view, fl fz_try(ctx) { - state[1].dest = dest = fz_new_pixmap_with_bbox(dev->ctx, model, &bbox); + state[1].dest = dest = fz_new_pixmap_with_bbox(ctx, model, &bbox); fz_clear_pixmap(ctx, dest); shape = state[0].shape; if (shape) { - state[1].shape = shape = fz_new_pixmap_with_bbox(dev->ctx, NULL, &bbox); + state[1].shape = shape = fz_new_pixmap_with_bbox(ctx, NULL, &bbox); fz_clear_pixmap(ctx, shape); } state[1].blendmode |= FZ_BLEND_ISOLATED; @@ -1873,14 +1864,14 @@ fz_draw_begin_tile(fz_device *devp, const fz_rect *area, const fz_rect *view, fl } fz_catch(ctx) { - emergency_pop_stack(dev, state); + emergency_pop_stack(ctx, dev, state); } return 0; } static void -fz_draw_end_tile(fz_device *devp) +fz_draw_end_tile(fz_context *ctx, fz_device *devp) { fz_draw_device *dev = devp->user; float xstep, ystep; @@ -1888,7 +1879,6 @@ fz_draw_end_tile(fz_device *devp) fz_irect area, scissor; fz_rect scissor_tmp; int x0, y0, x1, y1, x, y; - fz_context *ctx = dev->ctx; fz_draw_state *state; tile_record *tile; tile_key *key; @@ -1940,12 +1930,12 @@ fz_draw_end_tile(fz_device *devp) #ifdef DUMP_GROUP_BLENDS dump_spaces(dev->top, ""); - fz_dump_blend(dev->ctx, state[1].dest, "Tiling "); + fz_dump_blend(ctx, state[1].dest, "Tiling "); if (state[1].shape) - fz_dump_blend(dev->ctx, state[1].shape, "/"); - fz_dump_blend(dev->ctx, state[0].dest, " onto "); + fz_dump_blend(ctx, state[1].shape, "/"); + fz_dump_blend(ctx, state[0].dest, " onto "); if (state[0].shape) - fz_dump_blend(dev->ctx, state[0].shape, "/"); + fz_dump_blend(ctx, state[0].shape, "/"); #endif for (y = y0; y < y1; y++) @@ -2023,25 +2013,26 @@ fz_draw_end_tile(fz_device *devp) * errors can cause the stack to get out of sync, and this might save * our bacon. */ if (state[0].dest != state[1].dest) - fz_drop_pixmap(dev->ctx, state[1].dest); + fz_drop_pixmap(ctx, state[1].dest); if (state[0].shape != state[1].shape) - fz_drop_pixmap(dev->ctx, state[1].shape); + fz_drop_pixmap(ctx, state[1].shape); #ifdef DUMP_GROUP_BLENDS - fz_dump_blend(dev->ctx, state[0].dest, " to get "); + fz_dump_blend(ctx, state[0].dest, " to get "); if (state[0].shape) - fz_dump_blend(dev->ctx, state[0].shape, "/"); + fz_dump_blend(ctx, state[0].shape, "/"); printf("\n"); #endif if (state->blendmode & FZ_BLEND_KNOCKOUT) - fz_knockout_end(dev); + fz_knockout_end(ctx, dev); } static void -fz_draw_drop_user(fz_device *devp) +fz_draw_drop_user(fz_context *ctx, fz_device *devp) { fz_draw_device *dev = devp->user; - fz_context *ctx = dev->ctx; + fz_gel *gel = dev->gel; + /* pop and free the stacks */ if (dev->top > 0) fz_warn(ctx, "items left on stack in draw device: %d", dev->top+1); @@ -2064,7 +2055,7 @@ fz_draw_drop_user(fz_device *devp) fz_free(ctx, dev->stack); fz_drop_scale_cache(ctx, dev->cache_x); fz_drop_scale_cache(ctx, dev->cache_y); - fz_drop_gel(dev->gel); + fz_drop_gel(ctx, gel); fz_free(ctx, dev); } @@ -2079,7 +2070,6 @@ fz_new_draw_device(fz_context *ctx, fz_pixmap *dest) { ddev->gel = fz_new_gel(ctx); ddev->flags = 0; - ddev->ctx = ctx; ddev->top = 0; ddev->cache_x = fz_new_scale_cache(ctx); ddev->cache_y = fz_new_scale_cache(ctx); @@ -2100,7 +2090,7 @@ fz_new_draw_device(fz_context *ctx, fz_pixmap *dest) { fz_drop_scale_cache(ctx, ddev->cache_x); fz_drop_scale_cache(ctx, ddev->cache_y); - fz_drop_gel(ddev->gel); + fz_drop_gel(ctx, ddev->gel); fz_free(ctx, ddev); fz_rethrow(ctx); } @@ -2166,18 +2156,18 @@ fz_bound_path_accurate(fz_context *ctx, fz_irect *bbox, const fz_irect *scissor, { fz_gel *gel = fz_new_gel(ctx); - fz_reset_gel(gel, scissor); + fz_reset_gel(ctx, gel, scissor); if (stroke) { if (stroke->dash_len > 0) - fz_flatten_dash_path(gel, path, stroke, ctm, flatness, linewidth); + fz_flatten_dash_path(ctx, gel, path, stroke, ctm, flatness, linewidth); else - fz_flatten_stroke_path(gel, path, stroke, ctm, flatness, linewidth); + fz_flatten_stroke_path(ctx, gel, path, stroke, ctm, flatness, linewidth); } else - fz_flatten_fill_path(gel, path, ctm, flatness); - fz_bound_gel(gel, bbox); - fz_drop_gel(gel); + fz_flatten_fill_path(ctx, gel, path, ctm, flatness); + fz_bound_gel(ctx, gel, bbox); + fz_drop_gel(ctx, gel); return bbox; } |