/*
** This is the central routine of this section.
*/
void ttfont_CharStrings(TTStreamWriter& stream, struct TTFONT *font, std::vector<int>& glyph_ids)
{
Fixed post_format;
/* The 'post' table format number. */
post_format = getFixed( font->post_table );
if( post_format.whole != 2 || post_format.fraction != 0 )
throw TTException("TrueType fontdoes not have a format 2.0 'post' table");
/* Emmit the start of the PostScript code to define the dictionary. */
stream.printf("/CharStrings %d dict dup begin\n", glyph_ids.size());
/* Emmit one key-value pair for each glyph. */
for(std::vector<int>::const_iterator i = glyph_ids.begin();
i != glyph_ids.end(); ++i)
{
if(font->target_type == PS_TYPE_42) /* type 42 */
{
stream.printf("/%s %d def\n",ttfont_CharStrings_getname(font, *i), *i);
}
else /* type 3 */
{
stream.printf("/%s{",ttfont_CharStrings_getname(font, *i));
tt_type3_charproc(stream, font, *i);
stream.putline("}_d"); /* "} bind def" */
}
}
stream.putline("end readonly def");
} /* end of ttfont_CharStrings() */
/*
** This is called once at the start.
*/
void sfnts_start(TTStreamWriter& stream)
{
stream.puts("/sfnts[<");
in_string=TRUE;
string_len=0;
line_len=8;
} /* end of sfnts_start() */
void GlyphToType3::stack_end(TTStreamWriter& stream) /* called at end */
{
if ( !pdf_mode && stack_depth )
{
stream.puts("}_e");
stack_depth=0;
}
} /* end of stack_end() */
/*
** This routine is used to break the character
** procedure up into a number of smaller
** procedures. This is necessary so as not to
** overflow the stack on certain level 1 interpreters.
**
** Prepare to push another item onto the stack,
** starting a new proceedure if necessary.
**
** Not all the stack depth calculations in this routine
** are perfectly accurate, but they do the job.
*/
void GlyphToType3::stack(TTStreamWriter& stream, int new_elem)
{
if ( !pdf_mode && num_pts > 25 ) /* Only do something of we will */
{
/* have a log of points. */
if (stack_depth == 0)
{
stream.put_char('{');
stack_depth=1;
}
stack_depth += new_elem; /* Account for what we propose to add */
if (stack_depth > 100)
{
stream.puts("}_e{");
stack_depth = 3 + new_elem; /* A rough estimate */
}
}
} /* end of stack() */
/*-------------------------------------------------------------
** Define the encoding array for this font.
** Since we don't really want to deal with converting all of
** the possible font encodings in the wild to a standard PS
** one, we just explicitly create one for each font.
-------------------------------------------------------------*/
void ttfont_encoding(TTStreamWriter& stream, struct TTFONT *font, std::vector<int>& glyph_ids, font_type_enum target_type)
{
if (target_type == PS_TYPE_3 || target_type == PS_TYPE_42_3_HYBRID)
{
stream.printf("/Encoding [ ");
for (std::vector<int>::const_iterator i = glyph_ids.begin();
i != glyph_ids.end(); ++i)
{
const char* name = ttfont_CharStrings_getname(font, *i);
stream.printf("/%s ", name);
}
stream.printf("] def\n");
}
else
{
stream.putline("/Encoding StandardEncoding def");
}
} /* end of ttfont_encoding() */
/*
** Write a BYTE as a hexadecimal value as part of the sfnts array.
*/
void sfnts_pputBYTE(TTStreamWriter& stream, BYTE n)
{
static const char hexdigits[]="0123456789ABCDEF";
if (!in_string)
{
stream.put_char('<');
string_len=0;
line_len++;
in_string=TRUE;
}
stream.put_char( hexdigits[ n / 16 ] );
stream.put_char( hexdigits[ n % 16 ] );
string_len++;
line_len+=2;
if (line_len > 70)
{
stream.put_char('\n');
line_len=0;
}
} /* end of sfnts_pputBYTE() */
/*
** This is called whenever it is
** necessary to end a string in the sfnts array.
**
** (The array must be broken into strings which are
** no longer than 64K characters.)
*/
void sfnts_end_string(TTStreamWriter& stream)
{
if (in_string)
{
string_len=0; /* fool sfnts_pputBYTE() */
#ifdef DEBUG_TRUETYPE_INLINE
puts("\n% dummy byte:\n");
#endif
sfnts_pputBYTE(stream, 0); /* extra byte for pre-2013 compatibility */
stream.put_char('>');
line_len++;
}
in_string=FALSE;
} /* end of sfnts_end_string() */
/*
** Emit a PostScript "curveto" command, assuming the current point
** is (x0, y0), the control point of a quadratic spline is (x1, y1),
** and the endpoint is (x2, y2). Note that this requires a conversion,
** since PostScript splines are cubic.
*/
void GlyphToType3::PSCurveto(TTStreamWriter& stream,
FWord x0, FWord y0,
FWord x1, FWord y1,
FWord x2, FWord y2)
{
double sx[3], sy[3], cx[3], cy[3];
sx[0] = x0;
sy[0] = y0;
sx[1] = x1;
sy[1] = y1;
sx[2] = x2;
sy[2] = y2;
cx[0] = (2*sx[1]+sx[0])/3;
cy[0] = (2*sy[1]+sy[0])/3;
cx[1] = (sx[2]+2*sx[1])/3;
cy[1] = (sy[2]+2*sy[1])/3;
cx[2] = sx[2];
cy[2] = sy[2];
stream.printf("%d %d %d %d %d %d %s\n",
(int)cx[0], (int)cy[0], (int)cx[1], (int)cy[1],
(int)cx[2], (int)cy[2], pdf_mode ? "c" : "_c");
}
void GlyphToType3::PSLineto(TTStreamWriter& stream, int x, int y)
{
stream.printf(pdf_mode ? "%d %d l\n" : "%d %d _l\n",
x, y);
}
/*
** We call this routine to emmit the PostScript code
** for the character we have loaded with load_char().
*/
void GlyphToType3::PSConvert(TTStreamWriter& stream)
{
int i,j,k;
assert(area_ctr == NULL);
area_ctr=(double*)calloc(num_ctr, sizeof(double));
memset(area_ctr, 0, (num_ctr*sizeof(double)));
assert(check_ctr == NULL);
check_ctr=(char*)calloc(num_ctr, sizeof(char));
memset(check_ctr, 0, (num_ctr*sizeof(char)));
assert(ctrset == NULL);
ctrset=(int*)calloc(num_ctr, 2*sizeof(int));
memset(ctrset, 0, (num_ctr*2*sizeof(int)));
check_ctr[0]=1;
area_ctr[0]=area(xcoor, ycoor, epts_ctr[0]+1);
for (i=1; i<num_ctr; i++)
{
area_ctr[i]=area(xcoor+epts_ctr[i-1]+1, ycoor+epts_ctr[i-1]+1, epts_ctr[i]-epts_ctr[i-1]);
}
for (i=0; i<num_ctr; i++)
{
if (area_ctr[i]>0)
{
ctrset[2*i]=i;
ctrset[2*i+1]=nearout(i);
}
else
{
ctrset[2*i]=-1;
ctrset[2*i+1]=-1;
}
}
/* Step thru the coutours. */
/* I believe that a contour is a detatched */
/* set of curves and lines. */
for(i = j = k = 0;
i != NOMOREOUTCTR && i < num_ctr;
k = nextinctr(i, k), (k == NOMOREINCTR && (i = k = nextoutctr(i))))
{
// A TrueType contour consists of on-path and off-path points.
// Two consecutive on-path points are to be joined with a
// line; off-path points between on-path points indicate a
// quadratic spline, where the off-path point is the control
// point. Two consecutive off-path points have an implicit
// on-path point midway between them.
std::list<FlaggedPoint> points;
// Represent flags and x/y coordinates as a C++ list
for (; j <= epts_ctr[k]; j++)
{
if (!(tt_flags[j] & 1)) {
points.push_back(FlaggedPoint(OFF_PATH, xcoor[j], ycoor[j]));
} else {
points.push_back(FlaggedPoint(ON_PATH, xcoor[j], ycoor[j]));
}
}
if (points.size() == 0) {
// Don't try to access the last element of an empty list
continue;
}
// For any two consecutive off-path points, insert the implied
// on-path point.
FlaggedPoint prev = points.back();
for (std::list<FlaggedPoint>::iterator it = points.begin();
it != points.end();
it++)
{
if (prev.flag == OFF_PATH && it->flag == OFF_PATH)
{
points.insert(it,
FlaggedPoint(ON_PATH,
(prev.x + it->x) / 2,
(prev.y + it->y) / 2));
}
prev = *it;
}
// Handle the wrap-around: insert a point either at the beginning
// or at the end that has the same coordinates as the opposite point.
// This also ensures that the initial point is ON_PATH.
if (points.front().flag == OFF_PATH)
{
assert(points.back().flag == ON_PATH);
points.insert(points.begin(), points.back());
}
else
{
assert(points.front().flag == ON_PATH);
points.push_back(points.front());
}
// The first point
stack(stream, 3);
PSMoveto(stream, points.front().x, points.front().y);
// Step through the remaining points
std::list<FlaggedPoint>::const_iterator it = points.begin();
for (it++; it != points.end(); /* incremented inside */)
{
const FlaggedPoint& point = *it;
if (point.flag == ON_PATH)
{
stack(stream, 3);
PSLineto(stream, point.x, point.y);
it++;
} else {
std::list<FlaggedPoint>::const_iterator prev = it, next = it;
prev--;
next++;
assert(prev->flag == ON_PATH);
assert(next->flag == ON_PATH);
stack(stream, 7);
PSCurveto(stream,
prev->x, prev->y,
point.x, point.y,
next->x, next->y);
it++;
it++;
}
}
}
/* Now, we can fill the whole thing. */
stack(stream, 1);
stream.puts( pdf_mode ? "f" : "_cl" );
/* Free our work arrays. */
free(area_ctr);
free(check_ctr);
free(ctrset);
area_ctr = NULL;
check_ctr = NULL;
ctrset = NULL;
} /* end of PSConvert() */
/*
** We call this routine to emmit the PostScript code
** for the character we have loaded with load_char().
*/
void GlyphToType3::PSConvert(TTStreamWriter& stream)
{
int j, k;
/* Step thru the contours.
* j = index to xcoor, ycoor, tt_flags (point data)
* k = index to epts_ctr (which points belong to the same contour) */
for(j = k = 0; k < num_ctr; k++)
{
// A TrueType contour consists of on-path and off-path points.
// Two consecutive on-path points are to be joined with a
// line; off-path points between on-path points indicate a
// quadratic spline, where the off-path point is the control
// point. Two consecutive off-path points have an implicit
// on-path point midway between them.
std::list<FlaggedPoint> points;
// Represent flags and x/y coordinates as a C++ list
for (; j <= epts_ctr[k]; j++)
{
if (!(tt_flags[j] & 1)) {
points.push_back(FlaggedPoint(OFF_PATH, xcoor[j], ycoor[j]));
} else {
points.push_back(FlaggedPoint(ON_PATH, xcoor[j], ycoor[j]));
}
}
if (points.size() == 0) {
// Don't try to access the last element of an empty list
continue;
}
// For any two consecutive off-path points, insert the implied
// on-path point.
FlaggedPoint prev = points.back();
for (std::list<FlaggedPoint>::iterator it = points.begin();
it != points.end();
it++)
{
if (prev.flag == OFF_PATH && it->flag == OFF_PATH)
{
points.insert(it,
FlaggedPoint(ON_PATH,
(prev.x + it->x) / 2,
(prev.y + it->y) / 2));
}
prev = *it;
}
// Handle the wrap-around: insert a point either at the beginning
// or at the end that has the same coordinates as the opposite point.
// This also ensures that the initial point is ON_PATH.
if (points.front().flag == OFF_PATH)
{
assert(points.back().flag == ON_PATH);
points.insert(points.begin(), points.back());
}
else
{
assert(points.front().flag == ON_PATH);
points.push_back(points.front());
}
// The first point
stack(stream, 3);
PSMoveto(stream, points.front().x, points.front().y);
// Step through the remaining points
std::list<FlaggedPoint>::const_iterator it = points.begin();
for (it++; it != points.end(); /* incremented inside */)
{
const FlaggedPoint& point = *it;
if (point.flag == ON_PATH)
{
stack(stream, 3);
PSLineto(stream, point.x, point.y);
it++;
} else {
std::list<FlaggedPoint>::const_iterator prev = it, next = it;
prev--;
next++;
assert(prev->flag == ON_PATH);
assert(next->flag == ON_PATH);
stack(stream, 7);
PSCurveto(stream,
prev->x, prev->y,
point.x, point.y,
next->x, next->y);
it++;
it++;
}
}
}
/* Now, we can fill the whole thing. */
stack(stream, 1);
stream.puts( pdf_mode ? "f" : "_cl" );
} /* end of PSConvert() */
/*----------------------------------------------------------------
** Emmit the code to finish up the dictionary and turn
** it into a font.
----------------------------------------------------------------*/
void ttfont_trailer(TTStreamWriter& stream, struct TTFONT *font)
{
/* If we are generating a type 3 font, we need to provide */
/* a BuildGlyph and BuildChar proceedures. */
if (font->target_type == PS_TYPE_3 ||
font->target_type == PS_TYPE_42_3_HYBRID)
{
stream.put_char('\n');
stream.putline("/BuildGlyph");
stream.putline(" {exch begin"); /* start font dictionary */
stream.putline(" CharStrings exch");
stream.putline(" 2 copy known not{pop /.notdef}if");
stream.putline(" true 3 1 roll get exec");
stream.putline(" end}_d");
stream.put_char('\n');
/* This proceedure is for compatiblity with */
/* level 1 interpreters. */
stream.putline("/BuildChar {");
stream.putline(" 1 index /Encoding get exch get");
stream.putline(" 1 index /BuildGlyph get exec");
stream.putline("}_d");
stream.put_char('\n');
}
/* If we are generating a type 42 font, we need to check to see */
/* if this PostScript interpreter understands type 42 fonts. If */
/* it doesn't, we will hope that the Apple TrueType rasterizer */
/* has been loaded and we will adjust the font accordingly. */
/* I found out how to do this by examining a TrueType font */
/* generated by a Macintosh. That is where the TrueType interpreter */
/* setup instructions and part of BuildGlyph came from. */
if (font->target_type == PS_TYPE_42 ||
font->target_type == PS_TYPE_42_3_HYBRID)
{
stream.put_char('\n');
/* If we have no "resourcestatus" command, or FontType 42 */
/* is unknown, leave "true" on the stack. */
stream.putline("systemdict/resourcestatus known");
stream.putline(" {42 /FontType resourcestatus");
stream.putline(" {pop pop false}{true}ifelse}");
stream.putline(" {true}ifelse");
/* If true, execute code to produce an error message if */
/* we can't find Apple's TrueDict in VM. */
stream.putline("{/TrueDict where{pop}{(%%[ Error: no TrueType rasterizer ]%%)= flush}ifelse");
/* Since we are expected to use Apple's TrueDict TrueType */
/* reasterizer, change the font type to 3. */
stream.putline("/FontType 3 def");
/* Define a string to hold the state of the Apple */
/* TrueType interpreter. */
stream.putline(" /TrueState 271 string def");
/* It looks like we get information about the resolution */
/* of the printer and store it in the TrueState string. */
stream.putline(" TrueDict begin sfnts save");
stream.putline(" 72 0 matrix defaultmatrix dtransform dup");
stream.putline(" mul exch dup mul add sqrt cvi 0 72 matrix");
stream.putline(" defaultmatrix dtransform dup mul exch dup");
stream.putline(" mul add sqrt cvi 3 -1 roll restore");
stream.putline(" TrueState initer end");
/* This BuildGlyph procedure will look the name up in the */
/* CharStrings array, and then check to see if what it gets */
/* is a procedure. If it is, it executes it, otherwise, it */
/* lets the TrueType rasterizer loose on it. */
/* When this proceedure is executed the stack contains */
/* the font dictionary and the character name. We */
/* exchange arguments and move the dictionary to the */
/* dictionary stack. */
stream.putline(" /BuildGlyph{exch begin");
/* stack: charname */
/* Put two copies of CharStrings on the stack and consume */
/* one testing to see if the charname is defined in it, */
/* leave the answer on the stack. */
stream.putline(" CharStrings dup 2 index known");
/* stack: charname CharStrings bool */
/* Exchange the CharStrings dictionary and the charname, */
/* but if the answer was false, replace the character name */
/* with ".notdef". */
stream.putline(" {exch}{exch pop /.notdef}ifelse");
/* stack: CharStrings charname */
/* Get the value from the CharStrings dictionary and see */
/* if it is executable. */
stream.putline(" get dup xcheck");
/* stack: CharStrings_entry */
/* If is a proceedure. Execute according to RBIIp 277-278. */
stream.putline(" {currentdict systemdict begin begin exec end end}");
/* Is a TrueType character index, let the rasterizer at it. */
stream.putline(" {TrueDict begin /bander load cvlit exch TrueState render end}");
stream.putline(" ifelse");
/* Pop the font's dictionary off the stack. */
stream.putline(" end}bind def");
/* This is the level 1 compatibility BuildChar procedure. */
/* See RBIIp 281. */
stream.putline(" /BuildChar{");
stream.putline(" 1 index /Encoding get exch get");
stream.putline(" 1 index /BuildGlyph get exec");
stream.putline(" }bind def");
/* Here we close the condition which is true */
/* if the printer has no built-in TrueType */
/* rasterizer. */
stream.putline("}if");
stream.put_char('\n');
} /* end of if Type 42 not understood. */
stream.putline("FontName currentdict end definefont pop");
/* stream.putline("%%EOF"); */
} /* end of ttfont_trailer() */
/*-----------------------------------------------------------
** Create the optional "FontInfo" sub-dictionary.
-----------------------------------------------------------*/
void ttfont_FontInfo(TTStreamWriter& stream, struct TTFONT *font)
{
Fixed ItalicAngle;
/* We create a sub dictionary named "FontInfo" where we */
/* store information which though it is not used by the */
/* interpreter, is useful to some programs which will */
/* be printing with the font. */
stream.putline("/FontInfo 10 dict dup begin");
/* These names come from the TrueType font's "name" table. */
stream.printf("/FamilyName (%s) def\n",font->FamilyName);
stream.printf("/FullName (%s) def\n",font->FullName);
if ( font->Copyright != (char*)NULL || font->Trademark != (char*)NULL )
{
stream.printf("/Notice (%s",
font->Copyright != (char*)NULL ? font->Copyright : "");
stream.printf("%s%s) def\n",
font->Trademark != (char*)NULL ? " " : "",
font->Trademark != (char*)NULL ? font->Trademark : "");
}
/* This information is not quite correct. */
stream.printf("/Weight (%s) def\n",font->Style);
/* Some fonts have this as "version". */
stream.printf("/Version (%s) def\n",font->Version);
/* Some information from the "post" table. */
ItalicAngle = getFixed( font->post_table + 4 );
stream.printf("/ItalicAngle %d.%d def\n",ItalicAngle.whole,ItalicAngle.fraction);
stream.printf("/isFixedPitch %s def\n", getULONG( font->post_table + 12 ) ? "true" : "false" );
stream.printf("/UnderlinePosition %d def\n", (int)getFWord( font->post_table + 8 ) );
stream.printf("/UnderlineThickness %d def\n", (int)getFWord( font->post_table + 10 ) );
stream.putline("end readonly def");
} /* end of ttfont_FontInfo() */
/*---------------------------------------------------------------------
** Write the header for a PostScript font.
---------------------------------------------------------------------*/
void ttfont_header(TTStreamWriter& stream, struct TTFONT *font)
{
int VMMin;
int VMMax;
/*
** To show that it is a TrueType font in PostScript format,
** we will begin the file with a specific string.
** This string also indicates the version of the TrueType
** specification on which the font is based and the
** font manufacturer's revision number for the font.
*/
if ( font->target_type == PS_TYPE_42 ||
font->target_type == PS_TYPE_42_3_HYBRID)
{
stream.printf("%%!PS-TrueTypeFont-%d.%d-%d.%d\n",
font->TTVersion.whole, font->TTVersion.fraction,
font->MfrRevision.whole, font->MfrRevision.fraction);
}
/* If it is not a Type 42 font, we will use a different format. */
else
{
stream.putline("%!PS-Adobe-3.0 Resource-Font");
} /* See RBIIp 641 */
/* We will make the title the name of the font. */
stream.printf("%%%%Title: %s\n",font->FullName);
/* If there is a Copyright notice, put it here too. */
if ( font->Copyright != (char*)NULL )
{
stream.printf("%%%%Copyright: %s\n",font->Copyright);
}
/* We created this file. */
if ( font->target_type == PS_TYPE_42 )
{
stream.putline("%%Creator: Converted from TrueType to type 42 by PPR");
}
else if (font->target_type == PS_TYPE_42_3_HYBRID)
{
stream.putline("%%Creator: Converted from TypeType to type 42/type 3 hybrid by PPR");
}
else
{
stream.putline("%%Creator: Converted from TrueType to type 3 by PPR");
}
/* If VM usage information is available, print it. */
if ( font->target_type == PS_TYPE_42 || font->target_type == PS_TYPE_42_3_HYBRID)
{
VMMin = (int)getULONG( font->post_table + 16 );
VMMax = (int)getULONG( font->post_table + 20 );
if ( VMMin > 0 && VMMax > 0 )
stream.printf("%%%%VMUsage: %d %d\n",VMMin,VMMax);
}
/* Start the dictionary which will eventually */
/* become the font. */
if (font->target_type == PS_TYPE_42)
{
stream.putline("15 dict begin");
}
else
{
stream.putline("25 dict begin");
/* Type 3 fonts will need some subroutines here. */
stream.putline("/_d{bind def}bind def");
stream.putline("/_m{moveto}_d");
stream.putline("/_l{lineto}_d");
stream.putline("/_cl{closepath eofill}_d");
stream.putline("/_c{curveto}_d");
stream.putline("/_sc{7 -1 roll{setcachedevice}{pop pop pop pop pop pop}ifelse}_d");
stream.putline("/_e{exec}_d");
}
stream.printf("/FontName /%s def\n",font->PostName);
stream.putline("/PaintType 0 def");
if (font->target_type == PS_TYPE_42 || font->target_type == PS_TYPE_42_3_HYBRID)
{
stream.putline("/FontMatrix[1 0 0 1 0 0]def");
}
else
{
stream.putline("/FontMatrix[.001 0 0 .001 0 0]def");
}
stream.printf("/FontBBox[%d %d %d %d]def\n",font->llx-1,font->lly-1,font->urx,font->ury);
if (font->target_type == PS_TYPE_42 || font->target_type == PS_TYPE_42_3_HYBRID)
{
stream.printf("/FontType 42 def\n", font->target_type );
}
else
{
stream.printf("/FontType 3 def\n", font->target_type );
}
} /* end of ttfont_header() */
/*
** Emmit PostScript code for a composite character.
*/
void GlyphToType3::do_composite(TTStreamWriter& stream, struct TTFONT *font, BYTE *glyph)
{
USHORT flags;
USHORT glyphIndex;
int arg1;
int arg2;
USHORT xscale;
USHORT yscale;
USHORT scale01;
USHORT scale10;
/* Once around this loop for each component. */
do
{
flags = getUSHORT(glyph); /* read the flags word */
glyph += 2;
glyphIndex = getUSHORT(glyph); /* read the glyphindex word */
glyph += 2;
if (flags & ARG_1_AND_2_ARE_WORDS)
{
/* The tt spec. seems to say these are signed. */
arg1 = getSHORT(glyph);
glyph += 2;
arg2 = getSHORT(glyph);
glyph += 2;
}
else /* The tt spec. does not clearly indicate */
{
/* whether these values are signed or not. */
arg1 = *(signed char *)(glyph++);
arg2 = *(signed char *)(glyph++);
}
if (flags & WE_HAVE_A_SCALE)
{
xscale = yscale = getUSHORT(glyph);
glyph += 2;
scale01 = scale10 = 0;
}
else if (flags & WE_HAVE_AN_X_AND_Y_SCALE)
{
xscale = getUSHORT(glyph);
glyph += 2;
yscale = getUSHORT(glyph);
glyph += 2;
scale01 = scale10 = 0;
}
else if (flags & WE_HAVE_A_TWO_BY_TWO)
{
xscale = getUSHORT(glyph);
glyph += 2;
scale01 = getUSHORT(glyph);
glyph += 2;
scale10 = getUSHORT(glyph);
glyph += 2;
yscale = getUSHORT(glyph);
glyph += 2;
}
else
{
xscale = yscale = scale01 = scale10 = 0;
}
/* Debugging */
#ifdef DEBUG_TRUETYPE
stream.printf("%% flags=%d, arg1=%d, arg2=%d, xscale=%d, yscale=%d, scale01=%d, scale10=%d\n",
(int)flags,arg1,arg2,(int)xscale,(int)yscale,(int)scale01,(int)scale10);
#endif
if (pdf_mode)
{
if ( flags & ARGS_ARE_XY_VALUES )
{
/* We should have been able to use 'Do' to reference the
subglyph here. However, that doesn't seem to work with
xpdf or gs (only acrobat), so instead, this just includes
the subglyph here inline. */
stream.printf("q 1 0 0 1 %d %d cm\n", topost(arg1), topost(arg2));
}
else
{
stream.printf("%% unimplemented shift, arg1=%d, arg2=%d\n",arg1,arg2);
}
GlyphToType3(stream, font, glyphIndex, true);
if ( flags & ARGS_ARE_XY_VALUES )
{
stream.printf("\nQ\n");
}
}
else
{
/* If we have an (X,Y) shif and it is non-zero, */
/* translate the coordinate system. */
if ( flags & ARGS_ARE_XY_VALUES )
{
if ( arg1 != 0 || arg2 != 0 )
stream.printf("gsave %d %d translate\n", topost(arg1), topost(arg2) );
}
else
{
stream.printf("%% unimplemented shift, arg1=%d, arg2=%d\n",arg1,arg2);
}
/* Invoke the CharStrings procedure to print the component. */
stream.printf("false CharStrings /%s get exec\n",
ttfont_CharStrings_getname(font,glyphIndex));
/* If we translated the coordinate system, */
/* put it back the way it was. */
if ( flags & ARGS_ARE_XY_VALUES && (arg1 != 0 || arg2 != 0) )
{
stream.puts("grestore ");
}
}
}
while (flags & MORE_COMPONENTS);
} /* end of do_composite() */
GlyphToType3::GlyphToType3(TTStreamWriter& stream, struct TTFONT *font, int charindex, bool embedded /* = false */)
{
BYTE *glyph;
tt_flags = NULL;
xcoor = NULL;
ycoor = NULL;
epts_ctr = NULL;
area_ctr = NULL;
check_ctr = NULL;
ctrset = NULL;
stack_depth = 0;
pdf_mode = font->target_type < 0;
/* Get a pointer to the data. */
glyph = find_glyph_data( font, charindex );
/* If the character is blank, it has no bounding box, */
/* otherwise read the bounding box. */
if ( glyph == (BYTE*)NULL )
{
llx=lly=urx=ury=0; /* A blank char has an all zero BoundingBox */
num_ctr=0; /* Set this for later if()s */
}
else
{
/* Read the number of contours. */
num_ctr = getSHORT(glyph);
/* Read PostScript bounding box. */
llx = getFWord(glyph + 2);
lly = getFWord(glyph + 4);
urx = getFWord(glyph + 6);
ury = getFWord(glyph + 8);
/* Advance the pointer. */
glyph += 10;
}
/* If it is a simple character, load its data. */
if (num_ctr > 0)
{
load_char(font, glyph);
}
else
{
num_pts=0;
}
/* Consult the horizontal metrics table to determine */
/* the character width. */
if ( charindex < font->numberOfHMetrics )
{
advance_width = getuFWord( font->hmtx_table + (charindex * 4) );
}
else
{
advance_width = getuFWord( font->hmtx_table + ((font->numberOfHMetrics-1) * 4) );
}
/* Execute setcachedevice in order to inform the font machinery */
/* of the character bounding box and advance width. */
stack(stream, 7);
if (pdf_mode)
{
if (!embedded) {
stream.printf("%d 0 %d %d %d %d d1\n",
topost(advance_width),
topost(llx), topost(lly), topost(urx), topost(ury) );
}
}
else if (font->target_type == PS_TYPE_42_3_HYBRID)
{
stream.printf("pop gsave .001 .001 scale %d 0 %d %d %d %d setcachedevice\n",
topost(advance_width),
topost(llx), topost(lly), topost(urx), topost(ury) );
}
else
{
stream.printf("%d 0 %d %d %d %d _sc\n",
topost(advance_width),
topost(llx), topost(lly), topost(urx), topost(ury) );
}
/* If it is a simple glyph, convert it, */
/* otherwise, close the stack business. */
if ( num_ctr > 0 ) /* simple */
{
PSConvert(stream);
}
else if ( num_ctr < 0 ) /* composite */
{
do_composite(stream, font, glyph);
}
if (font->target_type == PS_TYPE_42_3_HYBRID)
{
stream.printf("\ngrestore\n");
}
stack_end(stream);
}
/*
** Here is the routine which ties it all together.
**
** Create the array called "sfnts" which
** holds the actual TrueType data.
*/
void ttfont_sfnts(TTStreamWriter& stream, struct TTFONT *font)
{
static const char *table_names[] = /* The names of all tables */
{
/* which it is worth while */
"cvt ", /* to include in a Type 42 */
"fpgm", /* PostScript font. */
"glyf",
"head",
"hhea",
"hmtx",
"loca",
"maxp",
"prep"
} ;
struct /* The location of each of */
{
ULONG oldoffset; /* the above tables. */
ULONG newoffset;
ULONG length;
ULONG checksum;
} tables[9];
BYTE *ptr; /* A pointer into the origional table directory. */
ULONG x,y; /* General use loop countes. */
int c; /* Input character. */
int diff;
ULONG nextoffset;
int count; /* How many `important' tables did we find? */
ptr = font->offset_table + 12;
nextoffset=0;
count=0;
/*
** Find the tables we want and store there vital
** statistics in tables[].
*/
for (x=0; x < 9; x++ )
{
do
{
diff = strncmp( (char*)ptr, table_names[x], 4 );
if ( diff > 0 ) /* If we are past it. */
{
tables[x].length = 0;
diff = 0;
}
else if ( diff < 0 ) /* If we haven't hit it yet. */
{
ptr += 16;
}
else if ( diff == 0 ) /* Here it is! */
{
tables[x].newoffset = nextoffset;
tables[x].checksum = getULONG( ptr + 4 );
tables[x].oldoffset = getULONG( ptr + 8 );
tables[x].length = getULONG( ptr + 12 );
nextoffset += ( ((tables[x].length + 3) / 4) * 4 );
count++;
ptr += 16;
}
}
while (diff != 0);
} /* end of for loop which passes over the table directory */
/* Begin the sfnts array. */
sfnts_start(stream);
/* Generate the offset table header */
/* Start by copying the TrueType version number. */
ptr = font->offset_table;
for (x=0; x < 4; x++)
{
sfnts_pputBYTE( stream, *(ptr++) );
}
/* Now, generate those silly numTables numbers. */
sfnts_pputUSHORT(stream, count); /* number of tables */
if ( count == 9 )
{
sfnts_pputUSHORT(stream, 7); /* searchRange */
sfnts_pputUSHORT(stream, 3); /* entrySelector */
sfnts_pputUSHORT(stream, 81); /* rangeShift */
}
#ifdef DEBUG_TRUETYPE
else
{
debug("only %d tables selected",count);
}
#endif
/* Now, emmit the table directory. */
for (x=0; x < 9; x++)
{
if ( tables[x].length == 0 ) /* Skip missing tables */
{
continue;
}
/* Name */
sfnts_pputBYTE( stream, table_names[x][0] );
sfnts_pputBYTE( stream, table_names[x][1] );
sfnts_pputBYTE( stream, table_names[x][2] );
sfnts_pputBYTE( stream, table_names[x][3] );
/* Checksum */
sfnts_pputULONG( stream, tables[x].checksum );
/* Offset */
sfnts_pputULONG( stream, tables[x].newoffset + 12 + (count * 16) );
/* Length */
sfnts_pputULONG( stream, tables[x].length );
}
/* Now, send the tables */
for (x=0; x < 9; x++)
{
if ( tables[x].length == 0 ) /* skip tables that aren't there */
{
continue;
}
#ifdef DEBUG_TRUETYPE
debug("emmiting table '%s'",table_names[x]);
#endif
/* 'glyf' table gets special treatment */
if ( strcmp(table_names[x],"glyf")==0 )
{
sfnts_glyf_table(stream,font,tables[x].oldoffset,tables[x].length);
}
else /* Other tables may not exceed */
{
/* 65535 bytes in length. */
if ( tables[x].length > 65535 )
{
throw TTException("TrueType font has a table which is too long");
}
/* Start new string if necessary. */
sfnts_new_table(stream, tables[x].length);
/* Seek to proper position in the file. */
fseek( font->file, tables[x].oldoffset, SEEK_SET );
/* Copy the bytes of the table. */
for ( y=0; y < tables[x].length; y++ )
{
if ( (c = fgetc(font->file)) == EOF )
{
throw TTException("TrueType font may be corrupt (reason 7)");
}
sfnts_pputBYTE(stream, c);
}
}
/* Padd it out to a four byte boundary. */
y=tables[x].length;
while ( (y % 4) != 0 )
{
sfnts_pputBYTE(stream, 0);
y++;
#ifdef DEBUG_TRUETYPE_INLINE
puts("\n% pad byte:\n");
#endif
}
} /* End of loop for all tables */
/* Close the array. */
sfnts_end_string(stream);
stream.putline("]def");
} /* end of ttfont_sfnts() */
