From ddb92b7c3fdfcf9bf3d7463dde4e662ca10f79ba Mon Sep 17 00:00:00 2001 From: Tor Andersson Date: Fri, 25 Jan 2013 14:07:29 +0100 Subject: Eliminate fz_bbox in favor of fz_rect everywhere. --- android/jni/mupdf.c | 30 ++++----- apps/mudraw.c | 32 ++++----- apps/pdfapp.c | 36 +++++----- apps/pdfapp.h | 4 +- doc/example.c | 5 +- doc/multi-threaded.c | 10 ++- draw/draw_affine.c | 14 ++-- draw/draw_blend.c | 4 +- draw/draw_device.c | 108 +++++++++++++++--------------- draw/draw_edge.c | 24 +++---- draw/draw_glyph.c | 6 +- draw/draw_mesh.c | 6 +- draw/draw_paint.c | 16 ++--- draw/draw_scale.c | 6 +- draw/draw_simple_scale.c | 6 +- fitz/base_geometry.c | 155 +++++++++++-------------------------------- fitz/dev_bbox.c | 37 +++++------ fitz/dev_list.c | 26 ++++---- fitz/doc_search.c | 58 ++++++++-------- fitz/fitz-internal.h | 28 ++++---- fitz/fitz.h | 168 ++++++++++++----------------------------------- fitz/res_font.c | 27 ++++---- fitz/res_pixmap.c | 44 +++++++------ ios/main.m | 24 ++++--- 24 files changed, 355 insertions(+), 519 deletions(-) diff --git a/android/jni/mupdf.c b/android/jni/mupdf.c index a4180e54..62a45d33 100644 --- a/android/jni/mupdf.c +++ b/android/jni/mupdf.c @@ -61,7 +61,7 @@ struct globals_s fz_document *doc; int resolution; fz_context *ctx; - fz_bbox *hit_bbox; + fz_rect *hit_bbox; int current; char *current_path; @@ -444,7 +444,7 @@ JNI_FN(MuPDFCore_gotoPageInternal)(JNIEnv *env, jobject thiz, int page) int furthest_dist = -1; float zoom; fz_matrix ctm; - fz_bbox bbox; + fz_rect bbox; page_cache *pc; globals *glo = get_globals(env, thiz); fz_context *ctx = glo->ctx; @@ -537,10 +537,10 @@ JNI_FN(MuPDFCore_drawPage)(JNIEnv *env, jobject thiz, jobject bitmap, fz_device *dev = NULL; float zoom; fz_matrix ctm; - fz_bbox bbox; + fz_rect bbox; fz_pixmap *pix = NULL; float xscale, yscale; - fz_bbox rect; + fz_rect rect; globals *glo = get_globals(env, thiz); fz_context *ctx = glo->ctx; fz_document *doc = glo->doc; @@ -697,10 +697,10 @@ JNI_FN(MuPDFCore_updatePageInternal)(JNIEnv *env, jobject thiz, jobject bitmap, fz_device *dev = NULL; float zoom; fz_matrix ctm; - fz_bbox bbox; + fz_rect bbox; fz_pixmap *pix = NULL; float xscale, yscale; - fz_bbox rect; + fz_rect rect; fz_interactive *idoc; page_cache *pc = NULL; int hq = (patchW < pageW || patchH < pageH); @@ -799,12 +799,12 @@ JNI_FN(MuPDFCore_updatePageInternal)(JNIEnv *env, jobject thiz, jobject bitmap, LOGI("Start polling for updates"); while (idoc && (annot = fz_poll_changed_annot(idoc, page)) != NULL) { - fz_bbox abox = fz_round_rect(fz_transform_rect(ctm, fz_bound_annot(doc, annot))); - abox = fz_intersect_bbox(abox, rect); + fz_rect abox = fz_round_rect(fz_transform_rect(ctm, fz_bound_annot(doc, annot))); + abox = fz_intersect_rect(abox, rect); LOGI("Update rectanglefor %s - (%d, %d, %d, %d)", widget_type_string(fz_widget_get_type((fz_widget*)annot)), abox.x0, abox.y0, abox.x1, abox.y1); - if (!fz_is_empty_bbox(abox)) + if (!fz_is_empty_rect(abox)) { LOGI("And it isn't empty"); fz_clear_pixmap_rect_with_value(ctx, pix, 0xff, abox); @@ -868,10 +868,10 @@ charat(fz_text_page *page, int idx) return textcharat(page, idx).c; } -static fz_bbox +static fz_rect bboxcharat(fz_text_page *page, int idx) { - return fz_round_rect(textcharat(page, idx).bbox); + return textcharat(page, idx).bbox; } static int @@ -1076,12 +1076,12 @@ JNI_FN(MuPDFCore_searchPage)(JNIEnv * env, jobject thiz, jstring jtext) len = textlen(text); for (pos = 0; pos < len; pos++) { - fz_bbox rr = fz_empty_bbox; + fz_rect rr = fz_empty_rect; n = match(text, str, pos); for (i = 0; i < n; i++) - rr = fz_union_bbox(rr, bboxcharat(text, pos + i)); + rr = fz_union_rect(rr, bboxcharat(text, pos + i)); - if (!fz_is_empty_bbox(rr) && hit_count < MAX_SEARCH_HITS) + if (!fz_is_empty_rect(rr) && hit_count < MAX_SEARCH_HITS) glo->hit_bbox[hit_count++] = rr; } } @@ -1421,7 +1421,7 @@ JNI_FN(MuPDFCore_getWidgetAreasInternal)(JNIEnv * env, jobject thiz, int pageNum count = 0; for (widget = fz_first_widget(idoc, pc->page); widget; widget = fz_next_widget(idoc, widget)) { - fz_rect rect = fz_transform_rect(ctm, *fz_widget_bbox(widget)); + fz_rect rect = fz_transform_rect(ctm, fz_widget_bbox(widget)); rectF = (*env)->NewObject(env, rectFClass, ctor, (float)rect.x0, (float)rect.y0, (float)rect.x1, (float)rect.y1); diff --git a/apps/mudraw.c b/apps/mudraw.c index c6d329a0..84c02682 100644 --- a/apps/mudraw.c +++ b/apps/mudraw.c @@ -333,7 +333,7 @@ static void drawpage(fz_context *ctx, fz_document *doc, int pagenum) dev = fz_new_trace_device(ctx); printf("\n", pagenum); if (list) - fz_run_display_list(list, dev, fz_identity, fz_infinite_bbox, &cookie); + fz_run_display_list(list, dev, fz_identity, fz_infinite_rect, &cookie); else fz_run_page(doc, page, dev, fz_identity, &cookie); printf("\n"); @@ -362,7 +362,7 @@ static void drawpage(fz_context *ctx, fz_document *doc, int pagenum) text = fz_new_text_page(ctx, fz_bound_page(doc, page)); dev = fz_new_text_device(ctx, sheet, text); if (list) - fz_run_display_list(list, dev, fz_identity, fz_infinite_bbox, &cookie); + fz_run_display_list(list, dev, fz_identity, fz_infinite_rect, &cookie); else fz_run_page(doc, page, dev, fz_identity, &cookie); fz_free_device(dev); @@ -402,8 +402,7 @@ static void drawpage(fz_context *ctx, fz_document *doc, int pagenum) { float zoom; fz_matrix ctm; - fz_rect bounds, bounds2; - fz_bbox bbox; + fz_rect bounds, tbounds, ibounds; fz_pixmap *pix = NULL; int w, h; @@ -413,28 +412,31 @@ static void drawpage(fz_context *ctx, fz_document *doc, int pagenum) zoom = resolution / 72; ctm = fz_scale(zoom, zoom); ctm = fz_concat(ctm, fz_rotate(rotation)); - bounds2 = fz_transform_rect(ctm, bounds); - bbox = fz_round_rect(bounds2); + tbounds = fz_transform_rect(ctm, bounds); + ibounds = fz_round_rect(tbounds); /* convert to integers */ + /* Make local copies of our width/height */ w = width; h = height; + /* If a resolution is specified, check to see whether w/h are * exceeded; if not, unset them. */ if (res_specified) { int t; - t = bbox.x1 - bbox.x0; + t = ibounds.x1 - ibounds.x0; if (w && t <= w) w = 0; - t = bbox.y1 - bbox.y0; + t = ibounds.y1 - ibounds.y0; if (h && t <= h) h = 0; } - /* Now w or h will be 0 unless then need to be enforced. */ + + /* Now w or h will be 0 unless they need to be enforced. */ if (w || h) { - float scalex = w/(bounds2.x1-bounds2.x0); - float scaley = h/(bounds2.y1-bounds2.y0); + float scalex = w / (tbounds.x1 - tbounds.x0); + float scaley = h / (tbounds.y1 - tbounds.y0); if (fit) { @@ -458,15 +460,15 @@ static void drawpage(fz_context *ctx, fz_document *doc, int pagenum) scaley = scalex; } ctm = fz_concat(ctm, fz_scale(scalex, scaley)); - bounds2 = fz_transform_rect(ctm, bounds); + tbounds = fz_transform_rect(ctm, bounds); } - bbox = fz_round_rect(bounds2); + ibounds = fz_round_rect(tbounds); /* TODO: banded rendering and multi-page ppm */ fz_try(ctx) { - pix = fz_new_pixmap_with_bbox(ctx, colorspace, bbox); + pix = fz_new_pixmap_with_bbox(ctx, colorspace, ibounds); if (savealpha) fz_clear_pixmap(ctx, pix); @@ -475,7 +477,7 @@ static void drawpage(fz_context *ctx, fz_document *doc, int pagenum) dev = fz_new_draw_device(ctx, pix); if (list) - fz_run_display_list(list, dev, ctm, bbox, &cookie); + fz_run_display_list(list, dev, ctm, ibounds, &cookie); else fz_run_page(doc, page, dev, ctm, &cookie); fz_free_device(dev); diff --git a/apps/pdfapp.c b/apps/pdfapp.c index 24668af7..167c118d 100644 --- a/apps/pdfapp.c +++ b/apps/pdfapp.c @@ -98,7 +98,7 @@ void pdfapp_init(fz_context *ctx, pdfapp_t *app) #endif } -void pdfapp_invert(pdfapp_t *app, fz_bbox rect) +void pdfapp_invert(pdfapp_t *app, fz_rect rect) { fz_invert_pixmap_rect(app->image, rect); } @@ -566,7 +566,7 @@ static void pdfapp_updatepage(pdfapp_t *app) while ((annot = fz_poll_changed_annot(idoc, app->page)) != NULL) { - fz_bbox bbox = fz_round_rect(fz_transform_rect(ctm, fz_bound_annot(app->doc, annot))); + fz_rect bbox = fz_transform_rect(ctm, fz_bound_annot(app->doc, annot)); fz_clear_pixmap_rect_with_value(app->ctx, app->image, 255, bbox); idev = fz_new_draw_device_with_bbox(app->ctx, app->image, bbox); @@ -589,7 +589,7 @@ static void pdfapp_showpage(pdfapp_t *app, int loadpage, int drawpage, int repai fz_device *tdev; fz_colorspace *colorspace; fz_matrix ctm; - fz_bbox bbox; + fz_rect bbox; fz_cookie cookie = { 0 }; if (!app->nowaitcursor) @@ -620,9 +620,9 @@ static void pdfapp_showpage(pdfapp_t *app, int loadpage, int drawpage, int repai { tdev = fz_new_text_device(app->ctx, app->page_sheet, app->page_text); if (app->page_list) - fz_run_display_list(app->page_list, tdev, fz_identity, fz_infinite_bbox, &cookie); + fz_run_display_list(app->page_list, tdev, fz_identity, fz_infinite_rect, &cookie); if (app->annotations_list) - fz_run_display_list(app->annotations_list, tdev, fz_identity, fz_infinite_bbox, &cookie); + fz_run_display_list(app->annotations_list, tdev, fz_identity, fz_infinite_rect, &cookie); fz_free_device(tdev); } } @@ -646,7 +646,7 @@ static void pdfapp_showpage(pdfapp_t *app, int loadpage, int drawpage, int repai wintitle(app, buf); ctm = pdfapp_viewctm(app); - bbox = fz_round_rect(fz_transform_rect(ctm, app->page_bbox)); + bbox = fz_transform_rect(ctm, app->page_bbox); /* Draw */ if (app->image) @@ -807,21 +807,21 @@ static inline int charat(fz_text_page *page, int idx) return textcharat(page, idx).c; } -static inline fz_bbox bboxcharat(fz_text_page *page, int idx) +static inline fz_rect bboxcharat(fz_text_page *page, int idx) { - return fz_bbox_covering_rect(textcharat(page, idx).bbox); + return textcharat(page, idx).bbox; } void pdfapp_inverthit(pdfapp_t *app) { - fz_bbox hitbox, bbox; + fz_rect hitbox, bbox; fz_matrix ctm; int i; if (app->hit < 0) return; - hitbox = fz_empty_bbox; + hitbox = fz_empty_rect; ctm = pdfapp_viewctm(app); for (i = app->hit; i < app->hit + app->hitlen; i++) @@ -830,17 +830,17 @@ void pdfapp_inverthit(pdfapp_t *app) if (fz_is_empty_rect(bbox)) { if (!fz_is_empty_rect(hitbox)) - pdfapp_invert(app, fz_transform_bbox(ctm, hitbox)); - hitbox = fz_empty_bbox; + pdfapp_invert(app, fz_transform_rect(ctm, hitbox)); + hitbox = fz_empty_rect; } else { - hitbox = fz_union_bbox(hitbox, bbox); + hitbox = fz_union_rect(hitbox, bbox); } } if (!fz_is_empty_rect(hitbox)) - pdfapp_invert(app, fz_transform_bbox(ctm, hitbox)); + pdfapp_invert(app, fz_transform_rect(ctm, hitbox)); } static int match(char *s, fz_text_page *page, int n) @@ -1336,7 +1336,7 @@ void pdfapp_onkey(pdfapp_t *app, int c) void pdfapp_onmouse(pdfapp_t *app, int x, int y, int btn, int modifiers, int state) { fz_context *ctx = app->ctx; - fz_bbox rect = fz_pixmap_bbox(app->ctx, app->image); + fz_rect rect = fz_pixmap_bbox(app->ctx, app->image); fz_link *link; fz_matrix ctm; fz_point p; @@ -1608,7 +1608,7 @@ void pdfapp_onmouse(pdfapp_t *app, int x, int y, int btn, int modifiers, int sta void pdfapp_oncopy(pdfapp_t *app, unsigned short *ucsbuf, int ucslen) { - fz_bbox hitbox; + fz_rect hitbox; fz_matrix ctm; fz_text_page *page = app->page_text; fz_text_block *block; @@ -1646,8 +1646,8 @@ void pdfapp_oncopy(pdfapp_t *app, unsigned short *ucsbuf, int ucslen) for (i = 0; i < span->len; i++) { - hitbox = fz_bbox_covering_rect(span->text[i].bbox); - hitbox = fz_transform_bbox(ctm, hitbox); + hitbox = span->text[i].bbox; + hitbox = fz_transform_rect(ctm, hitbox); c = span->text[i].c; if (c < 32) c = '?'; diff --git a/apps/pdfapp.h b/apps/pdfapp.h index 22e4ba67..425ba93a 100644 --- a/apps/pdfapp.h +++ b/apps/pdfapp.h @@ -108,7 +108,7 @@ struct pdfapp_s * Used in pdfapp.c:pdfapp_onmouse. */ int beyondy; - fz_bbox selr; + fz_rect selr; int nowaitcursor; @@ -139,7 +139,7 @@ void pdfapp_oncopy(pdfapp_t *app, unsigned short *ucsbuf, int ucslen); void pdfapp_onresize(pdfapp_t *app, int w, int h); void pdfapp_gotopage(pdfapp_t *app, int number); -void pdfapp_invert(pdfapp_t *app, fz_bbox rect); +void pdfapp_invert(pdfapp_t *app, fz_rect rect); void pdfapp_inverthit(pdfapp_t *app); void pdfapp_postblit(pdfapp_t *app); diff --git a/doc/example.c b/doc/example.c index 9ffe7023..b834e3ff 100644 --- a/doc/example.c +++ b/doc/example.c @@ -41,9 +41,8 @@ render(char *filename, int pagenumber, int zoom, int rotation) // Take the page bounds and transform them by the same matrix that // we will use to render the page. - fz_rect rect = fz_bound_page(doc, page); - rect = fz_transform_rect(transform, rect); - fz_bbox bbox = fz_round_rect(rect); + fz_rect bbox = fz_bound_page(doc, page); + bbox = fz_transform_rect(transform, rect); // Create a blank pixmap to hold the result of rendering. The // pixmap bounds used here are the same as the transformed page diff --git a/doc/multi-threaded.c b/doc/multi-threaded.c index 68cd568d..b54beb81 100644 --- a/doc/multi-threaded.c +++ b/doc/multi-threaded.c @@ -58,7 +58,7 @@ struct data { // The area of the page to render as obtained by the main // thread and sent from main to rendering thread. - fz_bbox bbox; + fz_rect bbox; // This is the result, a pixmap containing the rendered page. // It is passed first from main thread to the rendering @@ -79,7 +79,7 @@ renderer(void *data) int pagenumber = ((struct data *) data)->pagenumber; fz_context *ctx = ((struct data *) data)->ctx; fz_display_list *list = ((struct data *) data)->list; - fz_bbox bbox = ((struct data *) data)->bbox; + fz_rect bbox = ((struct data *) data)->bbox; fz_pixmap *pix = ((struct data *) data)->pix; fprintf(stderr, "thread at page %d loading!\n", pagenumber); @@ -180,8 +180,7 @@ int main(int argc, char **argv) // Compute the bounding box for each page. - fz_rect rect = fz_bound_page(doc, page); - fz_bbox bbox = fz_round_rect(rect); + fz_rect bbox = fz_bound_page(doc, page); // Create a display list that will hold the drawing // commands for the page. @@ -202,8 +201,7 @@ int main(int argc, char **argv) // Create a white pixmap using the correct dimensions. - fz_pixmap *pix = fz_new_pixmap_with_bbox(ctx, - fz_device_rgb, bbox); + fz_pixmap *pix = fz_new_pixmap_with_bbox(ctx, fz_device_rgb, bbox); fz_clear_pixmap_with_value(ctx, pix, 0xff); // Populate the data structure to be sent to the diff --git a/draw/draw_affine.c b/draw/draw_affine.c index 67dbd37d..347346b9 100644 --- a/draw/draw_affine.c +++ b/draw/draw_affine.c @@ -597,14 +597,14 @@ fz_gridfit_matrix(fz_matrix *m) /* Draw an image with an affine transform on destination */ static void -fz_paint_image_imp(fz_pixmap *dst, fz_bbox scissor, fz_pixmap *shape, fz_pixmap *img, fz_matrix ctm, byte *color, int alpha) +fz_paint_image_imp(fz_pixmap *dst, fz_rect scissor, fz_pixmap *shape, fz_pixmap *img, fz_matrix ctm, byte *color, int alpha) { byte *dp, *sp, *hp; int u, v, fa, fb, fc, fd; int x, y, w, h; int sw, sh, n, hw; fz_matrix inv; - fz_bbox bbox; + fz_rect bbox; int dolerp; void (*paintfn)(byte *dp, byte *sp, int sw, int sh, int u, int v, int fa, int fb, int w, int n, int alpha, byte *color, byte *hp); @@ -629,8 +629,10 @@ fz_paint_image_imp(fz_pixmap *dst, fz_bbox scissor, fz_pixmap *shape, fz_pixmap dolerp = 0; } - bbox = fz_bbox_covering_rect(fz_transform_rect(ctm, fz_unit_rect)); - bbox = fz_intersect_bbox(bbox, scissor); + bbox = fz_transform_rect(ctm, fz_unit_rect); + bbox = fz_intersect_rect(bbox, scissor); + bbox = fz_rect_covering_rect(bbox); + x = bbox.x0; if (shape && shape->x > x) x = shape->x; @@ -729,14 +731,14 @@ fz_paint_image_imp(fz_pixmap *dst, fz_bbox scissor, fz_pixmap *shape, fz_pixmap } void -fz_paint_image_with_color(fz_pixmap *dst, fz_bbox scissor, fz_pixmap *shape, fz_pixmap *img, fz_matrix ctm, byte *color) +fz_paint_image_with_color(fz_pixmap *dst, fz_rect scissor, fz_pixmap *shape, fz_pixmap *img, fz_matrix ctm, byte *color) { assert(img->n == 1); fz_paint_image_imp(dst, scissor, shape, img, ctm, color, 255); } void -fz_paint_image(fz_pixmap *dst, fz_bbox scissor, fz_pixmap *shape, fz_pixmap *img, fz_matrix ctm, int alpha) +fz_paint_image(fz_pixmap *dst, fz_rect scissor, fz_pixmap *shape, fz_pixmap *img, fz_matrix ctm, int alpha) { assert(dst->n == img->n || (dst->n == 4 && img->n == 2)); fz_paint_image_imp(dst, scissor, shape, img, ctm, NULL, alpha); diff --git a/draw/draw_blend.c b/draw/draw_blend.c index e70699d4..3e5dd932 100644 --- a/draw/draw_blend.c +++ b/draw/draw_blend.c @@ -574,7 +574,7 @@ void fz_blend_pixmap(fz_pixmap *dst, fz_pixmap *src, int alpha, int blendmode, int isolated, fz_pixmap *shape) { unsigned char *sp, *dp; - fz_bbox bbox; + fz_rect bbox; int x, y, w, h, n; /* TODO: fix this hack! */ @@ -590,7 +590,7 @@ fz_blend_pixmap(fz_pixmap *dst, fz_pixmap *src, int alpha, int blendmode, int is } bbox = fz_pixmap_bbox_no_ctx(dst); - bbox = fz_intersect_bbox(bbox, fz_pixmap_bbox_no_ctx(src)); + bbox = fz_intersect_rect(bbox, fz_pixmap_bbox_no_ctx(src)); x = bbox.x0; y = bbox.y0; diff --git a/draw/draw_device.c b/draw/draw_device.c index 2b6f62d8..d65d4a90 100644 --- a/draw/draw_device.c +++ b/draw/draw_device.c @@ -22,7 +22,7 @@ enum { typedef struct fz_draw_state_s fz_draw_state; struct fz_draw_state_s { - fz_bbox scissor; + fz_rect scissor; fz_pixmap *dest; fz_pixmap *mask; fz_pixmap *shape; @@ -127,7 +127,7 @@ static fz_draw_state * fz_knockout_begin(fz_draw_device *dev) { fz_context *ctx = dev->ctx; - fz_bbox bbox; + fz_rect bbox; fz_pixmap *dest, *shape; fz_draw_state *state = &dev->stack[dev->top]; int isolated = state->blendmode & FZ_BLEND_ISOLATED; @@ -138,7 +138,7 @@ fz_knockout_begin(fz_draw_device *dev) state = push_stack(dev); bbox = fz_pixmap_bbox(dev->ctx, state->dest); - bbox = fz_intersect_bbox(bbox, state->scissor); + bbox = fz_intersect_rect(bbox, state->scissor); dest = fz_new_pixmap_with_bbox(dev->ctx, state->dest->colorspace, bbox); if (isolated) @@ -246,7 +246,7 @@ fz_draw_fill_path(fz_device *devp, fz_path *path, int even_odd, fz_matrix ctm, float flatness = 0.3f / expansion; unsigned char colorbv[FZ_MAX_COLORS + 1]; float colorfv[FZ_MAX_COLORS]; - fz_bbox bbox; + fz_rect bbox; int i; fz_draw_state *state = &dev->stack[dev->top]; fz_colorspace *model = state->dest->colorspace; @@ -259,7 +259,7 @@ fz_draw_fill_path(fz_device *devp, fz_path *path, int even_odd, fz_matrix ctm, fz_sort_gel(dev->gel); bbox = fz_bound_gel(dev->gel); - bbox = fz_intersect_bbox(bbox, state->scissor); + bbox = fz_intersect_rect(bbox, state->scissor); if (fz_is_empty_rect(bbox)) return; @@ -297,7 +297,7 @@ fz_draw_stroke_path(fz_device *devp, fz_path *path, fz_stroke_state *stroke, fz_ float linewidth = stroke->linewidth; unsigned char colorbv[FZ_MAX_COLORS + 1]; float colorfv[FZ_MAX_COLORS]; - fz_bbox bbox; + fz_rect bbox; int i; fz_draw_state *state = &dev->stack[dev->top]; fz_colorspace *model = state->dest->colorspace; @@ -316,7 +316,7 @@ fz_draw_stroke_path(fz_device *devp, fz_path *path, fz_stroke_state *stroke, fz_ fz_sort_gel(dev->gel); bbox = fz_bound_gel(dev->gel); - bbox = fz_intersect_bbox(bbox, state->scissor); + bbox = fz_intersect_rect(bbox, state->scissor); if (fz_is_empty_rect(bbox)) return; @@ -353,7 +353,7 @@ fz_draw_clip_path(fz_device *devp, fz_path *path, fz_rect *rect, int even_odd, f fz_draw_device *dev = devp->user; float expansion = fz_matrix_expansion(ctm); float flatness = 0.3f / expansion; - fz_bbox bbox; + fz_rect bbox; fz_draw_state *state = &dev->stack[dev->top]; fz_colorspace *model; fz_context *ctx = dev->ctx; @@ -366,9 +366,9 @@ fz_draw_clip_path(fz_device *devp, fz_path *path, fz_rect *rect, int even_odd, f model = state->dest->colorspace; bbox = fz_bound_gel(dev->gel); - bbox = fz_intersect_bbox(bbox, state->scissor); + bbox = fz_intersect_rect(bbox, state->scissor); if (rect) - bbox = fz_intersect_bbox(bbox, fz_bbox_covering_rect(*rect)); + bbox = fz_intersect_rect(bbox, fz_rect_covering_rect(*rect)); if (fz_is_empty_rect(bbox) || fz_is_rect_gel(dev->gel)) { @@ -413,7 +413,7 @@ fz_draw_clip_stroke_path(fz_device *devp, fz_path *path, fz_rect *rect, fz_strok float expansion = fz_matrix_expansion(ctm); float flatness = 0.3f / expansion; float linewidth = stroke->linewidth; - fz_bbox bbox; + fz_rect bbox; fz_draw_state *state = &dev->stack[dev->top]; fz_colorspace *model; fz_context *ctx = dev->ctx; @@ -432,9 +432,9 @@ fz_draw_clip_stroke_path(fz_device *devp, fz_path *path, fz_rect *rect, fz_strok model = state->dest->colorspace; bbox = fz_bound_gel(dev->gel); - bbox = fz_intersect_bbox(bbox, state->scissor); + bbox = fz_intersect_rect(bbox, state->scissor); if (rect) - bbox = fz_intersect_bbox(bbox, fz_bbox_covering_rect(*rect)); + bbox = fz_intersect_rect(bbox, fz_rect_covering_rect(*rect)); fz_try(ctx) { @@ -465,15 +465,15 @@ fz_draw_clip_stroke_path(fz_device *devp, fz_path *path, fz_rect *rect, fz_strok static void draw_glyph(unsigned char *colorbv, fz_pixmap *dst, fz_pixmap *msk, - int xorig, int yorig, fz_bbox scissor) + int xorig, int yorig, fz_rect scissor) { unsigned char *dp, *mp; - fz_bbox bbox; + fz_rect bbox; int x, y, w, h; bbox = fz_pixmap_bbox_no_ctx(msk); - bbox = fz_translate_bbox(bbox, xorig, yorig); - bbox = fz_intersect_bbox(bbox, scissor); /* scissor < dst */ + bbox = fz_translate_rect(bbox, xorig, yorig); + bbox = fz_intersect_rect(bbox, scissor); /* scissor < dst */ x = bbox.x0; y = bbox.y0; w = bbox.x1 - bbox.x0; @@ -508,7 +508,7 @@ fz_draw_fill_text(fz_device *devp, fz_text *text, fz_matrix ctm, int i, x, y, gid; fz_draw_state *state = &dev->stack[dev->top]; fz_colorspace *model = state->dest->colorspace; - fz_bbox scissor = state->scissor; + fz_rect scissor = state->scissor; if (state->blendmode & FZ_BLEND_KNOCKOUT) state = fz_knockout_begin(dev); @@ -587,7 +587,7 @@ fz_draw_stroke_text(fz_device *devp, fz_text *text, fz_stroke_state *stroke, fz_ int i, x, y, gid; fz_draw_state *state = &dev->stack[dev->top]; fz_colorspace *model = state->dest->colorspace; - fz_bbox scissor = state->scissor; + fz_rect scissor = state->scissor; if (state->blendmode & FZ_BLEND_KNOCKOUT) state = fz_knockout_begin(dev); @@ -650,7 +650,7 @@ fz_draw_clip_text(fz_device *devp, fz_text *text, fz_matrix ctm, int accumulate) { fz_draw_device *dev = devp->user; fz_context *ctx = dev->ctx; - fz_bbox bbox; + fz_rect bbox; fz_pixmap *mask, *dest, *shape; fz_matrix tm, trm, trunc_trm; fz_pixmap *glyph; @@ -668,8 +668,8 @@ fz_draw_clip_text(fz_device *devp, fz_text *text, fz_matrix ctm, int accumulate) if (accumulate == 0) { /* make the mask the exact size needed */ - bbox = fz_bbox_covering_rect(fz_bound_text(dev->ctx, text, ctm)); - bbox = fz_intersect_bbox(bbox, state->scissor); + bbox = fz_rect_covering_rect(fz_bound_text(dev->ctx, text, ctm)); + bbox = fz_intersect_rect(bbox, state->scissor); } else { @@ -784,7 +784,7 @@ fz_draw_clip_stroke_text(fz_device *devp, fz_text *text, fz_stroke_state *stroke { fz_draw_device *dev = devp->user; fz_context *ctx = dev->ctx; - fz_bbox bbox; + fz_rect bbox; fz_pixmap *mask, *dest, *shape; fz_matrix tm, trm, trunc_trm; fz_pixmap *glyph; @@ -793,8 +793,8 @@ fz_draw_clip_stroke_text(fz_device *devp, fz_text *text, fz_stroke_state *stroke fz_colorspace *model = state->dest->colorspace; /* make the mask the exact size needed */ - bbox = fz_bbox_covering_rect(fz_bound_text(dev->ctx, text, ctm)); - bbox = fz_intersect_bbox(bbox, state->scissor); + bbox = fz_rect_covering_rect(fz_bound_text(dev->ctx, text, ctm)); + bbox = fz_intersect_rect(bbox, state->scissor); fz_try(ctx) { @@ -895,7 +895,7 @@ fz_draw_fill_shade(fz_device *devp, fz_shade *shade, fz_matrix ctm, float alpha) { fz_draw_device *dev = devp->user; fz_rect bounds; - fz_bbox bbox, scissor; + fz_rect bbox, scissor; fz_pixmap *dest, *shape; float colorfv[FZ_MAX_COLORS]; unsigned char colorbv[FZ_MAX_COLORS + 1]; @@ -904,7 +904,7 @@ fz_draw_fill_shade(fz_device *devp, fz_shade *shade, fz_matrix ctm, float alpha) bounds = fz_bound_shade(dev->ctx, shade, ctm); scissor = state->scissor; - bbox = fz_intersect_bbox(fz_bbox_covering_rect(bounds), scissor); + bbox = fz_intersect_rect(fz_rect_covering_rect(bounds), scissor); if (fz_is_empty_rect(bbox)) return; @@ -984,7 +984,7 @@ fz_draw_fill_shade(fz_device *devp, fz_shade *shade, fz_matrix ctm, float alpha) } 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, fz_bbox *clip) +fz_transform_pixmap(fz_draw_device *dev, fz_pixmap *image, fz_matrix *ctm, int x, int y, int dx, int dy, int gridfit, fz_rect *clip) { fz_pixmap *scaled; fz_context *ctx = dev->ctx; @@ -1009,7 +1009,7 @@ fz_transform_pixmap(fz_draw_device *dev, fz_pixmap *image, fz_matrix *ctm, int x { /* Other orthogonal flip/rotation cases */ fz_matrix m = *ctm; - fz_bbox rclip; + fz_rect rclip; if (gridfit) fz_gridfit_matrix(&m); if (clip) @@ -1052,9 +1052,9 @@ fz_draw_fill_image(fz_device *devp, fz_image *image, fz_matrix ctm, float alpha) fz_context *ctx = dev->ctx; fz_draw_state *state = &dev->stack[dev->top]; fz_colorspace *model = state->dest->colorspace; - fz_bbox clip = fz_pixmap_bbox(ctx, state->dest); + fz_rect clip = fz_pixmap_bbox(ctx, state->dest); - clip = fz_intersect_bbox(clip, state->scissor); + clip = fz_intersect_rect(clip, state->scissor); fz_var(scaled); @@ -1156,9 +1156,9 @@ fz_draw_fill_image_mask(fz_device *devp, fz_image *image, fz_matrix ctm, fz_context *ctx = dev->ctx; fz_draw_state *state = &dev->stack[dev->top]; fz_colorspace *model = state->dest->colorspace; - fz_bbox clip = fz_pixmap_bbox(ctx, state->dest); + fz_rect clip = fz_pixmap_bbox(ctx, state->dest); - clip = fz_intersect_bbox(clip, state->scissor); + clip = fz_intersect_rect(clip, state->scissor); if (image->w == 0 || image->h == 0) return; @@ -1217,7 +1217,7 @@ fz_draw_clip_image_mask(fz_device *devp, fz_image *image, fz_rect *rect, fz_matr { fz_draw_device *dev = devp->user; fz_context *ctx = dev->ctx; - fz_bbox bbox; + fz_rect bbox; fz_pixmap *mask = NULL; fz_pixmap *dest = NULL; fz_pixmap *shape = NULL; @@ -1227,9 +1227,9 @@ fz_draw_clip_image_mask(fz_device *devp, fz_image *image, fz_rect *rect, fz_matr int dx, dy; fz_draw_state *state = push_stack(dev); fz_colorspace *model = state->dest->colorspace; - fz_bbox clip = fz_pixmap_bbox(ctx, state->dest); + fz_rect clip = fz_pixmap_bbox(ctx, state->dest); - clip = fz_intersect_bbox(clip, state->scissor); + clip = fz_intersect_rect(clip, state->scissor); fz_var(mask); fz_var(dest); @@ -1242,7 +1242,7 @@ fz_draw_clip_image_mask(fz_device *devp, fz_image *image, fz_rect *rect, fz_matr #ifdef DUMP_GROUP_BLENDS dump_spaces(dev->top-1, "Clip (image mask) (empty) begin\n"); #endif - state[1].scissor = fz_empty_bbox; + state[1].scissor = fz_empty_rect; state[1].mask = NULL; return; } @@ -1251,10 +1251,10 @@ fz_draw_clip_image_mask(fz_device *devp, fz_image *image, fz_rect *rect, fz_matr dump_spaces(dev->top-1, "Clip (image mask) begin\n"); #endif - bbox = fz_bbox_covering_rect(fz_transform_rect(ctm, fz_unit_rect)); - bbox = fz_intersect_bbox(bbox, state->scissor); + bbox = fz_rect_covering_rect(fz_transform_rect(ctm, fz_unit_rect)); + bbox = fz_intersect_rect(bbox, state->scissor); if (rect) - bbox = fz_intersect_bbox(bbox, fz_bbox_covering_rect(*rect)); + bbox = fz_intersect_rect(bbox, fz_rect_covering_rect(*rect)); dx = sqrtf(ctm.a * ctm.a + ctm.b * ctm.b); dy = sqrtf(ctm.c * ctm.c + ctm.d * ctm.d); @@ -1363,13 +1363,13 @@ fz_draw_begin_mask(fz_device *devp, fz_rect rect, int luminosity, fz_colorspace { fz_draw_device *dev = devp->user; fz_pixmap *dest; - fz_bbox bbox; + fz_rect bbox; fz_draw_state *state = push_stack(dev); fz_pixmap *shape = state->shape; fz_context *ctx = dev->ctx; - bbox = fz_bbox_covering_rect(rect); - bbox = fz_intersect_bbox(bbox, state->scissor); + bbox = fz_rect_covering_rect(rect); + bbox = fz_intersect_rect(bbox, state->scissor); fz_try(ctx) { @@ -1419,7 +1419,7 @@ fz_draw_end_mask(fz_device *devp) { fz_draw_device *dev = devp->user; fz_pixmap *temp, *dest; - fz_bbox bbox; + fz_rect bbox; int luminosity; fz_context *ctx = dev->ctx; fz_draw_state *state; @@ -1471,7 +1471,7 @@ static void fz_draw_begin_group(fz_device *devp, fz_rect rect, int isolated, int knockout, int blendmode, float alpha) { fz_draw_device *dev = devp->user; - fz_bbox bbox; + fz_rect bbox; fz_pixmap *dest, *shape; fz_context *ctx = dev->ctx; fz_draw_state *state = &dev->stack[dev->top]; @@ -1481,8 +1481,8 @@ fz_draw_begin_group(fz_device *devp, fz_rect rect, int isolated, int knockout, i fz_knockout_begin(dev); state = push_stack(dev); - bbox = fz_bbox_covering_rect(rect); - bbox = fz_intersect_bbox(bbox, state->scissor); + bbox = fz_rect_covering_rect(rect); + bbox = fz_intersect_rect(bbox, state->scissor); fz_try(ctx) { @@ -1594,7 +1594,7 @@ fz_draw_begin_tile(fz_device *devp, fz_rect area, fz_rect view, float xstep, flo fz_draw_device *dev = devp->user; fz_pixmap *dest = NULL; fz_pixmap *shape; - fz_bbox bbox; + fz_rect bbox; fz_context *ctx = dev->ctx; fz_draw_state *state = &dev->stack[dev->top]; fz_colorspace *model = state->dest->colorspace; @@ -1606,7 +1606,7 @@ fz_draw_begin_tile(fz_device *devp, fz_rect area, fz_rect view, float xstep, flo fz_knockout_begin(dev); state = push_stack(dev); - bbox = fz_bbox_covering_rect(fz_transform_rect(ctm, view)); + bbox = fz_rect_covering_rect(fz_transform_rect(ctm, view)); /* We should never have a bbox that entirely covers our destination. * If we do, then the check for only 1 tile being visible above has * failed. Actually, this *can* fail due to the round_rect, at extreme @@ -1649,7 +1649,7 @@ fz_draw_end_tile(fz_device *devp) float xstep, ystep; fz_matrix ttm, ctm, shapectm; fz_rect area, scissor; - fz_bbox scissor_box; + fz_rect scissor_box; int x0, y0, x1, y1, x, y; fz_context *ctx = dev->ctx; fz_draw_state *state; @@ -1668,7 +1668,7 @@ fz_draw_end_tile(fz_device *devp) /* Fudge the scissor bbox a little to allow for inaccuracies in the * matrix inversion. */ - scissor_box = fz_expand_bbox(state[0].scissor, 1); + scissor_box = fz_expand_rect(state[0].scissor, 1); scissor.x0 = (float)scissor_box.x0; scissor.y0 = (float)scissor_box.y0; scissor.x1 = (float)scissor_box.x1; @@ -1711,13 +1711,13 @@ fz_draw_end_tile(fz_device *devp) continue; if (state[1].dest->y > 0 && state[1].dest->y + state[1].dest->h < 0) continue; - fz_paint_pixmap_with_rect(state[0].dest, state[1].dest, 255, state[0].scissor); + fz_paint_pixmap_with_bbox(state[0].dest, state[1].dest, 255, state[0].scissor); if (state[1].shape) { ttm = fz_concat(fz_translate(x * xstep, y * ystep), shapectm); state[1].shape->x = ttm.e; state[1].shape->y = ttm.f; - fz_paint_pixmap_with_rect(state[0].shape, state[1].shape, 255, state[0].scissor); + fz_paint_pixmap_with_bbox(state[0].shape, state[1].shape, 255, state[0].scissor); } } } @@ -1834,7 +1834,7 @@ fz_new_draw_device(fz_context *ctx, fz_pixmap *dest) } fz_device * -fz_new_draw_device_with_bbox(fz_context *ctx, fz_pixmap *dest, fz_bbox clip) +fz_new_draw_device_with_bbox(fz_context *ctx, fz_pixmap *dest, fz_rect clip) { fz_device *dev = fz_new_draw_device(ctx, dest); fz_draw_device *ddev = dev->user; diff --git a/draw/draw_edge.c b/draw/draw_edge.c index 9fc21d97..df59ba14 100644 --- a/draw/draw_edge.c +++ b/draw/draw_edge.c @@ -158,8 +158,8 @@ struct fz_edge_s struct fz_gel_s { - fz_bbox clip; - fz_bbox bbox; + fz_rect clip; + fz_rect bbox; int cap, len; fz_edge *edges; int acap, alen; @@ -203,7 +203,7 @@ fz_new_gel(fz_context *ctx) } void -fz_reset_gel(fz_gel *gel, fz_bbox clip) +fz_reset_gel(fz_gel *gel, fz_rect clip) { fz_aa_context *ctxaa = gel->ctx->aa; @@ -235,13 +235,13 @@ fz_free_gel(fz_gel *gel) fz_free(gel->ctx, gel); } -fz_bbox +fz_rect fz_bound_gel(fz_gel *gel) { - fz_bbox bbox; + fz_rect bbox; fz_aa_context *ctxaa = gel->ctx->aa; if (gel->len == 0) - return fz_empty_bbox; + return fz_empty_rect; bbox.x0 = fz_idiv(gel->bbox.x0, fz_aa_hscale); bbox.y0 = fz_idiv(gel->bbox.y0, fz_aa_vscale); bbox.x1 = fz_idiv(gel->bbox.x1, fz_aa_hscale) + 1; @@ -666,7 +666,7 @@ static inline void blit_aa(fz_pixmap *dst, int x, int y, } static void -fz_scan_convert_aa(fz_gel *gel, int eofill, fz_bbox clip, +fz_scan_convert_aa(fz_gel *gel, int eofill, fz_rect clip, fz_pixmap *dst, unsigned char *color) { unsigned char *alphas; @@ -851,7 +851,7 @@ clip_ended: */ static inline void blit_sharp(int x0, int x1, int y, - fz_bbox clip, fz_pixmap *dst, unsigned char *color) + fz_rect clip, fz_pixmap *dst, unsigned char *color) { unsigned char *dp; x0 = fz_clampi(x0, dst->x, dst->x + dst->w); @@ -867,7 +867,7 @@ static inline void blit_sharp(int x0, int x1, int y, } static inline void non_zero_winding_sharp(fz_gel *gel, int y, - fz_bbox clip, fz_pixmap *dst, unsigned char *color) + fz_rect clip, fz_pixmap *dst, unsigned char *color) { int winding = 0; int x = 0; @@ -883,7 +883,7 @@ static inline void non_zero_winding_sharp(fz_gel *gel, int y, } static inline void even_odd_sharp(fz_gel *gel, int y, - fz_bbox clip, fz_pixmap *dst, unsigned char *color) + fz_rect clip, fz_pixmap *dst, unsigned char *color) { int even = 0; int x = 0; @@ -899,7 +899,7 @@ static inline void even_odd_sharp(fz_gel *gel, int y, } static void -fz_scan_convert_sharp(fz_gel *gel, int eofill, fz_bbox clip, +fz_scan_convert_sharp(fz_gel *gel, int eofill, fz_rect clip, fz_pixmap *dst, unsigned char *color) { int e = 0; @@ -955,7 +955,7 @@ fz_scan_convert_sharp(fz_gel *gel, int eofill, fz_bbox clip, } void -fz_scan_convert(fz_gel *gel, int eofill, fz_bbox clip, +fz_scan_convert(fz_gel *gel, int eofill, fz_rect clip, fz_pixmap *dst, unsigned char *color) { fz_aa_context *ctxaa = gel->ctx->aa; diff --git a/draw/draw_glyph.c b/draw/draw_glyph.c index de2f47c2..40c71241 100644 --- a/draw/draw_glyph.c +++ b/draw/draw_glyph.c @@ -95,7 +95,7 @@ fz_keep_glyph_cache(fz_context *ctx) } fz_pixmap * -fz_render_stroked_glyph(fz_context *ctx, fz_font *font, int gid, fz_matrix trm, fz_matrix ctm, fz_stroke_state *stroke, fz_bbox scissor) +fz_render_stroked_glyph(fz_context *ctx, fz_font *font, int gid, fz_matrix trm, fz_matrix ctm, fz_stroke_state *stroke, fz_rect scissor) { if (font->ft_face) { @@ -116,7 +116,7 @@ fz_render_stroked_glyph(fz_context *ctx, fz_font *font, int gid, fz_matrix trm, This must not be inserted into the cache. */ fz_pixmap * -fz_render_glyph(fz_context *ctx, fz_font *font, int gid, fz_matrix ctm, fz_colorspace *model, fz_bbox scissor) +fz_render_glyph(fz_context *ctx, fz_font *font, int gid, fz_matrix ctm, fz_colorspace *model, fz_rect scissor) { fz_glyph_cache *cache; fz_glyph_key key; @@ -126,7 +126,7 @@ fz_render_glyph(fz_context *ctx, fz_font *font, int gid, fz_matrix ctm, fz_color if (size <= MAX_GLYPH_SIZE) { - scissor = fz_infinite_bbox; + scissor = fz_infinite_rect; do_cache = 1; } else diff --git a/draw/draw_mesh.c b/draw/draw_mesh.c index 03d187f7..98669e17 100644 --- a/draw/draw_mesh.c +++ b/draw/draw_mesh.c @@ -213,7 +213,7 @@ static inline void step_edge(int *ael, int *del, int n) } static void -fz_paint_triangle(fz_pixmap *pix, float *av, float *bv, float *cv, int n, fz_bbox bbox) +fz_paint_triangle(fz_pixmap *pix, float *av, float *bv, float *cv, int n, fz_rect bbox) { float poly[MAXV][MAXN]; float temp[MAXV][MAXN]; @@ -307,7 +307,7 @@ struct paint_tri_data fz_context *ctx; fz_shade *shade; fz_pixmap *dest; - fz_bbox bbox; + fz_rect bbox; }; static void @@ -349,7 +349,7 @@ do_paint_tri(void *arg, fz_vertex *av, fz_vertex *bv, fz_vertex *cv) } void -fz_paint_shade(fz_context *ctx, fz_shade *shade, fz_matrix ctm, fz_pixmap *dest, fz_bbox bbox) +fz_paint_shade(fz_context *ctx, fz_shade *shade, fz_matrix ctm, fz_pixmap *dest, fz_rect bbox) { unsigned char clut[256][FZ_MAX_COLORS]; fz_pixmap *temp = NULL; diff --git a/draw/draw_paint.c b/draw/draw_paint.c index 57e69748..2f6ef368 100644 --- a/draw/draw_paint.c +++ b/draw/draw_paint.c @@ -375,15 +375,15 @@ fz_paint_span(byte * restrict dp, byte * restrict sp, int n, int w, int alpha) */ void -fz_paint_pixmap_with_rect(fz_pixmap *dst, fz_pixmap *src, int alpha, fz_bbox bbox) +fz_paint_pixmap_with_bbox(fz_pixmap *dst, fz_pixmap *src, int alpha, fz_rect bbox) { unsigned char *sp, *dp; int x, y, w, h, n; assert(dst->n == src->n); - bbox = fz_intersect_bbox(bbox, fz_pixmap_bbox_no_ctx(dst)); - bbox = fz_intersect_bbox(bbox, fz_pixmap_bbox_no_ctx(src)); + bbox = fz_intersect_rect(bbox, fz_pixmap_bbox_no_ctx(dst)); + bbox = fz_intersect_rect(bbox, fz_pixmap_bbox_no_ctx(src)); x = bbox.x0; y = bbox.y0; @@ -408,13 +408,13 @@ void fz_paint_pixmap(fz_pixmap *dst, fz_pixmap *src, int alpha) { unsigned char *sp, *dp; - fz_bbox bbox; + fz_rect bbox; int x, y, w, h, n; assert(dst->n == src->n); bbox = fz_pixmap_bbox_no_ctx(dst); - bbox = fz_intersect_bbox(bbox, fz_pixmap_bbox_no_ctx(src)); + bbox = fz_intersect_rect(bbox, fz_pixmap_bbox_no_ctx(src)); x = bbox.x0; y = bbox.y0; @@ -439,15 +439,15 @@ void fz_paint_pixmap_with_mask(fz_pixmap *dst, fz_pixmap *src, fz_pixmap *msk) { unsigned char *sp, *dp, *mp; - fz_bbox bbox; + fz_rect bbox; int x, y, w, h, n; assert(dst->n == src->n); assert(msk->n == 1); bbox = fz_pixmap_bbox_no_ctx(dst); - bbox = fz_intersect_bbox(bbox, fz_pixmap_bbox_no_ctx(src)); - bbox = fz_intersect_bbox(bbox, fz_pixmap_bbox_no_ctx(msk)); + bbox = fz_intersect_rect(bbox, fz_pixmap_bbox_no_ctx(src)); + bbox = fz_intersect_rect(bbox, fz_pixmap_bbox_no_ctx(msk)); x = bbox.x0; y = bbox.y0; diff --git a/draw/draw_scale.c b/draw/draw_scale.c index 34738fab..a2439216 100644 --- a/draw/draw_scale.c +++ b/draw/draw_scale.c @@ -1238,13 +1238,13 @@ scale_single_col(unsigned char *dst, unsigned char *src, fz_weights *weights, in #endif /* SINGLE_PIXEL_SPECIALS */ fz_pixmap * -fz_scale_pixmap(fz_context *ctx, fz_pixmap *src, float x, float y, float w, float h, fz_bbox *clip) +fz_scale_pixmap(fz_context *ctx, fz_pixmap *src, float x, float y, float w, float h, fz_rect *clip) { return fz_scale_pixmap_cached(ctx, src, x, y, w, h, clip, NULL, NULL); } fz_pixmap * -fz_scale_pixmap_cached(fz_context *ctx, fz_pixmap *src, float x, float y, float w, float h, fz_bbox *clip, fz_scale_cache *cache_x, fz_scale_cache *cache_y) +fz_scale_pixmap_cached(fz_context *ctx, fz_pixmap *src, float x, float y, float w, float h, fz_rect *clip, fz_scale_cache *cache_x, fz_scale_cache *cache_y) { fz_scale_filter *filter = &fz_scale_filter_simple; fz_weights *contrib_rows = NULL; @@ -1254,7 +1254,7 @@ fz_scale_pixmap_cached(fz_context *ctx, fz_pixmap *src, float x, float y, float int max_row, temp_span, temp_rows, row; int dst_w_int, dst_h_int, dst_x_int, dst_y_int; int flip_x, flip_y; - fz_bbox patch; + fz_rect patch; fz_var(contrib_cols); fz_var(contrib_rows); diff --git a/draw/draw_simple_scale.c b/draw/draw_simple_scale.c index 55c981b4..d2b69cf9 100644 --- a/draw/draw_simple_scale.c +++ b/draw/draw_simple_scale.c @@ -1214,13 +1214,13 @@ scale_single_col(unsigned char *dst, unsigned char *src, fz_weights *weights, in #endif /* SINGLE_PIXEL_SPECIALS */ fz_pixmap * -fz_scale_pixmap(fz_context *ctx, fz_pixmap *src, float x, float y, float w, float h, fz_bbox *clip) +fz_scale_pixmap(fz_context *ctx, fz_pixmap *src, float x, float y, float w, float h, fz_rect *clip) { return fz_scale_pixmap_cached(ctx, src, x, y, w, h, clip, NULL, NULL); } fz_pixmap * -fz_scale_pixmap_cached(fz_context *ctx, fz_pixmap *src, float x, float y, float w, float h, fz_bbox *clip, fz_scale_cache *cache_x, fz_scale_cache *cache_y) +fz_scale_pixmap_cached(fz_context *ctx, fz_pixmap *src, float x, float y, float w, float h, fz_rect *clip, fz_scale_cache *cache_x, fz_scale_cache *cache_y) { fz_scale_filter *filter = &fz_scale_filter_simple; fz_weights *contrib_rows = NULL; @@ -1230,7 +1230,7 @@ fz_scale_pixmap_cached(fz_context *ctx, fz_pixmap *src, float x, float y, float int max_row, temp_span, temp_rows, row; int dst_w_int, dst_h_int, dst_x_int, dst_y_int; int flip_x, flip_y; - fz_bbox patch; + fz_rect patch; fz_var(contrib_cols); fz_var(contrib_rows); diff --git a/fitz/base_geometry.c b/fitz/base_geometry.c index ef22a6fa..1486279f 100644 --- a/fitz/base_geometry.c +++ b/fitz/base_geometry.c @@ -3,24 +3,6 @@ #define MAX4(a,b,c,d) fz_max(fz_max(a,b), fz_max(c,d)) #define MIN4(a,b,c,d) fz_min(fz_min(a,b), fz_min(c,d)) -/* A useful macro to add with overflow detection and clamping. - - We want to do "b = a + x", but to allow for overflow. Consider the - top bits, and the cases in which overflow occurs: - - overflow a x b ~a^x a^b (~a^x)&(a^b) - no 0 0 0 1 0 0 - yes 0 0 1 1 1 1 - no 0 1 0 0 0 0 - no 0 1 1 0 1 0 - no 1 0 0 0 1 0 - no 1 0 1 0 0 0 - yes 1 1 0 1 1 1 - no 1 1 1 1 0 0 -*/ -#define ADD_WITH_SAT(b,a,x) \ - ((b) = (a) + (x), (b) = (((~(a)^(x))&((a)^(b))) < 0 ? ((x) < 0 ? INT_MIN : INT_MAX) : (b))) - /* Matrices, points and affine transformations */ const fz_matrix fz_identity = { 1, 0, 0, 1, 0, 0 }; @@ -180,43 +162,44 @@ fz_transform_vector(fz_matrix m, fz_point p) /* Rectangles and bounding boxes */ +/* biggest and smallest integers that a float can represent perfectly (i.e. 24 bits) */ +#define MAX_SAFE_INT 16777216 +#define MIN_SAFE_INT -16777216 + const fz_rect fz_infinite_rect = { 1, 1, -1, -1 }; const fz_rect fz_empty_rect = { 0, 0, 0, 0 }; const fz_rect fz_unit_rect = { 0, 0, 1, 1 }; -const fz_bbox fz_infinite_bbox = { 1, 1, -1, -1 }; -const fz_bbox fz_empty_bbox = { 0, 0, 0, 0 }; -const fz_bbox fz_unit_bbox = { 0, 0, 1, 1 }; - -#define SAFE_INT(f) ((f > INT_MAX) ? INT_MAX : ((f < INT_MIN) ? INT_MIN : (int)f)) -fz_bbox -fz_bbox_covering_rect(fz_rect f) +fz_rect +fz_rect_covering_rect(fz_rect f) { - fz_bbox i; f.x0 = floorf(f.x0); f.y0 = floorf(f.y0); f.x1 = ceilf(f.x1); f.y1 = ceilf(f.y1); - i.x0 = SAFE_INT(f.x0); - i.y0 = SAFE_INT(f.y0); - i.x1 = SAFE_INT(f.x1); - i.y1 = SAFE_INT(f.y1); - return i; + + /* check for integer overflow */ + f.x0 = fz_clamp(f.x0, MIN_SAFE_INT, MAX_SAFE_INT); + f.y0 = fz_clamp(f.y0, MIN_SAFE_INT, MAX_SAFE_INT); + f.x1 = fz_clamp(f.x1, MIN_SAFE_INT, MAX_SAFE_INT); + f.y1 = fz_clamp(f.y1, MIN_SAFE_INT, MAX_SAFE_INT); + return f; } -fz_bbox +fz_rect fz_round_rect(fz_rect f) { - fz_bbox i; f.x0 = floorf(f.x0 + 0.001); f.y0 = floorf(f.y0 + 0.001); f.x1 = ceilf(f.x1 - 0.001); f.y1 = ceilf(f.y1 - 0.001); - i.x0 = SAFE_INT(f.x0); - i.y0 = SAFE_INT(f.y0); - i.x1 = SAFE_INT(f.x1); - i.y1 = SAFE_INT(f.y1); - return i; + + /* check for integer overflow */ + f.x0 = fz_clamp(f.x0, MIN_SAFE_INT, MAX_SAFE_INT); + f.y0 = fz_clamp(f.y0, MIN_SAFE_INT, MAX_SAFE_INT); + f.x1 = fz_clamp(f.x1, MIN_SAFE_INT, MAX_SAFE_INT); + f.y1 = fz_clamp(f.y1, MIN_SAFE_INT, MAX_SAFE_INT); + return f; } fz_rect @@ -251,52 +234,6 @@ fz_union_rect(fz_rect a, fz_rect b) return r; } -fz_bbox -fz_intersect_bbox(fz_bbox a, fz_bbox b) -{ - fz_bbox r; - /* Check for empty box before infinite box */ - if (fz_is_empty_rect(a)) return fz_empty_bbox; - if (fz_is_empty_rect(b)) return fz_empty_bbox; - if (fz_is_infinite_rect(a)) return b; - if (fz_is_infinite_rect(b)) return a; - r.x0 = fz_maxi(a.x0, b.x0); - r.y0 = fz_maxi(a.y0, b.y0); - r.x1 = fz_mini(a.x1, b.x1); - r.y1 = fz_mini(a.y1, b.y1); - return (r.x1 < r.x0 || r.y1 < r.y0) ? fz_empty_bbox : r; -} - -fz_bbox -fz_translate_bbox(fz_bbox a, int xoff, int yoff) -{ - fz_bbox b; - - if (fz_is_empty_rect(a)) return a; - if (fz_is_infinite_rect(a)) return a; - ADD_WITH_SAT(b.x0, a.x0, xoff); - ADD_WITH_SAT(b.y0, a.y0, yoff); - ADD_WITH_SAT(b.x1, a.x1, xoff); - ADD_WITH_SAT(b.y1, a.y1, yoff); - return b; -} - -fz_bbox -fz_union_bbox(fz_bbox a, fz_bbox b) -{ - fz_bbox r; - /* Check for empty box before infinite box */ - if (fz_is_empty_rect(a)) return b; - if (fz_is_empty_rect(b)) return a; - if (fz_is_infinite_rect(a)) return a; - if (fz_is_infinite_rect(b)) return b; - r.x0 = fz_mini(a.x0, b.x0); - r.y0 = fz_mini(a.y0, b.y0); - r.x1 = fz_maxi(a.x1, b.x1); - r.y1 = fz_maxi(a.y1, b.y1); - return r; -} - fz_rect fz_transform_rect(fz_matrix m, fz_rect r) { @@ -320,42 +257,28 @@ fz_transform_rect(fz_matrix m, fz_rect r) return r; } -fz_bbox -fz_transform_bbox(fz_matrix m, fz_bbox b) +fz_rect +fz_translate_rect(fz_rect a, float xoff, float yoff) { - fz_point s, t, u, v; - - if (fz_is_infinite_bbox(b)) - return b; - - s.x = b.x0; s.y = b.y0; - t.x = b.x0; t.y = b.y1; - u.x = b.x1; u.y = b.y1; - v.x = b.x1; v.y = b.y0; - s = fz_transform_point(m, s); - t = fz_transform_point(m, t); - u = fz_transform_point(m, u); - v = fz_transform_point(m, v); - b.x0 = MIN4(s.x, t.x, u.x, v.x); - b.y0 = MIN4(s.y, t.y, u.y, v.y); - b.x1 = MAX4(s.x, t.x, u.x, v.x); - b.y1 = MAX4(s.y, t.y, u.y, v.y); + fz_rect b; + if (fz_is_empty_rect(a)) return a; + if (fz_is_infinite_rect(a)) return a; + b.x0 = a.x0 + xoff; + b.y0 = a.y0 + yoff; + b.x1 = a.x1 + xoff; + b.y1 = a.y1 + yoff; return b; - } -fz_bbox -fz_expand_bbox(fz_bbox a, int expand) +fz_rect +fz_expand_rect(fz_rect a, float expand) { - fz_bbox b; - - if (fz_is_infinite_bbox(a)) - return a; - - ADD_WITH_SAT(b.x0, a.x0, -expand); - ADD_WITH_SAT(b.y0, a.y0, -expand); - ADD_WITH_SAT(b.x1, a.x1, expand); - ADD_WITH_SAT(b.y1, a.y1, expand); + fz_rect b; + if (fz_is_empty_rect(a)) return a; + if (fz_is_infinite_rect(a)) return a; + b.x0 = a.x0 - expand; + b.y0 = a.y0 - expand; + b.x1 = a.x1 + expand; + b.y1 = a.y1 + expand; return b; - } diff --git a/fitz/dev_bbox.c b/fitz/dev_bbox.c index 87cb4dca..6c910afb 100644 --- a/fitz/dev_bbox.c +++ b/fitz/dev_bbox.c @@ -6,63 +6,58 @@ static void fz_bbox_fill_path(fz_device *dev, fz_path *path, int even_odd, fz_matrix ctm, fz_colorspace *colorspace, float *color, float alpha) { - fz_bbox *result = dev->user; - fz_bbox bbox = fz_bbox_covering_rect(fz_bound_path(dev->ctx, path, NULL, ctm)); - *result = fz_union_bbox(*result, bbox); + fz_rect *result = dev->user; + *result = fz_union_rect(*result, fz_bound_path(dev->ctx, path, NULL, ctm)); } static void fz_bbox_stroke_path(fz_device *dev, fz_path *path, fz_stroke_state *stroke, fz_matrix ctm, fz_colorspace *colorspace, float *color, float alpha) { - fz_bbox *result = dev->user; - fz_bbox bbox = fz_bbox_covering_rect(fz_bound_path(dev->ctx, path, stroke, ctm)); - *result = fz_union_bbox(*result, bbox); + fz_rect *result = dev->user; + *result = fz_union_rect(*result, fz_bound_path(dev->ctx, path, stroke, ctm)); } static void fz_bbox_fill_text(fz_device *dev, fz_text *text, fz_matrix ctm, fz_colorspace *colorspace, float *color, float alpha) { - fz_bbox *result = dev->user; - fz_bbox bbox = fz_bbox_covering_rect(fz_bound_text(dev->ctx, text, ctm)); - *result = fz_union_bbox(*result, bbox); + fz_rect *result = dev->user; + *result = fz_union_rect(*result, fz_bound_text(dev->ctx, text, ctm)); } static void fz_bbox_stroke_text(fz_device *dev, fz_text *text, fz_stroke_state *stroke, fz_matrix ctm, fz_colorspace *colorspace, float *color, float alpha) { - fz_bbox *result = dev->user; - fz_bbox bbox = fz_bbox_covering_rect(fz_bound_text(dev->ctx, text, ctm)); - *result = fz_union_bbox(*result, bbox); + fz_rect *result = dev->user; + *result = fz_union_rect(*result, fz_bound_text(dev->ctx, text, ctm)); } static void fz_bbox_fill_shade(fz_device *dev, fz_shade *shade, fz_matrix ctm, float alpha) { - fz_bbox *result = dev->user; - fz_bbox bbox = fz_bbox_covering_rect(fz_bound_shade(dev->ctx, shade, ctm)); - *result = fz_union_bbox(*result, bbox); + fz_rect *result = dev->user; + *result = fz_union_rect(*result, fz_bound_shade(dev->ctx, shade, ctm)); } static void fz_bbox_fill_image(fz_device *dev, fz_image *image, fz_matrix ctm, float alpha) { - fz_bbox *result = dev->user; - fz_bbox bbox = fz_bbox_covering_rect(fz_transform_rect(ctm, fz_unit_rect)); - *result = fz_union_bbox(*result, bbox); + fz_rect *result = dev->user; + *result = fz_union_rect(*result, fz_transform_rect(ctm, fz_unit_rect)); } static void fz_bbox_fill_image_mask(fz_device *dev, fz_image *image, fz_matrix ctm, fz_colorspace *colorspace, float *color, float alpha) { - fz_bbox_fill_image(dev, image, ctm, alpha); + fz_rect *result = dev->user; + *result = fz_union_rect(*result, fz_transform_rect(ctm, fz_unit_rect)); } fz_device * -fz_new_bbox_device(fz_context *ctx, fz_bbox *result) +fz_new_bbox_device(fz_context *ctx, fz_rect *result) { fz_device *dev; @@ -76,7 +71,7 @@ fz_new_bbox_device(fz_context *ctx, fz_bbox *result) dev->fill_image = fz_bbox_fill_image; dev->fill_image_mask = fz_bbox_fill_image_mask; - *result = fz_empty_bbox; + *result = fz_empty_rect; return dev; } diff --git a/fitz/dev_list.c b/fitz/dev_list.c index e49f694b..26693e0f 100644 --- a/fitz/dev_list.c +++ b/fitz/dev_list.c @@ -588,12 +588,10 @@ fz_free_display_list(fz_context *ctx, fz_display_list *list) } void -fz_run_display_list(fz_display_list *list, fz_device *dev, fz_matrix top_ctm, fz_bbox scissor, fz_cookie *cookie) +fz_run_display_list(fz_display_list *list, fz_device *dev, fz_matrix top_ctm, fz_rect scissor, fz_cookie *cookie) { fz_display_node *node; fz_matrix ctm; - fz_rect rect; - fz_bbox bbox; int clipped = 0; int tiled = 0; int empty; @@ -624,9 +622,7 @@ fz_run_display_list(fz_display_list *list, fz_device *dev, fz_matrix top_ctm, fz } else { - bbox = fz_bbox_covering_rect(fz_transform_rect(top_ctm, node->rect)); - bbox = fz_intersect_bbox(bbox, scissor); - empty = fz_is_empty_bbox(bbox); + empty = fz_is_empty_rect(fz_intersect_rect(fz_transform_rect(top_ctm, node->rect), scissor)); } if (clipped || empty) @@ -725,30 +721,36 @@ visible: fz_pop_clip(dev); break; case FZ_CMD_BEGIN_MASK: - rect = fz_transform_rect(top_ctm, node->rect); - fz_begin_mask(dev, rect, node->flag, node->colorspace, node->color); + { + fz_rect trect = fz_transform_rect(top_ctm, node->rect); + fz_begin_mask(dev, trect, node->flag, node->colorspace, node->color); break; + } case FZ_CMD_END_MASK: fz_end_mask(dev); break; case FZ_CMD_BEGIN_GROUP: - rect = fz_transform_rect(top_ctm, node->rect); - fz_begin_group(dev, rect, + { + fz_rect trect = fz_transform_rect(top_ctm, node->rect); + fz_begin_group(dev, trect, (node->flag & ISOLATED) != 0, (node->flag & KNOCKOUT) != 0, node->item.blendmode, node->alpha); break; + } case FZ_CMD_END_GROUP: fz_end_group(dev); break; case FZ_CMD_BEGIN_TILE: + { + fz_rect rect; tiled++; rect.x0 = node->color[2]; rect.y0 = node->color[3]; rect.x1 = node->color[4]; rect.y1 = node->color[5]; - fz_begin_tile(dev, node->rect, rect, - node->color[0], node->color[1], ctm); + fz_begin_tile(dev, node->rect, rect, node->color[0], node->color[1], ctm); break; + } case FZ_CMD_END_TILE: tiled--; fz_end_tile(dev); diff --git a/fitz/doc_search.c b/fitz/doc_search.c index 53cf7486..76e5e9dc 100644 --- a/fitz/doc_search.c +++ b/fitz/doc_search.c @@ -42,9 +42,9 @@ static int charat(fz_text_page *page, int idx) return textcharat(page, idx).c; } -static fz_bbox bboxat(fz_text_page *page, int idx) +static fz_rect bboxat(fz_text_page *page, int idx) { - return fz_round_rect(textcharat(page, idx).bbox); + return textcharat(page, idx).bbox; } static int textlen(fz_text_page *page) @@ -88,7 +88,7 @@ static int match(fz_text_page *page, const char *s, int n) } int -fz_search_text_page(fz_context *ctx, fz_text_page *text, char *needle, fz_bbox *hit_bbox, int hit_max) +fz_search_text_page(fz_context *ctx, fz_text_page *text, char *needle, fz_rect *hit_bbox, int hit_max) { int pos, len, i, n, hit_count; @@ -102,25 +102,25 @@ fz_search_text_page(fz_context *ctx, fz_text_page *text, char *needle, fz_bbox * n = match(text, needle, pos); if (n) { - fz_bbox linebox = fz_empty_bbox; + fz_rect linebox = fz_empty_rect; for (i = 0; i < n; i++) { - fz_bbox charbox = bboxat(text, pos + i); - if (!fz_is_empty_bbox(charbox)) + fz_rect charbox = bboxat(text, pos + i); + if (!fz_is_empty_rect(charbox)) { - if (charbox.y0 != linebox.y0 || fz_absi(charbox.x0 - linebox.x1) > 5) + if (charbox.y0 != linebox.y0 || fz_abs(charbox.x0 - linebox.x1) > 5) { - if (!fz_is_empty_bbox(linebox) && hit_count < hit_max) + if (!fz_is_empty_rect(linebox) && hit_count < hit_max) hit_bbox[hit_count++] = linebox; linebox = charbox; } else { - linebox = fz_union_bbox(linebox, charbox); + linebox = fz_union_rect(linebox, charbox); } } } - if (!fz_is_empty_bbox(linebox) && hit_count < hit_max) + if (!fz_is_empty_rect(linebox) && hit_count < hit_max) hit_bbox[hit_count++] = linebox; } } @@ -129,18 +129,18 @@ fz_search_text_page(fz_context *ctx, fz_text_page *text, char *needle, fz_bbox * } int -fz_highlight_selection(fz_context *ctx, fz_text_page *page, fz_bbox rect, fz_bbox *hit_bbox, int hit_max) +fz_highlight_selection(fz_context *ctx, fz_text_page *page, fz_rect rect, fz_rect *hit_bbox, int hit_max) { - fz_bbox linebox, charbox; + fz_rect linebox, charbox; fz_text_block *block; fz_text_line *line; fz_text_span *span; int i, hit_count; - int x0 = rect.x0; - int x1 = rect.x1; - int y0 = rect.y0; - int y1 = rect.y1; + float x0 = rect.x0; + float x1 = rect.x1; + float y0 = rect.y0; + float y1 = rect.y1; hit_count = 0; @@ -148,28 +148,28 @@ fz_highlight_selection(fz_context *ctx, fz_text_page *page, fz_bbox rect, fz_bbo { for (line = block->lines; line < block->lines + block->len; line++) { - linebox = fz_empty_bbox; + linebox = fz_empty_rect; for (span = line->spans; span < line->spans + line->len; span++) { for (i = 0; i < span->len; i++) { - charbox = fz_bbox_covering_rect(span->text[i].bbox); + charbox = span->text[i].bbox; if (charbox.x1 >= x0 && charbox.x0 <= x1 && charbox.y1 >= y0 && charbox.y0 <= y1) { - if (charbox.y0 != linebox.y0 || fz_absi(charbox.x0 - linebox.x1) > 5) + if (charbox.y0 != linebox.y0 || fz_abs(charbox.x0 - linebox.x1) > 5) { - if (!fz_is_empty_bbox(linebox) && hit_count < hit_max) + if (!fz_is_empty_rect(linebox) && hit_count < hit_max) hit_bbox[hit_count++] = linebox; linebox = charbox; } else { - linebox = fz_union_bbox(linebox, charbox); + linebox = fz_union_rect(linebox, charbox); } } } } - if (!fz_is_empty_bbox(linebox) && hit_count < hit_max) + if (!fz_is_empty_rect(linebox) && hit_count < hit_max) hit_bbox[hit_count++] = linebox; } } @@ -178,20 +178,20 @@ fz_highlight_selection(fz_context *ctx, fz_text_page *page, fz_bbox rect, fz_bbo } char * -fz_copy_selection(fz_context *ctx, fz_text_page *page, fz_bbox rect) +fz_copy_selection(fz_context *ctx, fz_text_page *page, fz_rect rect) { fz_buffer *buffer; - fz_bbox hitbox; + fz_rect hitbox; fz_text_block *block; fz_text_line *line; fz_text_span *span; int c, i, seen = 0; char *s; - int x0 = rect.x0; - int x1 = rect.x1; - int y0 = rect.y0; - int y1 = rect.y1; + float x0 = rect.x0; + float x1 = rect.x1; + float y0 = rect.y0; + float y1 = rect.y1; buffer = fz_new_buffer(ctx, 1024); @@ -210,7 +210,7 @@ fz_copy_selection(fz_context *ctx, fz_text_page *page, fz_bbox rect) for (i = 0; i < span->len; i++) { - hitbox = fz_bbox_covering_rect(span->text[i].bbox); + hitbox = span->text[i].bbox; c = span->text[i].c; if (c < 32) c = '?'; diff --git a/fitz/fitz-internal.h b/fitz/fitz-internal.h index e853188d..0ac4c93a 100644 --- a/fitz/fitz-internal.h +++ b/fitz/fitz-internal.h @@ -872,22 +872,22 @@ struct fz_pixmap_s void fz_free_pixmap_imp(fz_context *ctx, fz_storable *pix); -void fz_copy_pixmap_rect(fz_context *ctx, fz_pixmap *dest, fz_pixmap *src, fz_bbox r); +void fz_copy_pixmap_rect(fz_context *ctx, fz_pixmap *dest, fz_pixmap *src, fz_rect r); void fz_premultiply_pixmap(fz_context *ctx, fz_pixmap *pix); fz_pixmap *fz_alpha_from_gray(fz_context *ctx, fz_pixmap *gray, int luminosity); unsigned int fz_pixmap_size(fz_context *ctx, fz_pixmap *pix); -fz_pixmap *fz_scale_pixmap(fz_context *ctx, fz_pixmap *src, float x, float y, float w, float h, fz_bbox *clip); +fz_pixmap *fz_scale_pixmap(fz_context *ctx, fz_pixmap *src, float x, float y, float w, float h, fz_rect *clip); typedef struct fz_scale_cache_s fz_scale_cache; fz_scale_cache *fz_new_scale_cache(fz_context *ctx); void fz_free_scale_cache(fz_context *ctx, fz_scale_cache *cache); -fz_pixmap *fz_scale_pixmap_cached(fz_context *ctx, fz_pixmap *src, float x, float y, float w, float h, fz_bbox *clip, fz_scale_cache *cache_x, fz_scale_cache *cache_y); +fz_pixmap *fz_scale_pixmap_cached(fz_context *ctx, fz_pixmap *src, float x, float y, float w, float h, fz_rect *clip, fz_scale_cache *cache_x, fz_scale_cache *cache_y); void fz_subsample_pixmap(fz_context *ctx, fz_pixmap *tile, int factor); -fz_bbox fz_pixmap_bbox_no_ctx(fz_pixmap *src); +fz_rect fz_pixmap_bbox_no_ctx(fz_pixmap *src); typedef struct fz_compression_params_s fz_compression_params; @@ -1187,10 +1187,10 @@ void fz_purge_glyph_cache(fz_context *ctx); fz_path *fz_outline_ft_glyph(fz_context *ctx, fz_font *font, int gid, fz_matrix trm); fz_path *fz_outline_glyph(fz_context *ctx, fz_font *font, int gid, fz_matrix ctm); fz_pixmap *fz_render_ft_glyph(fz_context *ctx, fz_font *font, int cid, fz_matrix trm, int aa); -fz_pixmap *fz_render_t3_glyph(fz_context *ctx, fz_font *font, int cid, fz_matrix trm, fz_colorspace *model, fz_bbox scissor); +fz_pixmap *fz_render_t3_glyph(fz_context *ctx, fz_font *font, int cid, fz_matrix trm, fz_colorspace *model, fz_rect scissor); fz_pixmap *fz_render_ft_stroked_glyph(fz_context *ctx, fz_font *font, int gid, fz_matrix trm, fz_matrix ctm, fz_stroke_state *state); -fz_pixmap *fz_render_glyph(fz_context *ctx, fz_font*, int, fz_matrix, fz_colorspace *model, fz_bbox scissor); -fz_pixmap *fz_render_stroked_glyph(fz_context *ctx, fz_font*, int, fz_matrix, fz_matrix, fz_stroke_state *stroke, fz_bbox scissor); +fz_pixmap *fz_render_glyph(fz_context *ctx, fz_font*, int, fz_matrix, fz_colorspace *model, fz_rect scissor); +fz_pixmap *fz_render_stroked_glyph(fz_context *ctx, fz_font*, int, fz_matrix, fz_matrix, fz_stroke_state *stroke, fz_rect scissor); void fz_render_t3_glyph_direct(fz_context *ctx, fz_device *dev, fz_font *font, int gid, fz_matrix trm, void *gstate, int nestedDepth); void fz_prepare_t3_glyph(fz_context *ctx, fz_font *font, int gid, int nestedDepth); @@ -1300,7 +1300,7 @@ void fz_drop_shade(fz_context *ctx, fz_shade *shade); void fz_free_shade_imp(fz_context *ctx, fz_storable *shade); fz_rect fz_bound_shade(fz_context *ctx, fz_shade *shade, fz_matrix ctm); -void fz_paint_shade(fz_context *ctx, fz_shade *shade, fz_matrix ctm, fz_pixmap *dest, fz_bbox bbox); +void fz_paint_shade(fz_context *ctx, fz_shade *shade, fz_matrix ctm, fz_pixmap *dest, fz_rect bbox); /* * Handy routine for processing mesh based shades @@ -1339,13 +1339,13 @@ typedef struct fz_gel_s fz_gel; fz_gel *fz_new_gel(fz_context *ctx); void fz_insert_gel(fz_gel *gel, float x0, float y0, float x1, float y1); -void fz_reset_gel(fz_gel *gel, fz_bbox clip); +void fz_reset_gel(fz_gel *gel, fz_rect clip); void fz_sort_gel(fz_gel *gel); -fz_bbox fz_bound_gel(fz_gel *gel); +fz_rect fz_bound_gel(fz_gel *gel); void fz_free_gel(fz_gel *gel); int fz_is_rect_gel(fz_gel *gel); -void fz_scan_convert(fz_gel *gel, int eofill, fz_bbox clip, fz_pixmap *pix, unsigned char *colorbv); +void fz_scan_convert(fz_gel *gel, int eofill, fz_rect clip, fz_pixmap *pix, unsigned char *colorbv); void fz_flatten_fill_path(fz_gel *gel, fz_path *path, fz_matrix ctm, float flatness); void fz_flatten_stroke_path(fz_gel *gel, fz_path *path, fz_stroke_state *stroke, fz_matrix ctm, float flatness, float linewidth); @@ -1458,12 +1458,12 @@ void fz_paint_solid_color(unsigned char * restrict dp, int n, int w, unsigned ch void fz_paint_span(unsigned char * restrict dp, unsigned char * restrict sp, int n, int w, int alpha); void fz_paint_span_with_color(unsigned char * restrict dp, unsigned char * restrict mp, int n, int w, unsigned char *color); -void fz_paint_image(fz_pixmap *dst, fz_bbox scissor, fz_pixmap *shape, fz_pixmap *img, fz_matrix ctm, int alpha); -void fz_paint_image_with_color(fz_pixmap *dst, fz_bbox scissor, fz_pixmap *shape, fz_pixmap *img, fz_matrix ctm, unsigned char *colorbv); +void fz_paint_image(fz_pixmap *dst, fz_rect scissor, fz_pixmap *shape, fz_pixmap *img, fz_matrix ctm, int alpha); +void fz_paint_image_with_color(fz_pixmap *dst, fz_rect scissor, fz_pixmap *shape, fz_pixmap *img, fz_matrix ctm, unsigned char *colorbv); void fz_paint_pixmap(fz_pixmap *dst, fz_pixmap *src, int alpha); void fz_paint_pixmap_with_mask(fz_pixmap *dst, fz_pixmap *src, fz_pixmap *msk); -void fz_paint_pixmap_with_rect(fz_pixmap *dst, fz_pixmap *src, int alpha, fz_bbox bbox); +void fz_paint_pixmap_with_bbox(fz_pixmap *dst, fz_pixmap *src, int alpha, fz_rect bbox); void fz_blend_pixmap(fz_pixmap *dst, fz_pixmap *src, int alpha, int blendmode, int isolated, fz_pixmap *shape); void fz_blend_pixel(unsigned char dp[3], unsigned char bp[3], unsigned char sp[3], int blendmode); diff --git a/fitz/fitz.h b/fitz/fitz.h index bb4d3831..7243c341 100644 --- a/fitz/fitz.h +++ b/fitz/fitz.h @@ -734,8 +734,7 @@ struct fz_point_s defined to be infinite. To check for empty or infinite rectangles use fz_is_empty_rect - and fz_is_infinite_rect. Compare to fz_bbox which has corners - at integer coordinates. + and fz_is_infinite_rect. x0, y0: The top left corner. @@ -748,23 +747,6 @@ struct fz_rect_s float x1, y1; }; -/* - fz_bbox is a bounding box similar to a fz_rect, except that - all corner coordinates are rounded to integer coordinates. - To check for empty or infinite bounding boxes use - fz_is_empty_bbox and fz_is_infinite_bbox. - - x0, y0: The top left corner. - - x1, y1: The bottom right corner. -*/ -typedef struct fz_bbox_s fz_bbox; -struct fz_bbox_s -{ - int x0, y0; - int x1, y1; -}; - /* A rectangle with sides of length one. @@ -773,11 +755,6 @@ struct fz_bbox_s */ extern const fz_rect fz_unit_rect; -/* - A bounding box with sides of length one. See fz_unit_rect. -*/ -extern const fz_bbox fz_unit_bbox; - /* An empty rectangle with an area equal to zero. @@ -785,11 +762,6 @@ extern const fz_bbox fz_unit_bbox; */ extern const fz_rect fz_empty_rect; -/* - An empty bounding box. See fz_empty_rect. -*/ -extern const fz_bbox fz_empty_bbox; - /* An infinite rectangle with negative area. @@ -798,11 +770,6 @@ extern const fz_bbox fz_empty_bbox; */ extern const fz_rect fz_infinite_rect; -/* - An infinite bounding box. See fz_infinite_rect. -*/ -extern const fz_bbox fz_infinite_bbox; - /* fz_is_empty_rect: Check if rectangle is empty. @@ -810,14 +777,6 @@ extern const fz_bbox fz_infinite_bbox; */ #define fz_is_empty_rect(r) ((r).x0 == (r).x1 || (r).y0 == (r).y1) -/* - fz_is_empty_bbox: Check if bounding box is empty. - - Same definition of empty bounding boxes as for empty - rectangles. See fz_is_empty_rect. -*/ -#define fz_is_empty_bbox(b) ((b).x0 == (b).x1 || (b).y0 == (b).y1) - /* fz_is_infinite: Check if rectangle is infinite. @@ -826,14 +785,6 @@ extern const fz_bbox fz_infinite_bbox; */ #define fz_is_infinite_rect(r) ((r).x0 > (r).x1 || (r).y0 > (r).y1) -/* - fz_is_infinite_bbox: Check if bounding box is infinite. - - Same definition of infinite bounding boxes as for infinite - rectangles. See fz_is_infinite_rect. -*/ -#define fz_is_infinite_bbox(b) ((b).x0 > (b).x1 || (b).y0 > (b).y1) - /* fz_matrix is a a row-major 3x3 matrix used for representing transformations of coordinates throughout MuPDF. @@ -948,39 +899,6 @@ int fz_is_rectilinear(fz_matrix m); */ float fz_matrix_expansion(fz_matrix m); /* sumatrapdf */ -/* - fz_bbox_covering_rect: Convert a rect into the minimal bounding box - that covers the rectangle. - - Coordinates in a bounding box are integers, so rounding of the - rects coordinates takes place. The top left corner is rounded - upwards and left while the bottom right corner is rounded - downwards and to the right. Overflows or underflowing - coordinates are clamped to INT_MIN/INT_MAX. - - Does not throw exceptions. -*/ -fz_bbox fz_bbox_covering_rect(fz_rect rect); - -/* - fz_round_rect: Convert a rect into a bounding box. - - Coordinates in a bounding box are integers, so rounding of the - rects coordinates takes place. The top left corner is rounded - upwards and left while the bottom right corner is rounded - downwards and to the right. Overflows or underflowing - coordinates are clamped to INT_MIN/INT_MAX. - - This differs from fz_bbox_covering_rect, in that fz_bbox_covering_rect - slavishly follows the numbers (i.e any slight over/under calculations - can cause whole extra pixels to be added). fz_round_rect - allows for a small amount of rounding error when calculating - the bbox. - - Does not throw exceptions. -*/ -fz_bbox fz_round_rect(fz_rect rect); - /* fz_intersect_rect: Compute intersection of two rectangles. @@ -995,16 +913,6 @@ fz_bbox fz_round_rect(fz_rect rect); */ fz_rect fz_intersect_rect(fz_rect a, fz_rect b); -/* - fz_intersect_bbox: Compute intersection of two bounding boxes. - - Similar to fz_intersect_rect but operates on two bounding - boxes instead of two rectangles. - - Does not throw exceptions. -*/ -fz_bbox fz_intersect_bbox(fz_bbox a, fz_bbox b); - /* fz_union_rect: Compute union of two rectangles. @@ -1019,30 +927,52 @@ fz_bbox fz_intersect_bbox(fz_bbox a, fz_bbox b); fz_rect fz_union_rect(fz_rect a, fz_rect b); /* - fz_union_bbox: Compute union of two bounding boxes. + fz_rect_covering_rect: Convert a rect into the minimal bounding box + that covers the rectangle. + + Coordinates in a bounding box are integers, so rounding of the + rects coordinates takes place. The top left corner is rounded + upwards and left while the bottom right corner is rounded + downwards and to the right. + + Does not throw exceptions. +*/ + +fz_rect fz_rect_covering_rect(fz_rect rect); + +/* + fz_round_rect: Round rectangle coordinates. - Similar to fz_union_rect but operates on two bounding boxes - instead of two rectangles. + Coordinates in a bounding box are integers, so rounding of the + rects coordinates takes place. The top left corner is rounded + upwards and left while the bottom right corner is rounded + downwards and to the right. + + This differs from fz_rect_covering_rect, in that fz_rect_covering_rect + slavishly follows the numbers (i.e any slight over/under calculations + can cause whole extra pixels to be added). fz_round_rect + allows for a small amount of rounding error when calculating + the bbox. Does not throw exceptions. */ -fz_bbox fz_union_bbox(fz_bbox a, fz_bbox b); +fz_rect fz_round_rect(fz_rect rect); /* - fz_expand_bbox: Expand a bbox by a given amount in all directions. + fz_expand_rect: Expand a bbox by a given amount in all directions. Does not throw exceptions. */ -fz_bbox fz_expand_bbox(fz_bbox b, int expand); +fz_rect fz_expand_rect(fz_rect b, float expand); /* - fz_translate_bbox: Translate bounding box. + fz_translate_rect: Translate bounding box. Translate a bbox by a given x and y offset. Allows for overflow. Does not throw exceptions. */ -fz_bbox fz_translate_bbox(fz_bbox a, int xoff, int yoff); +fz_rect fz_translate_rect(fz_rect a, float xoff, float yoff); /* fz_transform_point: Apply a transformation to a point. @@ -1085,16 +1015,6 @@ fz_point fz_transform_vector(fz_matrix transform, fz_point vector); */ fz_rect fz_transform_rect(fz_matrix transform, fz_rect rect); -/* - fz_transform_bbox: Transform a given bounding box. - - Similar to fz_transform_rect, but operates on a bounding box - instead of a rectangle. - - Does not throw exceptions. -*/ -fz_bbox fz_transform_bbox(fz_matrix matrix, fz_bbox bbox); - /* fz_buffer is a wrapper around a dynamically allocated array of bytes. @@ -1323,11 +1243,9 @@ extern fz_colorspace *fz_device_cmyk; typedef struct fz_pixmap_s fz_pixmap; /* - fz_pixmap_bbox: Return a bounding box for a pixmap. - - Returns an exact bounding box for the supplied pixmap. + fz_pixmap_bbox: Return the bounding box for a pixmap. */ -fz_bbox fz_pixmap_bbox(fz_context *ctx, fz_pixmap *pix); +fz_rect fz_pixmap_bbox(fz_context *ctx, fz_pixmap *pix); /* fz_pixmap_width: Return the width of the pixmap in pixels. @@ -1371,7 +1289,7 @@ fz_pixmap *fz_new_pixmap(fz_context *ctx, fz_colorspace *cs, int w, int h); Returns a pointer to the new pixmap. Throws exception on failure to allocate. */ -fz_pixmap *fz_new_pixmap_with_bbox(fz_context *ctx, fz_colorspace *colorspace, fz_bbox bbox); +fz_pixmap *fz_new_pixmap_with_bbox(fz_context *ctx, fz_colorspace *colorspace, fz_rect bbox); /* fz_new_pixmap_with_data: Create a new pixmap, with it's origin at @@ -1410,7 +1328,7 @@ fz_pixmap *fz_new_pixmap_with_data(fz_context *ctx, fz_colorspace *colorspace, i Returns a pointer to the new pixmap. Throws exception on failure to allocate. */ -fz_pixmap *fz_new_pixmap_with_bbox_and_data(fz_context *ctx, fz_colorspace *colorspace, fz_bbox bbox, unsigned char *samples); +fz_pixmap *fz_new_pixmap_with_bbox_and_data(fz_context *ctx, fz_colorspace *colorspace, fz_rect rect, unsigned char *samples); /* fz_keep_pixmap: Take a reference to a pixmap. @@ -1478,7 +1396,7 @@ void fz_clear_pixmap_with_value(fz_context *ctx, fz_pixmap *pix, int value); Does not throw exceptions. */ -void fz_clear_pixmap_rect_with_value(fz_context *ctx, fz_pixmap *pix, int value, fz_bbox r); +void fz_clear_pixmap_rect_with_value(fz_context *ctx, fz_pixmap *pix, int value, fz_rect r); /* fz_clear_pixmap_with_value: Sets all components (including alpha) of @@ -1505,7 +1423,7 @@ void fz_invert_pixmap(fz_context *ctx, fz_pixmap *pix); Does not throw exceptions. */ -void fz_invert_pixmap_rect(fz_pixmap *image, fz_bbox rect); +void fz_invert_pixmap_rect(fz_pixmap *image, fz_rect rect); /* fz_gamma_pixmap: Apply gamma correction to a pixmap. All components @@ -1681,7 +1599,7 @@ fz_device *fz_new_trace_device(fz_context *ctx); The returned bounding box will be the union of all bounding boxes of all objects on a page. */ -fz_device *fz_new_bbox_device(fz_context *ctx, fz_bbox *bboxp); +fz_device *fz_new_bbox_device(fz_context *ctx, fz_rect *rectp); /* fz_new_draw_device: Create a device to draw on a pixmap. @@ -1706,7 +1624,7 @@ fz_device *fz_new_draw_device(fz_context *ctx, fz_pixmap *dest); clip: Bounding box to restrict any marking operations of the draw device. */ -fz_device *fz_new_draw_device_with_bbox(fz_context *ctx, fz_pixmap *dest, fz_bbox clip); +fz_device *fz_new_draw_device_with_bbox(fz_context *ctx, fz_pixmap *dest, fz_rect clip); /* Text extraction device: Used for searching, format conversion etc. @@ -1875,21 +1793,21 @@ void fz_print_text_page(fz_context *ctx, FILE *out, fz_text_page *page); NOTE: This is an experimental interface and subject to change without notice. */ -int fz_search_text_page(fz_context *ctx, fz_text_page *text, char *needle, fz_bbox *hit_bbox, int hit_max); +int fz_search_text_page(fz_context *ctx, fz_text_page *text, char *needle, fz_rect *hit_bbox, int hit_max); /* fz_highlight_selection: Return a list of rectangles to highlight given a selection rectangle. NOTE: This is an experimental interface and subject to change without notice. */ -int fz_highlight_selection(fz_context *ctx, fz_text_page *page, fz_bbox rect, fz_bbox *hit_bbox, int hit_max); +int fz_highlight_selection(fz_context *ctx, fz_text_page *page, fz_rect rect, fz_rect *hit_bbox, int hit_max); /* fz_copy_selection: Return a newly allocated UTF-8 string with the text for a given selection rectangle. NOTE: This is an experimental interface and subject to change without notice. */ -char *fz_copy_selection(fz_context *ctx, fz_text_page *page, fz_bbox rect); +char *fz_copy_selection(fz_context *ctx, fz_text_page *page, fz_rect rect); /* Cookie support - simple communication channel between app/library. @@ -2006,7 +1924,7 @@ fz_device *fz_new_list_device(fz_context *ctx, fz_display_list *list); progress information back to the caller. The fields inside cookie are continually updated while the page is being run. */ -void fz_run_display_list(fz_display_list *list, fz_device *dev, fz_matrix ctm, fz_bbox area, fz_cookie *cookie); +void fz_run_display_list(fz_display_list *list, fz_device *dev, fz_matrix ctm, fz_rect area, fz_cookie *cookie); /* fz_free_display_list: Frees a display list. diff --git a/fitz/res_font.c b/fitz/res_font.c index b790d198..1b07d060 100644 --- a/fitz/res_font.c +++ b/fitz/res_font.c @@ -872,7 +872,6 @@ fz_bound_t3_glyph(fz_context *ctx, fz_font *font, int gid, fz_matrix trm) fz_display_list *list; fz_matrix ctm; fz_rect bounds; - fz_bbox bbox; fz_device *dev; list = font->t3lists[gid]; @@ -880,23 +879,19 @@ fz_bound_t3_glyph(fz_context *ctx, fz_font *font, int gid, fz_matrix trm) return fz_transform_rect(trm, fz_empty_rect); ctm = fz_concat(font->t3matrix, trm); - dev = fz_new_bbox_device(ctx, &bbox); - fz_run_display_list(list, dev, ctm, fz_infinite_bbox, NULL); + dev = fz_new_bbox_device(ctx, &bounds); + fz_run_display_list(list, dev, ctm, fz_infinite_rect, NULL); fz_free_device(dev); - bounds.x0 = bbox.x0; - bounds.y0 = bbox.y0; - bounds.x1 = bbox.x1; - bounds.y1 = bbox.y1; return bounds; } fz_pixmap * -fz_render_t3_glyph(fz_context *ctx, fz_font *font, int gid, fz_matrix trm, fz_colorspace *model, fz_bbox scissor) +fz_render_t3_glyph(fz_context *ctx, fz_font *font, int gid, fz_matrix trm, fz_colorspace *model, fz_rect scissor) { fz_display_list *list; fz_matrix ctm; - fz_bbox bbox; + fz_rect bbox; fz_device *dev; fz_pixmap *glyph; fz_pixmap *result; @@ -925,20 +920,20 @@ fz_render_t3_glyph(fz_context *ctx, fz_font *font, int gid, fz_matrix trm, fz_co model = NULL; /* Treat as masked */ } - bbox = fz_bbox_covering_rect(fz_bound_glyph(ctx, font, gid, trm)); - bbox.x0--; - bbox.y0--; - bbox.x1++; - bbox.y1++; + bbox = fz_bound_glyph(ctx, font, gid, trm); + bbox.x0 -= 1; + bbox.y0 -= 1; + bbox.x1 += 1; + bbox.y1 += 1; - bbox = fz_intersect_bbox(bbox, scissor); + bbox = fz_intersect_rect(bbox, scissor); glyph = fz_new_pixmap_with_bbox(ctx, model ? model : fz_device_gray, bbox); fz_clear_pixmap(ctx, glyph); ctm = fz_concat(font->t3matrix, trm); dev = fz_new_draw_device_type3(ctx, glyph); - fz_run_display_list(list, dev, ctm, fz_infinite_bbox, NULL); + fz_run_display_list(list, dev, ctm, fz_infinite_rect, NULL); fz_free_device(dev); if (!model) diff --git a/fitz/res_pixmap.c b/fitz/res_pixmap.c index 7c6fbcc1..eb5d58ef 100644 --- a/fitz/res_pixmap.c +++ b/fitz/res_pixmap.c @@ -83,29 +83,29 @@ fz_new_pixmap(fz_context *ctx, fz_colorspace *colorspace, int w, int h) } fz_pixmap * -fz_new_pixmap_with_bbox(fz_context *ctx, fz_colorspace *colorspace, fz_bbox r) +fz_new_pixmap_with_bbox(fz_context *ctx, fz_colorspace *colorspace, fz_rect rf) { - fz_pixmap *pixmap; - pixmap = fz_new_pixmap(ctx, colorspace, r.x1 - r.x0, r.y1 - r.y0); + fz_rect r = fz_round_rect(rf); + fz_pixmap *pixmap = fz_new_pixmap(ctx, colorspace, r.x1 - r.x0, r.y1 - r.y0); pixmap->x = r.x0; pixmap->y = r.y0; return pixmap; } fz_pixmap * -fz_new_pixmap_with_bbox_and_data(fz_context *ctx, fz_colorspace *colorspace, fz_bbox r, unsigned char *samples) +fz_new_pixmap_with_bbox_and_data(fz_context *ctx, fz_colorspace *colorspace, fz_rect rf, unsigned char *samples) { - fz_pixmap *pixmap; - pixmap = fz_new_pixmap_with_data(ctx, colorspace, r.x1 - r.x0, r.y1 - r.y0, samples); + fz_rect r = fz_round_rect(rf); + fz_pixmap *pixmap = fz_new_pixmap_with_data(ctx, colorspace, r.x1 - r.x0, r.y1 - r.y0, samples); pixmap->x = r.x0; pixmap->y = r.y0; return pixmap; } -fz_bbox +fz_rect fz_pixmap_bbox(fz_context *ctx, fz_pixmap *pix) { - fz_bbox bbox; + fz_rect bbox; bbox.x0 = pix->x; bbox.y0 = pix->y; bbox.x1 = pix->x + pix->w; @@ -113,10 +113,10 @@ fz_pixmap_bbox(fz_context *ctx, fz_pixmap *pix) return bbox; } -fz_bbox +fz_rect fz_pixmap_bbox_no_ctx(fz_pixmap *pix) { - fz_bbox bbox; + fz_rect bbox; bbox.x0 = pix->x; bbox.y0 = pix->y; bbox.x1 = pix->x + pix->w; @@ -166,14 +166,15 @@ fz_clear_pixmap_with_value(fz_context *ctx, fz_pixmap *pix, int value) } void -fz_copy_pixmap_rect(fz_context *ctx, fz_pixmap *dest, fz_pixmap *src, fz_bbox r) +fz_copy_pixmap_rect(fz_context *ctx, fz_pixmap *dest, fz_pixmap *src, fz_rect r) { const unsigned char *srcp; unsigned char *destp; int x, y, w, destspan, srcspan; - r = fz_intersect_bbox(r, fz_pixmap_bbox(ctx, dest)); - r = fz_intersect_bbox(r, fz_pixmap_bbox(ctx, src)); + r = fz_round_rect(r); + r = fz_intersect_rect(r, fz_pixmap_bbox(ctx, dest)); + r = fz_intersect_rect(r, fz_pixmap_bbox(ctx, src)); w = r.x1 - r.x0; y = r.y1 - r.y0; if (w <= 0 || y <= 0) @@ -266,12 +267,13 @@ fz_copy_pixmap_rect(fz_context *ctx, fz_pixmap *dest, fz_pixmap *src, fz_bbox r) } void -fz_clear_pixmap_rect_with_value(fz_context *ctx, fz_pixmap *dest, int value, fz_bbox r) +fz_clear_pixmap_rect_with_value(fz_context *ctx, fz_pixmap *dest, int value, fz_rect r) { unsigned char *destp; int x, y, w, k, destspan; - r = fz_intersect_bbox(r, fz_pixmap_bbox(ctx, dest)); + r = fz_round_rect(r); + r = fz_intersect_rect(r, fz_pixmap_bbox(ctx, dest)); w = r.x1 - r.x0; y = r.y1 - r.y0; if (w <= 0 || y <= 0) @@ -382,15 +384,17 @@ fz_invert_pixmap(fz_context *ctx, fz_pixmap *pix) } } -void fz_invert_pixmap_rect(fz_pixmap *image, fz_bbox rect) +void fz_invert_pixmap_rect(fz_pixmap *image, fz_rect r) { unsigned char *p; + int x0, x1, y0, y1; int x, y, n; - int x0 = fz_clampi(rect.x0 - image->x, 0, image->w - 1); - int x1 = fz_clampi(rect.x1 - image->x, 0, image->w - 1); - int y0 = fz_clampi(rect.y0 - image->y, 0, image->h - 1); - int y1 = fz_clampi(rect.y1 - image->y, 0, image->h - 1); + r = fz_round_rect(r); + x0 = fz_clampi(r.x0 - image->x, 0, image->w - 1); + x1 = fz_clampi(r.x1 - image->x, 0, image->w - 1); + y0 = fz_clampi(r.y0 - image->y, 0, image->h - 1); + y1 = fz_clampi(r.y1 - image->y, 0, image->h - 1); for (y = y0; y < y1; y++) { diff --git a/ios/main.m b/ios/main.m index 56d31a50..250f6b0c 100644 --- a/ios/main.m +++ b/ios/main.m @@ -125,7 +125,7 @@ static fz_context *ctx = NULL; #pragma mark - static int hit_count = 0; -static fz_bbox hit_bbox[500]; +static fz_rect hit_bbox[500]; static int search_page(fz_document *doc, int number, char *needle, fz_cookie *cookie) @@ -147,7 +147,7 @@ search_page(fz_document *doc, int number, char *needle, fz_cookie *cookie) return hit_count; } -static fz_bbox +static fz_rect search_result_bbox(fz_document *doc, int i) { return hit_bbox[i]; @@ -236,7 +236,7 @@ static CGSize measurePage(fz_document *doc, fz_page *page) static UIImage *renderPage(fz_document *doc, fz_page *page, CGSize screenSize) { CGSize pageSize; - fz_bbox bbox; + fz_rect bbox; fz_matrix ctm; fz_device *dev; fz_pixmap *pix; @@ -248,7 +248,7 @@ static UIImage *renderPage(fz_document *doc, fz_page *page, CGSize screenSize) pageSize = measurePage(doc, page); scale = fitPageToScreen(pageSize, screenSize); ctm = fz_scale(scale.width, scale.height); - bbox = (fz_bbox){0, 0, pageSize.width * scale.width, pageSize.height * scale.height}; + bbox = (fz_rect){0, 0, pageSize.width * scale.width, pageSize.height * scale.height}; pix = fz_new_pixmap_with_bbox(ctx, fz_device_rgb, bbox); fz_clear_pixmap_with_value(ctx, pix, 255); @@ -263,8 +263,7 @@ static UIImage *renderPage(fz_document *doc, fz_page *page, CGSize screenSize) static UIImage *renderTile(fz_document *doc, fz_page *page, CGSize screenSize, CGRect tileRect, float zoom) { CGSize pageSize; - fz_rect rect; - fz_bbox bbox; + fz_rect bbox; fz_matrix ctm; fz_device *dev; fz_pixmap *pix; @@ -281,11 +280,10 @@ static UIImage *renderTile(fz_document *doc, fz_page *page, CGSize screenSize, C scale = fitPageToScreen(pageSize, screenSize); ctm = fz_scale(scale.width * zoom, scale.height * zoom); - rect.x0 = tileRect.origin.x; - rect.y0 = tileRect.origin.y; - rect.x1 = tileRect.origin.x + tileRect.size.width; - rect.y1 = tileRect.origin.y + tileRect.size.height; - bbox = fz_round_rect(rect); + bbox.x0 = tileRect.origin.x; + bbox.y0 = tileRect.origin.y; + bbox.x1 = tileRect.origin.x + tileRect.size.width; + bbox.y1 = tileRect.origin.y + tileRect.size.height; pix = fz_new_pixmap_with_bbox(ctx, fz_device_rgb, bbox); fz_clear_pixmap_with_value(ctx, pix, 255); @@ -602,7 +600,7 @@ static UIImage *renderTile(fz_document *doc, fz_page *page, CGSize screenSize, C pageSize = CGSizeMake(100,100); for (int i = 0; i < n && i < nelem(hitRects); i++) { - fz_bbox bbox = search_result_bbox(doc, i); // this is thread-safe enough + fz_rect bbox = search_result_bbox(doc, i); // this is thread-safe enough hitRects[i].origin.x = bbox.x0; hitRects[i].origin.y = bbox.y0; hitRects[i].size.width = bbox.x1 - bbox.x0; @@ -625,7 +623,7 @@ static UIImage *renderTile(fz_document *doc, fz_page *page, CGSize screenSize, C while (link && hitCount < nelem(hitRects)) { if (link->dest.kind == FZ_LINK_GOTO || link->dest.kind == FZ_LINK_URI) { - fz_bbox bbox = fz_round_rect(link->rect); + fz_rect bbox = link->rect; hitRects[hitCount].origin.x = bbox.x0; hitRects[hitCount].origin.y = bbox.y0; hitRects[hitCount].size.width = bbox.x1 - bbox.x0; -- cgit v1.2.3