<html>
<head>
<link rel="stylesheet" href="page.css" type="text/css">
<title>Documentation: Fonts</title>
</head>
<body bgcolor=#ffffff link=#990033 vlink=#990033 alink=#990033 text=#000000>
<!---- TOPIC TITLE WITH LOGO--->
<table border=0 cellpadding= cellspacing=2 width=100% ><tr><td><a href='http://www.fox-toolkit.org' target=_top><img src='art/foxlogo_small.jpg' border=0></a></td><td width=100% valign=bottom id="HEADLINE"><b>
Documentation: Fonts <A href='fonts.html' target="_top" align=left><font size=-2>[Remove Frame]</font></a>
<br><img src='art/line.gif' width=100% height=1></b></td></tr></table>
</p>
<!--- TOPIC TITLE WITH LOGO --->
<ul>
<p>Type faces in FOX are manipulated using <B>FXFont</B> objects.
To provide a consistent look and feel for all applications, most FOX widgets
normally share one common font object, which is automatically adopted when
the widget is constructed. However, a widget's font is readily changed
using the setFont() member function. Changing fonts on widgets will
automatically cause an adjustment in layout so that the new size of the
widget is accomodated.</p>
<p>As with most other resources such as FXIcon and FXCursor etc., building
FXFont objects also takes <B><I>two</I></B> steps:- <B><I>construction</I></B>
of the client-side part of the font object, followed by <B><I>creation</I></B>
of the corresponding server-side part. During construction,
all necessary information is supplied to the FXFont object so that the
desired font may be located and loaded into memory during the creation.
In most cases, the font objects are automatically created when the widget
that uses it is being created. If you have constructed a new FXFont
object later on, however, you may have to make a call to the font object's
<TT>create()</TT> member function to make sure the font object is fully initialized.
As different computer systems may have different fonts, it is possible
that the specific font your application needs may not be available.
Since you probably still would like this application to run anyway, alternative
fonts must be found.</p>
<P>FOX supports mechanisms to localize fonts which are ``close'' [in some
easthetic sense] to the desired font, so that applications will typically
not fail simply because of missing fonts. Keep in mind, however,
that the information you supplied to the FXFont contructor may not accurately
reflect the font that is actually being used in your application.
<P>Also note that information about a font will not be available until
after the font has been created using <TT>create()</TT>.</p>
</ul>
<!--- TOPIC TITLE -->
<p>
<table width=100% cellpadding=0 cellspacing=2><tr><td width=100% valign=bottom id=HEADLINE><b>
Using Font Objects
<br><img src='art/line.gif' width=100% height=1></b></td></tr></table>
</p>
<!--- TOPIC TITLE -->
<ul>
<p>Using fonts is really very easy. For example, to build a Button
Control with a different Font for the caption, you would use the following
C++ code:</p>
<pre>
FXButton *button = new FXButton(parent,"&Caption");
FXFont* captionfont = new FXFont(app,"times",24);
button->setFont(captionfont);
</pre>
<P>This statements will create a Button with caption ``<B><FONT SIZE=+2><U>C</U>aption</FONT></B>''
and use a font of <B><I>24</I></B> points <B><I>Times</I></B>. Note
that in this case we assume that the captionfont will be created in the
process of creating the Button; if you were to change fonts after the application
has already started running, you would want to call <TT>captionfont->create()</TT>
to make sure the font resources are created.
Also note that font objects may be <B><I>shared</I></B> between several
controls; thus, you don't have to create a different font object for each
control [unless of course you want to use a different font!].
In the above example, we have taken default values for many parameters
influencing the choice of font. The above call is actually equivalent to:</p>
<pre>
FXFont* captionfont = new FXFont(app,
"times",
24,
FONTWEIGHT_NORMAL,
FONTSLANT_REGULAR,
FONTENCODING_DEFAULT,
0);
</pre>
<P>That is to say, construct a font with face name ``times,'' 24 points,
normal weight [not bold], no italics, and use whatever character encoding
is available for this font; finally, the zero (0) indicates there are no
hints.</p>
Besides the above platform-independent font constructor, FXFont also
has an alternative constructor which is only applicable to the X11 Window
System; this method bypasses the font matching algorithm.
Assuming that our display was 75 dots per inch (dpi), the alternative
method of contructing fonts using the X11 font string would have been:</p>
<pre>
FXFont* captionfont = new FXFont(app,"-adobe-times-medium-r-normal--24-240-75-75-p-124-iso8859-1");
</pre>
<P>Besides being harder to remember, this method would not port over very
well to other systems, or systems where this particular font is not available.
However, there are a few reasons why sometimes you may need this method:</p>
<OL>
<LI>
You want to make sure you obtain a <I>specific font</I>, and do not want
the matching algorithm to get in the way;</LI>
<LI>
You need to obtain certain raster-based <I>system fonts,</I> for example
"9x15bold."</LI>
</OL>
</ul>
<!--- TOPIC TITLE -->
<p>
<table width=100% cellpadding=0 cellspacing=2><tr><td width=100% valign=bottom id=HEADLINE><b>
Font Matching and Substitution
<br><img src='art/line.gif' width=100% height=1></b></td></tr></table>
</p>
<!--- TOPIC TITLE -->
<ul>
<p>In order to be able to write applications which may be ported to a large
variety of computer systems and software environments, it is necessary
to make sure that the absence of certain fonts is handled gracefully.
<BR>The FXFont implementation offers a number of benefits that allow you
to get your application running under a wide variety of environments,
even on systems where very few fonts have been installed:</p>
<OL>
<LI>
<B>Font Substitution.</B> Font substitution is used to map type face
names which may be hard-coded in your application to another type face
name, so an alternative font may be used without having to make changes
to programs or recompiling them. FOX uses the standard <A HREF="registry.html#REGISTRY">Registry</A>
mechanism to map one type face name to another.</LI>
<LI>
<B>Font Matching.</B> Font matching algorithms are used to determine
the closest available font to the desired font. Different weighting
factors are applied to different font attributes to get the best visual
approximation.</LI>
<LI>
<B>Font Match Hints.</B> Hints may be passed to the matching algorithms
so you are able to emphasize certain types of font attributes more strongly
than others.</LI>
<LI>
<B>X11 Font String.</B> Platform-dependent fonts may be directly
specified also. This method is not recommended unless you need to
select a specific font, and are not interested in portability.</LI>
</OL>
<p>Before trying to acquire a list of available fonts for a certain type face,
the FXFont implementation first tries a substitution for the <B><I>type
face nam</I></B>e. The standard FOX registry is used to make this
association. The substitute font is found in the section FONTSUBSTITUTIONS
of the registry.
<BR>For example, the following fragment decribes the registry settings
which would replace ``swiss'' by ``helvetica'' and ``new century schoolbook''
by ``courier'':</p>
<pre>
[FONTSUBSTITUTIONS]
swiss = helvetica
new century schoolbook = courier
</pre>
<P> Thus, you can easily give a FOX application another font even
if you might not have the source code around!
<P>After having substituted the type face name, the FXFont implementation
tries to find the font from the given type face that best matches
the parameters and hints. Parameters or hints which are given a ``don't
care'' value are considered matched. For example, if you specify
FONTWEIGHT_DONTCARE for the font weight, all font weights would match and
the resulting font will be based on other parameters.
<P>Not all parameters have the same priority as far as matching goes; the
importance of the parameters is as follows:</p>
<BR>
<OL>
<LI>
<B>Character Set Encoding. </B> If you needed East European character
sets and you got Greek instead, even all other things being equal, you'd
be disappointed.</LI>
<LI>
<B>Fixed</B> or <B>Variable Pitch</B> hints. For programming editors,
for example, fixed pitch fonts are a must so that indentation is properly
maintained; therefore, font pitch is quite important for legibility purposes.</LI>
<LI>
<B>Screen Resolution</B>. Bitmapped fonts are much more readable
when the resolution matches that of your screen; so resolution is quite
important. The FXFont implementation tries to determine the screen's
resolution (in terms of <B><I>dots per inch</I></B>) and then match fonts
designed for this resolution.</LI>
<LI>
<B>Scalable Font Hint</B>. Certain operations such as scaling and
shearing [obliqueing] are only possible with scalable fonts; thus, if you
have specified this hint, all other things being equal, you'd prefer scalable
fonts over other ones.</LI>
<LI>
<B>Polymorphic Font Hint.</B> Polymorphic fonts allow continuous variations
in various attributes of a font, such as set width, weight, slant, and
others. If your application needs such fonts for certain effects, this
much be made to match.</LI>
<LI>
<B>Point Size</B>. When all the above are satisfied, you certainly want
the size of the font to be roughly equal to the one specified. For
scalable fonts, you can of course virtually always match the requested
size exactly. For non-scalable fonts, the FXFont implementation matches
the largest font which is less than or equal to the desired size.
Even though a larger font may be closer, the larger one may be too large
for proper layout on a finite screen; therefore, the implementation yields
only smaller fonts. As the resolution has influence over the observed
point size, the implementation corrects for this [see ``<A HREF="#SCREENRES">Screen
Resolution</A>'' below].</LI>
<LI>
<B>Weight. </B> The weight or ``boldness'' of the font.</LI>
<LI>
<B>Slant. </B>Oblique and italic may both be matched for a slanted font.</LI>
<LI>
<B>Set Width. </B>Wide or narrow (condensed) printing.</LI>
</OL>
<p>After having tried all the members of the specified type face, if no match
is found at all, the FXFont implementation tries a number of other common
fonts, based on additional hints:</P>
<UL>
<LI>
If no hints are given, or if the hint <B>FONTHINT_SWISS</B> is given, the
face ``helvetica'' or its substitution will be tried;</LI>
<LI>
Next, if no hint is given or if the hint given is <B>FONTHINT_ROMAN</B>,
the face ``times'' or its substitution will be tried;</LI>
<LI>
Next, if no hint given or if the given hint was equal to <B>FONTHINT_MODERN,</B>
the face ``courier'' or its substitution will be tried;</LI>
<LI>
After that, if no hint is given or if the hint was <B>FONTHINT_DECORATIVE</B>,
the face ``gothic'' or its substitution will be tried;</LI>
<LI>
Finally, if all else fails, the implementation will try a number of ``fallback
fonts'' which have been determined to be commonly available.</LI>
</UL>
<p>If all the above failed, yet there is at least one font on your system,
then you should report this problem on the FOX mailing list...</p>
</ul>
<!--- TOPIC TITLE -->
<p>
<table width=100% cellpadding=0 cellspacing=2><tr><td width=100% valign=bottom id=HEADLINE><b>
Screen Resolution
<br><img src='art/line.gif' width=100% height=1></b></td></tr></table>
</p>
<!--- TOPIC TITLE -->
<ul>
<p>Since current-day analog monitors can stretch and shrink the visible
field of the display, the actual resolution is typically not exactly 75dpi
or 100dpi. To get a font's point size as close to the desired pointsize
as possible, FOX adjusts for the actual screen dpi relative to the font's
dpi.For example, suppose we have a font such as:</p>
<pre>
-adobe-helvetica-bold-r-normal--12-<B><FONT COLOR="#FF6666">120</FONT></B>-<B><FONT COLOR="#FF6666">75</FONT></B>-<B><FONT COLOR="#FF6666">75</FONT></B>-p-70-iso8859-1
</pre>
<P>This font is a <B><I>12-point</I></B> font designed for a <B><I>75
dpi</I></B> device. If your monitor however is set to display 90
dpi, the font would be too small. The implementation can correct
for this by multiplying the font's point size by (75/90) which means visually
this font would actually be more like 10-points on your monitor.
Thus, to get a font <I>designed</I> for 100 dpi to <I>display</I> as 12
points on your monitor, we should search for a font which is slightly <I>larger</I>
than 12-point; to be exact, we should be looking for a font (90/75)*12
= 14.4-point font.</p>
<P>On many systems such as work stations, the machine is shipped with accurate
information about the particular monitor supplied with the system;
on such systems, the font implementation of FOX will correctly determine
the right resolution to use. On PC's however, hardware is mixed and
matched from different sources, and the reported screen sizes may be incorrect,
causing fonts to bigger or smaller than requested.
<P>When the system reports the wrong resolution, you can easily correct
that by setting the resolution yourself using the registry database. On
my system, for example, the XFree86 X Server reports 75 dpi, while I really
have 100dpi. So I change my registry database as follows:</p>
<pre>
[SETTINGS]
screenxres = 100
screenyres = 100
</pre>
<P>These entries need to go into the ``<B><I>Desktop</I></B>'' file so
that all FOX programs will be aware of this, regardless of vendor or application
name. For more about the registry, see the section on <A HREF="registry.html#REGISTRY">FXRegistry</A>.</p>
</ul>
<!--- COPYRIGHT -->
<p>
<table width=100% cellpadding=0 cellspacing=0><tr><td width=100% valign=top id=HEADLINE align=right>
<img src='art/line.gif' width=100% height=1><font size=-1>
Copyright © 1997-2004 Jeroen van der Zijp</font>
</td></tr></table>
</p>
<!--- COPYRIGHT -->
</body>
</html>
