diff --git a/docs/glyphs/glyphs-4.html b/docs/glyphs/glyphs-4.html index 4f07878ff..0bcc02cc1 100644 --- a/docs/glyphs/glyphs-4.html +++ b/docs/glyphs/glyphs-4.html @@ -1,12 +1,13 @@ - + - - - - FreeType Glyph Conventions + + + FreeType Glyph Conventions - -
-

-FreeType Glyph Conventions

+

+ FreeType Glyph Conventions +

-
-

-version 2.1

- -
-

-Copyright 1998-2000 David Turner (david@freetype.org)
-Copyright 2000 The FreeType Development Team (devel@freetype.org)

- -
+
- -
- - - -
-Previous - -Contents - -Next -
- -
-

-IV. Kerning +

+ Version 2.1

-
-

The term 'kerning' refers to specific information used to adjust -the relative positions of coincident glyphs in a string of text. This section -describes several types of kerning information, as well as the way to process -them when performing text layout. -

+

+ Copyright 1998-2000 David Turner (david@freetype.org)
+ Copyright 2000 The FreeType Development Team (devel@freetype.org) +

-

-1. Kerning pairs -

- -

Kerning consists in modifying the spacing between two successive -glyphs according to their outlines. For example, a "T" and a "y" can be -easily moved closer, as the top of the "y" fits nicely under the "T"'s -upper right bar. -

- -

When laying out text with only their standard widths, some consecutive -glyphs sometimes seem a bit too close or too distant. For example, the -space between the 'A' and the 'V' in the following word seems a little -wider than needed.

-

+ +
-

Compare this to the same word, when the distance between these two letters -has been slightly reduced : -

-

+
+ + + + + + +
+ Previous + + Contents + + Next +
+
-

As you can see, this adjustment can make a great difference. Some font -faces thus include a table containing kerning distances for a set of given -glyph pairs, used during text layout. Note that : -
  -

-
    -
  • -The pairs are ordered, i.e. the space for pair (A,V) isn't necessarily -the space for pair (V,A). They also index glyphs, and not characters.
    • -
+

-
    -
  • -Kerning distances can be expressed in horizontal or vertical directions, -depending on layout and/or script. For example, some horizontal layouts -like arabic can make use of vertical kerning adjustments between successive -glyphs. A vertical script can have vertical kerning distances.
    • -
+ + +
+

+ IV. Kerning +

+
-
    -
  • -Kerning distances are expressed in grid units. They are usually oriented -in the X axis, which means that a negative value indicates that two glyphs -must be set closer in a horizontal layout.
    • -
-
- +

The term kerning refers to specific information used to + adjust the relative positions of coincident glyphs in a string of text. + This section describes several types of kerning information, as well as + the way to process them when performing text layout.

-

-2. Applying kerning

-
Applying kerning when rendering text is a rather easy process. -It merely consists in adding the scaled kern distance to the pen position -before writing each next glyph. However, the typographically correct renderer -must take a few more details in consideration. -

The "sliding dot" problem is a good example : many font faces include -a kerning distance between capital letters like "T" or "F" and a following -dot ("."), in order to slide the latter glyph just right to their main -leg. I.e. -

-

+ +

+ 1. Kerning pairs +

-

However, this sometimes requires additional adjustments between the -dot and the letter following it, depending on the shapes of the enclosing -letters. When applying "standard" kerning adjustments, the previous sentence -would become : -

-

+

Kerning consists in modifying the spacing between two successive + glyphs according to their outlines. For example, a "T" and a "y" can be + easily moved closer, as the top of the "y" fits nicely under the upper + right bar of the "T".

-

Which clearly is too contracted. The solution here, as exhibited in -the first example is to only slide the dots when possible. Of course, this -requires a certain knowledge of the text's meaning. The above adjustments -would not necessarily be welcomed if we were rendering the final dot of -a given paragraph. -

This is only one example, and there are many others showing that a real -typographer is needed to layout text properly. If not available, some kind -of user interaction or tagging of the text could be used to specify some -adjustments, but in all cases, this requires some support in applications -and text libraries. -

For more mundane and common uses, however, we can have a very simple -algorithm, which  avoids the sliding dot problem, and others, though -not producing optimal results. It can be seen as : -
  -

-
    -
  1. -place the first glyph on the baseline
    2. +

    When laying out text with only their standard widths, some + consecutive glyphs seem a bit too close or too distant. For example, + the space between the "A" and the "V" in the following word seems a + little wider than needed.

    -
  2. -save the location of the pen position/origin in pen1
    3. +

    + the word 'bravo' unkerned +

    -
  3. -adjust the pen position with the kerning distance between the first and -second glyph
    4. +

    Compare this to the same word, where the distance between these two + letters has been slightly reduced:

    -
  4. -place the second glyph and compute the next pen position/origin in pen2.
    5. +

    + the word 'bravo' with kerning +

    -
  5. -use pen1 as the next pen position if it is beyond pen2, use pen2 otherwise.
    6. -
-
-
- +

As you can see, this adjustment can make a great difference. Some + font faces thus include a table containing kerning distances for a set + of given glyph pairs for text layout.

-
- - - -
-Previous - -Contents - -Next -
+
    +
  • +

    The pairs are ordered, i.e., the space for pair (A,V) isn't + necessarily the space for pair (V,A). They also index glyphs, and + not characters.

    +
    • +
  • +

    Kerning distances can be expressed in horizontal or vertical + directions, depending on layout and/or script. For example, some + horizontal layouts like Arabic can make use of vertical kerning + adjustments between successive glyphs. A vertical script can have + vertical kerning distances.

    +
    • +
  • +

    Kerning distances are expressed in grid units. They are usually + oriented in the X axis, which means that a negative + value indicates that two glyphs must be set closer in a horizontal + layout.

    +
    • +
-
+ + +

+ 2. Applying kerning +

+ +

Applying kerning when rendering text is a rather easy process. It + merely consists in adding the scaled kern distance to the pen position + before writing each next glyph. However, the typographically correct + renderer must take a few more details in consideration.

+ +

The "sliding dot" problem is a good example: Many font faces include + a kerning distance between capital letters like "T" or "F" and a + following dot ("."), in order to slide the latter glyph just right to + their main leg:

+ +

+ example for sliding dots +

+ +

This sometimes requires additional adjustments between the dot and + the letter following it, depending on the shapes of the enclosing + letters. When applying "standard" kerning adjustments, the previous + sentence would become:

+ +

+ example for too much kerning +

+ +

This is clearly too contracted. The solution here, as exhibited in + the first example, is to only slide the dots when possible. Of course, + this requires a certain knowledge of the text's meaning. The above + adjustments would not necessarily be welcome if we were rendering the + final dot of a given paragraph.This is only one example, and there are many others showing that a + real typographer is needed to layout text properly. If not available, + some kind of user interaction or tagging of the text could be used to + specify some adjustments, but in all cases, this requires some support + in applications and text libraries.

+ +

For more mundane and common uses, however, we can have a very simple + algorithm, which avoids the sliding dot problem, and others, though not + producing optimal results. It can be seen as

+ +
    +
  1. + Place the first glyph on the baseline. +
    2. +
  2. + Save the location of the pen position/origin in pen1. +
    3. +
  3. + Adjust the pen position with the kerning distance between the first + and second glyph. +
    4. +
  4. + Place the second glyph and compute the next pen position/origin in + pen2. +
    5. +
  5. + Use pen1 as the next pen position if it is beyond + pen2, use pen2 otherwise. +
    6. +
+ + +

+ +
+ + + + + + +
+ Previous + + Contents + + Next +
+
+ +
+
diff --git a/docs/glyphs/glyphs-5.html b/docs/glyphs/glyphs-5.html index deac4ead5..11acbc7bf 100644 --- a/docs/glyphs/glyphs-5.html +++ b/docs/glyphs/glyphs-5.html @@ -1,12 +1,13 @@ - + - - - - FreeType Glyph Conventions + + + FreeType Glyph Conventions - -

-FreeType Glyph Conventions -

+

+ FreeType Glyph Conventions +

-

-version 2.1 -

+

+ Version 2.1 +

-

-Copyright 1998-2000 David Turner (david@freetype.org)
-Copyright 2000 The FreeType Development Team (devel@freetype.org) -

+

+ Copyright 1998-2000 David Turner (david@freetype.org)
+ Copyright 2000 The FreeType Development Team (devel@freetype.org) +

-
+
+
+ +
-
- - - -
-Previous - -Contents - -Next -
+
+ + + + + + +
+ Previous + + Contents + + Next +
+
-

-V. Text processing -

+

-

This section demonstrates how to use the concepts previously -defined to render text, whatever the layout you use. -

+ + +
+

+ V. Text processing +

+
+ +

This section demonstrates how to use the concepts previously defined + to render text, whatever the layout you use.

-

-1. Writing simple text strings : -

+ +

+ 1. Writing simple text strings +

-

In this first example, we'll generate a simple string of Roman -text, i.e. with a horizontal left-to-right layout. Using exclusively pixel -metrics, the process looks like : -

1) convert the character string into a series of glyph -indexes. -
2) place the pen to the cursor position. -
3) get or load the glyph image. -
4) translate the glyph so that its 'origin' matches the pen position -
5) render the glyph to the target device -
6) increment the pen position by the glyph's advance width in pixels -
7) start over at step 3 for each of the remaining glyphs -
8) when all glyphs are done, set the text cursor to the new pen -position
-Note that kerning isn't part of this algorithm.
+

In this first example, we will generate a simple string of Roman + text, i.e. with a horizontal left-to-right layout. Using exclusively + pixel metrics, the process looks like: -

-2. Sub-pixel positioning :

+ +
    +
  1. + Convert the character string into a series of glyph + indices. +
    2. +
  2. + Place the pen to the cursor position. +
    3. +
  3. + Get or load the glyph image. +
    4. +
  4. + Translate the glyph so that its 'origin' matches the pen position. +
    5. +
  5. + Render the glyph to the target device. +
    6. +
  6. + Increment the pen position by the glyph's advance width in pixels. +
    7. +
  7. + Start over at step 3 for each of the remaining glyphs. +
    8. +
  8. + When all glyphs are done, set the text cursor to the new pen + position. +
    9. +
+ -
It is somewhat useful to use sub-pixel positioning when rendering -text. This is crucial, for example, to provide semi-WYSIWYG text layouts. -Text rendering is very similar to the algorithm described in sub-section -1, with the following few differences : -
    -
  • -The pen position is expressed in fractional pixels.
    • +

    Note that kerning isn't part of this algorithm.

    -
  • -Because translating a hinted outline by a non-integer distance will ruin -its grid-fitting, the position of the glyph origin must be rounded before -rendering the character image.
    • -
  • -The advance width is expressed in fractional pixels, and isn't necessarily -an integer.
    • -
+ +

+ 2. Sub-pixel positioning +

-


Which finally looks like : -

1. convert the character string into a series of glyph -indexes. -
2. place the pen to the cursor position. This can be a non-integer -point. -
3. get or load the glyph image. -
4. translate the glyph so that its 'origin' matches the rounded -pen position. -
5. render the glyph to the target device -
6. increment the pen position by the glyph's advance width in fractional -pixels. -
7. start over at step 3 for each of the remaining glyphs -
8. when all glyphs are done, set the text cursor to the new pen -position
-Note that with fractional pixel positioning, the space between two given -letters isn't fixed, but determined by the accumulation of previous rounding -errors in glyph positioning.
+

It is somewhat useful to use sub-pixel positioning when rendering + text. This is crucial, for example, to provide semi-WYSIWYG text + layouts. Text rendering is very similar to the algorithm described in + subsection 1, with the following few differences:

-

-3.  Simple kerning :

+
+

Right-to-left algorithm 1:

+ + +
    +
  1. + Convert the character string into a series of glyph + indices. +
    2. +
  2. + Place the pen to the cursor position. +
    3. +
  3. + Get or load the glyph image. +
    4. +
  4. + Decrement the pen position by the glyph's advance width in pixels. +
    5. +
  5. + Translate the glyph so that its "origin" matches the pen position. +
    6. +
  6. + Render the glyph to the target device. +
    7. +
  7. + Start over at step 3 for each of the remaining glyphs. +
    8. +
+ + +

The changes to algorithm 2, as well as the inclusion of kerning + are left as an exercise to the reader.

+ + + +

+ 5. Vertical layouts +

+ +

Laying out vertical text uses exactly the same processes, with the + following significant differences:

+ +
    +
  • +

    The baseline is vertical, and the vertical metrics must be used + instead of the horizontal one.

    +
    • +
  • +

    The left bearing is usually negative, but this doesn't change the + fact that the glyph origin must be located on the baseline.

    +
    • +
  • + The advance height is always positive, so the pen position must be + decremented if one wants to write top to bottom (assuming the + Y axis is oriented upwards). +
    • +
+ +

Here the algorithm:

+ + +
    +
  1. + Convert the character string into a series of glyph + indices. +
    2. +
  2. + Place the pen to the cursor position. +
    3. +
  3. + Get or load the glyph image. +
    4. +
  4. + Translate the glyph so that its "origin" matches the pen position. +
    5. +
  5. + Render the glyph to the target device. +
    6. +
  6. + Decrement the vertical pen position by the glyph's advance height + in pixels. +
    7. +
  7. + Start over at step 3 for each of the remaining glyphs. +
    8. +
  8. + When all glyphs are done, set the text cursor to the new pen + position. +
    9. +
+ + + + +

+ 6. WYSIWYG text layouts +

+ +

As you probably know, the acronym WYSIWYG stands for "What You See Is + What You Get". Basically, this means that the output of a document on + the screen should match "perfectly" its printed version. A + true WYSIWYG system requires two things:

+ +
    +
  • +

    device-independent text layout

    + +

    This means that the document's formatting is the same on the + screen than on any printed output, including line breaks, + justification, ligatures, fonts, position of inline images, etc.

    +
    • +
  • +

    matching display and print character sizes

    + +

    The displayed size of a given character should match its + dimensions when printed. For example, a text string which is + exactly 1 inch tall when printed should also appear 1 inch + tall on the screen (when using a scale of 100%).

    +
    • +
+ +

It is clear that matching sizes cannot be possible if the computer + has no knowledge of the physical resolutions of the display device(s) it + is using. And of course, this is the most common case! That is not too + unfortunate, however, because most users really don't care about this + feature. Legibility is much more important.

+ +

When the Mac appeared, Apple decided to choose a resolution of + 72 dpi to describe the Macintosh screen to the font sub-system + (whatever the monitor used). This choice was most probably driven by + the fact that, at this resolution, 1 point equals exactly + 1 pixel. However, it neglected one crucial fact: As most users + tend to choose a document character size between 10 and 14 points, + the resultant displayed text was rather small and not too legible + without scaling. Microsoft engineers took notice of this problem and + chose a resolution of 96 dpi on Windows, which resulted in slightly + larger, and more legible, displayed characters (for the same printed + text size).

+ +

These distinct resolutions explain some differences when displaying + text at the same character size on a Mac and a Windows machine. + Moreover, it is not unusual to find some TrueType fonts with enhanced + hinting (technical note: through delta-hinting) for the sizes of 10, 12, + 14 and 16 points at 96 dpi.

+ +

The term device-independent text is, unfortunately, often + abused. For example, many word processors, including MS Word, do + not really use device-independent glyph positioning algorithms when + laying out text. Rather, they use the target printer's resolution to + compute hinted glyph metrics for the layout. Though it + guarantees that the printed version is always the "nicest" it can be, + especially for very low resolution printers (like dot-matrix), it has a + very sad effect: Changing the printer can have dramatic effects on the + whole document layout, especially if it makes strong use of + justification, uses few page breaks, etc.

+ +

Because glyph metrics vary slightly when the resolution changes (due + to hinting), line breaks can change enormously, when these differences + accumulate over long runs of text. Try for example printing a very long + document (with no page breaks) on a 300 dpi ink-jet printer, then + the same one on a 3000 dpi laser printer: You will be extremely + lucky if your final page count didn't change between the prints! Of + course, we can still call this WYSIWYG, as long as the printer + resolution is fixed.

+ +

Some applications, like Adobe Acrobat, which targeted + device-independent placement from the start, do not suffer from this + problem. There are two ways to achieve this: either use the scaled and + unhinted glyph metrics when laying out text both in the rendering and + printing processes, or simply use whatever metrics you want and store + them with the text in order to get sure they are printed the same on all + devices (the latter being probably the best solution, as it also enables + font substitution without breaking text layouts).

+ +

Just like matching sizes, device-independent placement isn't + necessarily a feature that most users want. However, it is pretty clear + that for any kind of professional document processing work, it + is a requirement.

+ + +

+ +
+ + + + + + +
+ Previous + + Contents + + Next +
+
+ +
+