static int
xps_true_callback_build_char(gs_show_enum *penum, gs_state *pgs, gs_font *pfont,
gs_char chr, gs_glyph glyph)
{
gs_font_type42 *p42 = (gs_font_type42*)pfont;
const gs_rect *pbbox;
float sbw[4], w2[6];
gs_fixed_point saved_adjust;
int code;
// dprintf1("build char ttf %d\n", glyph);
code = gs_type42_get_metrics(p42, glyph, sbw);
if (code < 0)
return code;
w2[0] = sbw[2];
w2[1] = sbw[3];
pbbox = &p42->FontBBox;
w2[2] = pbbox->p.x;
w2[3] = pbbox->p.y;
w2[4] = pbbox->q.x;
w2[5] = pbbox->q.y;
/* Expand the bbox when stroking */
if ( pfont->PaintType )
{
float expand = max(1.415, gs_currentmiterlimit(pgs)) * gs_currentlinewidth(pgs) / 2;
w2[2] -= expand, w2[3] -= expand;
w2[4] += expand, w2[5] += expand;
}
if ( (code = gs_moveto(pgs, 0.0, 0.0)) < 0 )
return code;
if ( (code = gs_setcachedevice(penum, pgs, w2)) < 0 )
return code;
code = gs_type42_append(glyph, pgs,
gx_current_path(pgs),
(gs_text_enum_t*)penum, (gs_font*)p42,
gs_show_in_charpath(penum) != cpm_show);
if (code < 0)
return code;
/* Indicate that dropout prevention should be enabled by setting
fill_adjust to the special value -1. */
saved_adjust = pgs->fill_adjust;
pgs->fill_adjust.x = -1;
pgs->fill_adjust.y = -1;
code = (pfont->PaintType ? gs_stroke(pgs) : gs_fill(pgs));
if (code < 0)
return code;
pgs->fill_adjust = saved_adjust;
return 0;
}
/* - currentlinewidth <num> */
static int
zcurrentlinewidth(i_ctx_t *i_ctx_p)
{
os_ptr op = osp;
push(1);
make_real(op, gs_currentlinewidth(igs));
return 0;
}
/*
* Consult Metrics2 and CDevProc, and call setcachedevice[2]. Return
* o_push_estack if we had to call a CDevProc, or if we are skipping the
* rendering process (only getting the metrics).
* Returns exec_cont - a function, which must be called by caller after this function.
*/
int
zchar_set_cache(i_ctx_t *i_ctx_p, const gs_font_base * pbfont,
const ref * pcnref, const double psb[2],
const double pwidth[2], const gs_rect * pbbox,
op_proc_t cont, op_proc_t *exec_cont,
const double Metrics2_sbw_default[4])
{
os_ptr op = osp;
ref *pcdevproc, *valueref;
int have_cdevproc;
ref rpop;
ref cid, *cidptr;
bool metrics2;
bool metrics2_use_default = false;
double w2[10];
gs_text_enum_t *penum = op_show_find(i_ctx_p);
w2[0] = pwidth[0], w2[1] = pwidth[1];
/* Adjust the bounding box for stroking if needed. */
w2[2] = pbbox->p.x, w2[3] = pbbox->p.y;
w2[4] = pbbox->q.x, w2[5] = pbbox->q.y;
if (pbfont->PaintType != 0) {
double expand = max(1.415, gs_currentmiterlimit(igs)) *
gs_currentlinewidth(igs) / 2;
w2[2] -= expand, w2[3] -= expand;
w2[4] += expand, w2[5] += expand;
}
/* Check for Metrics2. */
{
int code = zchar_get_metrics2(pbfont, pcnref, w2 + 6);
if (code < 0)
return code;
metrics2 = code > 0;
}
/*
* For FontType 9 and 11, if Metrics2 is missing, the caller provides
* default Metrics2 values derived from the FontBBox.
*/
if (!metrics2 && Metrics2_sbw_default != NULL) {
w2[6] = Metrics2_sbw_default[2];
w2[7] = Metrics2_sbw_default[3];
w2[8] = Metrics2_sbw_default[0];
w2[9] = Metrics2_sbw_default[1];
metrics2 = true;
metrics2_use_default = true;
}
/* Check for CDevProc or "short-circuiting". */
have_cdevproc = zchar_get_CDevProc(pbfont, &pcdevproc);
/* Obscure test. The CDevProc is supposed to be called with the original CID but what we get passed
* here is the TT GID. So the CDevProc won't do the right thing. We need to extract the CID from the
* enumerator, and use that instead.
*/
cidptr = (ref *)pcnref;
if (pbfont->FontType == ft_CID_TrueType && dict_find_string(&pfont_data(gs_font_parent(pbfont))->dict, "File", &valueref) > 0) {
if (pbfont->key_name.size != pbfont->font_name.size ||
strncmp((const char *)pbfont->key_name.chars, (const char *)pbfont->font_name.chars, pbfont->key_name.size)) {
if (penum->returned.current_glyph >= GS_MIN_CID_GLYPH) {
make_int(&cid, penum->returned.current_glyph - GS_MIN_CID_GLYPH);
}
else {
make_int(&cid, penum->returned.current_glyph);
}
cidptr = &cid;
}
}
if (have_cdevproc || zchar_show_width_only(penum)) {
int i;
op_proc_t zsetc;
int nparams;
if (have_cdevproc) {
check_proc_only(*pcdevproc);
zsetc = zsetcachedevice2;
/* If we have cdevproc and the font type is CID type 0,
we'll throw away Metrics2_sbw_default that is calculated
from FontBBox. */
if (!metrics2
|| (penum->current_font->FontType == ft_CID_encrypted
&& metrics2_use_default)) {
w2[6] = w2[0], w2[7] = w2[1];
w2[8] = w2[9] = 0;
}
nparams = 10;
} else {
make_oper(&rpop, 0, zpop);
pcdevproc = &rpop;
if (metrics2)
zsetc = zsetcachedevice2, nparams = 10;
else
zsetc = zsetcachedevice, nparams = 6;
}
check_estack(3);
/* Push the l.s.b. for .type1addpath if necessary. */
if (psb != 0) {
push(nparams + 3);
make_real(op - (nparams + 2), psb[0]);
make_real(op - (nparams + 1), psb[1]);
} else {
push(nparams + 1);
}
for (i = 0; i < nparams; ++i)
make_real(op - nparams + i, w2[i]);
ref_assign(op, cidptr);
push_op_estack(cont);
push_op_estack(zsetc);
++esp;
ref_assign(esp, pcdevproc);
return o_push_estack;
} {
int code =
(metrics2 ? gs_text_setcachedevice2(penum, w2) :
gs_text_setcachedevice(penum, w2));
if (code < 0)
return code;
}
/* No metrics modification, do the stroke or fill now. */
/* Push the l.s.b. for .type1addpath if necessary. */
if (psb != 0) {
push(2);
make_real(op - 1, psb[0]);
make_real(op, psb[1]);
}
*exec_cont = cont;
return 0;
}
/* Stroke the current path */
int
gs_stroke(gs_state * pgs)
{
int code;
/*
* If we're inside a charpath, just merge the current path
* into the parent's path.
*/
if (pgs->in_charpath) {
if (pgs->in_charpath == cpm_true_charpath) {
/*
* A stroke inside a true charpath should do the
* equivalent of strokepath.
*/
code = gs_strokepath(pgs);
if (code < 0)
return code;
}
code = gx_path_add_char_path(pgs->show_gstate->path, pgs->path,
pgs->in_charpath);
}
if (gs_is_null_device(pgs->device)) {
/* Handle separately to prevent gs_state_color_load. */
gs_newpath(pgs);
code = 0;
} else {
int abits, acode, rcode = 0;
/* to distinguish text from vectors we hackly look at the
target device 1 bit per component is a cache and this is
text else it is a path */
if (gx_device_has_color(gs_currentdevice(pgs)))
gs_set_object_tag(pgs, GS_PATH_TAG);
else
gs_set_object_tag(pgs, GS_TEXT_TAG);
/* Here we need to distinguish text from vectors to compute the object tag.
Actually we need to know whether this function is called to rasterize a character,
or to rasterize a vector graphics to the output device.
Currently we assume it works for the bitrgbtags device only,
which is a low level device with a 4-component color model.
We use the fact that with printers a character is usually being rendered
to a 1bpp cache device rather than to the output device.
Therefore we hackly look whether the target device
"has a color" : either it's a multicomponent color model,
or it is not gray (such as a yellow separation).
This check has several limitations :
1. It doesn't work with -dNOCACHE.
2. It doesn't work with large characters,
which cannot fit into a cache cell and thus they
render directly to the output device.
3. It doesn't work for TextAlphaBits=2 or 4.
We don't care of this case because
text antialiasing usually usn't applied to printers.
4. It doesn't work for things like with "(xyz) true charpath stroke".
That's unfortunate, we'd like to improve someday.
5. It doesn't work for high level devices when a Type 3 character is being constructed.
This case is not important for low level devices
(which a printer is), because low level device doesn't accept
Type 3 charproc streams immediately.
*/
if (gx_device_has_color(gs_currentdevice(pgs))) {
gs_set_object_tag(pgs, GS_PATH_TAG);
}
else {
gs_set_object_tag(pgs, GS_TEXT_TAG);
}
gx_set_dev_color(pgs);
code = gs_state_color_load(pgs);
if (code < 0)
return code;
abits = alpha_buffer_bits(pgs);
if (abits > 1) {
/*
* Expand the bounding box by the line width.
* This is expensive to compute, so we only do it
* if we know we're going to buffer.
*/
float xxyy = fabs(pgs->ctm.xx) + fabs(pgs->ctm.yy);
float xyyx = fabs(pgs->ctm.xy) + fabs(pgs->ctm.yx);
float scale = (float)(1 << (abits / 2));
float orig_width = gs_currentlinewidth(pgs);
float new_width = orig_width * scale;
fixed extra_adjust =
float2fixed(max(xxyy, xyyx) * new_width / 2);
float orig_flatness = gs_currentflat(pgs);
gx_path spath;
/* Scale up the line width, dash pattern, and flatness. */
if (extra_adjust < fixed_1)
extra_adjust = fixed_1;
acode = alpha_buffer_init(pgs,
pgs->fill_adjust.x + extra_adjust,
pgs->fill_adjust.y + extra_adjust,
abits);
if (acode < 0)
return acode;
gs_setlinewidth(pgs, new_width);
scale_dash_pattern(pgs, scale);
gs_setflat(pgs, orig_flatness * scale);
/*
* The alpha-buffer device requires that we fill the
* entire path as a single unit.
*/
gx_path_init_local(&spath, pgs->memory);
code = gx_stroke_add(pgs->path, &spath, pgs);
gs_setlinewidth(pgs, orig_width);
scale_dash_pattern(pgs, 1.0 / scale);
if (code >= 0)
code = gx_fill_path(&spath, pgs->dev_color, pgs,
gx_rule_winding_number,
pgs->fill_adjust.x,
pgs->fill_adjust.y);
gs_setflat(pgs, orig_flatness);
gx_path_free(&spath, "gs_stroke");
if (acode > 0)
rcode = alpha_buffer_release(pgs, code >= 0);
} else
code = gx_stroke_fill(pgs->path, pgs);
if (code >= 0)
gs_newpath(pgs);
if (code >= 0 && rcode < 0)
code = rcode;
}
return code;
}
/*
* Consult Metrics2 and CDevProc, and call setcachedevice[2]. Return
* o_push_estack if we had to call a CDevProc, or if we are skipping the
* rendering process (only getting the metrics).
*/
int
zchar_set_cache(os_ptr op, const gs_font_base *pbfont, const ref *pcnref,
const float psb[2], const float pwidth[2], const gs_rect *pbbox,
int (*cont_fill)(P1(os_ptr)), int (*cont_stroke)(P1(os_ptr)))
{ const ref *pfdict = &pfont_data(pbfont)->dict;
ref *pmdict;
ref *pcdevproc;
int have_cdevproc;
ref rpop;
bool metrics2 = false;
int (*cont)(P1(os_ptr));
float w2[10];
gs_show_enum *penum = op_show_find();
w2[0] = pwidth[0], w2[1] = pwidth[1];
/* Adjust the bounding box for stroking if needed. */
w2[2] = pbbox->p.x, w2[3] = pbbox->p.y;
w2[4] = pbbox->q.x, w2[5] = pbbox->q.y;
if ( pbfont->PaintType == 0 )
cont = cont_fill;
else
{ double expand = max(1.415, gs_currentmiterlimit(igs)) *
gs_currentlinewidth(igs) / 2;
w2[2] -= expand, w2[3] -= expand;
w2[4] += expand, w2[5] += expand;
cont = cont_stroke;
}
/* Check for Metrics2. */
if ( dict_find_string(pfdict, "Metrics2", &pmdict) > 0 )
{ ref *pmvalue;
check_type_only(*pmdict, t_dictionary);
check_dict_read(*pmdict);
if ( dict_find(pmdict, pcnref, &pmvalue) > 0 )
{ check_read_type_only(*pmvalue, t_array);
if ( r_size(pmvalue) == 4 )
{ int code = num_params(pmvalue->value.refs + 3,
4, w2 + 6);
if ( code < 0 )
return code;
metrics2 = true;
}
}
}
/* Check for CDevProc or "short-circuiting". */
have_cdevproc = dict_find_string(pfdict, "CDevProc", &pcdevproc) > 0;
if ( have_cdevproc || gs_show_width_only(penum) )
{ int i;
int (*zsetc)(P1(os_ptr));
int nparams;
if ( have_cdevproc )
{ check_proc_only(*pcdevproc);
zsetc = zsetcachedevice2;
if ( !metrics2 )
{ w2[6] = w2[0], w2[7] = w2[1];
w2[8] = w2[9] = 0;
}
nparams = 10;
}
else
{ make_oper(&rpop, 0, zpop);
pcdevproc = &rpop;
if ( metrics2 )
zsetc = zsetcachedevice2, nparams = 10;
else
zsetc = zsetcachedevice, nparams = 6;
}
check_estack(3);
/* Push the l.s.b. for .type1addpath if necessary. */
if ( psb != 0 )
{ push(nparams + 3);
make_real(op - (nparams + 2), psb[0]);
make_real(op - (nparams + 1), psb[1]);
}
else
{ push(nparams + 1);
}
for ( i = 0; i < nparams; ++i )
make_real(op - nparams + i, w2[i]);
ref_assign(op, pcnref);
push_op_estack(cont);
push_op_estack(zsetc);
++esp;
ref_assign(esp, pcdevproc);
return o_push_estack;
}
{ int code =
(metrics2 ? gs_setcachedevice2(penum, igs, w2) :
gs_setcachedevice(penum, igs, w2));
if ( code < 0 )
return code;
}
/* No metrics modification, do the stroke or fill now. */
/* Push the l.s.b. for .type1addpath if necessary. */
if ( psb != 0 )
{ push(2);
make_real(op - 1, psb[0]);
make_real(op, psb[1]);
}
return cont(op);
}
/*
* Check the path against FontBBox before drawing. The original operands
* of type1execchar are still on the o-stack.
* Returns exec_cont - a function, which must be called by caller after this function.
*/
static int
bbox_draw(i_ctx_t *i_ctx_p, int (*draw)(gs_state *), op_proc_t *exec_cont)
{
os_ptr op = osp;
gs_rect bbox;
gs_font *pfont;
gs_text_enum_t *penum;
gs_font_base * pbfont;
gs_font_type1 * pfont1;
gs_type1exec_state cxs;
int code;
if (igs->in_cachedevice < 2) /* not caching */
return nobbox_draw(i_ctx_p, draw);
if ((code = font_param(op - 3, &pfont)) < 0)
return code;
penum = op_show_find(i_ctx_p);
if (penum == 0 || !font_uses_charstrings(pfont))
return_error(e_undefined);
if ((code = gs_pathbbox(igs, &bbox)) < 0) {
/*
* If the matrix is singular, all user coordinates map onto a
* straight line. Don't bother rendering the character at all.
*/
if (code == e_undefinedresult) {
pop(4);
gs_newpath(igs);
return 0;
}
return code;
}
if (draw == gs_stroke) {
/* Expand the bounding box by the line width. */
float width = gs_currentlinewidth(igs) * 1.41422;
bbox.p.x -= width, bbox.p.y -= width;
bbox.q.x += width, bbox.q.y += width;
}
pbfont = (gs_font_base *)pfont;
if (rect_within(bbox, pbfont->FontBBox)) /* within bounds */
return nobbox_draw(i_ctx_p, draw);
/* Enlarge the FontBBox to save work in the future. */
rect_merge(pbfont->FontBBox, bbox);
/* Dismantle everything we've done, and start over. */
gs_text_retry(penum);
pfont1 = (gs_font_type1 *) pfont;
if ((penum->FontBBox_as_Metrics2.x == 0 &&
penum->FontBBox_as_Metrics2.y == 0) ||
gs_rootfont(igs)->WMode == 0 ) {
code = zchar_get_metrics(pbfont, op - 1, cxs.sbw);
if (code < 0)
return code;
cxs.present = code;
cxs.use_FontBBox_as_Metrics2 = false;
} else {
cxs.sbw[0] = penum->FontBBox_as_Metrics2.x / 2;
cxs.sbw[1] = penum->FontBBox_as_Metrics2.y;
cxs.sbw[2] = 0;
cxs.sbw[3] = -penum->FontBBox_as_Metrics2.x; /* Sic! */
cxs.use_FontBBox_as_Metrics2 = true;
cxs.present = metricsSideBearingAndWidth;
}
code = type1_exec_init(&cxs.cis, penum, igs, pfont1);
if (code < 0)
return code;
cxs.char_bbox = pfont1->FontBBox;
code = type1exec_bbox(i_ctx_p, penum, &cxs, pfont, exec_cont);
return code;
}
static int
pl_fapi_set_cache(gs_text_enum_t * penum, const gs_font_base * pbfont,
const gs_string * char_name, int cid,
const double pwidth[2], const gs_rect * pbbox,
const double Metrics2_sbw_default[4], bool * imagenow)
{
gs_state *pgs = (gs_state *) penum->pis;
float w2[6];
int code = 0;
gs_fapi_server *I = pbfont->FAPI;
if ((penum->text.operation & TEXT_DO_DRAW) && (pbfont->WMode & 1)
&& pwidth[0] == 1.0) {
gs_rect tmp_pbbox;
gs_matrix save_ctm;
const gs_matrix id_ctm = { 1.0, 0.0, 0.0, 1.0, 0.0, 0.0 };
/* This is kind of messy, but the cache entry has already been calculated
using the in-force matrix. The problem is that we have to call gs_setcachedevice
with the in-force matrix, not the rotated one, so we have to recalculate the extents
to be correct for the rotated glyph.
*/
/* save the ctm */
gs_currentmatrix(pgs, &save_ctm);
gs_setmatrix(pgs, &id_ctm);
/* magic numbers - we don't completelely understand
the translation magic used by HP. This provides a
good approximation */
gs_translate(pgs, 1.0 / 1.15, -(1.0 - 1.0 / 1.15));
gs_rotate(pgs, 90);
gs_transform(pgs, pbbox->p.x, pbbox->p.y, &tmp_pbbox.p);
gs_transform(pgs, pbbox->q.x, pbbox->q.y, &tmp_pbbox.q);
w2[0] = pwidth[0];
w2[1] = pwidth[1];
w2[2] = tmp_pbbox.p.x;
w2[3] = tmp_pbbox.p.y;
w2[4] = tmp_pbbox.q.x;
w2[5] = tmp_pbbox.q.y;
gs_setmatrix(pgs, &save_ctm);
} else {
w2[0] = pwidth[0];
w2[1] = pwidth[1];
w2[2] = pbbox->p.x;
w2[3] = pbbox->p.y;
w2[4] = pbbox->q.x;
w2[5] = pbbox->q.y;
}
if (pbfont->PaintType) {
double expand = max(1.415,
gs_currentmiterlimit(pgs)) *
gs_currentlinewidth(pgs) / 2;
w2[2] -= expand;
w2[3] -= expand;
w2[4] += expand;
w2[5] += expand;
}
if (I->ff.embolden != 0) {
code = gs_setcharwidth((gs_show_enum *) penum, pgs, w2[0], w2[1]);
} else {
if ((code = gs_setcachedevice((gs_show_enum *) penum, pgs, w2)) < 0) {
return (code);
}
}
if ((penum->text.operation & TEXT_DO_DRAW) && (pbfont->WMode & 1)
&& pwidth[0] == 1.0) {
*imagenow = false;
return (gs_error_unknownerror);
}
*imagenow = true;
return (code);
}
/*
* Consult Metrics2 and CDevProc, and call setcachedevice[2]. Return
* o_push_estack if we had to call a CDevProc, or if we are skipping the
* rendering process (only getting the metrics).
* Returns exec_cont - a function, which must be called by caller after this function.
*/
int
zchar_set_cache(i_ctx_t *i_ctx_p, const gs_font_base * pbfont,
const ref * pcnref, const double psb[2],
const double pwidth[2], const gs_rect * pbbox,
op_proc_t cont, op_proc_t *exec_cont,
const double Metrics2_sbw_default[4])
{
os_ptr op = osp;
ref *pcdevproc;
int have_cdevproc;
ref rpop;
bool metrics2;
bool metrics2_use_default = false;
double w2[10];
gs_text_enum_t *penum = op_show_find(i_ctx_p);
w2[0] = pwidth[0], w2[1] = pwidth[1];
/* Adjust the bounding box for stroking if needed. */
w2[2] = pbbox->p.x, w2[3] = pbbox->p.y;
w2[4] = pbbox->q.x, w2[5] = pbbox->q.y;
if (pbfont->PaintType != 0) {
double expand = max(1.415, gs_currentmiterlimit(igs)) *
gs_currentlinewidth(igs) / 2;
w2[2] -= expand, w2[3] -= expand;
w2[4] += expand, w2[5] += expand;
}
/* Check for Metrics2. */
{
int code = zchar_get_metrics2(pbfont, pcnref, w2 + 6);
if (code < 0)
return code;
metrics2 = code > 0;
}
/*
* For FontType 9 and 11, if Metrics2 is missing, the caller provides
* default Metrics2 values derived from the FontBBox.
*/
if (!metrics2 && Metrics2_sbw_default != NULL) {
w2[6] = Metrics2_sbw_default[2];
w2[7] = Metrics2_sbw_default[3];
w2[8] = Metrics2_sbw_default[0];
w2[9] = Metrics2_sbw_default[1];
metrics2 = true;
metrics2_use_default = true;
}
/* Check for CDevProc or "short-circuiting". */
have_cdevproc = zchar_get_CDevProc(pbfont, &pcdevproc);
if (have_cdevproc || zchar_show_width_only(penum)) {
int i;
op_proc_t zsetc;
int nparams;
if (have_cdevproc) {
check_proc_only(*pcdevproc);
zsetc = zsetcachedevice2;
/* If we have cdevproc and the font type is CID type 0,
we'll throw away Metrics2_sbw_default that is calculated
from FontBBox. */
if (!metrics2
|| (penum->current_font->FontType == ft_CID_encrypted
&& metrics2_use_default)) {
w2[6] = w2[0], w2[7] = w2[1];
w2[8] = w2[9] = 0;
}
nparams = 10;
} else {
make_oper(&rpop, 0, zpop);
pcdevproc = &rpop;
if (metrics2)
zsetc = zsetcachedevice2, nparams = 10;
else
zsetc = zsetcachedevice, nparams = 6;
}
check_estack(3);
/* Push the l.s.b. for .type1addpath if necessary. */
if (psb != 0) {
push(nparams + 3);
make_real(op - (nparams + 2), psb[0]);
make_real(op - (nparams + 1), psb[1]);
} else {
push(nparams + 1);
}
for (i = 0; i < nparams; ++i)
make_real(op - nparams + i, w2[i]);
ref_assign(op, pcnref);
push_op_estack(cont);
push_op_estack(zsetc);
++esp;
ref_assign(esp, pcdevproc);
return o_push_estack;
} {
int code =
(metrics2 ? gs_text_setcachedevice2(penum, w2) :
gs_text_setcachedevice(penum, w2));
if (code < 0)
return code;
}
/* No metrics modification, do the stroke or fill now. */
/* Push the l.s.b. for .type1addpath if necessary. */
if (psb != 0) {
push(2);
make_real(op - 1, psb[0]);
make_real(op, psb[1]);
}
*exec_cont = cont;
return 0;
}