1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
|
@c -*- coding: utf-8; mode: texinfo; -*-
@node Modifying the feta font
@chapter Modifying the feta font
@menu
* Overview of the feta font::
* Font creation tools::
* Adding a new font section::
* Adding a new glyph::
* Building the changed font::
* METAFONT formatting rules::
@end menu
@node Overview of the feta font
@section Overview of the feta font
The feta font is a font that was created specifically for use in
LilyPond. The sources for the font are found in mf/*.mf.
The feta font is merged from a number of subfonts. Each subfont
can contain at most 224 glyphs. This is because each subfont is
limited to a one-byte address space (256 glyphs maximum) and we
avoid the first 32 points in that address space, since they are
non-printing control characters in ASCII.
In LilyPond, glyphs are accessed by glyph name, rather than by code point.
Therefore, the naming of glyphs is significant.
Information about correctly creating glyphs is found in @file{mf/README}.
Please make sure you read and understand this file.
TODO -- we should get mf/README automatically generated from texinfo source
and include it here.
@node Font creation tools
@section Font creation tools
The sources for the feta font are written in metafont. The definitive
reference for metafont is "The METAFONT book". Source for the book is
available at CTAN.
mf2pt1 is used to create type 1 fonts from the metafont sources.
FontForge is used to postprocess the output of mf2pt1 and clean up
details of the font. It can also be used by a developer to
display the resulting glyph shapes.
@node Adding a new font section
@section Adding a new font section
The font is divided into sections, each of which contains less
than 224 glyphs. If more than 224 glyphs are included in a section,
an error will be generated.
Each of the sections is contained in a separate @code{.mf} file. The
files are named according to the type of glyphs in that section.
When adding a new section, it will be necessary to add the following:
@itemize
@item
The code for the glyphs, in a file @code{<section-name>.mf}
@item
Driver files used to create the font in different sizes
@item
An entry in the generic file used to create the font, or a new
generic file
@item
If necessary, new entries in the GNUmakefile
@item
An entry in @file{scripts/build/gen-emmentaler-scripts.py}
@end itemize
See the examples in @code{mf/} for more information.
@node Adding a new glyph
@section Adding a new glyph
Adding a new glyph is done by modifying the .mf file to which the
glyph will be added.
Necessary functions to draw the glyph can be added anywhere in the file,
but it is standard to put them immediately before the glyph definition.
The glyph definition begins with:
@example
fet_beginchar ("glyph description", "glyphname");
@end example
@noindent
with @code{glyph description} replaced with a short description of the
glyph, and @code{glyphname} replaced with the glyphname, which is chosen
to comply with the naming rules in @file{mf/README}.
The metafont code used to draw the glyph follows the @code{fet_beginchar}
entry. The glyph is finished with:
@example
fet_endchar;
@end example
@node Building the changed font
@section Building the changed font
In order to rebuild the font after making the changes, the existing
font files must be deleted. The simplest and quickest way to do this
is to do:
@example
rm mf/out/*
make
@end example
@node METAFONT formatting rules
@section METAFONT formatting rules
There are special formatting rules for METAFONT files.
Tabs are used for the indentation of commands.
When a path contains more than two points, put each point on a
separate line, with the operator at the beginning of the line.
The operators are indented to the same depth as the initial point
on the path using spaces. The indentation mechanism is illustrated
below, with @samp{------->} indicating a tab character and any other
indentation created using spaces.
@example
def draw_something (test) =
------->if test:
------->------->fill z1
------->-------> -- z2
------->-------> -- z3
------->-------> .. cycle;
------->fi;
enddef;
@end example
|
