The built in procedures are very similar to the menu items
with the same names. Often the description here is sketchy,
look at the menu item for more information.
To mean that arguments after the first are optional. However
if you wish to set the fourth argument you must specify the
second and third arguments too.
A |
- AddAccent(accent[,pos])
-
There must be exactly one glyph selected. That glyph
must contain at least one reference (and the least
recently added reference must be the base glyph --
the letter on which the accent is placed). The first
argument should be either the glyph-name of an
accent, or the unicode code point of that accent (and
it should be in the font). The second argument, if
present indicates how the accent should be
positioned... if omitted a default position will be
chosen from the unicode value for the accent, this
argument is the or of the following flags:
0x100 |
Above |
0x200 |
Below |
0x400 |
Overstrike |
0x800 |
Left |
0x1000 |
Right |
0x4000 |
Center Left |
0x8000 |
Center Right |
0x10000 |
Centered Outside |
0x20000 |
Outside |
0x40000 |
Left Edge |
0x80000 |
Right Edge |
0x100000 |
Touching |
- AddAnchorClass(name,type,lookup-subtable-name)
AddAnchorClass(name,type,script-lang,tag,flags,merge-with)
- These mirror the values of the Anchor class dialog
of Element->Font Info. The first argument should be
a utf8 encoded name for the anchor class. The second
should be one of the strings "default", "mk-mk", or
"cursive". The third should be a lookup subtable
name.
- AddAnchorPoint(name,type,x,y[,lig-index])
- Adds an AnchorPoint to the currently selected
glyph. The first argument is the name of the
AnchorClass. The second should be one of the strings:
"mark", "basechar" (or "base"), "baselig" (or
"ligature"), "basemark", "cursentry" (or "entry") ,
"cursexit" (or "exit") or "default" ("default" tries to
guess an appropriate setting for you). The next two
values specify the location of the point. The final
argument is only present for things of type
"baselig".
- AddATT(type,script-lang,tag,flags,variant)
AddATT("Position",script-lang,tag,flags,xoff,yoff,h_adv_off,v_adv_off)
AddATT("Pair",script-lang,tag,flags,name,xoff,yoff,h_adv_off,v_adv_off,xoff2,yoff2,h_adv_off2,v_adv_off2)
- See AddPosSub
- AddDHint(x1,y1,x2,y2,unit.x,unit.y)
- Adds a diagonal hint. A diagonal hint requires two
points on oposite sides of the stem and a unit vector
in the direction of the stem.
- AddExtrema([all])
- If a spline in a glyph reaches a maximum or minimum
x or y value within a spline then break the spline so
that there will be a point at all significant extrema.
(If this point is too close to an end-point then the
end-point itself may be moved. There are various other
caveats. See Element->AddExtrema for more information). If
the "all" argument is specified and is a nonzero
integer, then all extrema will be added; otherwise,
some that would be very close to existing endpoints
will not be added.
- AddHHint(start,width)
- Adds horizontal stem hint to any selected glyphs.
The hint starts at location "start" and is width wide.
A hint will be added to all selected glyphs.
- AddInstrs(thingamy,replace,instrs)
- Where thingamy is a string, either "fpgm" or "prep"
in which case it refers to that truetype table (which
will be created if need be), or a glyph-name in which
case it refers to that glyph, or a null string in which
case any selected characters will be used.
Where replace is an integer. If zero then the
instructions will be appended to any already present.
If non-zero then the instructions will replace those
already present.
And instrs is a string containing fontforge's human
readable version of tt instructions, as
"IUP[x]\nIUP[y] "
- AddLookup(name,type,flags,features-script-lang-array[,after-lookup-name)
-
Creates a new lookup with the given name, type and
flags. It will tag it with any indicated features.
The type of one of
- gsub_single
- gsub_multiple
- gsub_alternate
- gsub_ligature
- gsub_context
- gsub_contextchain
- gsub_revesechain
- morx_indic
- morx_context
- morx_insert
- gpos_single
- gpos_pair
- gpos_cursive
- gpos_mark2base
- gpos_mark2ligature
- gpos_mark2mark
- gpos_context
- gpos_contextchain
- kern_statemachine
A feature-script-lang array is an array with one
entry for each feature (there may be no entries if
there are no features). Each entry is itself a two
element array, the first entry is a string containing
a 4 letter feature tag, and the second entry is
another array (potentially empty) with an entry for
each script for which the feature is active. Each
entry here is itself a two element array. The first
element is a 4 letter script tag and the second is an
array of languages. Each entry in the language array
is a four letter language. Example:
[["liga",[["latn",["dflt"]]]]]
The optional final argument allows you to specify the
ordering of the lookup. If not specified the lookup
will be come the first lookup in its table.
- AddLookupSubtable(lookup-name,new-subtable-name[,after-subtable])
- Creates a new subtable within the specified lookup.
The optional final argument allows you to specify the
ordering within the lookup. If not specified this
subtable will be first in the lookup.
- AddPosSub(subtable-name,variant-glyph-name(s))
AddPosSub(subtable-name,dx,dy,dadv_x,dadv_y)
AddPosSub(subtable-name,other-glyph-name,dx1,dy1,dadv_x1,dadv_y1,dx2,dy2,dadv_x2,dadv_y2)
- One glyph must be selected. The arguments of the
command depend on the type of the lookup containing the
subtable.
- AddSizeFeature(default-size[,range-bottom,range-top,style-id,array-of-lang-names])
-
This allows you to specify an OpenType 'size'
feature. It will also set the TeX design size header
value.
The 'size' feature has two formats. The simplest one
specifies the optical design size for the font, the
more complex one specifies that as well as a design
range, a style id, and a list of language/name pairs
(at least one of which must be in English).
The design range is a range of point sizes for which
this font is to be preferred. For instance you might
have a family of fonts with the following attributes:
Optical design size |
Bottom of range |
Top of range |
Style name |
18 |
13 |
72 |
Title |
10 |
12.9 |
8.0 |
Text |
6 |
7.9 |
5 |
Tiny |
The list of language/name pairs should be an array
of arrays. All the sub-arrays should have two
entries, the first, an integer which represents an MS
language id, the second a string containing the name
of the style in that language.
New()
AddSizeFeature(10,8,12.9,211,[[0x409,"Text"],[0x40c,"Texte"]])
This will set the current font to have a design
size of 10 points, this font will then be used in
preference to other fonts in its family if the
requested size is between 8 and 12.9 points. The 211
is used by applications to associate font families
into smaller groups based on optical size. The final
argument specifies that this size be called "Text" in
English and "Texte" in French (0x409 is the ms
language code for US English, 0x40c is the code for
French from France).
- AddVHint(start,width)
- Adds a vertical stem hint to any selected glyphs.
The hint starts at location "start" and is width wide.
A hint will be added to all selected glyphs.
- ApplySubstitution(script,lang,tag)
-
All three arguments must be strings of no more that
four characters (shorter strings will be padded with
blanks to become 4 character strings). For each
selected glyph this command will look up that glyph's
list of substitutions, and if it finds a substitution
with the tag "tag" (and if that substitution matches
the script and language combination) then it will
apply the substitution-- that is it will find the
variant glyph specified in the substitution and
replace the current glyph with the variant, and clear
the variant.
FontForge recognizes the string "*" as a wildcard
for both the script and the language (not for the tag
though). So if you wish to replace all glyphs with
their vertical variants:
SelectAll()
ApplySubstitution("*","*","vrt2")
- 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";
It can execute with no current font.
- AskUser(question[,default-answer])
- Asks the user the question and returns an answer (a
string). A default-answer may be specified too. It can
execute with no current font.
- ATan2(val1,val2)
- Returns the arc-tangent. See atan2(3) for more
info. It can execute with no current font.
- AutoCounter()
- Generates (PostScript) counter masks for selected
glyphs automagically.
- AutoHint()
- Generates (PostScript) hints for selected glyphs
automagically.
- AutoInstr()
- Generates (TrueType) instructions for selected
glyphs.
- AutoKern(spacing,threshold,subtable-name[,kernfile])
AutoKern(spacing,threshold[,kernfile])
- (AutoKern doesn't work well in general)
Guesses at kerning pairs by looking at all selected
glyphs, store the new kerning pairs in the indicated
subtable, or if a kernfile is specified, FontForge will
read the kern pairs out of the file.
- AutoTrace()
- If you have either potrace or autotrace installed,
this will invoke them on the selected glyphs to trace
the background image and generate splines.
- AutoWidth(spacing)
- Guesses at the widths of all selected glyphs so
that two adjacent "I" glyphs 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).
|
B |
- BitmapsAvail(sizes[,rasterized])
- 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
specified 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.
If you want to create blank strikes (with no glyphs in
them) set the optional rasterized parameter to 0.
- BitmapsRegen(sizes)
- Allows you to update specific bitmaps in an already
generated bitmap font. It will regenerate the bitmaps
of all selected glyphs at the specified
pixelsizes.
- BuildAccented()
- If any of the selected glyphs are accented, then
clear them and create a new glyph by inserting
references to the approriate base glyph and
accents.
- BuildComposite()
- Similar to BuildAccented but will build any
composite glyph -- ligatures and what not.
- BuildDuplicate()
- Changes the encoding so that to encoding points
share the same glyph.
|
C |
- CanonicalContours()
- Orders the contours in the currently selected
glyph(s) by the x coordinate of their leftmost point.
(This can reduce the size of the charstring needed to
describe the glyph(s).
- CanonicalStart()
- Sets the start point of all the contours of the
currently selected glyph(s) to be the leftmost point on
the contour. (If there are several points with that
value then use the one which is closest to the
baseline). This can reduce the size of the charstring
needed to describe the glyph(s). By regularizing things
it can also make more things available to be put in
subroutines.
- Ceil(real)
- Converts a real number to the smallest integer
larger than the real. It can execute with no current
font.
See Also Int, Round, Floor
- CenterInWidth()
- Centers any selected glyphs so that their right and
left side bearings are equal.
- ChangePrivateEntry(key,val)
- Changes (or adds if the key is not already present)
the value in the dictionary indexed by key. (all values
must be strings even if they represent numbers in
PostScript)
- CharCnt()
- Returns the number of encoding slots (or encoding
slots + unencoded glyphs) in the current font
- CharInfo(str)
- Deprecated name for GlyphInfo
- CheckForAnchorClass(name)
- Returns 1 if the current font contains an Anchor
class with the given name (which must be in utf8).
- Chr(int)
Chr(array)
- Takes an integer [0,255] and returns a single
character string containing that code point. Internally
FontForge interprets strings as if they were in utf8
(well really, FontForge almost always just uses
ASCII-US internally). If passed an array, it should be
an array of integers and the result is the string. It
can execute with no 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)
- CIDFlatten()
- Flattens a cid-keyed font.
- CIDFlattenByCMap(cmap-filename)
- Flattens a cid-keyed font, producing a font encoded
with the result of the CMAP file.
- 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).
- Clear
- Clears out all selected glyphs
- ClearBackground
- Clears the background of all selected glyphs
- ClearCharCounterMasks()
- Deprecated name for ClearGlyphCounterMasks
- ClearGlyphCounterMasks()
- Clears any counter masks from the (one) selected
glyph.
- ClearHints()
ClearHints("Vertical")
ClearHints("Horizontal")
ClearHints("Diagonal")
- Clears any (PostScript) hints from the selected
instructions. The first form clears all hints, the
other three clear either all vertical, all horizontal
or all diagonal hints respectively.
- ClearInstrs()
- Clears any (TrueType) instructions from selected
glyphs
- ClearPrivateEntry(key)
- Removes the entry indexed by the given key from the
private dictionary of the font.
- ClearTable(tag)
- Removes the table named tag. This may be 'fpgm',
'prep', 'cvt ', 'maxp' or any user defined tables. It
returns 1 if it found (and removed) the table, 0 if the
table was not present.
- 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.
- CompareFonts(other-font-filename,output-filename,flags)
-
This will compare the current font with the font in
other-font-filename (which must already
have been opened). It will write the results to the
output-filename , you may use "-" to send
the output to stdout. The flags argument
controls what will be compared.
flags
1 |
compare outlines |
2 |
compare outlines exactly (otherwise allow
slight errors and the unlinking of
references) |
4 |
warn if the outlines don't exactly match (but
are pretty close) |
8 |
compare hints |
0x10 |
compare hintmasks |
0x20 |
compare hintmasks only if the glyph has hint
conflicts |
0x40 |
warn if references need to be unlinked before
a match is found |
0x80 |
compare bitmap strikes |
0x100 |
compare font names |
0x200 |
compare glyph positioning |
0x400 |
compare glyph substitutions |
0x800 |
for any glyphs whose outlines differ, add the
outlines of the glyph in the second font to the
background of the glyph in the first |
0x1000 |
if a glyph exists in the second font but not
the first, create that glyph in the first and add
the outlines from the second into the backgroun
layer |
- CompareGlyphs([pt_err[,spline_err[,pixel_off_frac[,bb_err[,compare_hints[,report_diffs_as_errors]]]]]])
-
This function compares two versions of one or several
glyphs. It looks at any selected glyphs in the font
and compares them to an equivalent glyph in the
clipboard (there must be the same number of selected
glyphs as glyphs in the clipboard).
- It checks to make sure the advance width of
each glyph pair is similar
- It checks to make sure that each contains the
same set of references
- It checks to make sure that all points (both
base and control) are within pt_err of each
other
- If that fails then it performs a slower check
to see if points lying along the contours have
equivalent points in the other glyph (that is: If
you have simplified a glyph and are comparing it to
the original, this check should pass it while the
previous check would fail).
- Optionally you may check that the bitmaps
match.
- Optionally you may check if hints (and
hintmasks) match.
The first argument controls the accuracy with
which points must match. A value of 0 is an exact
match and will also check hints. If you provide a
negative value then this test will be skipped.
The second argument controls the accuracy with
which the contour check must match. A value of 0 will
not work due to rounding errors in the process. A
negative value will skip the test.
The third argument controls bitmap tests. A
negative value (the default) will mean no bitmap
tests are done. A value of 0 requires an exact match
of the bitmap. A value between 0 and 1 specifies the
fraction of the pixel range that will be accepted for
a match (so in a greymap with a depth of 8 the pixel
range in 256, and a fraction value of .25 would mean
any pixel value within 64 (.25*256) would match).
The fourth argument controls how different the
bounding boxes of anti-aliased bitmaps can be (the
bounding boxes of bitmaps with depth 1 must match
exactly)
The fifth argument controls whether to tests hints
and hintmasks. A value of 1 tests hints, 2 tests
hintmasks and 3 tests both, a value of 7 will test
hintmasks only in glyphs with conflicts.
Normally this function treats any differences it
finds as errors and stops the script. If you set the
sixth argument to 0 then it will return a value which
ors the following flags together (some flags indicate
errors, others unusual conditions, others success --
the function will never return both an error and
success flag, but it can return several success flags
at once if you are comparing more than one glyph)
1 |
Different numbers of contours in a glyph |
2 |
A contour in one glyph is open when the
corresponding contour is closed |
4 |
Disordered contours (contours are in
different orders in the two glyphs) |
8 |
Disordered start (the start point is at a
different place in the two glyphs) |
16 |
Disordered direction (the contour is
clockwise in one and counter in the other) |
32 |
Glyphs match by checking points |
64 |
Glyphs match by checking the contours |
128 |
Outline glyphs do not match |
256 |
Different references in the two glyphs (or
different transformation matrices) |
512 |
Different advance widths in the two
glyphs |
1024 |
Different vertical advance widths in the two
glyphs |
2048 |
Different hints in the two glyphs |
4096 |
Different hintmasks in the two glyphs |
8192 |
Different numbers of layers in the two
glyphs |
16384 |
Contours do not match in the two glyphs |
32768 |
We only find a match after we have unlinked
references |
65536 |
Bitmap glyphs have different depths |
2*65536 |
Bitmap glyphs have different bounding
boxes |
4*65536 |
Bitmaps are different |
8*65536 |
Bitmap glyphs do not match (set with all the
above) |
16*65536 |
Bitmap glyphs match |
- ControlAfmLigatureOutput(script,lang,ligature-tag-list)
- ConvertByCMap(cmapfilename)
- Converts current font to a CID-keyed font using
specified CMap file. cmapfilename must be a path name
of a file conforming Adobe CMap File Format.
- ConvertToCID(registry, ordering,
supplement)
- Converts current font to a CID-keyed font using
given registry, ordering and supplement. registry and
ordering must be strings, supplement must be a
integer.
- Copy
- Makes a copy of all selected glyphs.
- CopyAnchors
- Copies all the anchor points in a glyph.
- CopyFgToBg
- Copies all foreground splines into the background
in all selected glyphs
- CopyGlyphFeatures(arg,...)
- CopyLBearing
- Stores the left side bearing of all selected glyphs
in the clipboard
- CopyRBearing
- Stores the right side bearing of all selected
glyphs in the clipboard
- CopyReference
- Makes references to all selected glyphs and stores
them in the clipboard.
- CopyUnlinked
- Makes a copy of all selected glyphs, just as
Copy does. However if
a glyph contains a reference, then the reference will
be unlinked (turned into splines) before it is added to
the clipboard.
- CopyVWidth
- Stores the vertical widths of all selected glyphs
in the clipboard
- CopyWidth
- Stores the widths of all selected glyphs in the
clipboard
- 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.
- Cos(val)
- Returns the cosine of val. It can execute with no
current font.
- Cut
- Makes a copy of all selected glyphs and saves it in
the clipboard, then clears out the selected glyphs
|
D |
- DefaultATT(tag)
- DefaultOtherSubrs()
- Returns to using Adobe's versions of the OtherSubrs
subroutines. It can execute with no current font.
- DefaultRoundToGrid()
- Looks at all selected glyphs, if any reference is
not positioned by point matching, then FontForge will
set the truetype "ROUND-TO-GRID" flag for the
reference.
- DefaultUseMyMetrics()
- Looks at all selected glyphs. If any glyph contains
references, does not have the "USE-MY-METRICS" bit set
on any of those references, and if one of those
references has the same width as the current glyph, and
has an identity transformation matrix, then set the bit
on that reference.
- DetachAndRemoveGlyphs()
- Any selected encoding slots will have their glyph
pointer nulled out. In addition, if this glyph is now
unencoded it will remove the glyph from the font.
- DetachGlyphs()
- Any selected encoding slots will have their glyph
pointer nulled out. This does not remove the glyph from
the font, it just makes it unreachable through this
encoding slot.
- DontAutoHint()
- Mark any selected glyphs so that they will not be
AutoHinted when saving the font. (This flag is cleared
if the user explicitely AutoHints the glyph
himself).
- DrawsSomething([arg])
- Arg is as in InFont. This
returns true if the glyph contains any splines,
references or images.
|
E |
- Error(str)
- Prints out str as an error message and aborts the
current script. It can execute with no current
font.
- Exp(val)
- Returns eval. It can execute with no
current font.
- ExpandStroke(width)
ExpandStroke(width,line cap, line join)
ExpandStroke(width,line cap, line join,0,removeinternal
/external flag)
ExpandStroke(width,calligraphic-angle,height-numerator,height-denom)
ExpandStroke(width,calligraphic-angle,height-numerator,height-denom,
0, remove internal/external flag)
-
In the first format a line cap of "butt" and line
join of "round" are implied.
A value of 1 for remove internal/external will remove
the internal contour, a value of 2 will remove the
external contour.
The first three calls simulate the PostScript
"stroke" command, the two final simulate a
caligraphic pen.
- Width
- In the PostScript "stroke" command the width is
the distance between the two generated curves. To
be more precise, at ever point on the original
curve, a point will be added to each of the new
curves at width/2 units as measured on a vector
normal to the direction of the original curve at
that point.
In a caligraphic pen, the width is the width of the
pen used to draw the curve.
- Line-cap
- Can have one of three values: 0=> butt,
1=>round, 2=>square
- Line-join
- Can have one of three values: 0=>miter,
1=>round, 2=>bevel
- caligraphic-angle
- the (fixed) angle at which the pen is
held.
- height-numerator/denominator
- These two values specify a ratio between the
height and the width
height = numerator * width / denominator
(the scripting language only deals in integers, so
when fractions are needed this kludge is used)
- remove internal/external contour flags
- 1 => remove internal contour
2=> remove external contour
(you may not remove both contours)
4 => run remove overlap on result (buggy)
- Export(format[,bitmap-size])
-
For each selected glyph in the current font, this
command will export that glyph into a file in the
current directory. Format must be a string and must
end with one of
eps -- the selected glyphs will
have their splines output into eps files.
pdf -- the selected glyphs will
have their splines output into pdf files.
svg -- the selected glyphs will
have their splines output into svg files.
fig -- the selected glyphs will
have their splines converted (badly) into xfig
files.
xbm -- The second argument
specifies a bitmap font size, the selected glyphs
in that bitmap font will be output as xbm
files.
bmp -- The second argument
specifies a bitmap font size, the selected glyphs
in that bitmap font will be output as bmp
files.
png -- The second argument
specifies a bitmap font size, the selected glyphs
in that bitmap font will be output as png
files.
The format may consist entirely of the filetype
(extension, see above), or it may include a full
filename (with some format control within it) which
has the file type as an extension:
"Glyph %n from font %f.svg"
"U+%U.bmp"
If the format constists entirely of a filetype
then FontForge will use a format of
"%n_%f.<filetype>"
All characters in the format string except for %
are copied verbatim. If there is a % then the
following character controls behavior:
%n -- inserts the glyph name (or
the first 40 characters of it for long names)
%f -- inserts the font name (or
the first 40 characters)
%e -- inserts the glyph's encoding
as a decimal integer
%u -- inserts the glyph's unicode
code point in lower case hex
%U -- inserts the glyph's unicode
code point in upper case hex
%% -- inserts a single '%'
If you select one of the types that generate an
image (xbm, bmp, png) then you must specify a second
argument contain a bitmap-size. FontForge will search
the list of bitmap strikes in the font data base and
use the images in the matching strike. It will NOT
rasterize an image for you here. For bitmap strikes
just use the pixel size, for grey scale strikes use
the (depth of the grey scale<<16) +
pixel_size , in most cases the depth will be
8.
|
F |
- FileAccess(filename[,prot])
- Behaves like the unix access system call. Returns 0
if the file exists, -1 if it does not. If protection is
omitted, checks for read access. It can execute with no
current font.
- FindIntersections()
- Finds everywhere that splines cross and creates
points there.
- FindOrAddCvtIndex(value[,sign-matters])
- Returns the index in the cvt table of the given
value. If the value does not exist in the table it will
be added, and an index at the end of the table will be
returned. Most tt instructions ignore the sign of items
in the cvt table, but a few care. Usually this command
stores the absolute value of value, but if sign-matters
is present and non-zero a negative value can be looked
up (or added).
- Floor(real)
- Converts a real number to the largest integer
smaller than the real. It can execute with no current
font.
See Also Ceil, Int, Round
- FontImage(filename,array[,width[,height]])
- Produces a thumbnail image of the font and stores
it in the given filename. Images may be stored in
either png or bmp format (png requires that you have
libpng on your system). The array is a list of pairs of
[pointsize, utf8-string] each of which specifies a line
of text for the image. The width need not be specified,
if omitted (or specified as -1) the image will be just
wide enough to contain the longest string. The height
need not be specified, if omitted (or specified as -1)
it will be just long enough to contain all the
lines.
FontImage("FontImage.png",[17,"abcd",38,"ABCD"])
produces

- FontsInFile(filename)
- Returns an array of strings containing the names of
all fonts within a file. Most files contain one font,
but some (mac font suitcases, dfonts, ttc files, svg
files, etc) may contain several. If the file contains
no fonts (or the file doesn't exist, or the fonts
aren't named), a zero length array is returned. It does
not open the font. It can execute without a current
font.
|
G |
- Generate(filename[,bitmaptype[,fmflags[,res[,mult-sfd-file[,namelist-name]]]]])
-
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:
- bdf
- ttf (for EBDT/bdat table in
truetype/opentype)
- sbit (for bdat table in truetype without any
outline font in a dfont wrapper)
- bin (for nfnt in macbinary)
NOTE: Mac OS/X does not appear to support NFNT
bitmaps. However even though unused itself, an
NFNT bitmap must be present for a resource based
type1 postscript font to be used. (More
accurately the obsolete FOND must be present, and
that will only be present if an obsolete NFNT is
also present)
- fnt (For windows FNT format)
- otb (For X11 opentype bitmap format)
- pdb (for palm bitmap
fonts)
- pt3 (for a postscript type3 bitmap font)
- "" for no bitmaps
Note: If you request bitmap output then all
strikes in the current font database will be output,
but this command will not create bitmaps, so if there
are no strikes in your font database, no strikes will
be output (even if you ask for them). If you wish to
output bitmaps you must first create them with the
BitmapsAvail scripting
command or Element->Bitmaps
Avail.
fmflags controls
- -1 => default (generate an afm file for
postscript fonts, never generate a pfm file, full
'post' table, ttf hints)
- fmflags&1 => generate an afm file (if
you are generating a multiple master font then
setting this flag means you get several afm files
(one for each master design, and one for the
default version of the font) and an amfm file)
- fmflags&2 => generate a pfm file
- fmflags&4 => generate a short 'post'
table with no glyph name info in it.
- fmflags&8 => do not include ttf
instructions
- fmflags&0x10 => where apple and ms/adobe
differ about the format of a true/open type file,
use apple's definition (otherwise use
ms/adobe)
Currently this affects bitmaps stored in the font
(Apple calls the table 'bdat', ms/adobe 'EBDT'),
the PostScript name in the 'name' table (Apple says
it must occur exactly once, ms/adobe say at least
twice), and whether morx/feat/kern/opbd/prop/lcar
or GSUB/GPOS/GDEF tables are generated.
- fmflags&0x20 => generate a 'PfEd' table and store
glyph comments
- fmflags&0x40 => generate a 'PfEd' table and store
glyph colors
- fmflags&0x80 => generate tables so the
font will work on both Apple and MS
platforms.
Apple has screwed up and in Mac 10.4 (Tigger), if
OpenType tables are present in a font then the AAT
tables will be ignored -- or so I'm told (I can't
test this myself). Unfortunately Apple does not
implement all of OpenType, so the result is almost
certain to be wrong).
- If you want neither OpenType nor Apple tables
(just an old fashioned 'kern' table and nothing
else) then set both 0x80 and 0x10.
- fmflags&0x100 => generate a glyph map
file (GID=>glyph name, unicode map). The map
file will have extension ".g2n".
- fmflags&0x200 => generate a 'TeX ' table containing
(most) TeX font metrics information
- fmflags&0x400 => generate an ofm file
(for omega)
- fmflags&0x800 => generate an old style
'kern'ing table. Only meaningful if set with
OpenType (GPOS/GSUB) tables and without Apple
tables.
- fmflags&0x1000 =>
generate an old, broken, 'size' feature (if size
data be present). Deprecated.
- fmflags&0x2000 => use a symbol cmap
entry (same as .sym.ttf, except you can now specify
a filename ending in .ttf)
- fmflags&0x10000 => generate a tfm
file
- fmflags&0x40000 => do not do flex
hints
- fmflags&0x80000 => do not include
postscript hints
- fmflags&0x200000 => round postscript
coordinates
- fmflags&0x400000 => add composite (mark
to base) information to the afm file
- fmflags&0x800000 => store lookup and
lookup subtable names in the 'PfEd' table
- fmflags&0x1000000 => store guidelines in
the 'PfEd' table
- fmflags&0x2000000 => store the
background (and spiro) layers in the 'PfEd'
table
res controls the resolution of generated bdf
fonts. A value of -1 means fontforge will guess for
each strike.
If the filename contains a "%s" and has either a
".pf[ab]" 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 FontForge 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) from the fonts
(which must be loaded) in the
array-of-font-filenames. filename, bitmaptype,
fmflags are as in Generate.
#!/usr/local/bin/fontforge
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)
- GenerateFeatureFile(filename[,lookup-name])
- Generates an adobe feature file for the current
font. If a lookup name is specified, then only data for
that lookup will be output.
- GetAnchorPoints()
- Return an array of arrays, one sub-array for each
anchor point in the currently selected glyph. The
sub-arrays contain: the AnchorClass name, the type name
of the point (mark, base, ligature, basemark, entry,
exit), the x and y coordinates, and (for ligatures) the
ligature component index.
- GetCvtAt(index)
- Return the value in the cvt table at the given
index.
- GetEnv(str)
- Returns the value of the unix environment variable
named by str. It can execute with no current font.
- GetFontBoundingBox()
- Returns a 4 element array containing
[minimum-x-value, minimum-y-value, maximum-x-value,
maximum-y-value] of the entire font.
- GetLookupInfo(lookup-name)
- Returns an array whose entries are: [lookup-type,
lookup-flags, feature-script-lang-array] The lookup
type is a string as described in AddLookup, and the feature-script-lang
array is also described there.
- GetLookups(table-name)
- The table name is either "GPOS" or "GSUB". Returns
an array of all lookup names in that table.
- GetLookupSubtables(lookup-name)
- Returns an array of all subtable names in that
lookup.
- GetLookupOfSubtable(subtable-name)
- Returns the name of the lookup containing this
subtable.
- GetMaxpValue(field-name)
- Field name can be the same set of tag strings as
SetMaxpValue.
- GetOS2Value(field-name)
- The argument takes the same set of tag strings as
SetOS2Value.
VendorId returns a string, and
Panose returns an array. The others return
integers.
- GetPosSub(lookup-subtable-name)
GetPosSub(feature-tag,script,lang)
-
One glyph must be selected, this returns information
about GPOS/GSUB features attached to this glyph (It
will not return information about class based kerning
or contextual features -- nothing that applies to the
font as a whole -- just things relating to the
current glyph). The argument must be a
lookup-subtable name (or "*") and only information
about the current glyph in that subtable will be
returned, if the argument is "*" all subtable
information will be returned. If nothing matches a 0
length array will be returned.
Each sub-array contains the following
information
- The subtable name
- The type (As a string, One of
Position,
Pair, Substitution, AltSubs, MultSubs or
Ligature )
The remaining entries depend on the type.
- For Positions
- There will be 4 numbers indicating respectively
the contents of a GPOS value record
(dx,dy,d_horizontal_advance,d_vertical_advance)
- For Pairs
-
A string containing the name of the other glyph
in the pair
A list of 8 numbers indicating the contents of
two GPOS value records (the first four numbers
control the current glyph, the next four numbers
control the second glyph)
- For Substitutions
- A string containing the name of a glyph with
which the current glyph is to be replaced.
- For the others
- A set of glyph names, one for each
component.
Examples:
>Select("ffl")
>Print( GetPosSub("Latin ligatures",)
[[Latin Ligatures ,Ligature,f,f,l],
[Latin Ligatures ,Ligature,ff,l]]
>Select("T")
>Print( GetPosSub("*"))
[[Latin kerns ,Pair,u,0,0,-76,0,0,0,0,0],
[Latin kerns ,Pair,e,0,0,-92,0,0,0,0,0],
[Latin kerns ,Pair,a,0,0,-92,0,0,0,0,0],
[Latin kerns ,Pair,o,0,0,-76,0,0,0,0,0]]
>Select("onehalf")
>Print( GetPosSub("Fractions"))
[[Fractions ,Ligature,one,slash,two],
[Fractions ,Ligature,one,fraction,two]]
- 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. Encodings
(NewCharset) are returned as magic numbers, these are
meaningless outside the context of get/set Pref. It can
execute with no current font.
- GetPrivateEntry(key)
- Returns the entry indexed by key in the private
dictionary. All return values will be strings. If an
entry does not exist a null string is returned.
- GetTeXParam(index)
- If index == -1 then the tex font type will be
returned (text==0, math==1, math extended=2)
Else index is used to index into the font's tex params
array.
- GetSubtableOfAnchor(anchor-class-name)
- Returns the name of the lookup subtable containing
this anchor class.
- GetTTFName(lang,nameid)
- The lang and nameid arguments are as in SetTTFName. This returns the current
value as a utf8 encoded string. Combinations which are
not present will be returned as "".
- GlyphInfo(str)
GlyphInfo("Kern",glyph-spec)
GlyphInfo("VKern",glyph-spec)
GlyphInfo(str,script,lang,tag)
GlyphInfo(str,position)
-
There must be exactly one glyph selected in the font,
and this returns information on it. The information
returned depends on str with the obvious meanings:
- "Name" returns the glyph's name
- "Unicode" returns the glyph's unicode
encoding
- "Encoding" returns the glyph's encoding in the
current font
- "Width" returns the glyph's width
- "VWidth" returns the glyph's Vertical
width
- "TeXHeight" returns the tex_height field (a
value of 0x7fff indicates that a default value will
be used)
- "TeXDepth" returns the tex_depth field (a value
of 0x7fff indicates that a default value will be
used)
- "TeXSubPos" returns the tex_sub_pos field (a
value of 0x7fff indicates that a default value will
be used)
- "TeXSuperPos" returns the tex_super_pos field
(a value of 0x7fff indicates that a default value
will be used)
- "LBearing" returns the glyph's left side
bearing
- "RBearing" returns the glyph's right side
bearing
- "BBox" returns a 4 element array containing
[minimum-x-value, minimum-y-value, maximum-x-value,
maximum-y-value] of the glyph.
- "ValidationState" returns a bitmask of the
glyph's validation state. (See the ff python docs
for the bit break down)
- "Kern" (there must be a second argument here
which specifies another glyph as in Select())
Returns the kern offset between the two glyphs (or
0 if none).
- "VKern" (there must be a second argument here
which specifies another glyph as in Select())
Returns the vertical kern offset between the two
glyphs (or 0 if none).
- "Xextrema" (there must be a second argument
here which specifies the vertical position) Returns
a two element array containing the minimum and
maximum horizontal positions on the contours of the
glyph at the given vertical position. If the
position is beyond the glyph's bounding box the
minimum value will be set to 1 and the max to 0
(ie. max<min which is impossible).
- "Yextrema" (there must be a second argument
here which specifies the horizontal position)
Returns a two element array containing the minimum
and maximum vertical positions on the contours of
the glyph at the given horizontal position. If the
position is beyond the glyph's bounding box the
minimum value will be set to 1 and the max to 0
(ie. max<min which is impossible).
- "Color" returns the glyph's color as a 24bit
rgb value (or -2 if no color has been assigned to
the glyph).
- "Comment" returns the glyph's comment (it will
be converted from unicode into the default
encoding).
- "Changed" returns whether the glyph has been
changed since the last save or load.
- "DontAutoHint" returns the status of the "Don't
AutoHint" flag.
- "Position" takes three additional arguments, a
script, a language and a tag (all 4 character
strings) and returns whether the glyph has a
Position alternate with that tag.
- "Pair" takes three additional
arguments, a script, a language and a tag (all 4
character strings) and returns whether the glyph
has a Pairwise positioning alternate with that
tag.
- "Substitution" takes three
additional arguments, a script, a language and a
tag (all 4 character strings) and returns the name
of the Simple Substitution alternate with that tag
(or a null string if there is none).
- "AltSubs" takes three
additional arguments, a script, a language and a
tag (all 4 character strings) and returns a space
separated list of the names of all alternate
substitutions with that tag (or a null string if
there is none).
- "MultSubs" takes three
additional arguments, a script, a language and a
tag (all 4 character strings) and returns a space
separated list of all the names of all glyphs this
glyph gets decomposed into with that tag (or a null
string if there is none).
- "Ligature" takes three
additional arguments, a script, a language and a
tag (all 4 character strings) and returns a space
separated list of the names of all components with
that tag (or a null string if there is
none).
(See GetPosSub for
these)
- "GlyphIndex" returns the index of the current
glyph in the ttf 'glyf' table, or -1 if it has been
created since. This value may change when a
truetype/opentype font is generated (to the index
in the generated font).
- "PointCount" returns the number of points in
the glyph (this means different things in different
modes).
- "LayerCount" returns the number of layers in
the glyph. This will always be 2 (foreground &
background) except in the case of a multilayered
font.
- "RefCount" returns the number of references in
the glyph
- "RefNames" returns an array containing the
names of all glyphs refered to. This may contain 0
elements. This may contain a glyph twice ("colon"
might refer twice to period)
- "RefTransform" returns an array of arrays. The
bottom most arrays are 6 element (real)
transformation matrices which are applied to their
respective glyphs.
- "XProfile" takes an integer as its second
argument and returns an array of intersection
points between the foreground layer and a line
y=<the second argument>. The array is
sorted.
- "YProfile" takes an integer as its second
argument and returns an array of intersection
points between the foreground layer and a line
x=<the second argument>. The array is
sorted.
Examples:
Select("A")
lbearing = GlyphInfo("LBearing")
Select(0u410)
SetLBearing(lbearing)
|
H |
- HasPreservedTable(tag)
- Returns true if the font contains a preserved table
with the given tag.
- HasPrivateEntry(key)
- Returns whether key exists in the private
dictionary.
- HFlip([about-x])
- All selected glyphs will be horizontally flipped
about the vertical line through x=about-x. If no
argument is given then all selected glyphs will be
flipped about their central point.
|
I |
- Import(filename[,toback[,flags]])
-
Either imports a bitmap font into the database, or
imports background image[s] into various glyphs.
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 proceeds.
- If the extension is ".bdf" then a bdf font will
be imported
- If the extension is ".pcf" then a pcf font will
be imported.
- If the extension is ".ttf" then the EBDT or
bdat table of the ttf file will be searched for
bitmap fonts
- If the extension is "pk" then a metafont pk
(bitmap font) file will be import and by default
placed in the background
- Otherwise if the extension is an image
extension, and any loaded images will be placed in
the background.
- If the filename contains a "*" then it
should be a recognized template in which case
all images which match that template will be
loaded appropriately and stored in the
background
- Otherwise there may be several filenames
(separated by semicolons), the first will be
placed in the background of the first selected
glyph, the second into the background of the
second selected glyph, ...
- If the extension is "eps" then an encapsulated
postscript file will be merged into the foreground.
The file may be specified as for images (except the
extension should be "eps" rather than an image
extension). FontForge is limited in its ability to
read eps files.
- If the extension is "svg" then an svg file will
be read into the foreground.
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
glyphs (1). For eps and svg files this argument
controls whether the splines are added to the
foreground or the background layer of the glyph.
If there is a third argument it must also be an
integer and provides a set of flags controling the
behavior of importing an EPS (and in one case SVG
too) file.
- 16 => remove anything currently present
(works for SVG & EPS)
- 8 => correct direction
- 4 => attempt to handle TeX erasers (stroking
with a white pen)
- 2 => remove overlap
- 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 glyphs in the font. Otherwise if the argument is a
unicode code point or a postscript glyph name, true is
returned if that glyph is in the font.
- Inline(width,gap)
- Produces an outline as in Outline, and then shrinks the glyph so
that it fits inside the outline. In other words, it
produces an inlined glyph.
- Int(real)
- Uses standard C conversion from real to integer. It
can execute with no current font.
See Also Ceil, Round, Floor
- InterpolateFonts(percentage,other-font-name[,flags])
- Interpolates a font which is percentage of the way
from the current font to the one specified by
other-font-name (note: percentage may be negative or
more than 100, in which case we extrapolate a font).
This command changes the current font to be the new
font. NOTE: You
will need to set the fontname of this new font. The
flag argument is the same as for Open.
- IsAlNum(val)
- Returns whether val is an alpha-numberic character.
Val may be either an integer, a unicode or a string.
The first two cases are treated as unicode code points,
the third looks at the first (utf8) character in the
string. It can execute with no current font.
- IsAlpha(val)
- Returns whether val is an alphabetic character. Val
may be either an integer, a unicode or a string. The
first two cases are treated as unicode code points, the
third looks at the first (utf8) character in the
string. It can execute with no current font.
- IsDigit(val)
- Returns whether val is a digit. Val may be either
an integer, a unicode or a string. The first two cases
are treated as unicode code points, the third looks at
the first (utf8) character in the string. It can
execute with no current font.
- IsFinite(real)
- Returns whether the value is finite (not infinite
and not a nan). It can execute with no current
font.
- IsHexDigit(val)
- Returns whether val is a hex-digit. Val may be
either an integer, a unicode or a string. The first two
cases are treated as unicode code points, the third
looks at the first (utf8) character in the string. It
can execute with no current font.
- IsLower(val)
- Returns whether val is a lower case letter. Val may
be either an integer, a unicode or a string. The first
two cases are treated as unicode code points, the third
looks at the first (utf8) character in the string. It
can execute with no current font.
- IsNan(real)
- Returns whether the value is a nan. It can execute
with no current font.
- IsUpper(val)
- Returns whether val is an upper case letter. Val
may be either an integer, a unicode or a string. The
first two cases are treated as unicode code points, the
third looks at the first (utf8) character in the
string. It can execute with no current font.
|
J |
- Join([fudge])
- Joins open paths in selected glyphs. If fudge is
specified then the endpoints only need to be within
fudge em-units of each other to be merged.
|
K |
|
L |
- LoadEncodingFile(filename[,encname])
- Reads an encoding file and stores it in FontForge's
list of possible encodings. See Encoding->LoadEncoding for more
info. When loading encodings in Unicode consortium
format, an encname has to be specefied or the encoding
will be ignored.
- LoadNamelist(filename)
- Will load the namelist stored in the given file. It
can execute with no current font.
- LoadNamelistDir([directory-name])
- Searches the given directory for things that look
like fontforge namelists and loads them. If directory
is omitted then it will load the default directory. It
can execute with no current font.
- LoadPlugin()
- Deprecated, plugins support have been removed.
- LoadPluginDir()
- Deprecated, plugins support have been removed.
- LoadPrefs()
- Loads the user's preferences. This used to happen
automatically at startup. Now it happens automatically
when the UI is started, but scripts must request. It
can execute with no current font. it.
- LoadStringFromFile("filename")
- Reads the entire file into a string. Returns a null
string for a non-existant or empty file. The returned
string will have enough bytes allocated to hold the
entire file plus one trailing NUL byte. If the file
contains a NUL itself, fontforge will think the string
ends there. It can execute with no current font.
- LoadTableFromFile(tag,filename)
- Both arguments should be strings, the first should
be a 4 letter table tag. The file will be read and
preserved in the font as the contents of the table with
the specified tag. Don't use a tag that ff thinks it
understands!
- Log(val)
- Returns the natural log of val. It can execute with
no current font.
- LookupStoreLigatureInAfm(lookup-name,store-it)
- Sets whether the data in this ligature lookup
should be stored in an afm file.
- LookupSetFeatureList(lookup-name,feature-script-lang-array)
- Sets the feature list of indicated lookup. The
feature-script-lang array is described at AddLookup.
|
M |
- MergeFonts(other-font-name[,flags])
- Loads other-font-name, and extracts any glyphs 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 license to use a font with
fstype=2.
- MergeFeature(filename)
- Loads Feature and lookup info out of a feature file
or kerning info from either an afm or a tfm file and
merges it into the current font.
- MergeKern(filename)
- Deprecated name for MergeFeature.
- MergeLookups(lookup-name1,lookup-name2)
- The lookups must be of the same type. All subtables
from lookup-name2 will be moved to lookup-name1, the
features list of lookup-name2 will be merged with that
of lookup-name1, and lookup-name2 will be removed.
- MergeLookupSubtables(subtable-name1,subtable-name2)
- The subtables must be in the same lookup. Not all
lookup types allow their subtables to be merged
(contextual subtables may not be merged, kerning
classes may not be (kerning pairs may be)). Any
information bound to subtable2 will be bound to
subtable1 and subtable2 will be removed.
- MMAxisBounds(axis)
-
Axis is an integer less than the number of axes in
the mm font. Returns an array containing the lower
bound, default value and upper bound. Note each value
is multiplied by 65536 (because they need not be
integers on the mac, and ff doesn't support real
values).
(The default value is a GX Var concept. FF
simulates a reasonable value for true multiple master
fonts).
- MMAxisNames()
- Returns an array containing the names of all axes
in a multi master set.
- MMBlendToNewFont(weights)
- Weights is an array of integers, one for each axis.
Each value should be 65536 times the desired value (to
deal with mac blends which tend to be small real
numbers). This command creates a completely new font by
blending the mm font and sets the current font to the
new font.
- MMChangeInstance(instance)
- Where instance is either a font name or a small
integer. If passed a string FontForge searches through
all fonts in the multi master font set (instance fonts
and the weighted font) and changes the current font to
the indicated one. If passed a small integer, then -1
indicates the weighted font and values between
[0,$mmcount) represent that specific instance in the
font set.
- MMChangeWeight(weights)
- Weights is an array of integers, one for each axis.
Each value should be 65536 times the desired value (to
deal with mac blends which tend to be small real
numbers). This command changes the current multiple
master font to have a different default weight, and
sets that to be the current instance.
- MMInstanceNames()
- Returns an array containing the names of all
instance fonts in a multi master set.
- MMWeightedName()
- Returns the name of the weighted font in a multi
master set.
- Move(delta-x,delta-y)
- All selected glyphs will have their points moved
the given amount.
- MoveReference(delta-x,delta-y,[refname/ref-unicode]+)
-
References may be identified either by a string
containing the name of the glyph being refered to, or
an integer containing the unicode code point of the
glyph being refered to, there may be an arbitrary
(positive) number of references specified. Each
selected glyph will be searched for references that
match the name/unicode-values given, all references
found will be moved by the specified offsets.
MoveReference(300,0,"acute",0xb4)
Will move any acute or grave references 300
em-units horizontally from where they currently
are
- MultipleEncodingsToReferences()
-
If any selected glyphs have multiple encodings then
one of these encodings will be chosen as the real
one. For each of the others a new glyph will be
created containing a reference to the base glyph.
This sort of undoes the effect of SameGlyphAs.
MetaData, such as advanced typographic features,
are not copied.
|
N |
- NearlyHvCps([error[,err-denom]])
-
Checks for control points which are almost, but not
quite horzontal or vertical (where almost means (say)
that
abs( (control point).x - point.x ) <
error , where error is either:
.1 |
if no arguments are given |
first-arg |
if one argument is given |
first-arg/second-arg |
if two arguments are given |
- NearlyHvLines([error[,err-denom]])
-
Checks for lines which are almost, but not quite
horzontal or vertical (where almost means (say) that
abs( (end point).x - (start point).x ) <
error , where error is either:
.1 |
if no arguments are given |
first-arg |
if one argument is given |
first-arg/second-arg |
if two arguments are given |
- NearlyLines(error)
- Checks for splines that are nearly linear, and
makes them so. A spline is nearly linear if the maximum
deviation of the spline from the line between the
spline's endpoints is less than error.
- NameFromUnicode(uni[,namelist])
- Returns a glyph name given a unicode code point. If
a namelist is specified then the name will come from
it. It can execute with no current font.
- New()
- This creates a new font. It can execute with no
current font.
- NonLinearTransform(x-expression,y-expression)
-
Takes two string arguments which must contain valid
expressions of x and y and transforms all selected
glyphs using those expressions.
<e0> := "x" | "y" | "-" <e0> | "!" <e0> | "(" <expr> ")" |
"sin" "(" <expr> ")" | "cos" "(" <expr> ")" | "tan" "(" <expr> ")" |
"log" "(" <expr> ")" | "exp" "(" <expr> ")" | "sqrt" "(" <expr> ")" |
"abs" "(" <expr> ")" |
"rint" "(" <expr> ")" | "float" "(" <expr> ")" | "ceil" "(" <expr> ")"
<e1> := <e0> "^" <e1>
<e2> := <e1> "*" <e2> | <e1> "/" <e2> | <e1> "%" <e2>
<e3> := <e2> "+" <e3> | <e2> "-" <e3>
<e4> := <e3> "==" <e4> | <e3> "!=" <e4> |
<e3> ">=" <e4> | <e3> ">" <e4> |
<e3> "<=" <e4> | <e3> "<" <e4>
<e5> := <e4> "&&" <e5> | <e4> "||" <e5>
<expr> := <e5> "?" <expr> ":"
Example: To do a perspective transformation with a
vanishing point at (200,300):
NonLinearTrans("200+(x-200)*abs(y-300)/300","y")
This command is not available in the default
build, you must modify the file
configure-fontforge.h and then rebuild
FontForge.
|
O |
- 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 without a
current font.
When loading from a ttc file (mac suitcase, dfont,
svg, etc), a particular font may be selected by
placing the fontname in parens and appending it to
the filename, as
Open("gulim.ttc(Dotum)") . If you know
the font's index you may also say:
Open("gulim.ttc(0)") .
The optional flags argument current has only two
flags in it:
- 1 => the user does have the appropriate
license to examine the font no matter what the
fstype setting is.
- 4 => load all glyphs from the 'glyf' table
of a ttc font (rather than only the glyphs used in
the font picked).
- Ord(string[,pos])
- Returns an array of integers representing the bytes
in the string. If pos is given it should be an integer
less than the string length and the function will
return the integer representing that byte in the
string. It can execute with no current font.
- Outline(width)
- Strokes all selected glyphs with a stroke of the
specified width (internal to the glyphs). The bounding
box of the glyph will not change. In other words it
produces what the mac calls the "Outline Style".
- OverlapIntersect()
- Removes everything but the intersection.
|
P |
- Paste Into
- Copies the clipboard into the current font (merging
with what was there before)
- Paste
- Copies the clipboard into the selected glyphs of
the current font (removing what was there before)
- PasteWithOffset(xoff,yoff)
- Translates the clipboard by xoff,yoff before doing
a PasteInto(). Can be used to build accented
glyphs.
- PositionReference(x,y,[refname/ref-unicode]+)
-
References may be identified either by a string
containing the name of the glyph being refered to, or
an integer containing the unicode code point of the
glyph being refered to, there may be an arbitrary
(positive) number of references specified. Each
selected glyph will be searched for references that
match the name/unicode-values given, all references
found will be at the specified location.
PositionReference(0,0,"circumflex")
Will position any references to circumflex so
that they are where the base circumflex is
- PostNotice(str)
- When run from the UI will put up a window
displaying the string (the window will not block the
program and will disappear after a minute or so). When
run from the command line will write the string to
stderr. It can execute with no current font.
- Pow(val1,val2)
- Returns val1val2. It can execute with no
current font.
-
PreloadCidmap(filename,registry,ordering,supplement)
- Loads a user defined cidmap file for the specified
ROS. All arguments except the last should be strings
while supplement should be an integer. This can execute
without a font loaded.
- 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.
- PrintFont(type[,pointsize[,sample-text/filename[,output-file]]])
-
Prints the current font according to the PrintSetup. The values for type are
(meanings are described in the section on printing):
- 0 => Prints a full font display at the given
pointsize
- 1 => Prints selected glyphs to fill
page
- 2 => Prints selected glyphs at multiple
pointsizes
- 3 => Prints a text sample read from a file
at the given pointsize(s)
- 4 => Prints a text sample, except that
instead of treating the third argument as a file
name it represents the sample itself (in utf-8
encoding)
The pointsize is either a single integer or an
array of integers. It is only meaningful for types 0,
3 and 4. 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 FontForge to
use a default value.
If your PrintSetup specified printing to a file
(either PostScript or pdf) then the fourth argument
provides the filename of the output file.
- PrintSetup(type,[printer[,width,height]])
-
Allows you to configure the print command. Type may
be a value between 0 and 4
- 0 => print with lp
- 1 => print with lpr
- 2 => output to ghostview
- 3 => output to PostScript file
- 4 => other printing command
- 5 => output to a pdf file
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 1/72
inches (almost points), so 8.5x11" paper is 612,792
and A4 paper is (about) 595,842.
- PrivateGuess(key)
- key should be a string containing the name of a
standard thing in the PS Private dictionary that
fontforge can guess a value for. "BlueValues" for
example.
|
Q |
- Quit(status)
- Causes FontForge to exit with the given status (no
attempt is made to save unsaved files). This command
can execute with no current font.
|
R |
- Rand()
- returns a random integer. It can execute with no
current font.
- ReadOtherSubrsFile(filename)
-
Reads new PostScript subroutines to be used in the
OtherSubrs array of a type1 font. The file format is
a little more complicated than it should be (because
I can't figure out how to parse the OtherSubrs array
into individual subroutines).
- The subroutine list should not be enclosed in a
[ ] pair
- Each subroutine should be preceded by a line
starting with '%%%%' (there may be more stuff after
that)
- Subroutines should come in the obvious order,
and must have the expected meaning.
- If you don't wish to support flex hints set the
first three subroutines to "{}"
- You may specify at most 14 subroutines
(0-13)
- Any text before the first subroutine will be
treated as a copyright notice.
% Copyright (c) 1987-1990 Adobe Systems Incorporated.
% All Rights Reserved
% This code to be used for Flex and Hint Replacement
% Version 1.1
%%%%%%
{systemdict /internaldict known
1183615869 systemdict /internaldict get exec
...
%%%%%%
{gsave currentpoint newpath moveto} executeonly
%%%%%%
{currentpoint grestore gsave currentpoint newpath moveto} executeonly
%%%%%%
{systemdict /internaldict known not
{pop 3}
...
It can execute with no current font.
- Real(int)
- Converts an integer to a real number. It can
execute with no current font.
- Reencode(encoding-name[,force])
- Reencodes the current font into the given encoding
which may be:
compacted,original,
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,
isothai, iso8859-13, iso8859-14, iso8859-15, latin0,
koi8-r, jis201, jisx0201, AdobeStandardEncoding, win,
mac, symbol, wansung, big5, johab, jis208, jisx0208,
jis212, jisx0212, sjis, gh2312, gb2312packed, unicode,
iso10646-1, unicode4, TeX-Base-Encoding, one of the
user defined encodings.
You may also specify that you want to force the
encoding to be the given one.
Note: some encodings are specified by glyph names (ie.
user defined encodings specified as postscript encoding
arrays) others are specified as lists of unicode code
points (most built in encodings except for
AdobeStandard and TeX, user defined encodings specified
by codepoints). If you reencode to an encoding defined
by glyph names, then ff will first move glyphs to the
appropriate slots, and then force any glyphs with the
wrong name to have the correct one. The most obvious
example of this is the fi ligature: AdobeStandard says
it should be named "fi", modern fonts tend to call it
"f_i". Reencoding to AdobeStandard will move this glyph
to the right slot, and then name it "fi".
- RemoveAllKerns()
- Removes all kern pairs and classes from the current
font.
- RemoveAllVKerns()
- Removes all vertical kern pairs and classes from
the current font.
- RemoveAnchorClass(name)
- Removes the named AnchorClass (and all associated
points) from the font.
- RemoveATT(type,script-lang,tag)
- See RemoveLookupSubtable or
RemovePosSub
- RemoveLookup(lookup-name)
- Remove the lookup (and any subtables within
it).
- RemoveLookupSubtable(subtable-name)
- Remove the subtable.
- RemovePosSub(subtable-name)
- Remove any positionings or substitutions from the
selected glyphs that are controlled by the named
subtable. If the subtable name is "*" then all are
removed.
- RemoveDetachedGlyphs()
- If this font contains any glyphs which do not have
an encoding slot then those glyphs will be removed from
the font. In other words any glyph not displayed in the
fontview will be removed.
- RemoveOverlap()
- Does the obvious.
- RemovePreservedTable(tag)
- Searches for a preserved table with the given tag,
and removes it from the font.
- RenameGlyphs(namelist-name)
- Renames all the glyphs in the current font
according to the namelist.
- ReplaceCharCounterMasks(array)
- Deprecated name for ReplaceGlyphCounterMasks
- ReplaceGlyphCounterMasks(array)
- This requires that there be exactly one glyph
selected. It will create a set of counter masks for
that glyph. The single argument must be an array of
twelve element arrays of integers (in c this would be
"int array[][12]"). This is the format of a type2
counter mask. The number of elements in the top level
array is the number of counter groups to be specified.
The nested array thus corresponds to a counter mask,
and is treated as an array of bytes. Each bit in the
byte specifies whether the corresponding hint is active
in this counter. (there are at most 96 hints, so at
most 12 bytes). Array[i][0]&0x80 corresponds to the
first horizontal stem hint, Array[i][0]&0x40
corresponds to the second, Array[i][1]&0x80
corresponds to the eighth hint, etc.
- ReplaceCvtAt(index,value)
- Change the cvt table at the given index to have the
new value.
- ReplaceWithReference([fudge])
-
Finds any glyph which contains an inline copy of one
of the selected glyphs, and converts that copy into a
reference to the appropriate glyph. Selection is
changed to the set of glyphs which the command
alters.
If specified the fudge argument specifies the
error allowed for coordinate differences. The fudge
argument may be either a real number or two integers
where the first specifies the numerator and the
second the denominator of the fudge (=arg1/arg2).
Left over from the days when ff did not support real
numbers.
- Revert()
- Reverts the current font to the last version.
- RevertToBackup()
- Reverts the current font to a backup sfd file (if
any)
- Rotate(angle[,ox,oy])
- Rotates all selected glyph the specified number of
degrees. If the last two args are specified they
provide the origin of the rotation, otherwise the
center of the glyph is used.
- Round(real)
- Converts a real number to an integer by rounding to
the nearest integer. It can execute with no current
font.
See Also Ceil, Int, Floor
- RoundToCluster([within[,max]])
-
The first two provide a fraction that indicates a
value within which similar coordinates will be
bundled together. Max indicates how many "within"s
from the center point it will go if there are a chain
of points each within "within" of the previous one.
So
RoundToCluster(.1,.5)
Will merge coordinates within .1 em-unit of each
other. A sequence like
-.1,-.05,0,.05,.1,.15 will all be merged
together because each is within .1 of the next, and
none is more than .5 from the center.
- RoundToInt([factor])
- Rounds all points/hints/reference-offsets to be
integers. If the "factor" argument is specified then it
rounds like
rint(factor * x) / factor , in
other words if you set factor to 100 then it will round
to hundredths.
|
S |
- SameGlyphAs
-
If the clipboard contains a reference to a single
glyph then this makes all selected glyphs refer to
that one.
Adobe suggests that you avoid this. Use a
reference instead. In some situations (I think pdf
files is one) having one glyph with several encodings
causes problems (Acrobat uses the glyph to back-map
through the encoding to work out the unicode code
point. But that will fail if a glyph has two unicode
code points associated with it).
- 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.
If the filename has an extension ".sfdir" then the font
will be saved into a SplineFont Directory.
- SavePrefs()
- Save the current state of preferences. This used to
happen when SetPref was called, now a script must
request it explicitly. It can execute with no current
font.
- SaveTableToFile(tag,filename)
- Both arguments should be strings, the first should
be a 4 letter table tag. The list of preserved tables
will be searched for a table with the given tag, and
saved to the file.
- Scale(factor[,yfactor][,ox,oy])
-
All selected glyphs will be scaled (scale factors are
in percent)
- with one argument they will be scaled uniformly
about the glyph's center point
- with two arguments the first specifies the
scale factor for x, the second for y. Again scaling
will be about the center point
- with three arguments they will be scaled
uniformly about the specified center
- with four arguments they will be scaled
differently about the specified center
- ScaleToEm(em-size)
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.
- Select(arg1, arg2,
...)
-
This clears out the current selection, then for each
pair of arguments it selects all glyphs between
(inclusive) the bounds specified by the pair. If
there is a final singleton argument then that single
glyph will be selected. An argument may be specified
by:
- an integer which specifies the location in the
current font's encoding
- a postscript unicode name which gets mapped
into the current font's encoding
- a unicode code point (0u61) which gets mapped
to the current font's encoding
- If Select is given exactly one argument and
that argument is an array then the selection will
be set to that specified in the array. So array[0]
would set the selection of the glyph at encoding 0
and so forth. The array may have a different number
of elements from that number of glyphs in the font
but should otherwise be in the same format as that
returned by the $selection psuedo-variable.
- SelectAll
- Selects all glyphs
- SelectAllInstancesOf(name1[,...])
- A glyph may be mapped to more than one encoding
slot. This will select all encoding slots which refer
to the named glyph(s). The name may be either a string
containing a glyph name, or a unicode code point.
- SelectBitmap(size)
- In a bitmap only font this selects which bitmap
strike will be used for units in the following metrics
commands. If no bitmap is selected, then the units
should be in em-units, otherwise units will be in
pixels of the given bitmap strike. The size should be
the pixelsize of the font. If you use anti-aliased
fonts then size should be set to
(depth<<16)|pixel_size. A value of -1 for size
deselects all bitmaps (units become em-units).
- SelectByATT(type,tags,contents,search-type)
- See SelectByPosSub
- SelectByPosSub(lookup-subtable-name,search_type)
-
Selects all glyphs affected by the lookup
subtable.
And for search_type
- Select Results
- Merge Selection
- Restrict Selection
- SelectChanged([merge])
- Selects all changed glyphs. If merge is true, will
or the current selection with the new one.
- SelectFewer(arg1, arg2, ...)
- The same as in Select except
that it clears the selection on the indicated glyphs,
so it reduces the current selection.
- SelectFewerSingletons(arg1,
...)
- Same as SelectSingletons
except it removes single glyphs from the current
selection.
- SelectGlyphsBoth()
- Selects glyphs with both references and
contours.
- SelectHintingNeeded([merge])
- Selects all glyphs which FontForge thinks need
their hints updated.
- SelectIf(arg1,arg2, ...)
-
The same as Select() except that instead of
signalling an error when a glyph is not in the font
it returns an error code.
- 0 => there were no errors but no glyphs were
selected
- <a positive number> => there were no
errors and this many glyphs were selected
- -2 => there was an error and no glyphs were
selected
- -1 => there was an error and at least one
glyph was selected before that.
- SelectInvert()
- Inverts the selection.
- SelectMore(arg1, arg2, ...)
- The same as in Select except
that it does not clear the selection initially, so it
extends the current selection.
- SelectMoreIf(arg1, arg2, ...)
- The same as in SelectMore
except that it returns an error code if one of the
glyph(s) does not exist.
- SelectMoreSingletons(arg1,
...)
- Same as SelectSingletons
except it adds single glyphs from the current
selection.
- SelectMoreSingletonsIf(arg1,
...)
- Same as SelectMoreSingletons
except it returns an error code if one of the glyph(s)
does not exist.
- SelectNone()
- Deselects all glyphs
- SelectSingletons(arg1, ...)
- Selects its arguments without looking for
ranges.
- SelectSingletonsIf(arg1,
...)
- Selects its arguments without looking for ranges,
and returns an error code if a gyph did not exist.
- SelectWorthOutputting()
- Selects all glyphs WorthOutputting
- SetCharCnt(cnt)
- Sets the number of encoding slots in the font.
- SetCharColor(color)
- Deprecated name for SetGlyphColor
- etCharComment(comment)
- Deprecated name for SetGlyphComment
- SetCharCounterMask(cg,hint-index,hint-index,...)
- Deprecated name for SetGlyphCounterMask
- SetCharName(name[,set-from-name-flag])
- Deprecated name for SetGlyphName
- SetGasp([ppem,flag[,ppem2,flag[,...]]])
-
With no arguments gives the font an empty gasp
table.
With an even number of integer arguments it sets the
gasp table to the given pixel size/flag value pairs.
These must be ordered by pixel size (smallest first)
and must end with an entry for pixel size
65535.
With exactly one argument it must be an array
containing an ordered list of pixel size/flag value
pairs (as above).
SetGasp(8,2,16,1,65535,3)
SetGasp([8,2,16,1,65535,3])
A flag value of 0 means neither grid-fit nor
anti-alias
A flag value of 1 means grid-fit but no
anti-alias.
A flag value of 2 means no grid-fit but
anti-alias.
A flag value of 3 means both grid-fit and
anti-alias.
On other values are currently documented.
- SetGlyphColor(color)
- Sets any currently selected glyphs to have the
given color (expressed as 24 bit rgb (0xff0000 is red)
with the special value of -2 meaning the default
color.
- etGlyphComment(comment)
- Sets the currently selected glyph to have the given
comment. The comment is converted via the current
encoding to unicode.
- SetGlyphCounterMask(cg,hint-index,hint-index,...)
- Creates or sets the counter mask at index cg to
contain the hints listed. Hint index 0 corresponds to
the first hstem hint, index 1 to the second hstem hint,
etc. vstem hints follow hstems.
- SetGlyphName(name[,set-from-name-flag])
- Sets the currently selected glyph 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.
- SetFondName(fondname)
- Sets the FOND name of the font.
- SetFontHasVerticalMetrics(flag)
- Sets whether the font has vertical metrics or not.
A 0 value means it does not, any other value means it
does. Returns the old setting.
- SetFontNames(fontname[,family[,fullname[,weight[,copyright-notice[,fontversion]]]]])
- Sets various postscript names associated with a
font. If a name is omitted (or is the empty string) it
will not be changed.
- SetFontOrder(order)
- Sets the font's order. Order must be either 2
(quadratic) or 3 (cubic). It returns the old
order.
- SetGlyphChanged(flag)
- If flag is 1 sets all selected glyphs to be
changed, if flag is 0 sets them unchanged.
- SetGlyphClass(class-name)
- Sets the class on all selected glyphs to be one of
"automatic", "none", "base", "ligature", "mark" or
"component".
- SetGlyphTeX(height,depth[,subpos,suppos])
- Sets the tex_height and tex_depth fields of this
glyph. And the subscript pos and superscript pos for
math fonts.
- 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.
- SetKern(ch2,offset[,lookup-subtable-name])
- Sets the kern between any selected glyphs and the
glyph ch2 to be offset. The first argument may be
specified as in Select(), the second is an integer
representing the kern offset. You can also specify a
lookup-subtable-name in which to put the kerning
pair.
- SetLBearing(lbearing[,relative])
- If the second argument is absent or zero then the
left bearing will be set to the first argument, if the
second argument is 1 then the left bearing will be
incremented by the first, and if the argument is 2 then
the left bearing will be scaled by <first
argument>/100.0 . In bitmap only fonts see the
comment at SelectBitmap
about units.
- SetMacStyle(val)
SetMacStyle(str)
-
The argument may be either an integer or a string. If
an integer it is a set of bits expressing styles as
defined on the mac
0x01 |
Bold |
0x02 |
Italic |
0x04 |
Underline |
0x08 |
Outline |
0x10 |
Shadow |
0x20 |
Condensed |
0x40 |
Extended |
-1 |
FontForge should guess the styles from the
fontname |
The bits 0x20 and 0x40 (condensed and extended)
may not both be set.
If the argument is a string then the string should
be the concatenation of various style names, as "Bold
Italic Condensed"
- SetMaxpValue(field-name,value)
- The field-name must be a string and one of:
Zones, TwilightPntCnt, StorageCnt, MaxStackDepth,
FDEFs, or IDEFs . Value must be an
integer.
- SetOS2Value(field-name,field-value)
-
This sets one of the fields of the OS/2 table to the
given value. The field-name must be one of the
strings listed below:
Weight, Width, FSType, IBMFamily, VendorID,
Panose,
WinAscent, WinAscentIsOffset
These are equivalent to the WinAscent field &
[]Offset check box in Font
Info->OS/2->Misc. Where WinAscentOffset
controls whether WinAscent is treated as an absolute
number or as relative to the expected number.
WinDescent, WinDescentIsOffset,
TypoAscent, TypoAscentIsOffset,
TypoDescent, TypoDescentIsOffset,
HHeadAscent, HHeadAscentIsOffset,
HHeadDescent, HHeadDescentIsOffset,
TypoLineGap, HHeadLineGap, VHeadLineGap,
SubXSize, SubYSize, SubXOffset, SubYOffset
Sets the Subscript x/y sizes/offsets.
SupXSize, SupYSize, SupXOffset,
SupYOffset
Sets the Superscript x/y sizes/offsets.
StrikeOutSize, StrikeOutPos
Usually the second argument is an integer but
VendorID takes a 4 character ASCII
string, and Panose takes a 10 element
integer array.
- SetPanose(array)
SetPanose(index,value)
- This sets the panose values for the font. Either it
takes an array of 10 integers and sets all the values,
or it takes two integer arguments and sets
font.panose[index] = value
- SetPref(str,val[,val2])
- Sets the value of the preference item whose name is
contained 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. It can execute with no current
font.
- SetRBearing(rbearing[,relative])
- If the second argument is absent or zero then the
right bearing will be set to the first argument, if the
second argument is 1 then the right bearing will be
incremented by the first, and if the argument is 2 then
the right bearing will be scaled by <first
argument>/100.0 . In bitmap only fonts see the
comment at SelectBitmap
about units.
- SetTeXParams(type,design-size,slant,space,stretch,shrink,xheight,quad,extraspace[...])
- Sets the TeX (text) font parameters for the
font.
Type may be 1, 2 or 3, depending on whether the font is
text, math or math extension.
DesignSize is the pointsize the font was designed
for.
The remaining parameters are described in Knuth's The
MetaFont Book, pp. 98-100.
Slant is expressed as a percentage. All the others are
expressed in em-units.
If type is 1 then the 9 indicated arguments are
required. If type is 2 then 24 arguments are required
(the remaining 15 are described in the metafont book).
If type is 3 then 15 arguments are required.
- SetTTFName(lang,nameid,utf8-string)
- Sets the indicated truetype name in the MS
platform. Lang must be one of the
language/locales supported by MS, and nameid must
be one of the
small integers used to indicate a standard name,
while the final argument should be a utf8 encoded
string which will become the value of that entry. A
null string ("") may be used to clear an entry.
Example: To set the SubFamily string in the American
English language/locale
SetTTFName(0x409,2,"Bold
Oblique")
- SetUnicodeValue(uni[,set-from-value-flag])
- Sets the currently selected glyph 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.
- SetUniqueID(value)
- Sets the postscript uniqueid field as requested. If
you give a value of 0 then FontForge will pick a
reasonable random number for you.
- SetVKern(ch2,offset[,lookup-subtable-name])
- Sets the kern between any selected glyphs and the
glyph ch2 to be offset. The first argument may be
specified as in Select(), the second is an integer
representing the kern offset. You can also specify a
lookup-subtable-name in which to put the kerning
pair.
- SetVWidth(vertical-width[,relative])
- If the second argument is absent or zero then the
vertical width will be set to the first argument, if
the second argument is 1 then the vertical width will
be incremented by the first, and if the argument is 2
then the vertical width will be scaled by <first
argument>/100.0 . In bitmap only fonts see the
comment at SelectBitmap
about units.
- SetWidth(width[,relative])
- If the second argument is absent or zero then the
width will be set to the first argument, if the second
argument is 1 then the width will be incremented by the
first, and if the argument is 2 then the width will be
scaled by <first argument>/100.0 . In bitmap only
fonts see the comment at SelectBitmap about units.
- Shadow(angle,outline-width,shadow-width)
- Converts the selected glyphs into shadowed versions
of themselves.
- Simplify()
Simplify(flags,error[,tan_bounds[,bump_size[,error_denom,line_len_max]]])
-
With no arguments it does the obvious. If flags is -1
it does a Cleanup, otherwise
flags should be a bitwise or of
- 1 -- Slopes may change at the end points.
- 2 -- Points which are extremum may be
removed
- 4 -- Corner points may be smoothed into
curves
- 8 -- Smoothed points should be snapped to a
horizontal or vertical tangent if they are
close
- 16 -- Remove bumps from lines
- 32 -- make lines which are close to
horizontal/vertical be horizontal/vertical
- 64 -- merge lines which are nearly parallel
into one
- 128 -- change which point is the start point if
a contour's start point is not an extremum
The error argument is the number of font units by
which the modified path is allowed to stray from the
true path.
The tan_bounds argument specifies the tangent of the
angle between the curves at which smoothing will stop
(argument is multiplied by .01 before use).
And bump_size gives the maximum distance a bump can
move from the line and still be smoothed out.
If a fifth argument is given then it will be treated
as the denominator of the error term (so users can
express fraction pixel distances).
Generally it is a bad idea to merge a line segment
with any other than a collinear line segment. The
longer the line segment, the more likely that such a
merge will produce unpleasing results. The sixth
argument, if present, specifies the maximum length
for lines which may be merged (anything longer will
not be merged).
- Sin(val)
- Returns the sine of val. It can execute with no
current font.
- SizeOf(arr)
- Returns the number of elements in an array. It can
execute with no current font.
- Skew(angle[,ox,oy])
Skew(angle-num,angle-denom[,ox,oy])
- All selected glyphs will be skewed by the given
angle.
- Sqrt(val)
- Returns the square root. It can execute with no
current font.
- 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. It
can execute with no current font. Note: There is no
Strcmp function because that is done with relational
operators when applied to two strings.
- Strcasestr(haystack,needle)
- Returns the index of the first occurrence of the
string needle within the string haystack ignoring case
in the search (or -1 if not found). It can execute with
no current font.
- Strftime(format[,isgmt[,locale]])
- Same as the c strftime routine. By default it
formats the current time in gmt, but if that argument
is 0 it will use the local timezone. By default it will
format the argument acording to the current locale, but
if a locale is specified it will be used.
- StrJoin(string-array,delimiter)
- Returns a single string made by concatenating all
the strings in the array together with the delimiter
string added after each. So:
StrJoin(["The","quick","brown","box"]," ")
yields
"The quick brown box"
- Strlen(str)
- Returns the length of the string. It can execute
with no current font.
- Strrstr(haystack,needle)
- Returns the index of the last occurrence of the
string needle within the string haystack (or -1 if not
found). It can execute with no current font.
- Strskipint(str[,base])
- Parses as much of str as possible and returns the
offset to the first character that could not be parsed.
It can execute with no current font.
- StrSplit(str,delimiter[,max-cnt])
- Splits the string at every occurance of the
delimiter and produces an array of sub-strings.
StrSplit("The quick brown box"," ")
yields
["The", "quick","brown","box"]
If max-cnt is specified then it will limit the number
of sub-strings in the array
StrSplit("The quick brown box"," ",2)
yields
["The", "quick brown box"]
- Strstr(haystack,needle)
- Returns the index of the first occurrence of the
string needle within the string haystack (or -1 if not
found). It can execute with no current font.
- Strsub(str,start[,end])
- Returns a substring of the string argument. The
substring begins at position indexed by start and ends
before 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" . It can execute with no current
font.
- Strtod(str)
- Converts a string to a real number. It can execute
with no current font.
- 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). It can execute
with no current font.
- SubstitutionPoints()
|
T |
- Tan(val)
- Returns the tangent of val. It can execute with no
current font.
- ToLower(val)
- Converts value to a lower case letter. Val may be
either an integer, a unicode or a string. The first two
cases are treated as unicode code points, in the third
the entire string will be converted. It can execute
with no current font.
- ToMirror(val)
- Converts value to a mirror form (used in r2l
scripts where the latin open parenthesis looks like a
close parenthesis). Val may be either an integer, a
unicode or a string. The first two cases are treated as
unicode code points, in the third the entire string
will be converted. It can execute with no current
font.
- ToString(arg)
- Converts its argument to a string. (the output is
what the Print() command would print) It can execute
with no current font.
- ToUpper(val)
- Converts value to an upper case letter. Val may be
either an integer, a unicode or a string. The first two
cases are treated as unicode code points, in the third
the entire string will be converted. It can execute
with no current font.
- Transform(t1,t2,t3,t4,t5,t6)
-
Each argument will be divided by 100. and then all
selected glyphs will be transformed by this matrix
[ |
t1/100. |
t2/100. |
t3/100. |
] |
t4/100. |
t5/100. |
t6/100. |
This is a standard PostScript transformation
matrix where
x' |
= |
t1/100 * x + t2/100 * y + t3/100 |
y' |
= |
t4/100 * x + t5/100 * y + t6/100 |
The peculiar notion of dividing by 100 was to
overcome the fact that fontforge's scripting language
formerly could not handle real numbers. We've
overcome that limitation since, but it seemed best to
leave the behavior of the function as it was.
- TypeOf(any)
-
Returns a string naming the type of the argument:
- "Integer"
- "Real"
- "Unicode"
- "String"
- "Array"
- "Void"
(The following type is used internally, but I don't
think the user can ever see it. It is included here
for completeness)
- "LValue"
It can execute with no current font.
|
U |
- UCodePoint(int)
- Converts the argument to a unicode code point (a
special type used in several commands). It can execute
with no current font.
- UnicodeFromName(name)
- Looks the string "name" up in FontForge's database
of commonly used glyph names and returns the unicode
value associated with that name, or -1 if not found.
This does not check the current font (if any).
It can execute with no current font.
- UnlinkReference
- Unlinks all references within all selected
glyphs
- Ucs4(str)
- Takes a string in Utf8 encoding and returns an
array of integers, one for each unicode character in
the string.
- Utf8(int)
- Takes an integer [0,0x10ffff] and returns the utf8
string representing that unicode code point. If passed
an array of integers it will generate a utf8 string
containing all of those unicode code points. (it does
not expect to get surrogates). It can execute with no
current font.
|
V |
- Validate([force])
- Validates the font and returns a bitmask of errors.
If the font passes it will return 0. Normally each
glyph will cache its validation_state and it will not
be recalculated. If you pass a non-zero argument to the
routine then it will force recalculation of each glyph
-- this can be slow.
- VFlip([about-y])
- All selected glyphs will be vertically flipped
about the horizontal line through y=about-y. If no
argument is given then all selected glyphs will be
flipped about their central point.
- VKernFromHKern()
- Removes all vertical kern pairs and classes from
the current font, and then generates new vertical
kerning pairs by copying the horizontal kerning data
for a pair of glyphs to the vertically rotated versions
of those glyphs.
|
W |
- Wireframe(angle,outline-width,shadow-width)
- Converts the selected glyphs into wireframed
versions of themselves.
- WorthOutputting([arg])
- If there is no argument then a single glyph should
be selected and the function applies to that glyph,
otherwise arg is as in InFont.
This returns true if the glyph contains any splines,
references, images or has had its width set.
- WriteStringToFile("string","Filename"[,append])
- Creates the file named "Filename" and writes the
string to it. If the append flag is present and
non-zero, then the string will be appended to the file.
This deals with null-terminated strings, not with byte
arrays. Returns -1 on failure otherwise the number of
bytes written. It can execute with no current
font.
|
X |
|
Y |
|
Z |
|