void
fz_copy_pixmap_rect(fz_context *ctx, fz_pixmap *dest, fz_pixmap *src, fz_bbox r)
{
const unsigned char *srcp;
unsigned char *destp;
int y, w, destspan, srcspan;
r = fz_intersect_bbox(r, fz_pixmap_bbox(ctx, dest));
r = fz_intersect_bbox(r, fz_pixmap_bbox(ctx, src));
w = r.x1 - r.x0;
y = r.y1 - r.y0;
if (w <= 0 || y <= 0)
return;
w *= src->n;
srcspan = src->w * src->n;
srcp = src->samples + srcspan * (r.y0 - src->y) + src->n * (r.x0 - src->x);
destspan = dest->w * dest->n;
destp = dest->samples + destspan * (r.y0 - dest->y) + dest->n * (r.x0 - dest->x);
do
{
memcpy(destp, srcp, w);
srcp += srcspan;
destp += destspan;
}
while (--y);
}
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_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++;
}
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_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 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 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);
}
void
fz_clear_pixmap_rect_with_value(fz_context *ctx, fz_pixmap *dest, int value, fz_bbox r)
{
unsigned char *destp;
int x, y, w, k, destspan;
r = fz_intersect_bbox(r, fz_pixmap_bbox(ctx, dest));
w = r.x1 - r.x0;
y = r.y1 - r.y0;
if (w <= 0 || y <= 0)
return;
destspan = dest->w * dest->n;
destp = dest->samples + destspan * (r.y0 - dest->y) + dest->n * (r.x0 - dest->x);
if (value == 255)
do
{
memset(destp, 255, w * dest->n);
destp += destspan;
}
while (--y);
else
do
{
unsigned char *s = destp;
for (x = 0; x < w; x++)
{
for (k = 0; k < dest->n - 1; k++)
*s++ = value;
*s++ = 255;
}
destp += destspan;
}
while (--y);
}
static fz_draw_state *
fz_knockout_begin(fz_draw_device *dev)
{
fz_context *ctx = dev->ctx;
fz_bbox bbox;
fz_pixmap *dest, *shape;
fz_draw_state *state = &dev->stack[dev->top];
int isolated = state->blendmode & FZ_BLEND_ISOLATED;
if ((state->blendmode & FZ_BLEND_KNOCKOUT) == 0)
return state;
state = push_stack(dev);
bbox = fz_pixmap_bbox(dev->ctx, state->dest);
bbox = fz_intersect_bbox(bbox, state->scissor);
dest = fz_new_pixmap_with_bbox(dev->ctx, state->dest->colorspace, bbox);
if (isolated)
{
fz_clear_pixmap(ctx, dest);
}
else
{
/* Find the last but one destination to copy */
int i = dev->top-1; /* i = the one on entry (i.e. the last one) */
fz_pixmap *prev = state->dest;
while (i > 0)
{
prev = dev->stack[--i].dest;
if (prev != state->dest)
break;
}
if (prev)
fz_copy_pixmap_rect(ctx, dest, prev, bbox);
else
fz_clear_pixmap(ctx, dest);
}
if (state->blendmode == 0 && isolated)
{
/* We can render direct to any existing shape plane. If there
* isn't one, we don't need to make one. */
shape = state->shape;
}
else
{
shape = fz_new_pixmap_with_bbox(dev->ctx, NULL, bbox);
fz_clear_pixmap(dev->ctx, shape);
}
#ifdef DUMP_GROUP_BLENDS
dump_spaces(dev->top-1, "Knockout begin\n");
#endif
state[1].scissor = bbox;
state[1].dest = dest;
state[1].shape = shape;
state[1].blendmode &= ~FZ_BLEND_MODEMASK;
return &state[1];
}
static void
draw_glyph(unsigned char *colorbv, fz_pixmap *dst, fz_pixmap *msk,
int xorig, int yorig, fz_bbox scissor)
{
unsigned char *dp, *mp;
fz_bbox bbox;
int x, y, w, h;
bbox = fz_bound_pixmap(msk);
bbox.x0 += xorig;
bbox.y0 += yorig;
bbox.x1 += xorig;
bbox.y1 += yorig;
bbox = fz_intersect_bbox(bbox, scissor); /* scissor < dst */
x = bbox.x0;
y = bbox.y0;
w = bbox.x1 - bbox.x0;
h = bbox.y1 - bbox.y0;
mp = msk->samples + ((y - msk->y - yorig) * msk->w + (x - msk->x - xorig));
dp = dst->samples + ((y - dst->y) * dst->w + (x - dst->x)) * dst->n;
assert(msk->n == 1);
while (h--)
{
if (dst->colorspace)
fz_paint_span_with_color(dp, mp, dst->n, w, colorbv);
else
fz_paint_span(dp, mp, 1, w, 255);
dp += dst->w * dst->n;
mp += msk->w;
}
}
//sumatrapdf code
int extractText(miniexp_t item, Arraylist list, fz_bbox * target) {
miniexp_t type = miniexp_car(item);
if (!miniexp_symbolp(type))
return 0;
item = miniexp_cdr(item);
if (!miniexp_numberp(miniexp_car(item))) return 0;
int x0 = miniexp_to_int(miniexp_car(item)); item = miniexp_cdr(item);
if (!miniexp_numberp(miniexp_car(item))) return 0;
int y0 = miniexp_to_int(miniexp_car(item)); item = miniexp_cdr(item);
if (!miniexp_numberp(miniexp_car(item))) return 0;
int x1 = miniexp_to_int(miniexp_car(item)); item = miniexp_cdr(item);
if (!miniexp_numberp(miniexp_car(item))) return 0;
int y1 = miniexp_to_int(miniexp_car(item)); item = miniexp_cdr(item);
//RectI rect = RectI::FromXY(x0, y0, x1, y1);
fz_bbox rect = {x0 , y0 , x1 , y1};
miniexp_t str = miniexp_car(item);
if (miniexp_stringp(str) && !miniexp_cdr(item)) {
fz_bbox inters = fz_intersect_bbox(rect, *target);
//LOGI("Start text extraction: rectangle=[%d,%d,%d,%d] %s", rect.x0, rect.y0, rect.x1, rect.y1, content);
if (!fz_is_empty_bbox(inters)) {
const char *content = miniexp_to_str(str);
while (*content) {
arraylist_add(list, *content++);
}
// if (value) {
// size_t len = str::Len(value);
// // TODO: split the rectangle into individual parts per glyph
// for (size_t i = 0; i < len; i++)
// coords.Append(RectI(rect.x, rect.y, rect.dx, rect.dy));
// extracted.AppendAndFree(value);
// }
if (miniexp_symbol("word") == type) {
arraylist_add(list, ' ');
//coords.Append(RectI(rect.x + rect.dx, rect.y, 2, rect.dy));
}
else if (miniexp_symbol("char") != type) {
arraylist_add(list, '\n');
// extracted.Append(lineSep);
// for (size_t i = 0; i < str::Len(lineSep); i++)
// coords.Append(RectI());
}
}
item = miniexp_cdr(item);
}
while (miniexp_consp(str)) {
extractText(str, list, target);
item = miniexp_cdr(item);
str = miniexp_car(item);
}
return !item;
}
static void
fz_draw_begin_group(void *user, fz_rect rect, int isolated, int knockout, int blendmode, float alpha)
{
fz_draw_device *dev = user;
fz_colorspace *model = dev->dest->colorspace;
fz_bbox bbox;
fz_pixmap *dest;
if (dev->top == STACK_SIZE)
{
fz_warn("assert: too many buffers on stack");
return;
}
bbox = fz_round_rect(rect);
bbox = fz_intersect_bbox(bbox, dev->scissor);
dest = fz_new_pixmap_with_rect(model, bbox);
fz_clear_pixmap(dest);
dev->stack[dev->top].alpha = alpha;
dev->stack[dev->top].blendmode = blendmode;
dev->stack[dev->top].scissor = dev->scissor;
dev->stack[dev->top].dest = dev->dest;
dev->top++;
dev->scissor = bbox;
dev->dest = dest;
}
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_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_knockout_begin(fz_context *ctx, void *user)
{
fz_draw_device *dev = user;
fz_bbox bbox;
fz_pixmap *dest, *shape;
int isolated = dev->blendmode & FZ_BLEND_ISOLATED;
if ((dev->blendmode & FZ_BLEND_KNOCKOUT) == 0)
return;
if (dev->top == dev->stack_max)
fz_grow_stack(dev);
bbox = fz_bound_pixmap(dev->dest);
bbox = fz_intersect_bbox(bbox, dev->scissor);
dest = fz_new_pixmap_with_rect(ctx, dev->dest->colorspace, bbox);
if (isolated)
{
fz_clear_pixmap(dest);
}
else
{
fz_pixmap *prev;
int i = dev->top;
do
prev = dev->stack[--i].dest;
while (prev == NULL);
fz_copy_pixmap_rect(dest, prev, bbox);
}
if (dev->blendmode == 0 && isolated || 1 /* SumatraPDF: disable crashy shape code */)
{
/* We can render direct to any existing shape plane. If there
* isn't one, we don't need to make one. */
shape = dev->shape;
}
else
{
shape = fz_new_pixmap_with_rect(dev->ctx, NULL, bbox);
fz_clear_pixmap(shape);
}
dev->stack[dev->top].blendmode = dev->blendmode;
dev->stack[dev->top].scissor = dev->scissor;
dev->stack[dev->top].dest = dev->dest;
dev->stack[dev->top].shape = dev->shape;
#ifdef DUMP_GROUP_BLENDS
dump_spaces(dev->top, "Knockout begin\n");
#endif
dev->top++;
dev->scissor = bbox;
dev->dest = dest;
dev->shape = shape;
dev->blendmode &= ~FZ_BLEND_MODEMASK;
}
static void
fz_draw_begin_mask(fz_context *ctx, void *user, fz_rect rect, int luminosity, fz_colorspace *colorspace, float *colorfv)
{
fz_draw_device *dev = user;
fz_pixmap *dest;
fz_pixmap *shape = dev->shape;
fz_bbox bbox;
if (dev->top == dev->stack_max)
fz_grow_stack(dev);
bbox = fz_round_rect(rect);
bbox = fz_intersect_bbox(bbox, dev->scissor);
dest = fz_new_pixmap_with_rect(ctx, fz_device_gray, bbox);
if (dev->shape)
{
/* FIXME: If we ever want to support AIS true, then we
* probably want to create a shape pixmap here, using:
* shape = fz_new_pixmap_with_rect(NULL, bbox);
* then, in the end_mask code, we create the mask from this
* rather than dest.
*/
shape = NULL;
}
if (luminosity)
{
float bc;
if (!colorspace)
colorspace = fz_device_gray;
fz_convert_color(ctx, colorspace, colorfv, fz_device_gray, &bc);
fz_clear_pixmap_with_color(dest, bc * 255);
if (shape)
fz_clear_pixmap_with_color(shape, 255);
}
else
{
fz_clear_pixmap(dest);
if (shape)
fz_clear_pixmap(shape);
}
dev->stack[dev->top].scissor = dev->scissor;
dev->stack[dev->top].dest = dev->dest;
dev->stack[dev->top].luminosity = luminosity;
dev->stack[dev->top].shape = dev->shape;
dev->stack[dev->top].blendmode = dev->blendmode;
#ifdef DUMP_GROUP_BLENDS
dump_spaces(dev->top, "Mask begin\n");
#endif
dev->top++;
dev->scissor = bbox;
dev->dest = dest;
dev->shape = shape;
}
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_begin_mask(fz_device *devp, fz_rect rect, int luminosity, fz_colorspace *colorspace, float *colorfv)
{
fz_draw_device *dev = devp->user;
fz_pixmap *dest;
fz_bbox bbox;
fz_draw_state *state = push_stack(dev);
fz_pixmap *shape = state->shape;
bbox = fz_bbox_covering_rect(rect);
bbox = fz_intersect_bbox(bbox, state->scissor);
dest = fz_new_pixmap_with_bbox(dev->ctx, fz_device_gray, bbox);
if (state->shape)
{
/* FIXME: If we ever want to support AIS true, then we
* probably want to create a shape pixmap here, using:
* shape = fz_new_pixmap_with_bbox(NULL, bbox);
* then, in the end_mask code, we create the mask from this
* rather than dest.
*/
shape = NULL;
}
if (luminosity)
{
float bc;
if (!colorspace)
colorspace = fz_device_gray;
fz_convert_color(dev->ctx, fz_device_gray, &bc, colorspace, colorfv);
fz_clear_pixmap_with_value(dev->ctx, dest, bc * 255);
if (shape)
fz_clear_pixmap_with_value(dev->ctx, shape, 255);
}
else
{
fz_clear_pixmap(dev->ctx, dest);
if (shape)
fz_clear_pixmap(dev->ctx, shape);
}
#ifdef DUMP_GROUP_BLENDS
dump_spaces(dev->top-1, "Mask begin\n");
#endif
state[1].scissor = bbox;
state[1].dest = dest;
state[1].shape = shape;
state[1].luminosity = luminosity;
}
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);
}
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_begin_mask(void *user, fz_rect rect, int luminosity, fz_colorspace *colorspace, float *colorfv)
{
fz_draw_device *dev = user;
fz_pixmap *dest;
fz_bbox bbox;
if (dev->top == STACK_SIZE)
{
fz_warn("assert: too many buffers on stack");
return;
}
bbox = fz_round_rect(rect);
bbox = fz_intersect_bbox(bbox, dev->scissor);
dest = fz_new_pixmap_with_rect(fz_device_gray, bbox);
if (luminosity)
{
float bc;
if (!colorspace)
colorspace = fz_device_gray;
fz_convert_color(colorspace, colorfv, fz_device_gray, &bc);
fz_clear_pixmap_with_color(dest, bc * 255);
}
else
fz_clear_pixmap(dest);
dev->stack[dev->top].scissor = dev->scissor;
dev->stack[dev->top].dest = dev->dest;
dev->stack[dev->top].luminosity = luminosity;
dev->top++;
dev->scissor = bbox;
dev->dest = dest;
}
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 void
fz_draw_begin_group(fz_context *ctx, void *user, fz_rect rect, int isolated, int knockout, int blendmode, float alpha)
{
fz_draw_device *dev = user;
fz_colorspace *model = dev->dest->colorspace;
fz_bbox bbox;
fz_pixmap *dest, *shape;
if (dev->top == dev->stack_max)
{
fz_warn(ctx, "assert: too many buffers on stack");
return;
}
if (dev->blendmode & FZ_BLEND_KNOCKOUT)
fz_knockout_begin(ctx, dev);
bbox = fz_round_rect(rect);
bbox = fz_intersect_bbox(bbox, dev->scissor);
dest = fz_new_pixmap_with_rect(ctx, model, bbox);
#ifndef ATTEMPT_KNOCKOUT_AND_ISOLATED
knockout = 0;
isolated = 1;
#endif
if (isolated)
{
fz_clear_pixmap(dest);
}
else
{
fz_copy_pixmap_rect(dest, dev->dest, bbox);
}
if (blendmode == 0 && alpha == 1.0 && isolated || 1 /* SumatraPDF: disable crashy shape code */)
{
/* We can render direct to any existing shape plane. If there
* isn't one, we don't need to make one. */
shape = dev->shape;
}
else
{
shape = fz_new_pixmap_with_rect(ctx, NULL, bbox);
fz_clear_pixmap(shape);
}
dev->stack[dev->top].alpha = alpha;
dev->stack[dev->top].blendmode = dev->blendmode;
dev->stack[dev->top].scissor = dev->scissor;
dev->stack[dev->top].dest = dev->dest;
dev->stack[dev->top].shape = dev->shape;
#ifdef DUMP_GROUP_BLENDS
dump_spaces(dev->top, "Group Begin\n");
#endif
dev->top++;
dev->scissor = bbox;
dev->dest = dest;
dev->shape = shape;
dev->blendmode = blendmode | (isolated ? FZ_BLEND_ISOLATED : 0) | (knockout ? FZ_BLEND_KNOCKOUT : 0);
}
static void
fz_draw_clip_image_mask(fz_context *ctx, void *user, fz_pixmap *image, fz_rect *rect, fz_matrix ctm)
{
fz_draw_device *dev = user;
fz_colorspace *model = dev->dest->colorspace;
fz_bbox bbox;
fz_pixmap *mask, *dest, *shape;
fz_pixmap *scaled = NULL;
int dx, dy;
if (dev->top == dev->stack_max)
fz_grow_stack(dev);
#ifdef DUMP_GROUP_BLENDS
dump_spaces(dev->top, "Clip (image mask) begin\n");
#endif
if (image->w == 0 || image->h == 0)
{
dev->stack[dev->top].scissor = dev->scissor;
dev->stack[dev->top].mask = NULL;
dev->stack[dev->top].dest = NULL;
dev->stack[dev->top].blendmode = dev->blendmode;
dev->scissor = fz_empty_bbox;
dev->top++;
return;
}
bbox = fz_round_rect(fz_transform_rect(ctm, fz_unit_rect));
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;
dx = sqrtf(ctm.a * ctm.a + ctm.b * ctm.b);
dy = sqrtf(ctm.c * ctm.c + ctm.d * ctm.d);
if (dx < image->w && dy < image->h)
{
int gridfit = !(dev->flags & FZ_DRAWDEV_FLAGS_TYPE3);
scaled = fz_transform_pixmap(ctx, image, &ctm, dev->dest->x, dev->dest->y, dx, dy, gridfit);
if (scaled == NULL)
{
if (dx < 1)
dx = 1;
if (dy < 1)
dy = 1;
scaled = fz_scale_pixmap(ctx, image, image->x, image->y, dx, dy);
}
if (scaled != NULL)
image = scaled;
}
fz_paint_image(mask, bbox, dev->shape, image, ctm, 255);
if (scaled)
fz_drop_pixmap(ctx, scaled);
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;
dev->top++;
}
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_fill_image(fz_device *devp, fz_image *image, fz_matrix ctm, float alpha)
{
fz_draw_device *dev = devp->user;
fz_pixmap *converted = NULL;
fz_pixmap *scaled = NULL;
fz_pixmap *pixmap;
fz_pixmap *orig_pixmap;
int after;
int dx, dy;
fz_context *ctx = dev->ctx;
fz_draw_state *state = &dev->stack[dev->top];
fz_colorspace *model = state->dest->colorspace;
fz_bbox clip = fz_pixmap_bbox(ctx, state->dest);
clip = fz_intersect_bbox(clip, state->scissor);
fz_var(scaled);
if (!model)
{
fz_warn(dev->ctx, "cannot render image directly to an alpha mask");
return;
}
if (image->w == 0 || image->h == 0)
return;
dx = sqrtf(ctm.a * ctm.a + ctm.b * ctm.b);
dy = sqrtf(ctm.c * ctm.c + ctm.d * ctm.d);
pixmap = fz_image_to_pixmap(ctx, image, dx, dy);
orig_pixmap = pixmap;
/* convert images with more components (cmyk->rgb) before scaling */
/* convert images with fewer components (gray->rgb after scaling */
/* convert images with expensive colorspace transforms after scaling */
fz_try(ctx)
{
if (state->blendmode & FZ_BLEND_KNOCKOUT)
state = fz_knockout_begin(dev);
after = 0;
if (pixmap->colorspace == fz_device_gray)
after = 1;
if (pixmap->colorspace != model && !after)
{
converted = fz_new_pixmap_with_bbox(ctx, model, fz_pixmap_bbox(ctx, pixmap));
fz_convert_pixmap(ctx, converted, pixmap);
pixmap = converted;
}
if (dx < pixmap->w && dy < pixmap->h)
{
int gridfit = alpha == 1.0f && !(dev->flags & FZ_DRAWDEV_FLAGS_TYPE3);
scaled = fz_transform_pixmap(ctx, pixmap, &ctm, state->dest->x, state->dest->y, dx, dy, gridfit, &clip);
if (!scaled)
{
if (dx < 1)
dx = 1;
if (dy < 1)
dy = 1;
scaled = fz_scale_pixmap(ctx, pixmap, pixmap->x, pixmap->y, dx, dy, NULL);
}
if (scaled)
pixmap = scaled;
}
if (pixmap->colorspace != model)
{
if ((pixmap->colorspace == fz_device_gray && model == fz_device_rgb) ||
(pixmap->colorspace == fz_device_gray && model == fz_device_bgr))
{
/* We have special case rendering code for gray -> rgb/bgr */
}
else
{
converted = fz_new_pixmap_with_bbox(ctx, model, fz_pixmap_bbox(ctx, pixmap));
fz_convert_pixmap(ctx, converted, pixmap);
pixmap = converted;
}
}
fz_paint_image(state->dest, state->scissor, state->shape, pixmap, ctm, alpha * 255);
if (state->blendmode & FZ_BLEND_KNOCKOUT)
fz_knockout_end(dev);
}
fz_always(ctx)
{
fz_drop_pixmap(ctx, scaled);
fz_drop_pixmap(ctx, converted);
fz_drop_pixmap(ctx, orig_pixmap);
}
fz_catch(ctx)
{
fz_rethrow(ctx);
}
}
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_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_pixmap *mask, *dest, *shape;
fz_matrix tm, trm, trunc_trm;
fz_pixmap *glyph;
int i, x, y, gid;
fz_draw_state *state;
fz_colorspace *model;
/* 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 */
state = push_stack(dev);
model = state->dest->colorspace;
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);
}
else
{
/* be conservative about the size of the mask needed */
bbox = state->scissor;
}
if (accumulate == 0 || accumulate == 1)
{
mask = fz_new_pixmap_with_bbox(dev->ctx, NULL, bbox);
fz_clear_pixmap(dev->ctx, mask);
dest = fz_new_pixmap_with_bbox(dev->ctx, model, bbox);
fz_clear_pixmap(dev->ctx, dest);
if (state->shape)
{
shape = fz_new_pixmap_with_bbox(dev->ctx, NULL, bbox);
fz_clear_pixmap(dev->ctx, shape);
}
else
shape = NULL;
state[1].blendmode |= FZ_BLEND_ISOLATED;
state[1].scissor = bbox;
state[1].dest = dest;
state[1].mask = mask;
state[1].shape = shape;
#ifdef DUMP_GROUP_BLENDS
dump_spaces(dev->top-1, "Clip (text) begin\n");
#endif
}
else
{
mask = state->mask;
dev->top--;
}
if (!fz_is_empty_rect(bbox) && mask)
{
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);
trunc_trm = trm;
trunc_trm.e = QUANT(trm.e - floorf(trm.e), HSUBPIX);
trunc_trm.f = QUANT(trm.f - floorf(trm.f), VSUBPIX);
glyph = fz_render_glyph(dev->ctx, text->font, gid, trunc_trm, model, bbox);
if (glyph)
{
draw_glyph(NULL, mask, glyph, x, y, bbox);
if (state[1].shape)
draw_glyph(NULL, state[1].shape, glyph, x, y, bbox);
fz_drop_pixmap(dev->ctx, glyph);
}
else
{
fz_path *path = fz_outline_glyph(dev->ctx, text->font, gid, trm);
if (path)
{
fz_pixmap *old_dest;
float white = 1;
state = &dev->stack[dev->top];
old_dest = state[0].dest;
state[0].dest = state[0].mask;
state[0].mask = NULL;
fz_try(ctx)
{
fz_draw_fill_path(devp, path, 0, fz_identity, fz_device_gray, &white, 1);
}
fz_always(ctx)
{
state[0].mask = state[0].dest;
state[0].dest = old_dest;
fz_free_path(dev->ctx, path);
}
fz_catch(ctx)
{
fz_rethrow(ctx);
}
}
else
{
fz_warn(dev->ctx, "cannot render glyph for clipping");
}
}
}
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);
}
void
fz_execute_display_list(fz_display_list *list, fz_device *dev, fz_matrix top_ctm, fz_bbox scissor)
{
fz_display_node *node;
fz_matrix ctm;
fz_rect rect;
fz_bbox bbox;
int clipped = 0;
int tiled = 0;
int empty;
if (!fz_is_infinite_bbox(scissor))
{
/* add some fuzz at the edges, as especially glyph rects
* are sometimes not actually completely bounding the glyph */
scissor.x0 -= 20; scissor.y0 -= 20;
scissor.x1 += 20; scissor.y1 += 20;
}
for (node = list->first; node; node = node->next)
{
/* cull objects to draw using a quick visibility test */
if (tiled || node->cmd == FZ_CMD_BEGIN_TILE || node->cmd == FZ_CMD_END_TILE)
{
empty = 0;
}
else
{
bbox = fz_round_rect(fz_transform_rect(top_ctm, node->rect));
bbox = fz_intersect_bbox(bbox, scissor);
empty = fz_is_empty_bbox(bbox);
}
if (clipped || empty)
{
switch (node->cmd)
{
case FZ_CMD_CLIP_PATH:
case FZ_CMD_CLIP_STROKE_PATH:
case FZ_CMD_CLIP_TEXT:
case FZ_CMD_CLIP_STROKE_TEXT:
case FZ_CMD_CLIP_IMAGE_MASK:
case FZ_CMD_BEGIN_MASK:
case FZ_CMD_BEGIN_GROUP:
clipped++;
continue;
case FZ_CMD_POP_CLIP:
case FZ_CMD_END_GROUP:
if (!clipped)
goto visible;
clipped--;
continue;
case FZ_CMD_END_MASK:
if (!clipped)
goto visible;
continue;
default:
continue;
}
}
visible:
ctm = fz_concat(node->ctm, top_ctm);
switch (node->cmd)
{
case FZ_CMD_FILL_PATH:
fz_fill_path(dev, node->item.path, node->flag, ctm,
node->colorspace, node->color, node->alpha);
break;
case FZ_CMD_STROKE_PATH:
fz_stroke_path(dev, node->item.path, node->stroke, ctm,
node->colorspace, node->color, node->alpha);
break;
case FZ_CMD_CLIP_PATH:
{
fz_rect trect = fz_transform_rect(top_ctm, node->rect);
fz_clip_path(dev, node->item.path, &trect, node->flag, ctm);
break;
}
case FZ_CMD_CLIP_STROKE_PATH:
{
fz_rect trect = fz_transform_rect(top_ctm, node->rect);
fz_clip_stroke_path(dev, node->item.path, &trect, node->stroke, ctm);
break;
}
case FZ_CMD_FILL_TEXT:
fz_fill_text(dev, node->item.text, ctm,
node->colorspace, node->color, node->alpha);
break;
case FZ_CMD_STROKE_TEXT:
fz_stroke_text(dev, node->item.text, node->stroke, ctm,
node->colorspace, node->color, node->alpha);
break;
case FZ_CMD_CLIP_TEXT:
fz_clip_text(dev, node->item.text, ctm, node->flag);
break;
case FZ_CMD_CLIP_STROKE_TEXT:
fz_clip_stroke_text(dev, node->item.text, node->stroke, ctm);
break;
case FZ_CMD_IGNORE_TEXT:
fz_ignore_text(dev, node->item.text, ctm);
break;
case FZ_CMD_FILL_SHADE:
fz_fill_shade(dev, node->item.shade, ctm, node->alpha);
break;
case FZ_CMD_FILL_IMAGE:
fz_fill_image(dev, node->item.image, ctm, node->alpha);
break;
case FZ_CMD_FILL_IMAGE_MASK:
fz_fill_image_mask(dev, node->item.image, ctm,
node->colorspace, node->color, node->alpha);
break;
case FZ_CMD_CLIP_IMAGE_MASK:
{
fz_rect trect = fz_transform_rect(top_ctm, node->rect);
fz_clip_image_mask(dev, node->item.image, &trect, ctm);
break;
}
case FZ_CMD_POP_CLIP:
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);
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,
node->flag & ISOLATED, node->flag & KNOCKOUT,
node->item.blendmode, node->alpha);
break;
case FZ_CMD_END_GROUP:
fz_end_group(dev);
break;
case FZ_CMD_BEGIN_TILE:
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);
break;
case FZ_CMD_END_TILE:
tiled--;
fz_end_tile(dev);
break;
}
}
}
