void pdfapp_gotouri(pdfapp_t *app, fz_obj *uri)
{
char buf[2048];
memcpy(buf, fz_tostrbuf(uri), fz_tostrlen(uri));
buf[fz_tostrlen(uri)] = 0;
winopenuri(app, buf);
}
void pdfmoz_gotouri(pdfmoz_t *moz, fz_obj *uri)
{
char buf[2048];
memcpy(buf, fz_tostrbuf(uri), fz_tostrlen(uri));
buf[fz_tostrlen(uri)] = 0;
NPN_GetURL(moz->inst, buf, "_blank");
}
static void pdfapp_gotouri(pdfapp_t *app, fz_obj *uri)
{
char *buf;
buf = fz_malloc(fz_tostrlen(uri) + 1);
memcpy(buf, fz_tostrbuf(uri), fz_tostrlen(uri));
buf[fz_tostrlen(uri)] = 0;
winopenuri(app, buf);
fz_free(buf);
}
unsigned short *
pdf_toucs2(fz_obj *src)
{
unsigned char *srcptr = (unsigned char *) fz_tostrbuf(src);
unsigned short *dstptr, *dst;
int srclen = fz_tostrlen(src);
int i;
if (srclen > 2 && srcptr[0] == 254 && srcptr[1] == 255)
{
dstptr = dst = fz_malloc(((srclen - 2) / 2 + 1) * sizeof(short));
for (i = 2; i < srclen; i += 2)
*dstptr++ = (srcptr[i] << 8) | srcptr[i+1];
}
else
{
dstptr = dst = fz_malloc((srclen + 1) * sizeof(short));
for (i = 0; i < srclen; i++)
*dstptr++ = pdf_docencoding[srcptr[i]];
}
*dstptr = '\0';
return dst;
}
fz_error *
pdf_toucs2(unsigned short **dstp, fz_obj *src)
{
unsigned char *srcptr = fz_tostrbuf(src);
unsigned short *dstptr;
int srclen = fz_tostrlen(src);
int i;
if (srclen > 2 && srcptr[0] == 254 && srcptr[1] == 255)
{
dstptr = *dstp = fz_malloc(((srclen - 2) / 2 + 1) * sizeof(short));
if (!dstptr)
return fz_outofmem;
for (i = 2; i < srclen; i += 2)
*dstptr++ = (srcptr[i] << 8) | srcptr[i+1];
}
else
{
dstptr = *dstp = fz_malloc((srclen + 1) * sizeof(short));
if (!dstptr)
return fz_outofmem;
for (i = 0; i < srclen; i++)
*dstptr++ = pdf_docencoding[srcptr[i]];
}
*dstptr = '\0';
return nil;
}
void
pdf_showtext(pdf_csi *csi, fz_obj *text)
{
pdf_gstate *gstate = csi->gstate + csi->gtop;
int i;
if (fz_isarray(text))
{
for (i = 0; i < fz_arraylen(text); i++)
{
fz_obj *item = fz_arrayget(text, i);
if (fz_isstring(item))
pdf_showstring(csi, (unsigned char *)fz_tostrbuf(item), fz_tostrlen(item));
else
pdf_showspace(csi, - fz_toreal(item) * gstate->size * 0.001f);
}
}
else if (fz_isstring(text))
{
pdf_showstring(csi, (unsigned char *)fz_tostrbuf(text), fz_tostrlen(text));
}
}
fz_error *
pdf_showtext(pdf_csi *csi, fz_obj *text)
{
pdf_gstate *gstate = csi->gstate + csi->gtop;
pdf_font *font = gstate->font;
fz_error *error;
unsigned char *buf;
unsigned char *end;
int i, len;
int cpt, cid;
if (fz_isarray(text))
{
for (i = 0; i < fz_arraylen(text); i++)
{
fz_obj *item = fz_arrayget(text, i);
if (fz_isstring(item))
{
error = pdf_showtext(csi, item);
if (error)
return fz_rethrow(error, "cannot draw text item");
}
else
{
showspace(csi, - fz_toreal(item) * gstate->size / 1000.0);
}
}
return fz_okay;
}
buf = (unsigned char *)fz_tostrbuf(text);
len = fz_tostrlen(text);
end = buf + len;
while (buf < end)
{
buf = pdf_decodecmap(font->encoding, buf, &cpt);
cid = pdf_lookupcmap(font->encoding, cpt);
if (cid == -1)
cid = 0;
error = showglyph(csi, cid);
if (error)
return fz_rethrow(error, "cannot draw glyph");
if (cpt == 32)
showspace(csi, gstate->wordspace);
}
return fz_okay;
}
fz_error *
pdf_toutf8(char **dstp, fz_obj *src)
{
unsigned char *srcptr = fz_tostrbuf(src);
char *dstptr;
int srclen = fz_tostrlen(src);
int dstlen = 0;
int ucs;
int i;
if (srclen > 2 && srcptr[0] == 254 && srcptr[1] == 255)
{
for (i = 2; i < srclen; i += 2)
{
ucs = (srcptr[i] << 8) | srcptr[i+1];
dstlen += runelen(ucs);
}
dstptr = *dstp = fz_malloc(dstlen + 1);
if (!dstptr)
return fz_outofmem;
for (i = 2; i < srclen; i += 2)
{
ucs = (srcptr[i] << 8) | srcptr[i+1];
dstptr += runetochar(dstptr, &ucs);
}
}
else
{
for (i = 0; i < srclen; i++)
dstlen += runelen(pdf_docencoding[srcptr[i]]);
dstptr = *dstp = fz_malloc(dstlen + 1);
if (!dstptr)
return fz_outofmem;
for (i = 0; i < srclen; i++)
{
ucs = pdf_docencoding[srcptr[i]];
dstptr += runetochar(dstptr, &ucs);
}
}
*dstptr = '\0';
return nil;
}
void
pdf_showtext(pdf_csi *csi, fz_obj *text)
{
pdf_gstate *gstate = csi->gstate + csi->gtop;
pdf_fontdesc *fontdesc = gstate->font;
unsigned char *buf;
unsigned char *end;
int i, len;
int cpt, cid;
if (!fontdesc)
{
fz_warn("cannot draw text since font and size not set");
return;
}
if (fz_isarray(text))
{
for (i = 0; i < fz_arraylen(text); i++)
{
fz_obj *item = fz_arrayget(text, i);
if (fz_isstring(item))
pdf_showtext(csi, item);
else
pdf_showspace(csi, - fz_toreal(item) * gstate->size * 0.001f);
}
}
if (fz_isstring(text))
{
buf = (unsigned char *)fz_tostrbuf(text);
len = fz_tostrlen(text);
end = buf + len;
while (buf < end)
{
buf = pdf_decodecmap(fontdesc->encoding, buf, &cpt);
cid = pdf_lookupcmap(fontdesc->encoding, cpt);
if (cid == -1)
cid = 0;
pdf_showglyph(csi, cid);
if (cpt == 32)
pdf_showspace(csi, gstate->wordspace);
}
}
}
char *
pdf_toutf8(fz_obj *src)
{
unsigned char *srcptr = (unsigned char *) fz_tostrbuf(src);
char *dstptr, *dst;
int srclen = fz_tostrlen(src);
int dstlen = 0;
int ucs;
int i;
if (srclen > 2 && srcptr[0] == 254 && srcptr[1] == 255)
{
for (i = 2; i < srclen; i += 2)
{
ucs = (srcptr[i] << 8) | srcptr[i+1];
dstlen += runelen(ucs);
}
dstptr = dst = fz_malloc(dstlen + 1);
for (i = 2; i < srclen; i += 2)
{
ucs = (srcptr[i] << 8) | srcptr[i+1];
dstptr += runetochar(dstptr, &ucs);
}
}
else
{
for (i = 0; i < srclen; i++)
dstlen += runelen(pdf_docencoding[srcptr[i]]);
dstptr = dst = fz_malloc(dstlen + 1);
for (i = 0; i < srclen; i++)
{
ucs = pdf_docencoding[srcptr[i]];
dstptr += runetochar(dstptr, &ucs);
}
}
*dstptr = '\0';
return dst;
}
void pdfmoz_onmouse(pdfmoz_t *moz, int x, int y, int click)
{
char buf[512];
pdf_link *link;
fz_matrix ctm;
fz_point p;
int pi;
int py;
if (!moz->pages)
return;
pi = moz->scrollpage;
py = -moz->scrollyofs;
while (pi < moz->pagecount)
{
if (!moz->pages[pi].image)
return;
if (y > py && y < moz->pages[pi].px)
break;
py += moz->pages[pi].px;
pi ++;
}
if (pi == moz->pagecount)
return;
p.x = x + moz->pages[pi].image->x;
p.y = y + moz->pages[pi].image->y - py;
ctm = pdfmoz_pagectm(moz, pi);
ctm = fz_invertmatrix(ctm);
p = fz_transformpoint(ctm, p);
for (link = moz->pages[pi].page->links; link; link = link->next)
{
if (p.x >= link->rect.x0 && p.x <= link->rect.x1)
if (p.y >= link->rect.y0 && p.y <= link->rect.y1)
break;
}
if (link)
{
SetCursor(moz->hand);
if (click)
{
if (link->kind == PDF_LURI)
pdfmoz_gotouri(moz, link->dest);
else if (link->kind == PDF_LGOTO)
pdfmoz_gotopage(moz, link->dest);
return;
}
else
{
if (fz_isstring(link->dest))
{
memcpy(buf, fz_tostrbuf(link->dest), fz_tostrlen(link->dest));
buf[fz_tostrlen(link->dest)] = 0;
NPN_Status(moz->inst, buf);
}
else if (fz_isindirect(link->dest))
{
sprintf(buf, "Go to page %d",
pdfmoz_getpagenum(moz, link->dest) + 1);
NPN_Status(moz->inst, buf);
}
else
NPN_Status(moz->inst, "Say what?");
}
}
else
{
sprintf(buf, "Page %d of %d", moz->scrollpage + 1, moz->pagecount);
NPN_Status(moz->inst, buf);
SetCursor(moz->arrow);
}
}
static fz_error
loadcidfont(pdf_fontdesc **fontdescp, pdf_xref *xref, fz_obj *dict, fz_obj *encoding, fz_obj *tounicode)
{
fz_error error;
fz_obj *widths;
fz_obj *descriptor;
pdf_fontdesc *fontdesc;
FT_Face face;
fz_bbox bbox;
int kind;
char collection[256];
char *basefont;
int i, k, fterr;
fz_obj *obj;
int dw;
/* Get font name and CID collection */
basefont = fz_toname(fz_dictgets(dict, "BaseFont"));
{
fz_obj *cidinfo;
char tmpstr[64];
int tmplen;
cidinfo = fz_dictgets(dict, "CIDSystemInfo");
if (!cidinfo)
return fz_throw("cid font is missing info");
obj = fz_dictgets(cidinfo, "Registry");
tmplen = MIN(sizeof tmpstr - 1, fz_tostrlen(obj));
memcpy(tmpstr, fz_tostrbuf(obj), tmplen);
tmpstr[tmplen] = '\0';
fz_strlcpy(collection, tmpstr, sizeof collection);
fz_strlcat(collection, "-", sizeof collection);
obj = fz_dictgets(cidinfo, "Ordering");
tmplen = MIN(sizeof tmpstr - 1, fz_tostrlen(obj));
memcpy(tmpstr, fz_tostrbuf(obj), tmplen);
tmpstr[tmplen] = '\0';
fz_strlcat(collection, tmpstr, sizeof collection);
}
/* Load font file */
fontdesc = pdf_newfontdesc();
pdf_logfont("load cid font (%d %d R) ptr=%p {\n", fz_tonum(dict), fz_togen(dict), fontdesc);
pdf_logfont("basefont %s\n", basefont);
pdf_logfont("collection %s\n", collection);
descriptor = fz_dictgets(dict, "FontDescriptor");
if (descriptor)
error = pdf_loadfontdescriptor(fontdesc, xref, descriptor, collection, basefont);
else
error = fz_throw("syntaxerror: missing font descriptor");
if (error)
goto cleanup;
face = fontdesc->font->ftface;
kind = ftkind(face);
bbox.x0 = (face->bbox.xMin * 1000) / face->units_per_EM;
bbox.y0 = (face->bbox.yMin * 1000) / face->units_per_EM;
bbox.x1 = (face->bbox.xMax * 1000) / face->units_per_EM;
bbox.y1 = (face->bbox.yMax * 1000) / face->units_per_EM;
pdf_logfont("ft bbox [%d %d %d %d]\n", bbox.x0, bbox.y0, bbox.x1, bbox.y1);
if (bbox.x0 == bbox.x1)
fz_setfontbbox(fontdesc->font, -1000, -1000, 2000, 2000);
else
fz_setfontbbox(fontdesc->font, bbox.x0, bbox.y0, bbox.x1, bbox.y1);
/* Encoding */
error = fz_okay;
if (fz_isname(encoding))
{
pdf_logfont("encoding /%s\n", fz_toname(encoding));
if (!strcmp(fz_toname(encoding), "Identity-H"))
fontdesc->encoding = pdf_newidentitycmap(0, 2);
else if (!strcmp(fz_toname(encoding), "Identity-V"))
fontdesc->encoding = pdf_newidentitycmap(1, 2);
else
error = pdf_loadsystemcmap(&fontdesc->encoding, fz_toname(encoding));
}
else if (fz_isindirect(encoding))
{
pdf_logfont("encoding %d %d R\n", fz_tonum(encoding), fz_togen(encoding));
error = pdf_loadembeddedcmap(&fontdesc->encoding, xref, encoding);
}
else
{
error = fz_throw("syntaxerror: font missing encoding");
}
if (error)
goto cleanup;
pdf_setfontwmode(fontdesc, pdf_getwmode(fontdesc->encoding));
pdf_logfont("wmode %d\n", pdf_getwmode(fontdesc->encoding));
if (kind == TRUETYPE)
{
fz_obj *cidtogidmap;
cidtogidmap = fz_dictgets(dict, "CIDToGIDMap");
if (fz_isindirect(cidtogidmap))
{
fz_buffer *buf;
pdf_logfont("cidtogidmap stream\n");
error = pdf_loadstream(&buf, xref, fz_tonum(cidtogidmap), fz_togen(cidtogidmap));
if (error)
goto cleanup;
fontdesc->ncidtogid = (buf->len) / 2;
fontdesc->cidtogid = fz_malloc(fontdesc->ncidtogid * sizeof(unsigned short));
for (i = 0; i < fontdesc->ncidtogid; i++)
fontdesc->cidtogid[i] = (buf->data[i * 2] << 8) + buf->data[i * 2 + 1];
fz_dropbuffer(buf);
}
/* if truetype font is external, cidtogidmap should not be identity */
/* so we map from cid to unicode and then map that through the (3 1) */
/* unicode cmap to get a glyph id */
else if (fontdesc->font->ftsubstitute)
{
pdf_logfont("emulate ttf cidfont\n");
fterr = FT_Select_Charmap(face, ft_encoding_unicode);
if (fterr)
{
error = fz_throw("fonterror: no unicode cmap when emulating CID font: %s", ft_errorstring(fterr));
goto cleanup;
}
if (!strcmp(collection, "Adobe-CNS1"))
error = pdf_loadsystemcmap(&fontdesc->tottfcmap, "Adobe-CNS1-UCS2");
else if (!strcmp(collection, "Adobe-GB1"))
error = pdf_loadsystemcmap(&fontdesc->tottfcmap, "Adobe-GB1-UCS2");
else if (!strcmp(collection, "Adobe-Japan1"))
error = pdf_loadsystemcmap(&fontdesc->tottfcmap, "Adobe-Japan1-UCS2");
else if (!strcmp(collection, "Adobe-Japan2"))
error = pdf_loadsystemcmap(&fontdesc->tottfcmap, "Adobe-Japan2-UCS2");
else if (!strcmp(collection, "Adobe-Korea1"))
error = pdf_loadsystemcmap(&fontdesc->tottfcmap, "Adobe-Korea1-UCS2");
else
error = fz_okay;
if (error)
{
error = fz_rethrow(error, "cannot load system cmap %s", collection);
goto cleanup;
}
}
}
error = pdf_loadtounicode(fontdesc, xref, nil, collection, tounicode);
if (error)
goto cleanup;
/* Horizontal */
dw = 1000;
obj = fz_dictgets(dict, "DW");
if (obj)
dw = fz_toint(obj);
pdf_setdefaulthmtx(fontdesc, dw);
widths = fz_dictgets(dict, "W");
if (widths)
{
int c0, c1, w;
for (i = 0; i < fz_arraylen(widths); )
{
c0 = fz_toint(fz_arrayget(widths, i));
obj = fz_arrayget(widths, i + 1);
if (fz_isarray(obj))
{
for (k = 0; k < fz_arraylen(obj); k++)
{
w = fz_toint(fz_arrayget(obj, k));
pdf_addhmtx(fontdesc, c0 + k, c0 + k, w);
}
i += 2;
}
else
{
c1 = fz_toint(obj);
w = fz_toint(fz_arrayget(widths, i + 2));
pdf_addhmtx(fontdesc, c0, c1, w);
i += 3;
}
}
}
pdf_endhmtx(fontdesc);
/* Vertical */
if (pdf_getwmode(fontdesc->encoding) == 1)
{
int dw2y = 880;
int dw2w = -1000;
obj = fz_dictgets(dict, "DW2");
if (obj)
{
dw2y = fz_toint(fz_arrayget(obj, 0));
dw2w = fz_toint(fz_arrayget(obj, 1));
}
pdf_setdefaultvmtx(fontdesc, dw2y, dw2w);
widths = fz_dictgets(dict, "W2");
if (widths)
{
int c0, c1, w, x, y;
for (i = 0; i < fz_arraylen(widths); )
{
c0 = fz_toint(fz_arrayget(widths, i));
obj = fz_arrayget(widths, i + 1);
if (fz_isarray(obj))
{
for (k = 0; k < fz_arraylen(obj); k += 3)
{
w = fz_toint(fz_arrayget(obj, k + 0));
x = fz_toint(fz_arrayget(obj, k + 1));
y = fz_toint(fz_arrayget(obj, k + 2));
pdf_addvmtx(fontdesc, c0 + k, c0 + k, x, y, w);
}
i += 2;
}
else
{
c1 = fz_toint(obj);
w = fz_toint(fz_arrayget(widths, i + 2));
x = fz_toint(fz_arrayget(widths, i + 3));
y = fz_toint(fz_arrayget(widths, i + 4));
pdf_addvmtx(fontdesc, c0, c1, x, y, w);
i += 5;
}
}
}
pdf_endvmtx(fontdesc);
}
pdf_logfont("}\n");
*fontdescp = fontdesc;
return fz_okay;
cleanup:
pdf_dropfont(fontdesc);
return fz_rethrow(error, "cannot load cid font (%d %d R)", fz_tonum(dict), fz_togen(dict));
}
static fz_error
loadindexed(fz_colorspace **csp, pdf_xref *xref, fz_obj *array)
{
fz_error error;
pdf_indexed *cs;
fz_obj *baseobj = fz_arrayget(array, 1);
fz_obj *highobj = fz_arrayget(array, 2);
fz_obj *lookup = fz_arrayget(array, 3);
fz_colorspace *base;
int n;
pdf_logrsrc("load Indexed {\n");
error = pdf_loadcolorspace(&base, xref, baseobj);
if (error)
return fz_rethrow(error, "cannot load base colorspace");
pdf_logrsrc("base %s\n", base->name);
cs = fz_malloc(sizeof(pdf_indexed));
initcs((fz_colorspace*)cs, "Indexed", 1, nil, nil, freeindexed);
cs->base = fz_keepcolorspace(base);
cs->high = fz_toint(highobj);
fz_dropcolorspace(base);
n = base->n * (cs->high + 1);
cs->lookup = fz_malloc(n);
if (fz_isstring(lookup) && fz_tostrlen(lookup) == n)
{
unsigned char *buf;
int i;
pdf_logrsrc("string lookup\n");
buf = (unsigned char *) fz_tostrbuf(lookup);
for (i = 0; i < n; i++)
cs->lookup[i] = buf[i];
}
else if (fz_isindirect(lookup))
{
fz_buffer *buf;
int i;
pdf_logrsrc("stream lookup\n");
error = pdf_loadstream(&buf, xref, fz_tonum(lookup), fz_togen(lookup));
if (error)
{
fz_dropcolorspace((fz_colorspace*)cs);
return fz_rethrow(error, "cannot load colorpsace lookup table");
}
for (i = 0; i < n && i < (buf->wp - buf->rp); i++)
cs->lookup[i] = buf->rp[i];
fz_dropbuffer(buf);
}
else
return fz_throw("cannot parse colorspace lookup table");
pdf_logrsrc("}\n");
*csp = (fz_colorspace*)cs;
return fz_okay;
}
static fz_error *
loadindexed(fz_colorspace **csp, pdf_xref *xref, fz_obj *array)
{
fz_error *error;
pdf_indexed *cs;
fz_obj *baseobj = fz_arrayget(array, 1);
fz_obj *highobj = fz_arrayget(array, 2);
fz_obj *lookup = fz_arrayget(array, 3);
fz_colorspace *base;
int n;
pdf_logrsrc("load Indexed {\n");
error = pdf_resolve(&baseobj, xref);
if (error)
return error;
error = pdf_loadcolorspace(&base, xref, baseobj);
fz_dropobj(baseobj);
if (error)
return error;
pdf_logrsrc("base %s\n", base->name);
cs = fz_malloc(sizeof(pdf_indexed));
if (!cs)
{
fz_dropcolorspace(base);
return fz_outofmem;
}
initcs((fz_colorspace*)cs, "Indexed", 1, nil, nil, dropindexed);
cs->base = base;
cs->high = fz_toint(highobj);
n = base->n * (cs->high + 1);
cs->lookup = fz_malloc(n);
if (!cs->lookup)
{
fz_dropcolorspace((fz_colorspace*)cs);
return fz_outofmem;
}
if (fz_isstring(lookup) && fz_tostrlen(lookup) == n)
{
unsigned char *buf;
int i;
pdf_logrsrc("string lookup\n");
buf = fz_tostrbuf(lookup);
for (i = 0; i < n; i++)
cs->lookup[i] = buf[i];
}
if (fz_isindirect(lookup))
{
fz_buffer *buf;
int i;
pdf_logrsrc("stream lookup\n");
error = pdf_loadstream(&buf, xref, fz_tonum(lookup), fz_togen(lookup));
if (error)
{
fz_dropcolorspace((fz_colorspace*)cs);
return error;
}
for (i = 0; i < n && i < (buf->wp - buf->rp); i++)
cs->lookup[i] = buf->rp[i];
fz_dropbuffer(buf);
}
pdf_logrsrc("}\n");
*csp = (fz_colorspace*)cs;
return nil;
}
