ch4.htm

JAVA Developing Professional JavaApplets

<BLOCKQUOTE>
<TT>Font f = new Font(&quot;Helvetica&quot;,
Font.BOLD + Font.ITALIC,36);</TT>
</BLOCKQUOTE>
<P>
Fonts can be tied to a component through the <TT>setFont()</TT>
method. To create the previous font and tie it to a label, the
following code could be invoked:
<BLOCKQUOTE>
<TT>Label l = new Label(&quot;My Label&quot;);
<BR>
l.setFont(new Font(&quot;Helvetica&quot;, Font.BOLD + Font.ITALIC,36));</TT>
</BLOCKQUOTE>
<P>
A reference to a component's Font can be retrieved through <TT>getFont()</TT>.
<P>
Another way to use fonts is in the <TT>paint()</TT>
method. The Graphics class used in <TT>paint()</TT>
can have the current font set through the <TT>setFont()</TT>
method. For example, Listing 4.4 provides the code for an applet
that paints a series of Strings containing a row number. Figure
4.3 shows the output. When the <TT>paint()</TT>
method begins, a new font is created and set to the graphics object;
this font is now the current font used for the following graphics
calls. The <TT>drawString()</TT> method
is then called repeatedly with the y coordinate being dynamically
calculated.
<P>
<A HREF="f4-3.gif" ><B>Figure 4.3 </B>: <I>A Font applet using hardcoded coordinates</I></A>
<HR>
<BLOCKQUOTE>
<B>Listing 4.4. Code for Font applet using hard-coded coordinates.
<BR>
</B>
</BLOCKQUOTE>
<BLOCKQUOTE>
<TT>import java.awt.*;<BR>
import java.lang.*;<BR>
import java.applet.*;<BR>
<BR>
// This aspect throws a string into the applet<BR>
// display separated by a height difference of the<BR>
// current font<BR>
public class FontTest extends Applet&nbsp;&nbsp;{<BR>
&nbsp;&nbsp;&nbsp;&nbsp;public void paint(Graphics g) {<BR>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;int y;<BR>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Font f = new Font(&quot;Helvetica&quot;,Font.BOLD
+ Font.PLAIN,16);<BR>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;g.setFont(f);<BR>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;for (int i = 0; i &lt; 5;
++i) {<BR>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;y = 40 +
(i * 20);<BR>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;g.drawString(&quot;Row
&quot; + i + &quot; of text output.&quot;,10,y);<BR>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;} // end for<BR>
&nbsp;&nbsp;&nbsp;}<BR>
}</TT>
</BLOCKQUOTE>
<P>
There are a couple of things about this applet that are not quite
optimal. First of all, it isn't good to create a new Font in the
paint routine. Painting occurs frequently and font creation is
an expensive operation. It is faster and more efficient to create
the font only once, as in the <TT>init()</TT>
method.
<P>
The other thing that might be avoided is using hard-coded values,
which is notorious for displays that do not appear uniformly across
different platforms. (After all, that is why AWT has layouts!)
Although this applet might look decent across platforms, it gives
an excuse for showing a better way of using coordinates. This
is where the FontMetrics class comes in.
<P>
FontMetrics is used to get a variety of information about a Font
object. Such information includes the font's dimensions, how big
a String or character using that font would be, and so forth.
Table 4.1 lists some of the methods of the FontMetrics class.
<BR>
<P>
<CENTER><B>Table 4.1. FontMetrics methods.</B></CENTER>
<P><CENTER><TABLE BORDERCOLOR=#000000 BORDER=1 WIDTH=80%>
<TR VALIGN=TOP><TD WIDTH=129><I>Method</I></TD><TD WIDTH=461><I>Description</I>
</TD></TR>
<TR VALIGN=TOP><TD WIDTH=129><TT>charWidth</TT>
</TD><TD WIDTH=461>Returns width of character using this font.
</TD></TR>
<TR VALIGN=TOP><TD WIDTH=129><TT>GetAscent</TT>
</TD><TD WIDTH=461>Returns the ascent of the font (distance between the baseline and top of the character).
</TD></TR>
<TR VALIGN=TOP><TD WIDTH=129><TT>GetDescent</TT>
</TD><TD WIDTH=461>Returns descent of font (distance from the baseline of the font and its bottom).
</TD></TR>
<TR VALIGN=TOP><TD WIDTH=129><TT>getHeight</TT>
</TD><TD WIDTH=461>Returns total height of font (ascent + descent + leading).
</TD></TR>
<TR VALIGN=TOP><TD WIDTH=129><TT>getLeading</TT>
</TD><TD WIDTH=461>Returns the line spacing of the font.</TD>
</TR>
<TR VALIGN=TOP><TD WIDTH=129><TT>stringWidth</TT>
</TD><TD WIDTH=461>Returns the number of pixels a String using this font will take.
</TD></TR>
</TABLE></CENTER>
<P>
<P>
You can retrieve a FontMetrics object for a specific font in a
couple of ways. First of all, the FontMetrics object can be created
from scratch by using its constructor; it takes the Font in question
as its only parameter. The reference to the FontMetrics can also
be taken directly from the Graphics class by using the <TT>getFontMetrics()</TT>
method. The first technique is used when the program is not painting,
but that is when the latter technique is applied. Finally, it
could retrieve from the default toolkit with a method also named
<TT>getFontMetrics()</TT>.The next
section explains how the Toolkit class works.
<P>
Figure 4.4 shows an improved version of the Font applet through
the use of FontMetrics; Listing 4.5 gives the new code. In this
version of the applet, each of the String displays are equally
incremented by the height of the font. The code calculates the
height increment from the <TT>getHeight()</TT>
method of the FontMetrics reference of the Graphics object. The
new code is also more efficient than the previous example since
it creates the font only once, at initialization.
<P>
<A HREF="f4-4.gif" ><B>Figure 4.4 </B>: <I>A Font applet using FontMetrics.</I></A>
<HR>
<BLOCKQUOTE>
<B>Listing 4.5. Code for a Font applet that uses FontMetrics.
<BR>
</B>
</BLOCKQUOTE>
<BLOCKQUOTE>
<TT>import java.awt.*;<BR>
import java.lang.*;<BR>
import java.applet.*;<BR>
<BR>
// This aspect throws a string into the applet<BR>
// display separated by a height difference of the<BR>
// current font<BR>
public class FontTest extends Applet {<BR>
&nbsp;&nbsp;&nbsp;Font f;<BR>
&nbsp;&nbsp;&nbsp;// Create the font...<BR>
&nbsp;&nbsp;&nbsp;public void init() {<BR>
&nbsp;&nbsp;&nbsp;&nbsp; f&nbsp;&nbsp;= new Font(&quot;Helvetica&quot;,Font.BOLD
+ Font.PLAIN,16);<BR>
&nbsp;&nbsp;&nbsp;}<BR>
&nbsp;&nbsp;&nbsp;// Paint using TextMetrics to set the height
in even<BR>
&nbsp;&nbsp;&nbsp;// increments...<BR>
&nbsp;&nbsp;&nbsp;public void paint(Graphics g) {<BR>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;// Set the font<BR>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;g.setFont(f);<BR>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;// Always increment by twice
the height of the font...<BR>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;int heightIncrement =&nbsp;&nbsp;2
* g.getFontMetrics().getHeight();<BR>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;int y = 0;<BR>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;for (int i = 0; i &lt; 5;
++i) {<BR>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;y += heightIncrement;
<BR>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;g.drawString(&quot;Row
&quot; + i + &quot; of text output.&quot;,10,y);<BR>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;} // end for<BR>
&nbsp;&nbsp;&nbsp;}<BR>
}</TT>
</BLOCKQUOTE>
<HR>
<P>
The tutorial that follows will have even more examples of fonts,
including a dialog box that can be used to select a font family,
size, and style.
<H3><A NAME="TheToolkitClass">The Toolkit Class</A></H3>
<P>
The AWT Toolkit class provides the link between the AWT system-independent
interface and the underlying platform-based toolkit (such as Windows).
The class is abstract, so the <TT>getDefaultToolkit()</TT>
method must be called to get a reference to the actual Toolkit
object. Once this is done, all kinds of information about the
underlying environment can be revealed. By working with the Toolkit,
this underlying information can be used in a way that does not
compromise portability.
<P>
For example, the following code gets a list of all the fonts available
on the native platform and prints them out:
<BLOCKQUOTE>
<TT>String fontList[] = Toolkit.getDefaultToolkit().getFontList();
<BR>
&nbsp;&nbsp;&nbsp;&nbsp;for (int i = 0; i &lt; fontList.length;
++i)<BR>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; System.out.println(fontList[i]);</TT>
</BLOCKQUOTE>
<P>
If the fonts used in an applet are derived from this list, versus
using hard-coded font names, the portability of an applet will
be improved. The <TT>getFontMetrics()</TT>
method returns the screen metrics of a font.
<P>
Another useful Toolkit method is <TT>getScreenSize()</TT>.
This returns the full-screen dimensions of the native platform.
If you want to create a window that fills up the screen, these
dimensions will be useful. The <TT>getScreenResolution()</TT>
method returns the dots-per-inch resolution of the screen.
<P>
The Toolkit class also provides a variety of methods for using
images, including a method for synchronizing the screen's graphics
state. This <TT>sync()</TT> method
can be used in animation to avoid flicker.
<H2><A NAME="IOandStreams"><FONT SIZE=5 COLOR=#FF0000>I/O and
Streams</FONT></A></H2>
<P>
<I>Streams</I> are a traditional way of representing a connection
between two objects. The types of streams that programmers are
most familiar with are ones between I/O devices (such as files)
and processes or streams between two memory structures. Each endpoint
of a stream connection can have one or two channels: an input
channel and an output channel. When a process is reading from
a file, it reads from a stream that receives data from the file
device's output channel. From the point of view of the process,
it is managing an <I>input stream</I>. From the viewpoint of the
file device, it is sending an <I>output stream</I>. Figure 4.5
illustrates the relationship.
<P>
<A HREF="f4-5.gif" ><B>Figure 4.5 : </B><I>Stream relationships when a process reads from a file.</I></A>
<P>
The JDK package for managing input and output interactions, called
java.io, has the stream concept at its foundation. It is structured
on the notion of input and output streams just discussed. These
stream classes permeate the Java programming environment. Their
use ranges from file I/O to network programming to the widely
used <TT>System.out.println()</TT>
method. There are few things that will increase the capabilities
of a Java programmer more than a full understanding of Java streams.
<H3><A NAME="StructureofthejavaioPackage">Structure of the java.io
Package</A></H3>
<P>
As just stated, the java.io package is based heavily on the notion
of input and output streams. This is made clear by the diagram
of significant java.io classes, shown in Figure 4.6. The most
important of these are, not surprisingly, the InputStream and
OutputStream classes, which are generally used to read and write
from a stream, respectively. They form the basis of an elaborate
network of stream classes that make it easy to build high-level
streams, such as those that work on newline delimited ASCII data,
to low-level streams, such as one that manages data on a byte-by-byte
level. How this works will be explored in the upcoming discussion
of the two foundation classes and their subclasses.
<P>
<A HREF="f4-6.gif" ><B>Figure 4.6 :</B><I> Significant classes of the java to hierarchy.</I></A>
<P>
Before engaging in a discussion of the input and output stream
classes, it's useful to look at some of the other aspects of Java
I/O programming. The File class can be used to get information
about a file or directory on the host file system. For example,
the following code checks to see whether a file exists in the
current directory and lists what is in the grandparent directory.
<BLOCKQUOTE>
<TT>myFile = new File(&quot;File.txt&quot;);
<BR>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;System.out.println(&quot;The
file &quot; + myFile.getName()<BR>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;+
&quot; existence is &quot; + myFile.exists());<BR>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;File myDirectory = new File(&quot;..\\..&quot;);
<BR>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;String s[] = myDirectory.list();
<BR>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;System.out.println(&quot;Directory
contents: &quot;);<BR>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;for (int i = 0; i &lt; s.length;
++i)<BR>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;System.out.println(s[i]);</TT>
</BLOCKQUOTE>
<P>
As you might have observed in the constructor for the directory
object, the naming conventions are based on the host file system.
Consequently, hard coding such conventions can result in nonportable
code. Fortunately, the class provides some constants that can
hide the platform-specific conventions. For example, the following
code makes the directory constructor portable:
<BLOCKQUOTE>
<TT>File myDirectory = new File(&quot;..&quot;
+ File.separator + &quot;..&quot;);</TT>
</BLOCKQUOTE>
<P>
The File class also offers a variety of other file operations.
This includes the ability to delete or rename a file, create a
new directory, and inspect a file's attributes. Note, however,
that these operations are subject to the native environment's
security constraints, discussed in the following section.
<H2><A NAME="IOandSecurity"><FONT SIZE=5 COLOR=#FF0000>I/O and
Security</FONT></A></H2>
<P>
The Java language and its native environment (such as a browser)