Writing scripts to change fonts in PfaEdit

PfaEdit includes an interpreter so you can write scripts to modify fonts.

Starting scripts

If you start pfaedit with a script on the command line it will not put up any windows and it will exit when the script is done.

$ pfaedit -script scriptfile.pe {fontnames}

PfaEdit can also be used as an interpreter that the shell will automatically pass scripts to. If you a mark your script files as executable
    $ chmod +x scriptfile.pe
and begin each one with the line
    #!/usr/local/bin/pfaedit
(or wherever pfaedit happens to reside on your system) then you can invoke the script just by typing
    $ scriptfile.pe {fontnames}

If you wish PfaEdit to read from stdin then you can use "-" as a "filename" for stdin. (If you build PfaEdit without X11 then pfaedit will attempt to read a script file from stdin if none is given on the command line.)

You can also start a script from within PfaEdit with File->Execute Script, and you can use the Preference Dlg to define a set of frequently used scripts which can be invoked directly by menu.

The scripting language provides access to much of the functionality found in the font view's menus. It does not currently (and probably never will) provide access to everything. (If you find a lack let me know, I may put it in for you). It does not provide commands for building up a character out of splines, instead it allows you to do high level modifications to characters.

If you set the environment variable PFAEDIT_VERBOSE (it doesn't need a value, just needs to be set) then PfaEdit will print scripts to stdout as it executes them.

In general I envision this as being useful for things like taking a latin font and extending it to contain cyrillic characters. So the script might:

Scripting Language

The syntax is rather like a mixture of C and shell commands. Every file corresponds to a procedure. As in a shell script arguments passed to the file are identified as $1, $2, ... $n. $0 is the file name itself. $argc gives the number of arguments. $argv[<expr>] provides array access to the arguments.

Terms can be

There are three different comments supported:

Expressions are similar to those in C, a few operators have been omitted, a few added from shell scripts. Operator precedence has been simplified slightly. So operators (and their precedences) are:

Note there is no comma operator, and no "?:" operator. The precedence of "and" and "or" has been simplified, as has that of the assignment operators.

Procedure calls may be applied either to a name token, or to a string. If the name or string is recognized as one of PfaEdit's internal procedures it will be executed, otherwise it will be assumed to be a filename containing another pfaedit script file, this file will be invoked (since filenames can contain characters not legal in name tokens it is important to allow general strings to specify filenames). If the procedure name does not contain a directory then it is assumed to be in the same directory as the current script file.

Arrays are passed by reference, strings and integers are passed by value.

Variables may be created by assigning a value to them (only with the "="), so:
    i=3
could be used to define "i" as a variable. Variables are limited in scope to the current file, they will not be inherited by called procedures.

A statement may be

As with C, non-zero expressions are defined to be true.
A return statement may be followed by a return value (the expression) or a procedure may return nothing (void).
The shift statement is stolen from shell scripts and shifts all arguments down by one. (argument 0, the name of the script file, remains unchanged.
The foreach statement requires that there be a current font. It executes the statements once for each character in the selection. Within the statements only one character at a time will be selected. After execution the selection will be restored to what it was initially. (Caveat: Don't reencode the font within a foreach statement).
Statements are terminated either by a new line or a semicolon.

Trivial example:

i=0;	#semicolon is not needed here, but it's ok
while ( i<3 )
   if ( i==1 /* pointless comment */ )
	Print( "Got to one" )	// Another comment
   endif
   ++i
endloop

PfaEdit maintains the concept of a "current font" almost all commands refer only to the current font (and require that there be a font). If you start a script with File->Execute Script, the font you were editing will be current, otherwise there will be no initial current font. The Open(), New() and Close() commands all change the current font. PfaEdit also maintains a list of all fonts that are currently open. This list is in no particular order. The list starts with $firstfont.

Similarly when working with cid keyed fonts, PfaEdit works in the "current sub font", and most commands refer to this font. The CIDChangeSubFont() command can alter that.

All builtin variables begin with "$", you may not create any variables that start with "$" yourself (though you may assign to (some) already existing ones)

The following example will perform an action on all loaded fonts:

file = $firstfont
while ( file != "" )
   Open(file)
   /* Do Stuff */
   file = $nextfont
endloop

The built in procedures are very similar to the menu items with the same names.

Print(arg1,arg2,arg3,...)
This corresponds to no menu item. It will print all of its arguments to stdout. It can execute with no current font.
Error(str)
Prints out str as an error message and aborts the current script
AskUser(question[,default-answer])
Asks the user the question and returns an answer. A default-answer may be specified too.
Array(size)
Allocates an array of the indicated size.
a = Array(10)
i = 0;
while ( i<10 )
   a[i] = i++
endloop
a[3] = "string"
a[4] = Array(10)
a[4][0] = "Nested array";
Strsub(str,start[,end])
Returns a substring of the string argument. The substring beings at position indexed by start and ends at the position indexed by end (if end is omitted the end of the string will be used, the first position is position 0). Thus Strsub("abcdef",2,3) == "c" and Strsub("abcdef",2) == "cdef"
Strlen(str)
Returns the length of the string.
Strstr(haystack,needle)
Returns the index of the first occurance of the string needle within the string haystack (or -1 if not found).
Strrstr(haystack,needle)
Returns the index of the last occurance of the string needle within the string haystack (or -1 if not found).
Strcasestr(haystack,needle)
Returns the index of the first occurance of the string needle within the string haystack ignoring case in the search (or -1 if not found).
Strcasecmp(str1,str2)
Compares the two strings ignoring case, returns zero if the two are equal, a negative number if str1<str2 and a positive number if str1>str2
Strtol(str[,base])
Parses as much of str as possible and returns the integer value it represents. A second argument may be used to specify the base of the conversion (it defaults to 10). Behavior is as for strtol(3).
Strskipint(str[,base])
Parses as much of str as possible and returns the offset to the first character that could not be parsed.
GetPref(str)
Gets the value of the preference item whose name is contained in str. Only boolean, integer, real, string and file preference items may be returned. Boolean and real items are returned with integer type and file items are returned with string type.
SetPrefs(str,val[,val2])
Sets the value of the preference item whose name is containted in str. If the preference item has a real type then a second argument may be passed and the value set will be val/val2.

Open(filename[,flags])
This makes the font named by filename be the current font. If filename has not yet been loaded into memory it will be loaded now. It can execute with no current font.
When loading from a ttc file, a particular font may be selected by placing the fontname in parens and appending it to the filename, as Open("gulim.ttc(Dotum)")
The optional flags argument current has only one flag in it:
New()
This creates a new font. It can execute with no current font.
Close()
This frees up any memory taken up by the current font and drops it off the list of loaded fonts. After this executes there will be no current font.
Save([filename])
If no filename is specified then this saves the current font back into its sfd file (if the font has no sfd file then this is an error). With one argument it executes a SaveAs command, saving the current font to that filename.
Generate(filename[,bitmaptype[,fmflags[,res[,mult-sfd-file]]]])
Generates a font. The type of font is determined by the extension of the filename. Valid extensions are:

If present, bitmaptype may be one of:

If you do not wish to generate an outline font then give the filename the extension of ".bdf".
fmflags controls whether an afm or pfm file should be generated

res controls the resolution of generated bdf fonts. A value of -1 means pfaedit will guess for each strike.

If the filename has a ".mult" extension then a "mult-sfd-file" may be present. This is the filename of a file containing the mapping from the current encoding into the subfonts. Here is an example. If this file is not present PfaEdit will go through its default search process to find a file for the encoding, and if it fails the fonts will not be saved.

GenerateFamily(filename,bitmaptype,fmflags,array-of-font-filenames)
Generates a mac font family (FOND) the fonts (which must be loaded) in the array-of-font-filenames. filename, bitmaptype, fmflags are as above.
#!/usr/local/bin/pfaedit
a = Array($argc-1)
i = 1
j = 0
while ( i < $argc )
# Open each of the fonts
  Open($argv[i], 1)
# and store the filenames of all the styles in the array
  a[j] = $filename
  j++
  i++
endloop

GenerateFamily("All.otf.dfont","dfont",16,a)
Import
Either imports a bitmap font into the database, or imports background image[s] into various characters. There may be one or two arguments. The first must be a string representing a filename. The extension of the file determines how the import procedes. If present the second argument must be an integer, if the first argument is a bitmap font then the second argument controls whether it is imported into the bitmap list (0) or to fill up the backgrounds of characters (1).
Export(format[,bitmap-size])
For each selected character in the current font, this command will export that character into a file in the current directory. Format must be a string and must be one of
MergeKern(filename)
Loads Kerning info out of either an afm or a tfm file and merges it into the current font.
PrintSetup(type,[printer[,width,height]])
Allows you to configure the print command. Type may be a value between 0 and 4

If the type is 4 (other) and the second argument is specified, then the second argument should be a string containing the "other" printing command.
If the type is 0 (lp) or 1 (lpr) and the second argument is specified, then the second argument should contain the name of a laser printer
(If the second argument is a null string neither will be set).

The third and fourth arguments should specify the page width and height respectively. Units are in points, so 8.5x11" paper is 612,792 and A4 paper is (about) 595,842.

PrintFont(type[,pointsize[,sample-text-file[,output-file]]])
Prints the current font according to the PrintSetup. The values for type are (meanings are described in the section on printing):

The pointsize is either a single integer or an array of integers. It is only meaningful for types 0 and 3. If omitted or set to 0 a default value will be chosen. The font display will only look at one value.

If you selected print type 3 then you may provide the name of a file containing sample text. This file may either be in ucs2 format (preceded by a 0xfeff value), or in the current default encoding. A null string or an omitted argument will cause PfaEdit to use a default value.

If your PrintSetup specified printing to a file then the fourth argument provides the filename of the output file.

Quit(status)
Causes PfaEdit to exit with the given status. It can execute with no current font.
Cut
Makes a copy of all selected characters and saves it in the clipboard, then clears out the selected characters
Copy
Makes a copy of all selected characters.
CopyReference
Makes references to all selected characters and stores them in the clipboard.
CopyWidth
Stores the widths of all selected characters in the clipboard
CopyVWidth
Stores the vertical widths of all selected characters in the clipboard
CopyLBearing
Stores the left side bearing of all selected characters in the clipboard
CopyRBearing
Stores the right side bearing of all selected characters in the clipboard
Paste
Copies the clipboard into the selected characters of the current font (removing what was there before)
PasteInto
Copies the clipboard into the current font (merging with what was there before)
Clear
Clears out all selected characters
ClearBackground
Clears the background of all selected characters
CopyFgToBd
Copies all foreground splines into the background in all selected characters
Join([fudge])
Joins open paths in selected characters. If fudge is specified then the endpoints only need to be within fudge em-units of each other to be merged.
UnlinkReference
Unlinks all references within all selected characters
SelectAll
Selects all characters
SelectNone
Deselects all characters
Select(arg1, arg2, ...)
This clears out the current selection, then for each pair of arguments it selects all characters between (inclusive) the bounds specified by the pair. If there is a final singleton argument then that single character will be selected. An argument may be specified by:
SelectMore(arg1, arg2, ...)
The same as the previous command except that it does not clear the selection, so it extends the current selection.
Reencode(encoding-name[,force])
Reencodes the current font into the given encoding which may be:
iso8859-1, isolatin1, latin1, iso8859-2, latin2, iso8859-3, latin3, iso8859-4, latin4, iso8859-5, iso8859-6, iso8859-7, iso8859-8, iso8859-9, iso8859-10, iso8859-13, iso8859-14, iso8859-15, latin0, koi8-r, AdobeStandardEncoding, win, mac, wansung, big5, johab, jis208, unicode, iso10646-1, TeX-Base-Encoding, one of the user defined encodings, or something of the form "unicode-plane-%x" to represent the x'th iso10646 plane (where the BMP is plane 0).
You may also specify that you want to force the encoding to be the given one.
SetCharCnt(cnt)
Sets the number of characters in the font.
SetFontNames(fontname[,family[,fullname[,weight[,copyright-notice]]]])
Sets various postscript names associated with a font. If a name is omitted (or is the empty string) it will not be changed.
SetItalicAngle(angle[,denom])
Sets the postscript italic angle field appropriately. If denom is specified then angle will be divided by denom before setting the italic angle field (a hack to get real values). The angle should be in degrees.
SetUniqueID(value)
Sets the postscript uniqueid field as requested. If you give a value of 0 then PfaEdit will pick a reasonable random number for you.
SetCharName(name[,set-from-name-flag])
Sets the currently selected character to have the given name. If set-from-name-flag is absent or is present and true then it will also set the unicode value and the ligature string to match the name.
SetUnicodeValue(uni[,set-from-value-flag])
Sets the currently selected character to have the given unicode value. If set-from-value-flag is absent or is present and true then it will also set the name and the ligature string to match the value.
SetCharColor(color)
Sets any currently selected characters to have the given color (expressed as 24 bit rgb (0xff0000 is red) with the special value of -2 meaning the default color.
SetCharComment(comment)
Sets the currently selected character to have the given comment. The comment is converted via the current encoding to unicode.
BitmapsAvail(sizes)
Controls what bitmap sizes are stored in the font's database. It is passed an array of sizes. If a size is specified which is not in the font database it will be generated. If a size is not specified which is in the font database it will be removed. A size which is specifed and present in the font database will not be touched.
If you want to specify greymap fonts then the low-order 16 bits will be the pixel size and the high order 16 bits will specify the bits/pixel. Thus 0x8000c would be a 12 pixel font with 8 bits per pixel, while either 0xc or 0x1000c could be used to refer to a 12 pixel bitmap font.
BitmapsRegen(sizes)
Allows you to update specific bitmaps in an already generated bitmap font. It will regenerate the bitmaps of all selected characters at the specified pixelsizes.
Transform(t1,t2,t3,t4,t5,t6)
Each argument will be divided by 100. and then all selected characters will be transformed by this matrix
HFlip([about-x])
All selected characters will be horizontally flipped about the vertical line through x=about-x. If no argument is given then all selected characters will be flipped about their central point.
VFlip([about-y])
All selected characters will be vertically flipped about the horizontal line through y=about-y. If no argument is given then all selected characters will be flipped about their central point.
Rotate(angle[,ox,oy])
Rotates all selected character the specified number of degrees. If the last two args are specified they provide the origin of the rotation, otherwise the center of the character is used.
Scale(factor[,yfactor][,ox,oy])
All selected characters will be scaled (scale factors are in percent)
Skew(angle[,ox,oy])
All selected characters will be skewed by the given angle.
Move(delta-x,delta-y)
All selected characters will have their points moved the given amount.
ScaleToEm(ascent,descent)
Change the font's ascent and descent and scale everything in the font to be in the same proportion to the new em (which is the sum of ascent and descent) value that it was to the old value.
ExpandStroke(width)
ExpandStroke(width,line cap, line join)
ExpandStroke(width,caligraphic-angle,height-numerator,height-denom)
In the first format a line cap of "butt" and line join of "round" are implied..
RemoveOverlap()
Does the obvious.
Simplify()
Simplify(flags,error)
With no arguments it does the obvious. If flags is -1 it does a Cleanup, otherwise flags should be a bitwise or of

The error argument is the number of pixels by which the modified path is allowed to stray from the true path.

AddExtrema()
RoundToInt()
AutoTrace()
CorrectDirection([unlinkrefs])
If the an argument is present it must be integral and is treated as a flag controlling whether flipped references should be unlinked before the CorrectDirection code runs. If the argument is not present, or if it has a non-zero value then flipped references will be unlinked.
BuildComposit()
BuildAccented()
MergeFonts(other-font-name[,flags])
Loads other-font-name, and extracts any characters from it which are not in the current font and moves them to the current font. The flags argument is the same as that for Open. Currently the only relevant flag is to say that you do have a lisence to use a font with fstype=2.
AutoHint()
ClearHints()
SetWidth(width)
SetVWidth(vertical-width)
SetLBearing(lbearing)
SetRBearing(rbearing)
CenterInWidth()
AutoWidth(spacing)
Guesses at the widths of all selected characters so that two adjacent "I" characters will appear to be spacing em-units apart. (if spacing is the negative of the em-size (sum of ascent and descent) then a default value will be used).
AutoKern(spacing,threshold[,kernfile])
(AutoKern doesn't work well in general)
Guesses at kerning pairs by looking at all selected characters, or if a kernfile is specified, PfaEdit will read the kern pairs out of the file.
SetKern(ch2,offset)
Sets the kern between any selected characters and the character ch2 to be offset. The first argument may be specified as in Select(), the second is an integer representing the kern offset.
RemoveAllKerns()
Removes all kern pairs from the current font.

CIDChangeSubFont(new-sub-font-name)
If the current font is a cid keyed font, this command changes the active sub-font to be the one specified (the string should be the postscript FontName of the subfont)
CIDSetFontNames(fontname[,family[,fullname[,weight[,copyright-notice]]]])
Sets various postscript names associated with the top level cid font. If a name is omitted (or is the empty string) it will not be changed. (this is just like SetFontNames except it works on the top level cid font rather than the current font).
CIDFlattenByCMap(cmap-filename)
CharCnt()
Returns the number of characters in the current font
InFont(arg)
Returns whether the argument is in the font. The argument may be an integer in which case true is returned if the value is >= 0 and < total number of characters in the font. Otherwise if the argument is a unicode code point or a postscript character name, true is returned if that character is in the font.
WorthOutputting(arg)
Arg is as above. This returns true if the character contains any splines, references or has had its width set.
CharInfo(str)
There must be exactly one character selected in the font, and this returns information on it. The information returned depends on str with the obvious meanings:

Examples:

Select("A")
lbearing = CharInfo("LBearing")
kern = CharInfo("Kern","O")
Select(0u410)
SetLBearing(lbearing)
SetKern(0u41e,kern)


Example 1:

#Set the color of all selected characters to be yellow
#designed to be run within an interactive pfaedit session.
foreach
  SetCharColor(0xffff00)
endloop

Example 2:

#!/usr/local/bin/pfaedit
#Take a Latin font and apply some simple transformations to it
#prior to adding cyrillic letters.
#can be run in a non-interactive pfaedit session.
Open($1);
Reencode("KOI8-R");
Select(0xa0,0xff);
//Copy those things which look just like latin
BuildComposit();
BuildAccented();

//Handle Ya which looks like a backwards "R"
Select("R");
Copy();
Select("afii10049");
Paste();
HFlip();
CorrectDirection();
Copy();
Select(0u044f);
Paste();
CopyFgToBg();
Clear();

//Gamma looks like an upside-down L
Select("L");
Copy();
Select(0u0413);
Paste();
VFlip();
CorrectDirection();
Copy();
Select(0u0433);
Paste();
CopyFgToBg();
Clear();

//Prepare for editing small caps K, etc.
Select("K");
Copy();
Select(0u043a);
Paste();
CopyFgToBg();
Clear();

Select("H");
Copy();
Select(0u043d);
Paste();
CopyFgToBg();
Clear();

Select("T");
Copy();
Select(0u0442);
Paste();
CopyFgToBg();
Clear();

Select("B");
Copy();
Select(0u0432);
Paste();
CopyFgToBg();
Clear();

Select("M");
Copy();
Select(0u043C);
Paste();
CopyFgToBg();
Clear();

Save($1:r+"-koi8-r.sfd");
Quit(0);

The Execute Script dialog

This dialog allows you to type a script directly in to PfaEdit and then run it. Of course the most common case is that you'll have a script file somewhere that you want to execute, so there's a button [Call] down at the bottom of the dlg. Pressing [Call] will bring up a file picker dlg looking for files with the extension *.pe (you can change that by typing a wildcard sequence and pressing the [Filter] button). After you have selected your scipt the appropriate text to text to invoke it will be placed in the text area.

The current font of the script will be set to whatever font you invoked it from.

The Scripts Menu

You can use the preference dialog to create a list of frequently used scripts. Invoke File->Preferences and select the Scripts tag. In this dialog are ten possible entries, each one should have a name (to be displayed in the menu) and an associated script file to be run.

After you have set up your preferences you can invoke scripts from the font view, either directly from the menu (File->Scripts-><your name>) or by a hot key. The first script you added will be invoked by Cnt-Alt-1, then second by Cnt-Alt-2, and the tenth by Cnt-Alt-0.

The current font of the script will be set to whatever font you invoked it from.

-- Prev -- TOC -- Next --