From 31186b61d979ba02c04ce68dcb66f7a5f1229c93 Mon Sep 17 00:00:00 2001 From: Tor Andersson Date: Tue, 17 Feb 2015 14:41:50 +0100 Subject: Use embedded superclass struct instead of user pointer in devices. --- source/fitz/bbox-device.c | 108 ++++++++++++++-------------- source/fitz/device.c | 15 ++-- source/fitz/draw-device.c | 174 ++++++++++++++++++++++----------------------- source/fitz/list-device.c | 105 +++++++++++++++------------ source/fitz/stext-device.c | 67 +++++++++-------- source/fitz/svg-device.c | 119 ++++++++++++++----------------- source/fitz/test-device.c | 55 +++++--------- source/fitz/trace-device.c | 2 +- source/pdf/pdf-device.c | 148 +++++++++++++++++++------------------- 9 files changed, 380 insertions(+), 413 deletions(-) (limited to 'source') diff --git a/source/fitz/bbox-device.c b/source/fitz/bbox-device.c index b11a78a7..2c639499 100644 --- a/source/fitz/bbox-device.c +++ b/source/fitz/bbox-device.c @@ -2,32 +2,34 @@ #define STACK_SIZE 96 -typedef struct fz_bbox_data_s +typedef struct fz_bbox_device_s { + fz_device super; + fz_rect *result; int top; fz_rect stack[STACK_SIZE]; /* mask content and tiles are ignored */ int ignore; -} fz_bbox_data; +} fz_bbox_device; static void fz_bbox_add_rect(fz_context *ctx, fz_device *dev, const fz_rect *rect, int clip) { - fz_bbox_data *data = dev->user; + fz_bbox_device *bdev = (fz_bbox_device*)dev; fz_rect r = *rect; - if (0 < data->top && data->top <= STACK_SIZE) + if (0 < bdev->top && bdev->top <= STACK_SIZE) { - fz_intersect_rect(&r, &data->stack[data->top-1]); + fz_intersect_rect(&r, &bdev->stack[bdev->top-1]); } - if (!clip && data->top <= STACK_SIZE && !data->ignore) + if (!clip && bdev->top <= STACK_SIZE && !bdev->ignore) { - fz_union_rect(data->result, &r); + fz_union_rect(bdev->result, &r); } - if (clip && ++data->top <= STACK_SIZE) + if (clip && ++bdev->top <= STACK_SIZE) { - data->stack[data->top-1] = r; + bdev->stack[bdev->top-1] = r; } } @@ -126,9 +128,9 @@ fz_bbox_clip_image_mask(fz_context *ctx, fz_device *dev, fz_image *image, const static void fz_bbox_pop_clip(fz_context *ctx, fz_device *dev) { - fz_bbox_data *data = dev->user; - if (data->top > 0) - data->top--; + fz_bbox_device *bdev = (fz_bbox_device*)dev; + if (bdev->top > 0) + bdev->top--; else fz_warn(ctx, "unexpected pop clip"); } @@ -136,17 +138,17 @@ fz_bbox_pop_clip(fz_context *ctx, fz_device *dev) static void fz_bbox_begin_mask(fz_context *ctx, fz_device *dev, const fz_rect *rect, int luminosity, fz_colorspace *colorspace, float *color) { - fz_bbox_data *data = dev->user; + fz_bbox_device *bdev = (fz_bbox_device*)dev; fz_bbox_add_rect(ctx, dev, rect, 1); - data->ignore++; + bdev->ignore++; } static void fz_bbox_end_mask(fz_context *ctx, fz_device *dev) { - fz_bbox_data *data = dev->user; - assert(data->ignore > 0); - data->ignore--; + fz_bbox_device *bdev = (fz_bbox_device*)dev; + assert(bdev->ignore > 0); + bdev->ignore--; } static void @@ -164,68 +166,66 @@ fz_bbox_end_group(fz_context *ctx, fz_device *dev) static int fz_bbox_begin_tile(fz_context *ctx, fz_device *dev, const fz_rect *area, const fz_rect *view, float xstep, float ystep, const fz_matrix *ctm, int id) { - fz_bbox_data *data = dev->user; + fz_bbox_device *bdev = (fz_bbox_device*)dev; fz_rect r = *area; fz_bbox_add_rect(ctx, dev, fz_transform_rect(&r, ctm), 0); - data->ignore++; + bdev->ignore++; return 0; } static void fz_bbox_end_tile(fz_context *ctx, fz_device *dev) { - fz_bbox_data *data = dev->user; - assert(data->ignore > 0); - data->ignore--; + fz_bbox_device *bdev = (fz_bbox_device*)dev; + assert(bdev->ignore > 0); + bdev->ignore--; } static void -fz_bbox_drop_user(fz_context *ctx, fz_device *dev) +fz_bbox_drop_imp(fz_context *ctx, fz_device *dev) { - fz_bbox_data *data = dev->user; - if (data->top > 0) - fz_warn(ctx, "items left on stack in bbox device: %d", data->top); - fz_free(ctx, dev->user); + fz_bbox_device *bdev = (fz_bbox_device*)dev; + if (bdev->top > 0) + fz_warn(ctx, "items left on stack in bbox device: %d", bdev->top); } fz_device * fz_new_bbox_device(fz_context *ctx, fz_rect *result) { - fz_device *dev; + fz_bbox_device *dev = fz_new_device(ctx, sizeof *dev); + + dev->super.drop_imp = fz_bbox_drop_imp; - fz_bbox_data *user = fz_malloc_struct(ctx, fz_bbox_data); - user->result = result; - user->top = 0; - user->ignore = 0; - dev = fz_new_device(ctx, user); - dev->drop_user = fz_bbox_drop_user; + dev->super.fill_path = fz_bbox_fill_path; + dev->super.stroke_path = fz_bbox_stroke_path; + dev->super.clip_path = fz_bbox_clip_path; + dev->super.clip_stroke_path = fz_bbox_clip_stroke_path; - dev->fill_path = fz_bbox_fill_path; - dev->stroke_path = fz_bbox_stroke_path; - dev->clip_path = fz_bbox_clip_path; - dev->clip_stroke_path = fz_bbox_clip_stroke_path; + dev->super.fill_text = fz_bbox_fill_text; + dev->super.stroke_text = fz_bbox_stroke_text; + dev->super.clip_text = fz_bbox_clip_text; + dev->super.clip_stroke_text = fz_bbox_clip_stroke_text; - dev->fill_text = fz_bbox_fill_text; - dev->stroke_text = fz_bbox_stroke_text; - dev->clip_text = fz_bbox_clip_text; - dev->clip_stroke_text = fz_bbox_clip_stroke_text; + dev->super.fill_shade = fz_bbox_fill_shade; + dev->super.fill_image = fz_bbox_fill_image; + dev->super.fill_image_mask = fz_bbox_fill_image_mask; + dev->super.clip_image_mask = fz_bbox_clip_image_mask; - dev->fill_shade = fz_bbox_fill_shade; - dev->fill_image = fz_bbox_fill_image; - dev->fill_image_mask = fz_bbox_fill_image_mask; - dev->clip_image_mask = fz_bbox_clip_image_mask; + dev->super.pop_clip = fz_bbox_pop_clip; - dev->pop_clip = fz_bbox_pop_clip; + dev->super.begin_mask = fz_bbox_begin_mask; + dev->super.end_mask = fz_bbox_end_mask; + dev->super.begin_group = fz_bbox_begin_group; + dev->super.end_group = fz_bbox_end_group; - dev->begin_mask = fz_bbox_begin_mask; - dev->end_mask = fz_bbox_end_mask; - dev->begin_group = fz_bbox_begin_group; - dev->end_group = fz_bbox_end_group; + dev->super.begin_tile = fz_bbox_begin_tile; + dev->super.end_tile = fz_bbox_end_tile; - dev->begin_tile = fz_bbox_begin_tile; - dev->end_tile = fz_bbox_end_tile; + dev->result = result; + dev->top = 0; + dev->ignore = 0; *result = fz_empty_rect; - return dev; + return (fz_device*)dev; } diff --git a/source/fitz/device.c b/source/fitz/device.c index 36a0f534..cb622a84 100644 --- a/source/fitz/device.c +++ b/source/fitz/device.c @@ -1,14 +1,9 @@ #include "mupdf/fitz.h" -fz_device * -fz_new_device(fz_context *ctx, void *user) +void * +fz_new_device(fz_context *ctx, int size) { - fz_device *dev = fz_malloc_struct(ctx, fz_device); - dev->hints = 0; - dev->flags = 0; - dev->user = user; - dev->error_depth = 0; - return dev; + return Memento_label(fz_calloc(ctx, 1, size), "fz_device"); } void @@ -16,8 +11,8 @@ fz_drop_device(fz_context *ctx, fz_device *dev) { if (dev == NULL) return; - if (dev->drop_user) - dev->drop_user(ctx, dev); + if (dev->drop_imp) + dev->drop_imp(ctx, dev); fz_free(ctx, dev->container); fz_free(ctx, dev); } diff --git a/source/fitz/draw-device.c b/source/fitz/draw-device.c index 1c093fc6..fad44050 100644 --- a/source/fitz/draw-device.c +++ b/source/fitz/draw-device.c @@ -37,6 +37,7 @@ struct fz_draw_state_s { struct fz_draw_device_s { + fz_device super; fz_gel *gel; int flags; int top; @@ -268,7 +269,7 @@ static void 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_draw_device *dev = (fz_draw_device*)devp; fz_gel *gel = dev->gel; float expansion = fz_matrix_expansion(ctm); @@ -322,7 +323,7 @@ static void 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_draw_device *dev = (fz_draw_device*)devp; fz_gel *gel = dev->gel; float expansion = fz_matrix_expansion(ctm); @@ -384,7 +385,7 @@ fz_draw_stroke_path(fz_context *ctx, fz_device *devp, fz_path *path, fz_stroke_s static void 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_draw_device *dev = (fz_draw_device*)devp; fz_gel *gel = dev->gel; float expansion = fz_matrix_expansion(ctm); @@ -450,7 +451,7 @@ fz_draw_clip_path(fz_context *ctx, fz_device *devp, fz_path *path, const fz_rect static void 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_draw_device *dev = (fz_draw_device*)devp; fz_gel *gel = dev->gel; float expansion = fz_matrix_expansion(ctm); @@ -562,7 +563,7 @@ static void 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; + fz_draw_device *dev = (fz_draw_device*)devp; unsigned char colorbv[FZ_MAX_COLORS + 1]; unsigned char shapebv; @@ -639,7 +640,7 @@ fz_draw_stroke_text(fz_context *ctx, fz_device *devp, fz_text *text, fz_stroke_s const fz_matrix *ctm, fz_colorspace *colorspace, float *color, float alpha) { - fz_draw_device *dev = devp->user; + fz_draw_device *dev = (fz_draw_device*)devp; unsigned char colorbv[FZ_MAX_COLORS + 1]; float colorfv[FZ_MAX_COLORS]; @@ -701,7 +702,7 @@ fz_draw_stroke_text(fz_context *ctx, fz_device *devp, fz_text *text, fz_stroke_s static void 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_draw_device *dev = (fz_draw_device*)devp; fz_irect bbox; fz_pixmap *mask, *dest, *shape; fz_matrix tm, trm; @@ -833,7 +834,7 @@ fz_draw_clip_text(fz_context *ctx, fz_device *devp, fz_text *text, const fz_matr static void 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_draw_device *dev = (fz_draw_device*)devp; fz_irect bbox; fz_pixmap *mask, *dest, *shape; fz_matrix tm, trm; @@ -941,7 +942,7 @@ fz_draw_ignore_text(fz_context *ctx, fz_device *dev, fz_text *text, const fz_mat static void 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_draw_device *dev = (fz_draw_device*)devp; fz_rect bounds; fz_irect bbox, scissor; fz_pixmap *dest, *shape; @@ -1089,7 +1090,7 @@ fz_transform_pixmap(fz_context *ctx, fz_draw_device *dev, fz_pixmap *image, fz_m static void 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_draw_device *dev = (fz_draw_device*)devp; fz_pixmap *converted = NULL; fz_pixmap *scaled = NULL; fz_pixmap *pixmap; @@ -1196,7 +1197,7 @@ static void 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; + fz_draw_device *dev = (fz_draw_device*)devp; unsigned char colorbv[FZ_MAX_COLORS + 1]; float colorfv[FZ_MAX_COLORS]; fz_pixmap *scaled = NULL; @@ -1267,7 +1268,7 @@ fz_draw_fill_image_mask(fz_context *ctx, fz_device *devp, fz_image *image, const static void 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_draw_device *dev = (fz_draw_device*)devp; fz_irect bbox; fz_pixmap *mask = NULL; fz_pixmap *dest = NULL; @@ -1368,7 +1369,7 @@ fz_draw_clip_image_mask(fz_context *ctx, fz_device *devp, fz_image *image, const static void fz_draw_pop_clip(fz_context *ctx, fz_device *devp) { - fz_draw_device *dev = devp->user; + fz_draw_device *dev = (fz_draw_device*)devp; fz_draw_state *state; if (dev->top == 0) @@ -1425,7 +1426,7 @@ fz_draw_pop_clip(fz_context *ctx, fz_device *devp) static void 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_draw_device *dev = (fz_draw_device*)devp; fz_pixmap *dest; fz_irect bbox; fz_draw_state *state = push_stack(ctx, dev); @@ -1480,7 +1481,7 @@ fz_draw_begin_mask(fz_context *ctx, fz_device *devp, const fz_rect *rect, int lu static void fz_draw_end_mask(fz_context *ctx, fz_device *devp) { - fz_draw_device *dev = devp->user; + fz_draw_device *dev = (fz_draw_device*)devp; fz_pixmap *temp, *dest; fz_irect bbox; int luminosity; @@ -1539,7 +1540,7 @@ fz_draw_end_mask(fz_context *ctx, fz_device *devp) static void 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_draw_device *dev = (fz_draw_device*)devp; fz_irect bbox; fz_pixmap *dest; fz_draw_state *state = &dev->stack[dev->top]; @@ -1599,7 +1600,7 @@ fz_draw_begin_group(fz_context *ctx, fz_device *devp, const fz_rect *rect, int i static void fz_draw_end_group(fz_context *ctx, fz_device *devp) { - fz_draw_device *dev = devp->user; + fz_draw_device *dev = (fz_draw_device*)devp; int blendmode; int isolated; float alpha; @@ -1766,7 +1767,7 @@ fz_tile_size(fz_context *ctx, tile_record *tile) static int 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_draw_device *dev = (fz_draw_device*)devp; fz_pixmap *dest = NULL; fz_pixmap *shape; fz_irect bbox; @@ -1856,7 +1857,7 @@ fz_draw_begin_tile(fz_context *ctx, fz_device *devp, const fz_rect *area, const static void fz_draw_end_tile(fz_context *ctx, fz_device *devp) { - fz_draw_device *dev = devp->user; + fz_draw_device *dev = (fz_draw_device*)devp; float xstep, ystep; fz_matrix ttm, ctm, shapectm; fz_irect area, scissor; @@ -2011,9 +2012,9 @@ fz_draw_end_tile(fz_context *ctx, fz_device *devp) } static void -fz_draw_drop_user(fz_context *ctx, fz_device *devp) +fz_draw_drop_imp(fz_context *ctx, fz_device *devp) { - fz_draw_device *dev = devp->user; + fz_draw_device *dev = (fz_draw_device*)devp; fz_gel *gel = dev->gel; /* pop and free the stacks */ @@ -2039,99 +2040,92 @@ fz_draw_drop_user(fz_context *ctx, fz_device *devp) fz_drop_scale_cache(ctx, dev->cache_x); fz_drop_scale_cache(ctx, dev->cache_y); fz_drop_gel(ctx, gel); - fz_free(ctx, dev); } fz_device * fz_new_draw_device(fz_context *ctx, fz_pixmap *dest) { - fz_device *dev = NULL; - fz_draw_device *ddev = fz_malloc_struct(ctx, fz_draw_device); + fz_draw_device *dev = fz_new_device(ctx, sizeof *dev); + + dev->super.drop_imp = fz_draw_drop_imp; + + dev->super.fill_path = fz_draw_fill_path; + dev->super.stroke_path = fz_draw_stroke_path; + dev->super.clip_path = fz_draw_clip_path; + dev->super.clip_stroke_path = fz_draw_clip_stroke_path; + + dev->super.fill_text = fz_draw_fill_text; + dev->super.stroke_text = fz_draw_stroke_text; + dev->super.clip_text = fz_draw_clip_text; + dev->super.clip_stroke_text = fz_draw_clip_stroke_text; + dev->super.ignore_text = fz_draw_ignore_text; + + dev->super.fill_image_mask = fz_draw_fill_image_mask; + dev->super.clip_image_mask = fz_draw_clip_image_mask; + dev->super.fill_image = fz_draw_fill_image; + dev->super.fill_shade = fz_draw_fill_shade; + + dev->super.pop_clip = fz_draw_pop_clip; + + dev->super.begin_mask = fz_draw_begin_mask; + dev->super.end_mask = fz_draw_end_mask; + dev->super.begin_group = fz_draw_begin_group; + dev->super.end_group = fz_draw_end_group; + + dev->super.begin_tile = fz_draw_begin_tile; + dev->super.end_tile = fz_draw_end_tile; + + dev->flags = 0; + dev->top = 0; + dev->stack = &dev->init_stack[0]; + dev->stack_cap = STACK_SIZE; + dev->stack[0].dest = dest; + dev->stack[0].shape = NULL; + dev->stack[0].mask = NULL; + dev->stack[0].blendmode = 0; + dev->stack[0].scissor.x0 = dest->x; + dev->stack[0].scissor.y0 = dest->y; + dev->stack[0].scissor.x1 = dest->x + dest->w; + dev->stack[0].scissor.y1 = dest->y + dest->h; - fz_var(dev); fz_try(ctx) { - ddev->gel = fz_new_gel(ctx); - ddev->flags = 0; - ddev->top = 0; - ddev->cache_x = fz_new_scale_cache(ctx); - ddev->cache_y = fz_new_scale_cache(ctx); - ddev->stack = &ddev->init_stack[0]; - ddev->stack_cap = STACK_SIZE; - ddev->stack[0].dest = dest; - ddev->stack[0].shape = NULL; - ddev->stack[0].mask = NULL; - ddev->stack[0].blendmode = 0; - ddev->stack[0].scissor.x0 = dest->x; - ddev->stack[0].scissor.y0 = dest->y; - ddev->stack[0].scissor.x1 = dest->x + dest->w; - ddev->stack[0].scissor.y1 = dest->y + dest->h; - - dev = fz_new_device(ctx, ddev); + dev->gel = fz_new_gel(ctx); + dev->cache_x = fz_new_scale_cache(ctx); + dev->cache_y = fz_new_scale_cache(ctx); } fz_catch(ctx) { - fz_drop_scale_cache(ctx, ddev->cache_x); - fz_drop_scale_cache(ctx, ddev->cache_y); - fz_drop_gel(ctx, ddev->gel); - fz_free(ctx, ddev); + fz_drop_device(ctx, (fz_device*)dev); fz_rethrow(ctx); } - dev->drop_user = fz_draw_drop_user; - dev->fill_path = fz_draw_fill_path; - dev->stroke_path = fz_draw_stroke_path; - dev->clip_path = fz_draw_clip_path; - dev->clip_stroke_path = fz_draw_clip_stroke_path; - - dev->fill_text = fz_draw_fill_text; - dev->stroke_text = fz_draw_stroke_text; - dev->clip_text = fz_draw_clip_text; - dev->clip_stroke_text = fz_draw_clip_stroke_text; - dev->ignore_text = fz_draw_ignore_text; - - dev->fill_image_mask = fz_draw_fill_image_mask; - dev->clip_image_mask = fz_draw_clip_image_mask; - dev->fill_image = fz_draw_fill_image; - dev->fill_shade = fz_draw_fill_shade; - - dev->pop_clip = fz_draw_pop_clip; - - dev->begin_mask = fz_draw_begin_mask; - dev->end_mask = fz_draw_end_mask; - dev->begin_group = fz_draw_begin_group; - dev->end_group = fz_draw_end_group; - - dev->begin_tile = fz_draw_begin_tile; - dev->end_tile = fz_draw_end_tile; - - return dev; + return (fz_device*)dev; } fz_device * fz_new_draw_device_with_bbox(fz_context *ctx, fz_pixmap *dest, const fz_irect *clip) { - fz_device *dev = fz_new_draw_device(ctx, dest); - fz_draw_device *ddev = dev->user; - - if (clip->x0 > ddev->stack[0].scissor.x0) - ddev->stack[0].scissor.x0 = clip->x0; - if (clip->x1 < ddev->stack[0].scissor.x1) - ddev->stack[0].scissor.x1 = clip->x1; - if (clip->y0 > ddev->stack[0].scissor.y0) - ddev->stack[0].scissor.y0 = clip->y0; - if (clip->y1 < ddev->stack[0].scissor.y1) - ddev->stack[0].scissor.y1 = clip->y1; - return dev; + fz_draw_device *dev = (fz_draw_device*)fz_new_draw_device(ctx, dest); + + if (clip->x0 > dev->stack[0].scissor.x0) + dev->stack[0].scissor.x0 = clip->x0; + if (clip->x1 < dev->stack[0].scissor.x1) + dev->stack[0].scissor.x1 = clip->x1; + if (clip->y0 > dev->stack[0].scissor.y0) + dev->stack[0].scissor.y0 = clip->y0; + if (clip->y1 < dev->stack[0].scissor.y1) + dev->stack[0].scissor.y1 = clip->y1; + + return (fz_device*)dev; } fz_device * fz_new_draw_device_type3(fz_context *ctx, fz_pixmap *dest) { - fz_device *dev = fz_new_draw_device(ctx, dest); - fz_draw_device *ddev = dev->user; - ddev->flags |= FZ_DRAWDEV_FLAGS_TYPE3; - return dev; + fz_draw_device *dev = (fz_draw_device*)fz_new_draw_device(ctx, dest); + dev->flags |= FZ_DRAWDEV_FLAGS_TYPE3; + return (fz_device*)dev; } fz_irect * diff --git a/source/fitz/list-device.c b/source/fitz/list-device.c index f56bc879..72a63ef4 100644 --- a/source/fitz/list-device.c +++ b/source/fitz/list-device.c @@ -2,6 +2,12 @@ typedef struct fz_display_node_s fz_display_node; +typedef struct fz_list_device_s +{ + fz_device super; + fz_display_list *list; +} fz_list_device; + #define STACK_SIZE 96 typedef enum fz_display_command_e @@ -101,8 +107,11 @@ fz_new_display_node(fz_context *ctx, fz_display_command cmd, const fz_matrix *ct } static void -fz_append_display_node(fz_display_list *list, fz_display_node *node) +fz_append_display_node(fz_context *ctx, fz_device *dev_, fz_display_node *node) { + fz_list_device *dev = (fz_list_device*)dev_; + fz_display_list *list = dev->list; + switch (node->cmd) { case FZ_CMD_CLIP_PATH: @@ -234,14 +243,14 @@ fz_list_begin_page(fz_context *ctx, fz_device *dev, const fz_rect *mediabox, con fz_display_node *node = fz_new_display_node(ctx, FZ_CMD_BEGIN_PAGE, ctm, NULL, NULL, 0); node->rect = *mediabox; fz_transform_rect(&node->rect, ctm); - fz_append_display_node(dev->user, node); + fz_append_display_node(ctx, dev, node); } static void fz_list_end_page(fz_context *ctx, fz_device *dev) { fz_display_node *node = fz_new_display_node(ctx, FZ_CMD_END_PAGE, &fz_identity, NULL, NULL, 0); - fz_append_display_node(dev->user, node); + fz_append_display_node(ctx, dev, node); } static void @@ -261,7 +270,7 @@ fz_list_fill_path(fz_context *ctx, fz_device *dev, fz_path *path, int even_odd, fz_free_display_node(ctx, node); fz_rethrow(ctx); } - fz_append_display_node(dev->user, node); + fz_append_display_node(ctx, dev, node); } static void @@ -281,7 +290,7 @@ fz_list_stroke_path(fz_context *ctx, fz_device *dev, fz_path *path, fz_stroke_st fz_free_display_node(ctx, node); fz_rethrow(ctx); } - fz_append_display_node(dev->user, node); + fz_append_display_node(ctx, dev, node); } static void @@ -302,7 +311,7 @@ fz_list_clip_path(fz_context *ctx, fz_device *dev, fz_path *path, const fz_rect fz_free_display_node(ctx, node); fz_rethrow(ctx); } - fz_append_display_node(dev->user, node); + fz_append_display_node(ctx, dev, node); } static void @@ -323,7 +332,7 @@ fz_list_clip_stroke_path(fz_context *ctx, fz_device *dev, fz_path *path, const f fz_free_display_node(ctx, node); fz_rethrow(ctx); } - fz_append_display_node(dev->user, node); + fz_append_display_node(ctx, dev, node); } static void @@ -342,7 +351,7 @@ fz_list_fill_text(fz_context *ctx, fz_device *dev, fz_text *text, const fz_matri fz_free_display_node(ctx, node); fz_rethrow(ctx); } - fz_append_display_node(dev->user, node); + fz_append_display_node(ctx, dev, node); } static void @@ -363,7 +372,7 @@ fz_list_stroke_text(fz_context *ctx, fz_device *dev, fz_text *text, fz_stroke_st fz_free_display_node(ctx, node); fz_rethrow(ctx); } - fz_append_display_node(dev->user, node); + fz_append_display_node(ctx, dev, node); } static void @@ -385,7 +394,7 @@ fz_list_clip_text(fz_context *ctx, fz_device *dev, fz_text *text, const fz_matri fz_free_display_node(ctx, node); fz_rethrow(ctx); } - fz_append_display_node(dev->user, node); + fz_append_display_node(ctx, dev, node); } static void @@ -404,7 +413,7 @@ fz_list_clip_stroke_text(fz_context *ctx, fz_device *dev, fz_text *text, fz_stro fz_free_display_node(ctx, node); fz_rethrow(ctx); } - fz_append_display_node(dev->user, node); + fz_append_display_node(ctx, dev, node); } static void @@ -422,7 +431,7 @@ fz_list_ignore_text(fz_context *ctx, fz_device *dev, fz_text *text, const fz_mat fz_free_display_node(ctx, node); fz_rethrow(ctx); } - fz_append_display_node(dev->user, node); + fz_append_display_node(ctx, dev, node); } static void @@ -430,7 +439,7 @@ fz_list_pop_clip(fz_context *ctx, fz_device *dev) { fz_display_node *node; node = fz_new_display_node(ctx, FZ_CMD_POP_CLIP, &fz_identity, NULL, NULL, 0); - fz_append_display_node(dev->user, node); + fz_append_display_node(ctx, dev, node); } static void @@ -440,7 +449,7 @@ fz_list_fill_shade(fz_context *ctx, fz_device *dev, fz_shade *shade, const fz_ma node = fz_new_display_node(ctx, FZ_CMD_FILL_SHADE, ctm, NULL, NULL, alpha); fz_bound_shade(ctx, shade, ctm, &node->rect); node->item.shade = fz_keep_shade(ctx, shade); - fz_append_display_node(dev->user, node); + fz_append_display_node(ctx, dev, node); } static void @@ -451,7 +460,7 @@ fz_list_fill_image(fz_context *ctx, fz_device *dev, fz_image *image, const fz_ma node->rect = fz_unit_rect; fz_transform_rect(&node->rect, ctm); node->item.image = fz_keep_image(ctx, image); - fz_append_display_node(dev->user, node); + fz_append_display_node(ctx, dev, node); } static void @@ -463,7 +472,7 @@ fz_list_fill_image_mask(fz_context *ctx, fz_device *dev, fz_image *image, const node->rect = fz_unit_rect; fz_transform_rect(&node->rect, ctm); node->item.image = fz_keep_image(ctx, image); - fz_append_display_node(dev->user, node); + fz_append_display_node(ctx, dev, node); } static void @@ -476,7 +485,7 @@ fz_list_clip_image_mask(fz_context *ctx, fz_device *dev, fz_image *image, const if (rect) fz_intersect_rect(&node->rect, rect); node->item.image = fz_keep_image(ctx, image); - fz_append_display_node(dev->user, node); + fz_append_display_node(ctx, dev, node); } static void @@ -486,7 +495,7 @@ fz_list_begin_mask(fz_context *ctx, fz_device *dev, const fz_rect *rect, int lum node = fz_new_display_node(ctx, FZ_CMD_BEGIN_MASK, &fz_identity, colorspace, color, 0); node->rect = *rect; node->flag = luminosity; - fz_append_display_node(dev->user, node); + fz_append_display_node(ctx, dev, node); } static void @@ -494,7 +503,7 @@ fz_list_end_mask(fz_context *ctx, fz_device *dev) { fz_display_node *node; node = fz_new_display_node(ctx, FZ_CMD_END_MASK, &fz_identity, NULL, NULL, 0); - fz_append_display_node(dev->user, node); + fz_append_display_node(ctx, dev, node); } static void @@ -506,7 +515,7 @@ fz_list_begin_group(fz_context *ctx, fz_device *dev, const fz_rect *rect, int is node->item.blendmode = blendmode; node->flag |= isolated ? ISOLATED : 0; node->flag |= knockout ? KNOCKOUT : 0; - fz_append_display_node(dev->user, node); + fz_append_display_node(ctx, dev, node); } static void @@ -514,7 +523,7 @@ fz_list_end_group(fz_context *ctx, fz_device *dev) { fz_display_node *node; node = fz_new_display_node(ctx, FZ_CMD_END_GROUP, &fz_identity, NULL, NULL, 0); - fz_append_display_node(dev->user, node); + fz_append_display_node(ctx, dev, node); } static int @@ -530,7 +539,7 @@ fz_list_begin_tile(fz_context *ctx, fz_device *dev, const fz_rect *area, const f node->color[3] = view->y0; node->color[4] = view->x1; node->color[5] = view->y1; - fz_append_display_node(dev->user, node); + fz_append_display_node(ctx, dev, node); return 0; } @@ -539,44 +548,46 @@ fz_list_end_tile(fz_context *ctx, fz_device *dev) { fz_display_node *node; node = fz_new_display_node(ctx, FZ_CMD_END_TILE, &fz_identity, NULL, NULL, 0); - fz_append_display_node(dev->user, node); + fz_append_display_node(ctx, dev, node); } fz_device * fz_new_list_device(fz_context *ctx, fz_display_list *list) { - fz_device *dev = fz_new_device(ctx, list); + fz_list_device *dev = fz_new_device(ctx, sizeof *dev); + + dev->super.begin_page = fz_list_begin_page; + dev->super.end_page = fz_list_end_page; - dev->begin_page = fz_list_begin_page; - dev->end_page = fz_list_end_page; + dev->super.fill_path = fz_list_fill_path; + dev->super.stroke_path = fz_list_stroke_path; + dev->super.clip_path = fz_list_clip_path; + dev->super.clip_stroke_path = fz_list_clip_stroke_path; - dev->fill_path = fz_list_fill_path; - dev->stroke_path = fz_list_stroke_path; - dev->clip_path = fz_list_clip_path; - dev->clip_stroke_path = fz_list_clip_stroke_path; + dev->super.fill_text = fz_list_fill_text; + dev->super.stroke_text = fz_list_stroke_text; + dev->super.clip_text = fz_list_clip_text; + dev->super.clip_stroke_text = fz_list_clip_stroke_text; + dev->super.ignore_text = fz_list_ignore_text; - dev->fill_text = fz_list_fill_text; - dev->stroke_text = fz_list_stroke_text; - dev->clip_text = fz_list_clip_text; - dev->clip_stroke_text = fz_list_clip_stroke_text; - dev->ignore_text = fz_list_ignore_text; + dev->super.fill_shade = fz_list_fill_shade; + dev->super.fill_image = fz_list_fill_image; + dev->super.fill_image_mask = fz_list_fill_image_mask; + dev->super.clip_image_mask = fz_list_clip_image_mask; - dev->fill_shade = fz_list_fill_shade; - dev->fill_image = fz_list_fill_image; - dev->fill_image_mask = fz_list_fill_image_mask; - dev->clip_image_mask = fz_list_clip_image_mask; + dev->super.pop_clip = fz_list_pop_clip; - dev->pop_clip = fz_list_pop_clip; + dev->super.begin_mask = fz_list_begin_mask; + dev->super.end_mask = fz_list_end_mask; + dev->super.begin_group = fz_list_begin_group; + dev->super.end_group = fz_list_end_group; - dev->begin_mask = fz_list_begin_mask; - dev->end_mask = fz_list_end_mask; - dev->begin_group = fz_list_begin_group; - dev->end_group = fz_list_end_group; + dev->super.begin_tile = fz_list_begin_tile; + dev->super.end_tile = fz_list_end_tile; - dev->begin_tile = fz_list_begin_tile; - dev->end_tile = fz_list_end_tile; + dev->list = list; - return dev; + return (fz_device*)dev; } static void diff --git a/source/fitz/stext-device.c b/source/fitz/stext-device.c index dd1249c8..cdba39f8 100644 --- a/source/fitz/stext-device.c +++ b/source/fitz/stext-device.c @@ -25,6 +25,7 @@ typedef struct span_soup_s span_soup; struct fz_text_device_s { + fz_device super; fz_text_sheet *sheet; fz_text_page *page; span_soup *spans; @@ -788,7 +789,7 @@ static void fz_text_fill_text(fz_context *ctx, fz_device *dev, fz_text *text, const fz_matrix *ctm, fz_colorspace *colorspace, float *color, float alpha) { - fz_text_device *tdev = dev->user; + fz_text_device *tdev = (fz_text_device*)dev; fz_text_style *style; style = fz_lookup_text_style(ctx, tdev->sheet, text, ctm, colorspace, color, alpha, NULL); fz_text_extract(ctx, tdev, text, ctm, style); @@ -798,7 +799,7 @@ static void fz_text_stroke_text(fz_context *ctx, fz_device *dev, fz_text *text, fz_stroke_state *stroke, const fz_matrix *ctm, fz_colorspace *colorspace, float *color, float alpha) { - fz_text_device *tdev = dev->user; + fz_text_device *tdev = (fz_text_device*)dev; fz_text_style *style; style = fz_lookup_text_style(ctx, tdev->sheet, text, ctm, colorspace, color, alpha, stroke); fz_text_extract(ctx, tdev, text, ctm, style); @@ -807,7 +808,7 @@ fz_text_stroke_text(fz_context *ctx, fz_device *dev, fz_text *text, fz_stroke_st static void fz_text_clip_text(fz_context *ctx, fz_device *dev, fz_text *text, const fz_matrix *ctm, int accumulate) { - fz_text_device *tdev = dev->user; + fz_text_device *tdev = (fz_text_device*)dev; fz_text_style *style; style = fz_lookup_text_style(ctx, tdev->sheet, text, ctm, NULL, NULL, 0, NULL); fz_text_extract(ctx, tdev, text, ctm, style); @@ -816,7 +817,7 @@ fz_text_clip_text(fz_context *ctx, fz_device *dev, fz_text *text, const fz_matri static void fz_text_clip_stroke_text(fz_context *ctx, fz_device *dev, fz_text *text, fz_stroke_state *stroke, const fz_matrix *ctm) { - fz_text_device *tdev = dev->user; + fz_text_device *tdev = (fz_text_device*)dev; fz_text_style *style; style = fz_lookup_text_style(ctx, tdev->sheet, text, ctm, NULL, NULL, 0, stroke); fz_text_extract(ctx, tdev, text, ctm, style); @@ -825,7 +826,7 @@ fz_text_clip_stroke_text(fz_context *ctx, fz_device *dev, fz_text *text, fz_stro static void fz_text_ignore_text(fz_context *ctx, fz_device *dev, fz_text *text, const fz_matrix *ctm) { - fz_text_device *tdev = dev->user; + fz_text_device *tdev = (fz_text_device*)dev; fz_text_style *style; style = fz_lookup_text_style(ctx, tdev->sheet, text, ctm, NULL, NULL, 0, NULL); fz_text_extract(ctx, tdev, text, ctm, style); @@ -835,7 +836,7 @@ static void fz_text_fill_image_mask(fz_context *ctx, fz_device *dev, fz_image *img, const fz_matrix *ctm, fz_colorspace *cspace, float *color, float alpha) { - fz_text_device *tdev = dev->user; + fz_text_device *tdev = (fz_text_device*)dev; fz_text_page *page = tdev->page; fz_image_block *block; @@ -956,7 +957,7 @@ fz_bidi_reorder_text_page(fz_context *ctx, fz_text_page *page) static void fz_text_begin_page(fz_context *ctx, fz_device *dev, const fz_rect *mediabox, const fz_matrix *ctm) { - fz_text_device *tdev = dev->user; + fz_text_device *tdev = (fz_text_device*)dev; if (tdev->page->len) { @@ -973,7 +974,7 @@ fz_text_begin_page(fz_context *ctx, fz_device *dev, const fz_rect *mediabox, con static void fz_text_end_page(fz_context *ctx, fz_device *dev) { - fz_text_device *tdev = dev->user; + fz_text_device *tdev = (fz_text_device*)dev; add_span_to_soup(ctx, tdev->spans, tdev->cur_span); tdev->cur_span = NULL; @@ -989,37 +990,35 @@ fz_text_end_page(fz_context *ctx, fz_device *dev) } static void -fz_text_drop_user(fz_context *ctx, fz_device *dev) +fz_text_drop_imp(fz_context *ctx, fz_device *dev) { - fz_text_device *tdev = dev->user; + fz_text_device *tdev = (fz_text_device*)dev; free_span_soup(ctx, tdev->spans); - fz_free(ctx, tdev); } fz_device * fz_new_text_device(fz_context *ctx, fz_text_sheet *sheet, fz_text_page *page) { - fz_device *dev; - - fz_text_device *tdev = fz_malloc_struct(ctx, fz_text_device); - tdev->sheet = sheet; - tdev->page = page; - tdev->spans = NULL; - tdev->cur_span = NULL; - tdev->lastchar = ' '; - - dev = fz_new_device(ctx, tdev); - dev->hints = FZ_IGNORE_IMAGE | FZ_IGNORE_SHADE; - dev->begin_page = fz_text_begin_page; - dev->end_page = fz_text_end_page; - dev->drop_user = fz_text_drop_user; - dev->fill_text = fz_text_fill_text; - dev->stroke_text = fz_text_stroke_text; - dev->clip_text = fz_text_clip_text; - dev->clip_stroke_text = fz_text_clip_stroke_text; - dev->ignore_text = fz_text_ignore_text; - dev->fill_image = fz_text_fill_image; - dev->fill_image_mask = fz_text_fill_image_mask; - - return dev; + fz_text_device *dev = fz_new_device(ctx, sizeof *dev); + + dev->super.hints = FZ_IGNORE_IMAGE | FZ_IGNORE_SHADE; + + dev->super.drop_imp = fz_text_drop_imp; + dev->super.begin_page = fz_text_begin_page; + dev->super.end_page = fz_text_end_page; + dev->super.fill_text = fz_text_fill_text; + dev->super.stroke_text = fz_text_stroke_text; + dev->super.clip_text = fz_text_clip_text; + dev->super.clip_stroke_text = fz_text_clip_stroke_text; + dev->super.ignore_text = fz_text_ignore_text; + dev->super.fill_image = fz_text_fill_image; + dev->super.fill_image_mask = fz_text_fill_image_mask; + + dev->sheet = sheet; + dev->page = page; + dev->spans = NULL; + dev->cur_span = NULL; + dev->lastchar = ' '; + + return (fz_device*)dev; } diff --git a/source/fitz/svg-device.c b/source/fitz/svg-device.c index 29acc530..8d977597 100644 --- a/source/fitz/svg-device.c +++ b/source/fitz/svg-device.c @@ -31,6 +31,8 @@ struct font_s struct svg_device_s { + fz_device super; + fz_output *out; fz_output *out_store; fz_output *defs; @@ -305,7 +307,7 @@ svg_dev_text(fz_context *ctx, svg_device *sdev, const fz_matrix *ctm, fz_text *t static font * svg_dev_text_as_paths_defs(fz_context *ctx, fz_device *dev, fz_text *text, const fz_matrix *ctm) { - svg_device *sdev = dev->user; + svg_device *sdev = (svg_device*)dev; fz_output *out = sdev->out; int i, font_idx; font *fnt; @@ -392,7 +394,7 @@ static void svg_dev_text_as_paths_fill(fz_context *ctx, fz_device *dev, fz_text *text, const fz_matrix *ctm, fz_colorspace *colorspace, float *color, float alpha, font *fnt) { - svg_device *sdev = dev->user; + svg_device *sdev = (svg_device*)dev; fz_output *out = sdev->out; fz_matrix local_trm, local_trm2; @@ -433,7 +435,7 @@ svg_dev_text_as_paths_stroke(fz_context *ctx, fz_device *dev, fz_text *text, fz_stroke_state *stroke, const fz_matrix *ctm, fz_colorspace *colorspace, float *color, float alpha, font *fnt) { - svg_device *sdev = dev->user; + svg_device *sdev = (svg_device*)dev; fz_output *out = sdev->out; fz_matrix local_trm, local_trm2; @@ -476,7 +478,7 @@ static void svg_dev_fill_path(fz_context *ctx, fz_device *dev, fz_path *path, int even_odd, const fz_matrix *ctm, fz_colorspace *colorspace, float *color, float alpha) { - svg_device *sdev = dev->user; + svg_device *sdev = (svg_device*)dev; fz_output *out = sdev->out; fz_printf(ctx, out, "user; + svg_device *sdev = (svg_device*)dev; fz_output *out = sdev->out; fz_printf(ctx, out, "user; + svg_device *sdev = (svg_device*)dev; fz_output *out; int num = sdev->id++; @@ -526,7 +528,7 @@ svg_dev_clip_path(fz_context *ctx, fz_device *dev, fz_path *path, const fz_rect static void svg_dev_clip_stroke_path(fz_context *ctx, fz_device *dev, fz_path *path, const fz_rect *rect, fz_stroke_state *stroke, const fz_matrix *ctm) { - svg_device *sdev = dev->user; + svg_device *sdev = (svg_device*)dev; fz_output *out; fz_rect bounds; @@ -552,7 +554,7 @@ static void svg_dev_fill_text(fz_context *ctx, fz_device *dev, fz_text *text, const fz_matrix *ctm, fz_colorspace *colorspace, float *color, float alpha) { - svg_device *sdev = dev->user; + svg_device *sdev = (svg_device*)dev; fz_output *out = sdev->out; font *fnt; @@ -568,7 +570,7 @@ static void svg_dev_stroke_text(fz_context *ctx, fz_device *dev, fz_text *text, fz_stroke_state *stroke, const fz_matrix *ctm, fz_colorspace *colorspace, float *color, float alpha) { - svg_device *sdev = dev->user; + svg_device *sdev = (svg_device*)dev; fz_output *out = sdev->out; font *fnt; @@ -583,7 +585,7 @@ svg_dev_stroke_text(fz_context *ctx, fz_device *dev, fz_text *text, fz_stroke_st static void svg_dev_clip_text(fz_context *ctx, fz_device *dev, fz_text *text, const fz_matrix *ctm, int accumulate) { - svg_device *sdev = dev->user; + svg_device *sdev = (svg_device*)dev; fz_output *out = sdev->out; fz_rect bounds; @@ -609,7 +611,7 @@ svg_dev_clip_text(fz_context *ctx, fz_device *dev, fz_text *text, const fz_matri static void svg_dev_clip_stroke_text(fz_context *ctx, fz_device *dev, fz_text *text, fz_stroke_state *stroke, const fz_matrix *ctm) { - svg_device *sdev = dev->user; + svg_device *sdev = (svg_device*)dev; fz_output *out; fz_rect bounds; @@ -636,7 +638,7 @@ svg_dev_clip_stroke_text(fz_context *ctx, fz_device *dev, fz_text *text, fz_stro static void svg_dev_ignore_text(fz_context *ctx, fz_device *dev, fz_text *text, const fz_matrix *ctm) { - svg_device *sdev = dev->user; + svg_device *sdev = (svg_device*)dev; fz_output *out = sdev->out; float black[3] = { 0, 0, 0}; @@ -687,7 +689,7 @@ send_data_base64(fz_context *ctx, fz_output *out, fz_buffer *buffer) static void svg_dev_fill_image(fz_context *ctx, fz_device *dev, fz_image *image, const fz_matrix *ctm, float alpha) { - svg_device *sdev = dev->user; + svg_device *sdev = (svg_device*)dev; fz_output *out = sdev->out; fz_matrix local_ctm = *ctm; @@ -729,7 +731,7 @@ svg_dev_fill_image(fz_context *ctx, fz_device *dev, fz_image *image, const fz_ma static void svg_dev_fill_shade(fz_context *ctx, fz_device *dev, fz_shade *shade, const fz_matrix *ctm, float alpha) { - svg_device *sdev = dev->user; + svg_device *sdev = (svg_device*)dev; fz_output *out = sdev->out; fz_rect rect; @@ -775,7 +777,7 @@ static void svg_dev_fill_image_mask(fz_context *ctx, fz_device *dev, fz_image *image, const fz_matrix *ctm, fz_colorspace *colorspace, float *color, float alpha) { - svg_device *sdev = dev->user; + svg_device *sdev = (svg_device*)dev; fz_output *out; fz_matrix local_ctm = *ctm; @@ -819,7 +821,7 @@ fz_colorspace *colorspace, float *color, float alpha) static void svg_dev_clip_image_mask(fz_context *ctx, fz_device *dev, fz_image *image, const fz_rect *rect, const fz_matrix *ctm) { - svg_device *sdev = dev->user; + svg_device *sdev = (svg_device*)dev; fz_output *out; fz_matrix local_ctm = *ctm; fz_matrix scale = { 0 }; @@ -860,7 +862,7 @@ svg_dev_clip_image_mask(fz_context *ctx, fz_device *dev, fz_image *image, const static void svg_dev_pop_clip(fz_context *ctx, fz_device *dev) { - svg_device *sdev = dev->user; + svg_device *sdev = (svg_device*)dev; fz_output *out = sdev->out; /* FIXME */ @@ -870,7 +872,7 @@ svg_dev_pop_clip(fz_context *ctx, fz_device *dev) static void svg_dev_begin_mask(fz_context *ctx, fz_device *dev, const fz_rect *bbox, int luminosity, fz_colorspace *colorspace, float *color) { - svg_device *sdev = dev->user; + svg_device *sdev = (svg_device*)dev; fz_output *out; int mask = sdev->id++; @@ -884,7 +886,7 @@ svg_dev_begin_mask(fz_context *ctx, fz_device *dev, const fz_rect *bbox, int lum static void svg_dev_end_mask(fz_context *ctx, fz_device *dev) { - svg_device *sdev = dev->user; + svg_device *sdev = (svg_device*)dev; fz_output *out = sdev->out; int mask = 0; @@ -900,7 +902,7 @@ svg_dev_end_mask(fz_context *ctx, fz_device *dev) static void svg_dev_begin_group(fz_context *ctx, fz_device *dev, const fz_rect *bbox, int isolated, int knockout, int blendmode, float alpha) { - svg_device *sdev = dev->user; + svg_device *sdev = (svg_device*)dev; fz_output *out = sdev->out; /* SVG 1.1 doesn't support adequate blendmodes/knockout etc, so just ignore it for now */ @@ -910,7 +912,7 @@ svg_dev_begin_group(fz_context *ctx, fz_device *dev, const fz_rect *bbox, int is static void svg_dev_end_group(fz_context *ctx, fz_device *dev) { - svg_device *sdev = dev->user; + svg_device *sdev = (svg_device*)dev; fz_output *out = sdev->out; fz_printf(ctx, out, "\n"); @@ -919,7 +921,7 @@ svg_dev_end_group(fz_context *ctx, fz_device *dev) static int svg_dev_begin_tile(fz_context *ctx, fz_device *dev, const fz_rect *area, const fz_rect *view, float xstep, float ystep, const fz_matrix *ctm, int id) { - svg_device *sdev = dev->user; + svg_device *sdev = (svg_device*)dev; fz_output *out; int num; tile *t; @@ -960,7 +962,7 @@ svg_dev_begin_tile(fz_context *ctx, fz_device *dev, const fz_rect *area, const f static void svg_dev_end_tile(fz_context *ctx, fz_device *dev) { - svg_device *sdev = dev->user; + svg_device *sdev = (svg_device*)dev; fz_output *out = sdev->out; int num, cp = -1; tile *t; @@ -1028,9 +1030,9 @@ svg_dev_end_tile(fz_context *ctx, fz_device *dev) } static void -svg_dev_drop_user(fz_context *ctx, fz_device *dev) +svg_dev_drop_imp(fz_context *ctx, fz_device *dev) { - svg_device *sdev = dev->user; + svg_device *sdev = (svg_device*)dev; fz_output *out = sdev->out; fz_free(ctx, sdev->tiles); @@ -1038,58 +1040,47 @@ svg_dev_drop_user(fz_context *ctx, fz_device *dev) fz_drop_output(ctx, sdev->defs); fz_printf(ctx, out, "\n"); - - fz_free(ctx, sdev); } fz_device *fz_new_svg_device(fz_context *ctx, fz_output *out, float page_width, float page_height) { - svg_device *sdev = fz_malloc_struct(ctx, svg_device); - fz_device *dev; + svg_device *dev = fz_new_device(ctx, sizeof *dev); - fz_try(ctx) - { - sdev->out = out; - sdev->out_store = out; - sdev->id = 0; + dev = fz_new_device(ctx, sizeof *dev); - dev = fz_new_device(ctx, sdev); - } - fz_catch(ctx) - { - fz_free(ctx, sdev); - fz_rethrow(ctx); - } + dev->super.drop_imp = svg_dev_drop_imp; - dev->drop_user = svg_dev_drop_user; + dev->super.fill_path = svg_dev_fill_path; + dev->super.stroke_path = svg_dev_stroke_path; + dev->super.clip_path = svg_dev_clip_path; + dev->super.clip_stroke_path = svg_dev_clip_stroke_path; - dev->fill_path = svg_dev_fill_path; - dev->stroke_path = svg_dev_stroke_path; - dev->clip_path = svg_dev_clip_path; - dev->clip_stroke_path = svg_dev_clip_stroke_path; + dev->super.fill_text = svg_dev_fill_text; + dev->super.stroke_text = svg_dev_stroke_text; + dev->super.clip_text = svg_dev_clip_text; + dev->super.clip_stroke_text = svg_dev_clip_stroke_text; + dev->super.ignore_text = svg_dev_ignore_text; - dev->fill_text = svg_dev_fill_text; - dev->stroke_text = svg_dev_stroke_text; - dev->clip_text = svg_dev_clip_text; - dev->clip_stroke_text = svg_dev_clip_stroke_text; - dev->ignore_text = svg_dev_ignore_text; + dev->super.fill_shade = svg_dev_fill_shade; + dev->super.fill_image = svg_dev_fill_image; + dev->super.fill_image_mask = svg_dev_fill_image_mask; + dev->super.clip_image_mask = svg_dev_clip_image_mask; - dev->fill_shade = svg_dev_fill_shade; - dev->fill_image = svg_dev_fill_image; - dev->fill_image_mask = svg_dev_fill_image_mask; - dev->clip_image_mask = svg_dev_clip_image_mask; + dev->super.pop_clip = svg_dev_pop_clip; - dev->pop_clip = svg_dev_pop_clip; + dev->super.begin_mask = svg_dev_begin_mask; + dev->super.end_mask = svg_dev_end_mask; + dev->super.begin_group = svg_dev_begin_group; + dev->super.end_group = svg_dev_end_group; - dev->begin_mask = svg_dev_begin_mask; - dev->end_mask = svg_dev_end_mask; - dev->begin_group = svg_dev_begin_group; - dev->end_group = svg_dev_end_group; + dev->super.begin_tile = svg_dev_begin_tile; + dev->super.end_tile = svg_dev_end_tile; - dev->begin_tile = svg_dev_begin_tile; - dev->end_tile = svg_dev_end_tile; + dev->super.hints |= FZ_MAINTAIN_CONTAINER_STACK; - dev->hints |= FZ_MAINTAIN_CONTAINER_STACK; + dev->out = out; + dev->out_store = out; + dev->id = 0; fz_printf(ctx, out, "\n"); fz_printf(ctx, out, "\n"); @@ -1098,5 +1089,5 @@ fz_device *fz_new_svg_device(fz_context *ctx, fz_output *out, float page_width, "width=\"%gcm\" height=\"%gcm\" viewBox=\"0 0 %g %g\">\n", page_width*2.54/72, page_height*2.54/72, page_width, page_height); - return dev; + return (fz_device*)dev; } diff --git a/source/fitz/test-device.c b/source/fitz/test-device.c index 16736c80..d0bd08c7 100644 --- a/source/fitz/test-device.c +++ b/source/fitz/test-device.c @@ -1,10 +1,11 @@ #include -struct test +typedef struct fz_test_device_s { + fz_device super; int *is_color; float threshold; -}; +} fz_test_device; static int is_rgb_color(float threshold, float r, float g, float b) @@ -27,7 +28,7 @@ is_rgb_color_u8(int threshold_u8, int r, int g, int b) static void fz_test_color(fz_context *ctx, fz_device *dev, fz_colorspace *colorspace, const float *color) { - struct test *t = dev->user; + fz_test_device *t = (fz_test_device*)dev; if (!*t->is_color && colorspace && colorspace != fz_device_gray(ctx)) { @@ -123,7 +124,7 @@ fz_test_fill_shade(fz_context *ctx, fz_device *dev, fz_shade *shade, const fz_ma static void fz_test_fill_image(fz_context *ctx, fz_device *dev, fz_image *image, const fz_matrix *ctm, float alpha) { - struct test *t = dev->user; + fz_test_device *t = (fz_test_device*)dev; fz_pixmap *pix; unsigned int count, i, k; @@ -247,45 +248,23 @@ fz_test_fill_image_mask(fz_context *ctx, fz_device *dev, fz_image *image, const fz_test_color(ctx, dev, colorspace, color); } -static void -fz_test_free(fz_context *ctx, fz_device *dev) -{ - if (dev == NULL) - return; - fz_free(ctx, dev->user); - dev->user = NULL; -} - fz_device * fz_new_test_device(fz_context *ctx, int *is_color, float threshold) { - struct test *t; - fz_device *dev; - - t = fz_malloc_struct(ctx, struct test); - t->is_color = is_color; - t->threshold = threshold; + fz_test_device *dev = fz_new_device(ctx, sizeof *dev); - fz_try(ctx) - { - dev = fz_new_device(ctx, t); - } - fz_catch(ctx) - { - fz_free(ctx, t); - fz_rethrow(ctx); - } + dev->super.fill_path = fz_test_fill_path; + dev->super.stroke_path = fz_test_stroke_path; + dev->super.fill_text = fz_test_fill_text; + dev->super.stroke_text = fz_test_stroke_text; + dev->super.fill_shade = fz_test_fill_shade; + dev->super.fill_image = fz_test_fill_image; + dev->super.fill_image_mask = fz_test_fill_image_mask; - dev->fill_path = fz_test_fill_path; - dev->stroke_path = fz_test_stroke_path; - dev->fill_text = fz_test_fill_text; - dev->stroke_text = fz_test_stroke_text; - dev->fill_shade = fz_test_fill_shade; - dev->fill_image = fz_test_fill_image; - dev->fill_image_mask = fz_test_fill_image_mask; - dev->drop_user = fz_test_free; + dev->is_color = is_color; + dev->threshold = threshold; - *t->is_color = 0; + *dev->is_color = 0; - return dev; + return (fz_device*)dev; } diff --git a/source/fitz/trace-device.c b/source/fitz/trace-device.c index 3a0bba0a..97dd4f79 100644 --- a/source/fitz/trace-device.c +++ b/source/fitz/trace-device.c @@ -303,7 +303,7 @@ fz_trace_end_tile(fz_context *ctx, fz_device *dev) fz_device *fz_new_trace_device(fz_context *ctx) { - fz_device *dev = fz_new_device(ctx, NULL); + fz_device *dev = fz_new_device(ctx, sizeof *dev); dev->begin_page = fz_trace_begin_page; dev->end_page = fz_trace_end_page; diff --git a/source/pdf/pdf-device.c b/source/pdf/pdf-device.c index 471aaced..b5db7e3a 100644 --- a/source/pdf/pdf-device.c +++ b/source/pdf/pdf-device.c @@ -72,6 +72,8 @@ struct group_entry_s struct pdf_device_s { + fz_device super; + pdf_document *doc; pdf_obj *contents; pdf_obj *resources; @@ -855,7 +857,7 @@ static void pdf_dev_fill_path(fz_context *ctx, fz_device *dev, fz_path *path, int even_odd, const fz_matrix *ctm, fz_colorspace *colorspace, float *color, float alpha) { - pdf_device *pdev = dev->user; + pdf_device *pdev = (pdf_device*)dev; gstate *gs = CURRENT_GSTATE(pdev); pdf_dev_end_text(ctx, pdev); @@ -870,7 +872,7 @@ static void pdf_dev_stroke_path(fz_context *ctx, fz_device *dev, fz_path *path, fz_stroke_state *stroke, const fz_matrix *ctm, fz_colorspace *colorspace, float *color, float alpha) { - pdf_device *pdev = dev->user; + pdf_device *pdev = (pdf_device*)dev; gstate *gs = CURRENT_GSTATE(pdev); pdf_dev_end_text(ctx, pdev); @@ -885,7 +887,7 @@ pdf_dev_stroke_path(fz_context *ctx, fz_device *dev, fz_path *path, fz_stroke_st static void pdf_dev_clip_path(fz_context *ctx, fz_device *dev, fz_path *path, const fz_rect *rect, int even_odd, const fz_matrix *ctm) { - pdf_device *pdev = dev->user; + pdf_device *pdev = (pdf_device*)dev; gstate *gs; pdf_dev_end_text(ctx, pdev); @@ -899,7 +901,7 @@ pdf_dev_clip_path(fz_context *ctx, fz_device *dev, fz_path *path, const fz_rect static void pdf_dev_clip_stroke_path(fz_context *ctx, fz_device *dev, fz_path *path, const fz_rect *rect, fz_stroke_state *stroke, const fz_matrix *ctm) { - pdf_device *pdev = dev->user; + pdf_device *pdev = (pdf_device*)dev; gstate *gs; pdf_dev_end_text(ctx, pdev); @@ -918,7 +920,7 @@ static void pdf_dev_fill_text(fz_context *ctx, fz_device *dev, fz_text *text, const fz_matrix *ctm, fz_colorspace *colorspace, float *color, float alpha) { - pdf_device *pdev = dev->user; + pdf_device *pdev = (pdf_device*)dev; fz_matrix trm = text->trm; float size = fz_matrix_expansion(&trm); @@ -936,7 +938,7 @@ static void pdf_dev_stroke_text(fz_context *ctx, fz_device *dev, fz_text *text, fz_stroke_state *stroke, const fz_matrix *ctm, fz_colorspace *colorspace, float *color, float alpha) { - pdf_device *pdev = dev->user; + pdf_device *pdev = (pdf_device*)dev; fz_matrix trm = text->trm; float size = fz_matrix_expansion(&trm); @@ -953,7 +955,7 @@ pdf_dev_stroke_text(fz_context *ctx, fz_device *dev, fz_text *text, fz_stroke_st static void pdf_dev_clip_text(fz_context *ctx, fz_device *dev, fz_text *text, const fz_matrix *ctm, int accumulate) { - pdf_device *pdev = dev->user; + pdf_device *pdev = (pdf_device*)dev; fz_matrix trm = text->trm; float size = fz_matrix_expansion(&trm); @@ -968,7 +970,7 @@ pdf_dev_clip_text(fz_context *ctx, fz_device *dev, fz_text *text, const fz_matri static void pdf_dev_clip_stroke_text(fz_context *ctx, fz_device *dev, fz_text *text, fz_stroke_state *stroke, const fz_matrix *ctm) { - pdf_device *pdev = dev->user; + pdf_device *pdev = (pdf_device*)dev; fz_matrix trm = text->trm; float size = fz_matrix_expansion(&trm); @@ -983,7 +985,7 @@ pdf_dev_clip_stroke_text(fz_context *ctx, fz_device *dev, fz_text *text, fz_stro static void pdf_dev_ignore_text(fz_context *ctx, fz_device *dev, fz_text *text, const fz_matrix *ctm) { - pdf_device *pdev = dev->user; + pdf_device *pdev = (pdf_device*)dev; fz_matrix trm = text->trm; float size = fz_matrix_expansion(&trm); @@ -998,7 +1000,7 @@ pdf_dev_ignore_text(fz_context *ctx, fz_device *dev, fz_text *text, const fz_mat static void pdf_dev_fill_image(fz_context *ctx, fz_device *dev, fz_image *image, const fz_matrix *ctm, float alpha) { - pdf_device *pdev = dev->user; + pdf_device *pdev = (pdf_device*)dev; int num; gstate *gs = CURRENT_GSTATE(pdev); fz_matrix local_ctm = *ctm; @@ -1016,7 +1018,7 @@ pdf_dev_fill_image(fz_context *ctx, fz_device *dev, fz_image *image, const fz_ma static void pdf_dev_fill_shade(fz_context *ctx, fz_device *dev, fz_shade *shade, const fz_matrix *ctm, float alpha) { - pdf_device *pdev = dev->user; + pdf_device *pdev = (pdf_device*)dev; /* FIXME */ pdf_dev_end_text(ctx, pdev); @@ -1026,7 +1028,7 @@ static void pdf_dev_fill_image_mask(fz_context *ctx, fz_device *dev, fz_image *image, const fz_matrix *ctm, fz_colorspace *colorspace, float *color, float alpha) { - pdf_device *pdev = dev->user; + pdf_device *pdev = (pdf_device*)dev; gstate *gs = CURRENT_GSTATE(pdev); int num; fz_matrix local_ctm = *ctm; @@ -1046,7 +1048,7 @@ fz_colorspace *colorspace, float *color, float alpha) static void pdf_dev_clip_image_mask(fz_context *ctx, fz_device *dev, fz_image *image, const fz_rect *rect, const fz_matrix *ctm) { - pdf_device *pdev = dev->user; + pdf_device *pdev = (pdf_device*)dev; /* FIXME */ pdf_dev_end_text(ctx, pdev); @@ -1056,7 +1058,7 @@ pdf_dev_clip_image_mask(fz_context *ctx, fz_device *dev, fz_image *image, const static void pdf_dev_pop_clip(fz_context *ctx, fz_device *dev) { - pdf_device *pdev = dev->user; + pdf_device *pdev = (pdf_device*)dev; /* FIXME */ pdf_dev_end_text(ctx, pdev); @@ -1066,7 +1068,7 @@ pdf_dev_pop_clip(fz_context *ctx, fz_device *dev) static void pdf_dev_begin_mask(fz_context *ctx, fz_device *dev, const fz_rect *bbox, int luminosity, fz_colorspace *colorspace, float *color) { - pdf_device *pdev = dev->user; + pdf_device *pdev = (pdf_device*)dev; pdf_document *doc = pdev->doc; gstate *gs; pdf_obj *smask = NULL; @@ -1130,7 +1132,7 @@ pdf_dev_begin_mask(fz_context *ctx, fz_device *dev, const fz_rect *bbox, int lum static void pdf_dev_end_mask(fz_context *ctx, fz_device *dev) { - pdf_device *pdev = dev->user; + pdf_device *pdev = (pdf_device*)dev; pdf_document *doc = pdev->doc; gstate *gs = CURRENT_GSTATE(pdev); fz_buffer *buf = fz_keep_buffer(ctx, gs->buf); @@ -1151,7 +1153,7 @@ pdf_dev_end_mask(fz_context *ctx, fz_device *dev) static void pdf_dev_begin_group(fz_context *ctx, fz_device *dev, const fz_rect *bbox, int isolated, int knockout, int blendmode, float alpha) { - pdf_device *pdev = dev->user; + pdf_device *pdev = (pdf_device*)dev; pdf_document *doc = pdev->doc; int num; pdf_obj *form_ref; @@ -1189,7 +1191,7 @@ pdf_dev_begin_group(fz_context *ctx, fz_device *dev, const fz_rect *bbox, int is static void pdf_dev_end_group(fz_context *ctx, fz_device *dev) { - pdf_device *pdev = dev->user; + pdf_device *pdev = (pdf_device*)dev; pdf_document *doc = pdev->doc; gstate *gs = CURRENT_GSTATE(pdev); fz_buffer *buf = fz_keep_buffer(ctx, gs->buf); @@ -1206,7 +1208,7 @@ pdf_dev_end_group(fz_context *ctx, fz_device *dev) static int pdf_dev_begin_tile(fz_context *ctx, fz_device *dev, const fz_rect *area, const fz_rect *view, float xstep, float ystep, const fz_matrix *ctm, int id) { - pdf_device *pdev = dev->user; + pdf_device *pdev = (pdf_device*)dev; /* FIXME */ pdf_dev_end_text(ctx, pdev); @@ -1216,16 +1218,16 @@ pdf_dev_begin_tile(fz_context *ctx, fz_device *dev, const fz_rect *area, const f static void pdf_dev_end_tile(fz_context *ctx, fz_device *dev) { - pdf_device *pdev = dev->user; + pdf_device *pdev = (pdf_device*)dev; /* FIXME */ pdf_dev_end_text(ctx, pdev); } static void -pdf_dev_drop_user(fz_context *ctx, fz_device *dev) +pdf_dev_drop_imp(fz_context *ctx, fz_device *dev) { - pdf_device *pdev = dev->user; + pdf_device *pdev = (pdf_device*)dev; pdf_document *doc = pdev->doc; gstate *gs = CURRENT_GSTATE(pdev); int i; @@ -1258,72 +1260,68 @@ pdf_dev_drop_user(fz_context *ctx, fz_device *dev) fz_free(ctx, pdev->images); fz_free(ctx, pdev->alphas); fz_free(ctx, pdev->gstates); - fz_free(ctx, pdev); } fz_device *pdf_new_pdf_device(fz_context *ctx, pdf_document *doc, pdf_obj *contents, pdf_obj *resources, const fz_matrix *ctm) { - pdf_device *pdev = fz_malloc_struct(ctx, pdf_device); - fz_device *dev; + pdf_device *dev = fz_new_device(ctx, sizeof *dev); - fz_try(ctx) - { - pdev->doc = doc; - pdev->contents = pdf_keep_obj(ctx, contents); - pdev->resources = pdf_keep_obj(ctx, resources); - pdev->gstates = fz_malloc_struct(ctx, gstate); - pdev->gstates[0].buf = fz_new_buffer(ctx, 256); - pdev->gstates[0].ctm = *ctm; - pdev->gstates[0].colorspace[0] = fz_device_gray(ctx); - pdev->gstates[0].colorspace[1] = fz_device_gray(ctx); - pdev->gstates[0].color[0][0] = 1; - pdev->gstates[0].color[1][0] = 1; - pdev->gstates[0].alpha[0] = 1.0; - pdev->gstates[0].alpha[1] = 1.0; - pdev->gstates[0].font = -1; - pdev->gstates[0].horizontal_scaling = 100; - pdev->num_gstates = 1; - pdev->max_gstates = 1; - - dev = fz_new_device(ctx, pdev); - } - fz_catch(ctx) - { - if (pdev->gstates) - fz_drop_buffer(ctx, pdev->gstates[0].buf); - fz_free(ctx, pdev); - fz_rethrow(ctx); - } + dev->super.drop_imp = pdf_dev_drop_imp; - dev->drop_user = pdf_dev_drop_user; + dev->super.fill_path = pdf_dev_fill_path; + dev->super.stroke_path = pdf_dev_stroke_path; + dev->super.clip_path = pdf_dev_clip_path; + dev->super.clip_stroke_path = pdf_dev_clip_stroke_path; - dev->fill_path = pdf_dev_fill_path; - dev->stroke_path = pdf_dev_stroke_path; - dev->clip_path = pdf_dev_clip_path; - dev->clip_stroke_path = pdf_dev_clip_stroke_path; + dev->super.fill_text = pdf_dev_fill_text; + dev->super.stroke_text = pdf_dev_stroke_text; + dev->super.clip_text = pdf_dev_clip_text; + dev->super.clip_stroke_text = pdf_dev_clip_stroke_text; + dev->super.ignore_text = pdf_dev_ignore_text; - dev->fill_text = pdf_dev_fill_text; - dev->stroke_text = pdf_dev_stroke_text; - dev->clip_text = pdf_dev_clip_text; - dev->clip_stroke_text = pdf_dev_clip_stroke_text; - dev->ignore_text = pdf_dev_ignore_text; + dev->super.fill_shade = pdf_dev_fill_shade; + dev->super.fill_image = pdf_dev_fill_image; + dev->super.fill_image_mask = pdf_dev_fill_image_mask; + dev->super.clip_image_mask = pdf_dev_clip_image_mask; - dev->fill_shade = pdf_dev_fill_shade; - dev->fill_image = pdf_dev_fill_image; - dev->fill_image_mask = pdf_dev_fill_image_mask; - dev->clip_image_mask = pdf_dev_clip_image_mask; + dev->super.pop_clip = pdf_dev_pop_clip; - dev->pop_clip = pdf_dev_pop_clip; + dev->super.begin_mask = pdf_dev_begin_mask; + dev->super.end_mask = pdf_dev_end_mask; + dev->super.begin_group = pdf_dev_begin_group; + dev->super.end_group = pdf_dev_end_group; - dev->begin_mask = pdf_dev_begin_mask; - dev->end_mask = pdf_dev_end_mask; - dev->begin_group = pdf_dev_begin_group; - dev->end_group = pdf_dev_end_group; + dev->super.begin_tile = pdf_dev_begin_tile; + dev->super.end_tile = pdf_dev_end_tile; - dev->begin_tile = pdf_dev_begin_tile; - dev->end_tile = pdf_dev_end_tile; + fz_try(ctx) + { + dev->doc = doc; + dev->contents = pdf_keep_obj(ctx, contents); + dev->resources = pdf_keep_obj(ctx, resources); + dev->gstates = fz_malloc_struct(ctx, gstate); + dev->gstates[0].buf = fz_new_buffer(ctx, 256); + dev->gstates[0].ctm = *ctm; + dev->gstates[0].colorspace[0] = fz_device_gray(ctx); + dev->gstates[0].colorspace[1] = fz_device_gray(ctx); + dev->gstates[0].color[0][0] = 1; + dev->gstates[0].color[1][0] = 1; + dev->gstates[0].alpha[0] = 1.0; + dev->gstates[0].alpha[1] = 1.0; + dev->gstates[0].font = -1; + dev->gstates[0].horizontal_scaling = 100; + dev->num_gstates = 1; + dev->max_gstates = 1; + } + fz_catch(ctx) + { + if (dev->gstates) + fz_drop_buffer(ctx, dev->gstates[0].buf); + fz_free(ctx, dev); + fz_rethrow(ctx); + } - return dev; + return (fz_device*)dev; } fz_device *pdf_page_write(fz_context *ctx, pdf_document *doc, pdf_page *page) -- cgit v1.2.3