void pdfapp_inverthit(pdfapp_t *app)
{
fz_bbox hitbox, bbox;
fz_matrix ctm;
int i;
if (app->hit < 0)
return;
hitbox = fz_empty_bbox;
ctm = pdfapp_viewctm(app);
for (i = app->hit; i < app->hit + app->hitlen; i++)
{
bbox = bboxcharat(app->page_text, i);
if (fz_is_empty_rect(bbox))
{
if (!fz_is_empty_rect(hitbox))
pdfapp_invert(app, fz_transform_bbox(ctm, hitbox));
hitbox = fz_empty_bbox;
}
else
{
hitbox = fz_union_bbox(hitbox, bbox);
}
}
if (!fz_is_empty_rect(hitbox))
pdfapp_invert(app, fz_transform_bbox(ctm, hitbox));
}
int
fz_highlight_selection(fz_context *ctx, fz_stext_page *page, fz_rect rect, fz_rect *hit_bbox, int hit_max)
{
fz_rect linebox, charbox;
fz_stext_block *block;
fz_stext_line *line;
fz_stext_span *span;
int i, block_num, hit_count;
float x0 = rect.x0;
float x1 = rect.x1;
float y0 = rect.y0;
float y1 = rect.y1;
hit_count = 0;
for (block_num = 0; block_num < page->len; block_num++)
{
if (page->blocks[block_num].type != FZ_PAGE_BLOCK_TEXT)
continue;
block = page->blocks[block_num].u.text;
for (line = block->lines; line < block->lines + block->len; line++)
{
linebox = fz_empty_rect;
for (span = line->first_span; span; span = span->next)
{
for (i = 0; i < span->len; i++)
{
fz_stext_char_bbox(ctx, &charbox, span, i);
if (charbox.x1 >= x0 && charbox.x0 <= x1 && charbox.y1 >= y0 && charbox.y0 <= y1)
{
if (charbox.y0 != linebox.y0 || fz_abs(charbox.x0 - linebox.x1) > 5)
{
if (!fz_is_empty_rect(&linebox) && hit_count < hit_max)
hit_bbox[hit_count++] = linebox;
linebox = charbox;
}
else
{
fz_union_rect(&linebox, &charbox);
}
}
}
}
if (!fz_is_empty_rect(&linebox) && hit_count < hit_max)
hit_bbox[hit_count++] = linebox;
}
}
return hit_count;
}
fz_rect
fz_intersect_rect(fz_rect a, fz_rect b)
{
fz_rect r;
if (fz_is_infinite_rect(a)) return b;
if (fz_is_infinite_rect(b)) return a;
if (fz_is_empty_rect(a)) return fz_empty_rect;
if (fz_is_empty_rect(b)) return fz_empty_rect;
r.x0 = MAX(a.x0, b.x0);
r.y0 = MAX(a.y0, b.y0);
r.x1 = MIN(a.x1, b.x1);
r.y1 = MIN(a.y1, b.y1);
return (r.x1 < r.x0 || r.y1 < r.y0) ? fz_empty_rect : r;
}
fz_bbox
fz_union_bbox(fz_bbox a, fz_bbox b)
{
fz_bbox r;
if (fz_is_infinite_rect(a)) return a;
if (fz_is_infinite_rect(b)) return b;
if (fz_is_empty_rect(a)) return b;
if (fz_is_empty_rect(b)) return a;
r.x0 = MIN(a.x0, b.x0);
r.y0 = MIN(a.y0, b.y0);
r.x1 = MAX(a.x1, b.x1);
r.y1 = MAX(a.y1, b.y1);
return r;
}
fz_bbox
fz_intersect_bbox(fz_bbox a, fz_bbox b)
{
fz_bbox r;
if (fz_is_infinite_rect(a)) return b;
if (fz_is_infinite_rect(b)) return a;
if (fz_is_empty_rect(a)) return fz_empty_bbox;
if (fz_is_empty_rect(b)) return fz_empty_bbox;
r.x0 = MAX(a.x0, b.x0);
r.y0 = MAX(a.y0, b.y0);
r.x1 = MIN(a.x1, b.x1);
r.y1 = MIN(a.y1, b.y1);
return (r.x1 < r.x0 || r.y1 < r.y0) ? fz_empty_bbox : r;
}
int
fz_highlight_selection(fz_context *ctx, fz_text_page *page, fz_rect rect, fz_rect *hit_bbox, int hit_max)
{
fz_rect linebox, charbox;
fz_text_block *block;
fz_text_line *line;
int i, hit_count;
float x0 = rect.x0;
float x1 = rect.x1;
float y0 = rect.y0;
float y1 = rect.y1;
hit_count = 0;
for (block = page->blocks; block < page->blocks + page->len; block++)
{
for (line = block->lines; line < block->lines + block->len; line++)
{
int span_num;
linebox = fz_empty_rect;
for (span_num = 0; span_num < line->len; span_num++)
{
fz_text_span *span = line->spans[span_num];
for (i = 0; i < span->len; i++)
{
fz_text_char_bbox(&charbox, span, i);
if (charbox.x1 >= x0 && charbox.x0 <= x1 && charbox.y1 >= y0 && charbox.y0 <= y1)
{
if (charbox.y0 != linebox.y0 || fz_abs(charbox.x0 - linebox.x1) > 5)
{
if (!fz_is_empty_rect(&linebox) && hit_count < hit_max)
hit_bbox[hit_count++] = linebox;
linebox = charbox;
}
else
{
fz_union_rect(&linebox, &charbox);
}
}
}
}
if (!fz_is_empty_rect(&linebox) && hit_count < hit_max)
hit_bbox[hit_count++] = linebox;
}
}
return hit_count;
}
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_intersect_rect(fz_rect a, fz_rect b)
{
fz_rect r;
/* Check for empty box before infinite box */
if (fz_is_empty_rect(a)) return fz_empty_rect;
if (fz_is_empty_rect(b)) return fz_empty_rect;
if (fz_is_infinite_rect(a)) return b;
if (fz_is_infinite_rect(b)) return a;
r.x0 = fz_max(a.x0, b.x0);
r.y0 = fz_max(a.y0, b.y0);
r.x1 = fz_min(a.x1, b.x1);
r.y1 = fz_min(a.y1, b.y1);
return (r.x1 < r.x0 || r.y1 < r.y0) ? fz_empty_rect : 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;
}
static void
fz_draw_clip_path(fz_device *devp, fz_path *path, fz_rect rect, int even_odd, fz_matrix ctm)
{
fz_draw_device *dev = devp->user;
float expansion = fz_matrix_expansion(ctm);
float flatness = 0.3f / expansion;
fz_bbox bbox;
fz_draw_state *state = &dev->stack[dev->top];
fz_colorspace *model;
fz_context *ctx = dev->ctx;
fz_reset_gel(dev->gel, state->scissor);
fz_flatten_fill_path(dev->gel, path, ctm, flatness);
fz_sort_gel(dev->gel);
state = push_stack(dev);
model = state->dest->colorspace;
bbox = fz_bound_gel(dev->gel);
bbox = fz_intersect_bbox(bbox, state->scissor);
bbox = fz_intersect_bbox(bbox, fz_bbox_from_rect(rect));
/* SumatraPDF: try to match rendering with and without display list */
if (fz_is_infinite_rect(rect))
bbox = fz_intersect_bbox(bbox, fz_bbox_from_rect(fz_bound_path(ctx, path, NULL, ctm)));
if (fz_is_empty_rect(bbox) || fz_is_rect_gel(dev->gel))
{
state[1].scissor = bbox;
state[1].mask = NULL;
#ifdef DUMP_GROUP_BLENDS
dump_spaces(dev->top-1, "Clip (rectangular) begin\n");
#endif
return;
}
fz_try(ctx)
{
state[1].mask = fz_new_pixmap_with_bbox(dev->ctx, NULL, bbox);
fz_clear_pixmap(dev->ctx, state[1].mask);
state[1].dest = fz_new_pixmap_with_bbox(dev->ctx, model, bbox);
fz_clear_pixmap(dev->ctx, state[1].dest);
if (state[1].shape)
{
state[1].shape = fz_new_pixmap_with_bbox(dev->ctx, NULL, bbox);
fz_clear_pixmap(dev->ctx, state[1].shape);
}
fz_scan_convert(dev->gel, even_odd, bbox, state[1].mask, NULL);
state[1].blendmode |= FZ_BLEND_ISOLATED;
state[1].scissor = bbox;
#ifdef DUMP_GROUP_BLENDS
dump_spaces(dev->top-1, "Clip (non-rectangular) begin\n");
#endif
}
fz_catch(ctx)
{
emergency_pop_stack(dev, state);
}
}
static void
fz_draw_fill_path(void *user, fz_path *path, int even_odd, fz_matrix ctm,
fz_colorspace *colorspace, float *color, float alpha)
{
fz_draw_device *dev = user;
fz_colorspace *model = dev->dest->colorspace;
float expansion = fz_matrix_expansion(ctm);
float flatness = 0.3f / expansion;
unsigned char colorbv[FZ_MAX_COLORS + 1];
float colorfv[FZ_MAX_COLORS];
fz_bbox bbox;
int i;
fz_reset_gel(dev->gel, dev->scissor);
fz_flatten_fill_path(dev->gel, path, ctm, flatness);
fz_sort_gel(dev->gel);
bbox = fz_bound_gel(dev->gel);
bbox = fz_intersect_bbox(bbox, dev->scissor);
if (fz_is_empty_rect(bbox))
return;
fz_convert_color(colorspace, color, model, colorfv);
for (i = 0; i < model->n; i++)
colorbv[i] = colorfv[i] * 255;
colorbv[i] = alpha * 255;
fz_scan_convert(dev->gel, even_odd, bbox, dev->dest, colorbv);
}
int
fz_search_stext_page(fz_context *ctx, fz_stext_page *text, const char *needle, fz_rect *hit_bbox, int hit_max)
{
int pos, len, i, n, hit_count;
if (strlen(needle) == 0)
return 0;
hit_count = 0;
len = textlen_stext(ctx, text);
pos = 0;
while (pos < len)
{
n = match_stext(ctx, text, needle, pos);
if (n)
{
fz_rect linebox = fz_empty_rect;
for (i = 0; i < n; i++)
{
fz_rect charbox;
bboxat(ctx, text, pos + i, &charbox);
if (!fz_is_empty_rect(&charbox))
{
if (charbox.y0 != linebox.y0 || fz_abs(charbox.x0 - linebox.x1) > 5)
{
if (!fz_is_empty_rect(&linebox) && hit_count < hit_max)
hit_bbox[hit_count++] = linebox;
linebox = charbox;
}
else
{
fz_union_rect(&linebox, &charbox);
}
}
}
if (!fz_is_empty_rect(&linebox) && hit_count < hit_max)
hit_bbox[hit_count++] = linebox;
pos += n;
}
else
{
pos += 1;
}
}
return hit_count;
}
int
fz_highlight_selection(fz_context *ctx, fz_stext_page *page, fz_rect rect, fz_rect *hit_bbox, int hit_max)
{
fz_rect linebox, charbox;
fz_stext_block *block;
fz_stext_line *line;
fz_stext_char *ch;
int hit_count;
float x0 = rect.x0;
float x1 = rect.x1;
float y0 = rect.y0;
float y1 = rect.y1;
hit_count = 0;
for (block = page->first_block; block; block = block->next)
{
if (block->type != FZ_STEXT_BLOCK_TEXT)
continue;
for (line = block->u.t.first_line; line; line = line->next)
{
linebox = fz_empty_rect;
for (ch = line->first_char; ch; ch = ch->next)
{
fz_stext_char_bbox(ctx, &charbox, line, ch);
if (charbox.x1 >= x0 && charbox.x0 <= x1 && charbox.y1 >= y0 && charbox.y0 <= y1)
{
if (charbox.y0 != linebox.y0 || fz_abs(charbox.x0 - linebox.x1) > 5)
{
if (!fz_is_empty_rect(&linebox) && hit_count < hit_max)
hit_bbox[hit_count++] = linebox;
linebox = charbox;
}
else
{
fz_union_rect(&linebox, &charbox);
}
}
}
if (!fz_is_empty_rect(&linebox) && hit_count < hit_max)
hit_bbox[hit_count++] = linebox;
}
}
return hit_count;
}
static void
fz_draw_clip_stroke_path(fz_device *devp, fz_path *path, fz_rect *rect, fz_stroke_state *stroke, fz_matrix ctm)
{
fz_draw_device *dev = devp->user;
float expansion = fz_matrix_expansion(ctm);
float flatness = 0.3f / expansion;
float linewidth = stroke->linewidth;
fz_bbox bbox;
fz_draw_state *state = &dev->stack[dev->top];
fz_colorspace *model;
fz_context *ctx = dev->ctx;
if (linewidth * expansion < 0.1f)
linewidth = 1 / expansion;
fz_reset_gel(dev->gel, state->scissor);
if (stroke->dash_len > 0)
fz_flatten_dash_path(dev->gel, path, stroke, ctm, flatness, linewidth);
else
fz_flatten_stroke_path(dev->gel, path, stroke, ctm, flatness, linewidth);
fz_sort_gel(dev->gel);
state = push_stack(dev);
model = state->dest->colorspace;
bbox = fz_bound_gel(dev->gel);
bbox = fz_intersect_bbox(bbox, state->scissor);
if (rect)
bbox = fz_intersect_bbox(bbox, fz_bbox_covering_rect(*rect));
/* SumatraPDF: try to match rendering with and without display list */
else
bbox = fz_intersect_bbox(bbox, fz_bbox_covering_rect(fz_bound_path(ctx, path, stroke, ctm)));
fz_try(ctx)
{
state[1].mask = fz_new_pixmap_with_bbox(dev->ctx, NULL, bbox);
fz_clear_pixmap(dev->ctx, state[1].mask);
state[1].dest = fz_new_pixmap_with_bbox(dev->ctx, model, bbox);
fz_clear_pixmap(dev->ctx, state[1].dest);
if (state->shape)
{
state[1].shape = fz_new_pixmap_with_bbox(dev->ctx, NULL, bbox);
fz_clear_pixmap(dev->ctx, state[1].shape);
}
if (!fz_is_empty_rect(bbox))
fz_scan_convert(dev->gel, 0, bbox, state[1].mask, NULL);
state[1].blendmode |= FZ_BLEND_ISOLATED;
state[1].scissor = bbox;
#ifdef DUMP_GROUP_BLENDS
dump_spaces(dev->top-1, "Clip (stroke) begin\n");
#endif
}
fz_catch(ctx)
{
emergency_pop_stack(dev, state);
}
}
static void
fz_draw_stroke_path(fz_device *devp, fz_path *path, fz_stroke_state *stroke, fz_matrix ctm,
fz_colorspace *colorspace, float *color, float alpha)
{
fz_draw_device *dev = devp->user;
float expansion = fz_matrix_expansion(ctm);
float flatness = 0.3f / expansion;
float linewidth = stroke->linewidth;
unsigned char colorbv[FZ_MAX_COLORS + 1];
float colorfv[FZ_MAX_COLORS];
fz_bbox bbox;
int i;
fz_draw_state *state = &dev->stack[dev->top];
fz_colorspace *model = state->dest->colorspace;
if (model == NULL)
model = fz_device_gray;
if (linewidth * expansion < 0.1f)
linewidth = 1 / expansion;
fz_reset_gel(dev->gel, state->scissor);
if (stroke->dash_len > 0)
fz_flatten_dash_path(dev->gel, path, stroke, ctm, flatness, linewidth);
else
fz_flatten_stroke_path(dev->gel, path, stroke, ctm, flatness, linewidth);
fz_sort_gel(dev->gel);
bbox = fz_bound_gel(dev->gel);
bbox = fz_intersect_bbox(bbox, state->scissor);
if (fz_is_empty_rect(bbox))
return;
if (state->blendmode & FZ_BLEND_KNOCKOUT)
state = fz_knockout_begin(dev);
fz_convert_color(dev->ctx, model, colorfv, colorspace, color);
for (i = 0; i < model->n; i++)
colorbv[i] = colorfv[i] * 255;
colorbv[i] = alpha * 255;
fz_scan_convert(dev->gel, 0, bbox, state->dest, colorbv);
if (state->shape)
{
fz_reset_gel(dev->gel, state->scissor);
if (stroke->dash_len > 0)
fz_flatten_dash_path(dev->gel, path, stroke, ctm, flatness, linewidth);
else
fz_flatten_stroke_path(dev->gel, path, stroke, ctm, flatness, linewidth);
fz_sort_gel(dev->gel);
colorbv[0] = 255;
fz_scan_convert(dev->gel, 0, bbox, state->shape, colorbv);
}
if (state->blendmode & FZ_BLEND_KNOCKOUT)
fz_knockout_end(dev);
}
static void
fz_draw_clip_stroke_path(fz_context *ctx, void *user, fz_path *path, fz_rect *rect, fz_stroke_state *stroke, fz_matrix ctm)
{
fz_draw_device *dev = user;
fz_colorspace *model = dev->dest->colorspace;
float expansion = fz_matrix_expansion(ctm);
float flatness = 0.3f / expansion;
float linewidth = stroke->linewidth;
fz_pixmap *mask, *dest, *shape;
fz_bbox bbox;
if (dev->top == dev->stack_max)
fz_grow_stack(dev);
if (linewidth * expansion < 0.1f)
linewidth = 1 / expansion;
fz_reset_gel(dev->gel, dev->scissor);
if (stroke->dash_len > 0)
fz_flatten_dash_path(ctx, dev->gel, path, stroke, ctm, flatness, linewidth);
else
fz_flatten_stroke_path(ctx, dev->gel, path, stroke, ctm, flatness, linewidth);
fz_sort_gel(dev->gel);
bbox = fz_bound_gel(dev->gel);
bbox = fz_intersect_bbox(bbox, dev->scissor);
if (rect)
bbox = fz_intersect_bbox(bbox, fz_round_rect(*rect));
mask = fz_new_pixmap_with_rect(ctx, NULL, bbox);
fz_clear_pixmap(mask);
dest = fz_new_pixmap_with_rect(ctx, model, bbox);
/* FIXME: See note #1 */
fz_clear_pixmap(dest);
if (dev->shape)
{
shape = fz_new_pixmap_with_rect(ctx, NULL, bbox);
fz_clear_pixmap(shape);
}
else
shape = NULL;
if (!fz_is_empty_rect(bbox))
fz_scan_convert(dev->gel, 0, bbox, mask, NULL);
dev->stack[dev->top].scissor = dev->scissor;
dev->stack[dev->top].mask = mask;
dev->stack[dev->top].dest = dev->dest;
dev->stack[dev->top].shape = dev->shape;
/* FIXME: See note #1 */
dev->stack[dev->top].blendmode = dev->blendmode | FZ_BLEND_ISOLATED;
dev->scissor = bbox;
dev->dest = dest;
dev->shape = shape;
#ifdef DUMP_GROUP_BLENDS
dump_spaces(dev->top, "Clip (stroke) begin\n");
#endif
dev->top++;
}
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;
}
static void
fz_draw_clip_path(void *user, fz_path *path, fz_rect *rect, int even_odd, fz_matrix ctm)
{
fz_draw_device *dev = user;
fz_colorspace *model = dev->dest->colorspace;
float expansion = fz_matrix_expansion(ctm);
float flatness = 0.3f / expansion;
fz_pixmap *mask, *dest;
fz_bbox bbox;
if (dev->top == STACK_SIZE)
{
fz_warn("assert: too many buffers on stack");
return;
}
fz_reset_gel(dev->gel, dev->scissor);
fz_flatten_fill_path(dev->gel, path, ctm, flatness);
fz_sort_gel(dev->gel);
bbox = fz_bound_gel(dev->gel);
bbox = fz_intersect_bbox(bbox, dev->scissor);
if (rect) {
bbox = fz_intersect_bbox(bbox, fz_round_rect(*rect));
}
if (fz_is_empty_rect(bbox) || fz_is_rect_gel(dev->gel))
{
dev->stack[dev->top].scissor = dev->scissor;
dev->stack[dev->top].mask = NULL;
dev->stack[dev->top].dest = NULL;
dev->scissor = bbox;
dev->top++;
return;
}
mask = fz_new_pixmap_with_rect(NULL, bbox);
dest = fz_new_pixmap_with_rect(model, bbox);
fz_clear_pixmap(mask);
fz_clear_pixmap(dest);
fz_scan_convert(dev->gel, even_odd, bbox, mask, NULL);
dev->stack[dev->top].scissor = dev->scissor;
dev->stack[dev->top].mask = mask;
dev->stack[dev->top].dest = dev->dest;
dev->scissor = bbox;
dev->dest = dest;
dev->top++;
}
static float
calcbboxoverlap(fz_bbox bbox1, fz_bbox bbox2)
{
fz_bbox intersect = fz_intersect_bbox(bbox1, bbox2);
int area1, area2, area3;
if (fz_is_empty_rect(intersect))
return 0;
area1 = (bbox1.x1 - bbox1.x0) * (bbox1.y1 - bbox1.y0);
area2 = (bbox2.x1 - bbox2.x0) * (bbox2.y1 - bbox2.y0);
area3 = (intersect.x1 - intersect.x0) * (intersect.y1 - intersect.y0);
return 1.0 * area3 / MAX(area1, area2);
}
static void
fz_draw_clip_stroke_path(void *user, fz_path *path, fz_rect *rect, fz_stroke_state *stroke, fz_matrix ctm)
{
fz_draw_device *dev = user;
fz_colorspace *model = dev->dest->colorspace;
float expansion = fz_matrix_expansion(ctm);
float flatness = 0.3f / expansion;
float linewidth = stroke->linewidth;
fz_pixmap *mask, *dest;
fz_bbox bbox;
if (dev->top == STACK_SIZE)
{
fz_warn("assert: too many buffers on stack");
return;
}
if (linewidth * expansion < 0.1f)
linewidth = 1 / expansion;
fz_reset_gel(dev->gel, dev->scissor);
if (stroke->dash_len > 0)
fz_flatten_dash_path(dev->gel, path, stroke, ctm, flatness, linewidth);
else
fz_flatten_stroke_path(dev->gel, path, stroke, ctm, flatness, linewidth);
fz_sort_gel(dev->gel);
bbox = fz_bound_gel(dev->gel);
bbox = fz_intersect_bbox(bbox, dev->scissor);
if (rect)
bbox = fz_intersect_bbox(bbox, fz_round_rect(*rect));
mask = fz_new_pixmap_with_rect(NULL, bbox);
dest = fz_new_pixmap_with_rect(model, bbox);
fz_clear_pixmap(mask);
fz_clear_pixmap(dest);
if (!fz_is_empty_rect(bbox))
fz_scan_convert(dev->gel, 0, bbox, mask, NULL);
dev->stack[dev->top].scissor = dev->scissor;
dev->stack[dev->top].mask = mask;
dev->stack[dev->top].dest = dev->dest;
dev->scissor = bbox;
dev->dest = dest;
dev->top++;
}
static float
calc_bbox_overlap(const fz_rect *bbox1, const fz_rect *bbox2)
{
float area1, area2, area3;
fz_rect intersect = *bbox1;
fz_intersect_rect(&intersect, bbox2);
if (fz_is_empty_rect(&intersect))
return 0;
area1 = (bbox1->x1 - bbox1->x0) * (bbox1->y1 - bbox1->y0);
area2 = (bbox2->x1 - bbox2->x0) * (bbox2->y1 - bbox2->y0);
area3 = (intersect.x1 - intersect.x0) * (intersect.y1 - intersect.y0);
return area3 / fz_max(area1, area2);
}
static void
fz_draw_clip_path(fz_device *devp, fz_path *path, fz_rect *rect, int even_odd, fz_matrix ctm)
{
fz_draw_device *dev = devp->user;
float expansion = fz_matrix_expansion(ctm);
float flatness = 0.3f / expansion;
fz_bbox bbox;
fz_draw_state *state = push_stack(dev);
fz_colorspace *model = state->dest->colorspace;
fz_reset_gel(dev->gel, state->scissor);
fz_flatten_fill_path(dev->gel, path, ctm, flatness);
fz_sort_gel(dev->gel);
bbox = fz_bound_gel(dev->gel);
bbox = fz_intersect_bbox(bbox, state->scissor);
if (rect)
bbox = fz_intersect_bbox(bbox, fz_bbox_covering_rect(*rect));
if (fz_is_empty_rect(bbox) || fz_is_rect_gel(dev->gel))
{
state[1].scissor = bbox;
state[1].mask = NULL;
#ifdef DUMP_GROUP_BLENDS
dump_spaces(dev->top-1, "Clip (rectangular) begin\n");
#endif
return;
}
state[1].mask = fz_new_pixmap_with_bbox(dev->ctx, NULL, bbox);
fz_clear_pixmap(dev->ctx, state[1].mask);
state[1].dest = fz_new_pixmap_with_bbox(dev->ctx, model, bbox);
fz_clear_pixmap(dev->ctx, state[1].dest);
if (state[1].shape)
{
state[1].shape = fz_new_pixmap_with_bbox(dev->ctx, NULL, bbox);
fz_clear_pixmap(dev->ctx, state[1].shape);
}
fz_scan_convert(dev->gel, even_odd, bbox, state[1].mask, NULL);
state[1].blendmode |= FZ_BLEND_ISOLATED;
state[1].scissor = bbox;
#ifdef DUMP_GROUP_BLENDS
dump_spaces(dev->top-1, "Clip (non-rectangular) begin\n");
#endif
}
static void
fz_draw_fill_path(fz_device *devp, fz_path *path, int even_odd, fz_matrix ctm,
fz_colorspace *colorspace, float *color, float alpha)
{
fz_draw_device *dev = devp->user;
float expansion = fz_matrix_expansion(ctm);
float flatness = 0.3f / expansion;
unsigned char colorbv[FZ_MAX_COLORS + 1];
float colorfv[FZ_MAX_COLORS];
fz_bbox bbox;
int i;
fz_draw_state *state = &dev->stack[dev->top];
fz_colorspace *model = state->dest->colorspace;
fz_reset_gel(dev->gel, state->scissor);
fz_flatten_fill_path(dev->gel, path, ctm, flatness);
fz_sort_gel(dev->gel);
bbox = fz_bound_gel(dev->gel);
bbox = fz_intersect_bbox(bbox, state->scissor);
if (fz_is_empty_rect(bbox))
return;
if (state->blendmode & FZ_BLEND_KNOCKOUT)
state = fz_knockout_begin(dev);
fz_convert_color(dev->ctx, model, colorfv, colorspace, color);
for (i = 0; i < model->n; i++)
colorbv[i] = colorfv[i] * 255;
colorbv[i] = alpha * 255;
fz_scan_convert(dev->gel, even_odd, bbox, state->dest, colorbv);
if (state->shape)
{
fz_reset_gel(dev->gel, state->scissor);
fz_flatten_fill_path(dev->gel, path, ctm, flatness);
fz_sort_gel(dev->gel);
colorbv[0] = alpha * 255;
fz_scan_convert(dev->gel, even_odd, bbox, state->shape, colorbv);
}
if (state->blendmode & FZ_BLEND_KNOCKOUT)
fz_knockout_end(dev);
}
fz_rect *
fz_bound_text(fz_context *ctx, const fz_text *text, const fz_stroke_state *stroke, const fz_matrix *ctm, fz_rect *bbox)
{
fz_text_span *span;
fz_matrix tm, trm;
fz_rect gbox;
int i;
*bbox = fz_empty_rect;
for (span = text->head; span; span = span->next)
{
if (span->len > 0)
{
tm = span->trm;
for (i = 0; i < span->len; i++)
{
if (span->items[i].gid >= 0)
{
tm.e = span->items[i].x;
tm.f = span->items[i].y;
fz_concat(&trm, &tm, ctm);
fz_bound_glyph(ctx, span->font, span->items[i].gid, &trm, &gbox);
fz_union_rect(bbox, &gbox);
}
}
}
}
if (!fz_is_empty_rect(bbox))
{
if (stroke)
fz_adjust_rect_for_stroke(ctx, bbox, stroke, ctm);
/* Compensate for the glyph cache limited positioning precision */
bbox->x0 -= 1;
bbox->y0 -= 1;
bbox->x1 += 1;
bbox->y1 += 1;
}
return bbox;
}
static void
fz_draw_stroke_path(void *user, fz_path *path, fz_stroke_state *stroke, fz_matrix ctm,
fz_colorspace *colorspace, float *color, float alpha)
{
fz_draw_device *dev = user;
fz_colorspace *model = dev->dest->colorspace;
float expansion = fz_matrix_expansion(ctm);
float flatness = 0.3f / expansion;
float linewidth = stroke->linewidth;
unsigned char colorbv[FZ_MAX_COLORS + 1];
float colorfv[FZ_MAX_COLORS];
fz_bbox bbox;
int i;
if (linewidth * expansion < 0.1f)
linewidth = 1 / expansion;
fz_reset_gel(dev->gel, dev->scissor);
if (stroke->dash_len > 0)
fz_flatten_dash_path(dev->gel, path, stroke, ctm, flatness, linewidth);
else
fz_flatten_stroke_path(dev->gel, path, stroke, ctm, flatness, linewidth);
fz_sort_gel(dev->gel);
bbox = fz_bound_gel(dev->gel);
bbox = fz_intersect_bbox(bbox, dev->scissor);
if (fz_is_empty_rect(bbox))
return;
fz_convert_color(colorspace, color, model, colorfv);
for (i = 0; i < model->n; i++)
colorbv[i] = colorfv[i] * 255;
colorbv[i] = alpha * 255;
fz_scan_convert(dev->gel, 0, bbox, dev->dest, colorbv);
}
static void
fz_draw_fill_shade(fz_context *ctx, void *user, fz_shade *shade, fz_matrix ctm, float alpha)
{
fz_draw_device *dev = user;
fz_colorspace *model = dev->dest->colorspace;
fz_pixmap *dest = dev->dest;
fz_rect bounds;
fz_bbox bbox, scissor;
float colorfv[FZ_MAX_COLORS];
unsigned char colorbv[FZ_MAX_COLORS + 1];
bounds = fz_bound_shade(shade, ctm);
bbox = fz_intersect_bbox(fz_round_rect(bounds), dev->scissor);
scissor = dev->scissor;
// TODO: proper clip by shade->bbox
if (fz_is_empty_rect(bbox))
return;
if (!model)
{
fz_warn(ctx, "cannot render shading directly to an alpha mask");
return;
}
if (alpha < 1)
{
dest = fz_new_pixmap_with_rect(ctx, dev->dest->colorspace, bbox);
fz_clear_pixmap(dest);
}
if (dev->blendmode & FZ_BLEND_KNOCKOUT)
fz_knockout_begin(ctx, dev);
if (shade->use_background)
{
unsigned char *s;
int x, y, n, i;
fz_convert_color(ctx, shade->colorspace, shade->background, model, colorfv);
for (i = 0; i < model->n; i++)
colorbv[i] = colorfv[i] * 255;
colorbv[i] = 255;
n = dest->n;
for (y = scissor.y0; y < scissor.y1; y++)
{
s = dest->samples + ((scissor.x0 - dest->x) + (y - dest->y) * dest->w) * dest->n;
for (x = scissor.x0; x < scissor.x1; x++)
{
for (i = 0; i < n; i++)
*s++ = colorbv[i];
}
}
if (dev->shape)
{
for (y = scissor.y0; y < scissor.y1; y++)
{
s = dev->shape->samples + (scissor.x0 - dev->shape->x) + (y - dev->shape->y) * dev->shape->w;
for (x = scissor.x0; x < scissor.x1; x++)
{
*s++ = 255;
}
}
}
}
fz_paint_shade(ctx, shade, ctm, dest, bbox);
if (dev->shape)
fz_clear_pixmap_rect_with_color(dev->shape, 255, bbox);
if (alpha < 1)
{
fz_paint_pixmap(dev->dest, dest, alpha * 255);
fz_drop_pixmap(ctx, dest);
}
if (dev->blendmode & FZ_BLEND_KNOCKOUT)
fz_knockout_end(ctx, dev);
}
static void
fz_draw_clip_stroke_text(fz_context *ctx, void *user, fz_text *text, fz_stroke_state *stroke, fz_matrix ctm)
{
fz_draw_device *dev = user;
fz_colorspace *model = dev->dest->colorspace;
fz_bbox bbox;
fz_pixmap *mask, *dest, *shape;
fz_matrix tm, trm;
fz_pixmap *glyph;
int i, x, y, gid;
if (dev->top == dev->stack_max)
fz_grow_stack(dev);
/* make the mask the exact size needed */
bbox = fz_round_rect(fz_bound_text(text, ctm));
bbox = fz_intersect_bbox(bbox, dev->scissor);
mask = fz_new_pixmap_with_rect(ctx, NULL, bbox);
fz_clear_pixmap(mask);
dest = fz_new_pixmap_with_rect(ctx, model, bbox);
/* FIXME: See note #1 */
fz_clear_pixmap(dest);
if (dev->shape)
{
shape = fz_new_pixmap_with_rect(ctx, NULL, bbox);
fz_clear_pixmap(shape);
}
else
shape = dev->shape;
dev->stack[dev->top].scissor = dev->scissor;
dev->stack[dev->top].mask = mask;
dev->stack[dev->top].dest = dev->dest;
dev->stack[dev->top].shape = dev->shape;
/* FIXME: See note #1 */
dev->stack[dev->top].blendmode = dev->blendmode | FZ_BLEND_ISOLATED;
dev->scissor = bbox;
dev->dest = dest;
dev->shape = shape;
#ifdef DUMP_GROUP_BLENDS
dump_spaces(dev->top, "Clip (stroke text) begin\n");
#endif
dev->top++;
if (!fz_is_empty_rect(bbox))
{
tm = text->trm;
for (i = 0; i < text->len; i++)
{
gid = text->items[i].gid;
if (gid < 0)
continue;
tm.e = text->items[i].x;
tm.f = text->items[i].y;
trm = fz_concat(tm, ctm);
x = floorf(trm.e);
y = floorf(trm.f);
trm.e = QUANT(trm.e - floorf(trm.e), HSUBPIX);
trm.f = QUANT(trm.f - floorf(trm.f), VSUBPIX);
glyph = fz_render_stroked_glyph(ctx, dev->cache, text->font, gid, trm, ctm, stroke);
if (glyph)
{
draw_glyph(NULL, mask, glyph, x, y, bbox);
if (dev->shape)
draw_glyph(NULL, dev->shape, glyph, x, y, bbox);
fz_drop_pixmap(ctx, glyph);
}
}
}
}
static void
fz_draw_clip_text(fz_context *ctx, void *user, fz_text *text, fz_matrix ctm, int accumulate)
{
fz_draw_device *dev = user;
fz_colorspace *model = dev->dest->colorspace;
fz_bbox bbox;
fz_pixmap *mask, *dest, *shape;
fz_matrix tm, trm;
fz_pixmap *glyph;
int i, x, y, gid;
/* If accumulate == 0 then this text object is guaranteed complete */
/* If accumulate == 1 then this text object is the first (or only) in a sequence */
/* If accumulate == 2 then this text object is a continuation */
if (dev->top == dev->stack_max)
fz_grow_stack(dev);
if (accumulate == 0)
{
/* make the mask the exact size needed */
bbox = fz_round_rect(fz_bound_text(text, ctm));
bbox = fz_intersect_bbox(bbox, dev->scissor);
}
else
{
/* be conservative about the size of the mask needed */
bbox = dev->scissor;
}
if (accumulate == 0 || accumulate == 1)
{
mask = fz_new_pixmap_with_rect(ctx, NULL, bbox);
fz_clear_pixmap(mask);
dest = fz_new_pixmap_with_rect(ctx, model, bbox);
/* FIXME: See note #1 */
fz_clear_pixmap(dest);
if (dev->shape)
{
shape = fz_new_pixmap_with_rect(ctx, NULL, bbox);
fz_clear_pixmap(shape);
}
else
shape = NULL;
dev->stack[dev->top].scissor = dev->scissor;
dev->stack[dev->top].mask = mask;
dev->stack[dev->top].dest = dev->dest;
dev->stack[dev->top].shape = dev->shape;
/* FIXME: See note #1 */
dev->stack[dev->top].blendmode = dev->blendmode | FZ_BLEND_ISOLATED;
dev->scissor = bbox;
dev->dest = dest;
dev->shape = shape;
#ifdef DUMP_GROUP_BLENDS
dump_spaces(dev->top, "Clip (text) begin\n");
#endif
dev->top++;
}
else
{
mask = dev->stack[dev->top-1].mask;
}
if (!fz_is_empty_rect(bbox))
{
tm = text->trm;
for (i = 0; i < text->len; i++)
{
gid = text->items[i].gid;
if (gid < 0)
continue;
tm.e = text->items[i].x;
tm.f = text->items[i].y;
trm = fz_concat(tm, ctm);
x = floorf(trm.e);
y = floorf(trm.f);
trm.e = QUANT(trm.e - floorf(trm.e), HSUBPIX);
trm.f = QUANT(trm.f - floorf(trm.f), VSUBPIX);
glyph = fz_render_glyph(ctx, dev->cache, text->font, gid, trm, model);
if (glyph)
{
draw_glyph(NULL, mask, glyph, x, y, bbox);
if (dev->shape)
draw_glyph(NULL, dev->shape, glyph, x, y, bbox);
fz_drop_pixmap(ctx, glyph);
}
}
}
}
static void
fz_draw_clip_path(fz_context *ctx, void *user, fz_path *path, fz_rect *rect, int even_odd, fz_matrix ctm)
{
fz_draw_device *dev = user;
fz_colorspace *model = dev->dest->colorspace;
float expansion = fz_matrix_expansion(ctm);
float flatness = 0.3f / expansion;
fz_pixmap *mask, *dest, *shape;
fz_bbox bbox;
if (dev->top == dev->stack_max)
fz_grow_stack(dev);
fz_reset_gel(dev->gel, dev->scissor);
fz_flatten_fill_path(ctx, dev->gel, path, ctm, flatness);
fz_sort_gel(dev->gel);
bbox = fz_bound_gel(dev->gel);
bbox = fz_intersect_bbox(bbox, dev->scissor);
if (rect)
bbox = fz_intersect_bbox(bbox, fz_round_rect(*rect));
if (fz_is_empty_rect(bbox) || fz_is_rect_gel(dev->gel))
{
dev->stack[dev->top].scissor = dev->scissor;
dev->stack[dev->top].mask = NULL;
dev->stack[dev->top].dest = NULL;
dev->stack[dev->top].shape = dev->shape;
dev->stack[dev->top].blendmode = dev->blendmode;
dev->scissor = bbox;
#ifdef DUMP_GROUP_BLENDS
dump_spaces(dev->top, "Clip (rectangular) begin\n");
#endif
dev->top++;
return;
}
mask = fz_new_pixmap_with_rect(ctx, NULL, bbox);
fz_clear_pixmap(mask);
dest = fz_new_pixmap_with_rect(ctx, model, bbox);
/* FIXME: See note #1 */
fz_clear_pixmap(dest);
if (dev->shape)
{
shape = fz_new_pixmap_with_rect(ctx, NULL, bbox);
fz_clear_pixmap(shape);
}
else
shape = NULL;
fz_scan_convert(dev->gel, even_odd, bbox, mask, NULL);
dev->stack[dev->top].scissor = dev->scissor;
dev->stack[dev->top].mask = mask;
dev->stack[dev->top].dest = dev->dest;
dev->stack[dev->top].shape = dev->shape;
/* FIXME: See note #1 */
dev->stack[dev->top].blendmode = dev->blendmode | FZ_BLEND_ISOLATED;
dev->scissor = bbox;
dev->dest = dest;
dev->shape = shape;
#ifdef DUMP_GROUP_BLENDS
dump_spaces(dev->top, "Clip (non-rectangular) begin\n");
#endif
dev->top++;
}
static int _pdf_doc_load(struct _pdf_doc *self, mume_stream_t *stm)
{
fz_error error;
fz_stream *fzstm;
fz_rect *mbox;
fz_obj *page_obj, *box_obj;
int i, c;
_pdf_doc_clear(self);
fzstm = fz_new_stream(stm, _pdf_stream_read, _pdf_stream_close);
mume_stream_reference(stm);
fzstm->seek = _pdf_stream_seek;
error = pdf_open_xref_with_stream(&self->xref, fzstm, NULL);
fz_close(fzstm);
if (error) {
mume_error(("Read xref failed\n", error));
return 0;
}
assert(!pdf_needs_password(self->xref));
/* Load meta information. */
error = pdf_load_page_tree(self->xref);
if (error) {
mume_error(("Cannot load page tree\n"));
return 0;
}
c = pdf_count_pages(self->xref);
self->glyph_cache = fz_new_glyph_cache();
self->pages = calloc_abort(c, sizeof(pdf_page*));
self->disps = calloc_abort(c, sizeof(fz_display_list*));
self->media_boxes = malloc_abort(c * sizeof(fz_rect));
self->page_rotates = malloc_abort(c * sizeof(int));
/* Extract each pages' media box and rotation. */
for (i = 0; i < c; ++i) {
mbox = self->media_boxes + i;
page_obj = self->xref->page_objs[i];
if (!page_obj) {
*mbox = fz_empty_rect;
continue;
}
box_obj = fz_dict_gets(page_obj, "MediaBox");
*mbox = pdf_to_rect(box_obj);
if (fz_is_empty_rect(*mbox)) {
fz_warn("Cannot find page bounds, guessing page bounds.");
mbox->x1 = 612;
mbox->y1 = 792;
}
box_obj = fz_dict_gets(page_obj, "CropBox");
if (fz_is_array(box_obj))
*mbox = fz_intersect_rect(*mbox, pdf_to_rect(box_obj));
self->page_rotates[i] = fz_to_int(
fz_dict_gets(page_obj, "Rotate"));
if (self->page_rotates[i] % 90)
self->page_rotates[i] = 0;
}
return 1;
}