\documentclass{report} % Must use LaTex 2e
\usepackage{html,a4}

\begin{document}

\title{Lookout For A Free Java Development Environment\\[2mm]and the\\[2mm]Jau-Package}
\author{Sven Goethel}

\maketitle

\tableofcontents
\pagebreak

\chapter{Introduction}
\section{What is Java ?}
Since Java \cite{2} is established, we are able to generate
executable code, which runs on many platforms. 
This independence is achieved by the \emph{Java virtual Machine (JVM)}
which is implemented for each platform. A Java executable, so called
Applet or Application is compiled into the Java-Bytecode format and runs
on the JVM. Because the JVM simulates a complete operation-system
and executes Java-Bytecode, Java source- and Bytecode is
very high portable with no need for recompilation.
Java Programs are written once and runs everywhere.

\section{What Is A Development Environment ?}
To produce software, we need many well known tools. E.g.:
\begin{enumerate}
	\item editor
	\item revision control system
	\item compiler
	\item linker
	\item debugger
	\item profiler
	\item lex \& yacc
	\item \LaTeX\ \cite{Kopka}
	\item \LaTeX\-2Html\cite{Dragos96}
\end{enumerate}
Each tool is a program which can be invoked at the command line,
and each tool can have a GUI, e.g. the editor, or can not have a GUI,
e.g. the compiler.
These Tools can be configurated and invokated manually.

All these tools, their configuration and invocation is the 
development environment (DE).
The operating system (OS), e.g. Unix, is also a part of the DE, because the
command line (shell), e.g. bash, and it�s configuration configures those tools either.

Nowadays software companys offers integrated development environments (IDE). The IDE contains all needed tools, which can be invocated and configurated by the IDE. The IDE usually uses a GUI and should be able to combine all needed tools in a convienient way. 
The problem of most IDE�s is their incompatibility. Some IDE�s create proprietaery makefile-scripts, 
some contains kind of functionality which are not portable to other OS�s.

\section{A development Environment for Java}
Because Java is avaiable for many platforms, i asked myself what kind of
environment is usefull for Java. A Java environment is distributed within
the JDK (see section \ref{jdk}, page \pageref{jdk}).
The goal of this paper is to lookout for tools, to create a Unix like 
development environment (see section \ref{unixenv}, page \pageref{unixenv}).
Because the Unix environment is well known and much portable, 
it can be very easy and convinience for developers to use the known
environment for Java on their platform too.

\section{What is the Jau-Package ?}
The Jau-Package is a toolkit to support java developers with
many convinient features. This package is introduced here as an example
project which uses a standard development environment.

\chapter{The Unix Standard Environment}
\label{unixenv}

\section{What Is Unix/Linux ?}
Unix is a operating system (OS) which supports the following
capabilitys and more:
\begin{itemize}
	\item multitasking
	\item multi-user
	\item TCP/IP connectivity (Internet)
	\item X-Window-System (Client-Server GUI)
\end{itemize}

In the beginning, Unix was accessible for high performance mainframe systems but not for personal computers (PC). In the early 80�s, 
\emph{BSD-Unix} supported Intel based PC�s. Today \emph{Linux} is
a free Unix and supports Motorola-68xxx, Alpha-, Intel- and other platforms.

Like other free software, Linux is distributed under the \emph{GNU General Public License (GPL)}. GNU-Software is distributed with it�s source-code,
can be used for commercial-issues also.
A Linux-System contains many other GNU-Software and is high avaiable.
GNU-Software can be compiled and used on other platforms like Windows.

In the following the so called Unix standard development environment 
will be described.
The big goal of a Unix environment is it�s portability. This means
that a whole project can be ported to any Unix platform with less 
or no affort.
The components of this environment are different and introduced below.

Because GNU-Software is avaiable on other platforms than Unix, 
many Unix-projects can be ported to those either.
The GNU-Win32 Project \cite{4} has ported a complete Unix-Layer 
inclusive the bash and utilitys to Windows 32 (95 \& NT).
\label{gnuwin32}


\section{Shell And Shell-Scripts}
Unix is controlled by the command line. Nowadays many software can be
controlled by a GUI either. Nevertheless the command line is the 
important user interface in Unix. To make the command line convinient
Unix offers several shells. A shell is the basic program which 
handles the keyboards input and the terminal output. The shell interprets
the input and trys to perform the apropiate action. This could be a shell command which is built in the shell itself, or this could be a programm which is invoked by the shell.
A shell has it�s environment variables, which can be set by the user and which can read out by programs. 
Mostly all shells support shell scripts. A shell script is like a little
program which can be interpreted by the shell.
Decisions, loops can be compined with the invokation of programs.

The most distributed shell is the kornshell. Kornshell scripts are high
portable. The new convinient Borne again shell (Bash) is Kornshell compatible and has very fine convinient features like command line completion for path- and filename, history via cursor keys and so on.

\section{X-Window-System}
Because the user wants an graphical interface, a GUI, the
X-Window-System (X) was developed.
Because X is a Unix standard,
programs have a unique grafical interface on a Unix system.
Nowadays other platform than Unix offers X-Server,
so that software can run or/and can be displayed on those.

A program using X is called the client. 
The display this program displays it�s data, is called the server.
Client and server can be different platforms connected via the Internet.

The design of the X-Window-System allows networking, remote-applications,
portable software.

To use specific grafical elements, so called widgets, another librarys 
are needed. E.g. the commercial motiv library contains many 
widgets and window types.
Motif contains the Motif Windowmanager (MWM) also. A windowmanager
manages the look and feel of the windows displayed with the X-Server.

\section{Utilitys}
The Unix environment has many little powerfull utilitys, command line tools.
These written tools are designed to perform one action, nothing more, nothing less. For example, the \emph{df} command shows the disk usage.
All these little tools has as standard command line interface,
and they should run on all Unix platforms well.
The combination of shell scripts, these utilitys and other programs
gives the developer the flexibility and comfort he needs.

Most of these tools acts like a filter. This means, that they will receive
their input from the standard input, and puts their output to the standard output. These standard streams can be redirected and piped.

\emph{sed} is a stream editor. With \emph{sed} you can modify text files 
automatic. E.g. you need to convert all strings named �foo� to �You�,
you can use \emph{sed} to convert all your files you need.

\emph{awk} is a pattern matching interpreter. With \emph{awk} you can
specify patterns with regular expressions\footnote{regular expressions are also used in grep, vi and lex} and a action which should be performed if \emph{awk} finds the pattern. The action is a c-like block interpreted by \emph{awk}.

\section{Editor}
The first editor on Unix was a line editor named \emph{ed}. 
Later \emph{vi} was born. \emph{vi} is a full screen editor with the 
command syntax of \emph{ed} and \emph{sed}.
\emph{vi} can be found on all Unix installations and can be run on a terminal.

\emph{emax} is a new editor, which is not part of a standard Unix installation.
\emph{emax} is more powerfull than \emph{vi} and can be controlled 
and extended via severall scrip languages.

\section{Revision Control System}
To control the versions of all the projects files, you need a 
revision control system (RCS). The tasks for a RCS is to:
\begin{itemize}
	\item control version of each file for each user
	\item add commentary for each version
	\item fetch specific version of the project
	\item be able to run in a network
\end{itemize}

\emph{sccs}, \emph{rcs} and \emph{cvs} are one of many RCS�s,
which are avaiable under the GPL.

\section{Compiler}
To compile the source code to the platforms binary format, you need 
a compiler for the specific programming language.

Ansi-C, Ansi-C++, Fortran and Pascal are some of many important languages,
where Ansi-C and Ansi-C++ is included in a standard unix installation.
Ansi-C is the de facto Unix programming language.
Both Ansi-C and Ansi-C++ are supported by the Gnu C Compiler (GCC).
The GCC is avaiable under the GPL. You can use the GCC for many platforms
and for cross platform development.

\section{Linker and Standard-Librarys}
The output of a compiler, e.g. GCC, is the object file with the postfix \emph{.o}. To create a executable file, you still have to bind all needed object files and some standard librarys together. These bindings are done with the linker, named \emph{ld}. Nowadays Unix systems uses the ELF binary format, which supports dynamic librarys. Dynamic librarys can be linked at runtime, so the executable file won�t consume disk- and memory-space for them.
A standard library is for example the standard C or C++ library,
which contains all string, input/output and other standard functions.

Other librarys can be used either, e.g. the X library to be able to use 
the X-Window-System.

\section{Make}
To built the goal, normaly the executable program, out of all
source files, \emph{make} can be used.
\emph{make} takes a \emph{makefile} as its input.
The \emph{makefile} contains recepts for each procedure. A recept defines a goal, it�s needed source files and the action which should be done if one of the source files is older than the goal.
The action could be a compilation, a linker but also a RCS command.

\section{Debugger}
If the written program does not do what is should do, often happens ;-),
the programmer must analyze the code. A debugger helps to analyze the code and to find the error. An error in a program is called a bug. So the debugger should help fixing all those bugs, a program has.
The debugger can show the values of variables, can set breakpoints where the
program should stop, can step through the source code lines.
Debugger does not replace the programmers brain, but they can help to
visualize how the program work.

\section{Profiler}
If the written program consumes much time and looks like it is inefficient,
a profiler may help. Profiler can show the costs, time consuming, of
different parts of programs.

\section{Lex \& Yacc}
With Lex \& Yacc parsers can be written fast and easily. The syntax is written
in an BNF style. Please refer chapter \ref{JavaCC} on page \pageref{JavaCC} where these tools are compared with it's java aequivalent.

\section{ \LaTeX\ }
To write the documentation \LaTeX\\cite{Kopka} is a low cost and a free avaiable for all
platforms text-setting compiler.
The \LaTeX\ source is an easy ASCII text with some macro-programming
features. Doing documentation with \LaTeX\ means not to let the layout be created and just to write the text while specifying the chapters, sections, footnotes, references, etc.

\section{ \LaTeX\-2Html }
The \LaTeX\ documentation can easily converted to HTML using \LaTeX\-2Html\cite{Dragos96}.
Thus the complete documentation can be put on a web server.
\LaTeX\-2Html supports the \LaTeX\ writer with many HTML features like
generating links to other places, etc. Today Html 3.2 is supported.

Later in this documentation, 
section \ref{latexhtml} on page \pageref{latexhtml}), 
you can find an approved example of using HTML-Source generated documentation.

\chapter{The Java Development Environment}

\section{Java Development Kit}
Sun Microsystems offers their Java Development Kit (JDK) \label{jdk} for
several platforms. The JDK contains powerful command line tools:
\begin{itemize}
	\item java virtual machine (JVM)
	\item compiler with dependency check
	\item debugger
	\item java documentation tool (javadoc)
\end{itemize}
Many commercial software producers started to develop their own
GUI\footnote{GUI = Graphical User Interface} based development
environment. 
As you can see, many tools are given with the JDK, but some tools are missing.

\section{Java Foundation Classes (JFC)}
The JFC, actualy known as Swing, supports Java with new very usefull 
components:
\begin{itemize}
	\item ToolTips (known as BubbleHelp)
	\item Editor-Classes (can browse html and rtf)
	\item Easy Hotkey-Bindings
	\item TabbedFolders
	\item Light-Weight-Components (Java-, Motiv-, Windows-Look)
	\item ...
\end{itemize}
These JFC will be a part for the upcoming JDK 1.2.X,
for now you can use it as a package-class-jar-file under the package
hirarchy com.java.swing.*.

\section{Using The Unix Standard Environment}
On Unix platforms and on man other platforms, e.g. Windows (see section \ref{gnuwin32}, page \pageref{gnuwin32}),
the Unix tools are avaiable.
Thus we can use .
\label{javaunixenv}

\section{JavaDepend}
JavaDepend\cite{5} is the makedepend (or the C compiler invokation with the option --M or --MM) aequivalent.
JavaDepend creates prerequisites for the makefile,
so all sources newer than it's goals will be compiled.

\section{javadoc}
With javadoc source documentations can be created.
The source can be added with simple javadoc-tags 
in the commentary-part.
javadoc creates a HTML documentations including a class-tree
and package index.

\section{Parser Generation using JavaCC}
\label{JavaCC}
Usually we need \emph{Lex \& Yacc} \cite{1} to generate a parser.
\emph{Lex \& Yacc} can generate Pascal, C or C++ source-code.
This source-code can be compiled to a platform specific executable.
Platform specific means, that the source-code is compiled into
native-code, which uses special machine-instructions and the
special operation-system environment.
If we have ANSI code, especially C or C++, we
are able to compile the same code with less or no modifications on
each target. But the executable binary-code is not portable.

Nowadays we can use Java as the programming language and
the JVM as the platform to use platform-independend compilers.
Sun Microsystems offers a Java based aquivalent to Lex \& Yacc,
the Java-Compiler-Compiler (JavaCC) \cite{3}

Instead of Lex \& Yacc, where Yacc is a LALR Parser generator,
JavaCC is a LL(k) Parser generator. So JavaCC uses the extended
Backus Naur Form (EBNF) for the syntax description. Also JavaCC 
descriptions defines the tokens in the same file, 
instead of Lex \& Yacc, where Lex supports Yacc with tokenisation.

\chapter{The Jau-Package }

\section{Goals}
The goals of the Jau-Package is to support java developers with:
\begin{enumerate}
	\item Bubble-Help ( for Swing-JComponents using ToolTips )
	\item HTML-Online-Manual (using Swings-Packages Html/Text View)
	\item GUI-Text settings (e.g. for language)
	\item Configure Swings-Tree GUI (not yet implemented)
	\item Runtime configuration with text files (e.g. for the above)
	\item EMail sending (SMTP)
	\item Misc. Stuff:
	\begin{enumerate}
		\item timer
		\item assert-functions
		\item graphical utilities (e.g. turtel graphics)
		\item easy standard windows (e.g. setup, system infos)
		\item new gui elements
	\end{enumerate}
\end{enumerate}

Many of the above goals are allready implemented and tested with some
demonstration applications.

This package does not want to be a kind of concurence to the new Swing
package or other wonderfull tools. It is just a little help and just
a demonstration. As you can see above, this package uses Swing allready.

The packages generated documentation is here:
\htmladdnormallink{packages.html}{packages.html}.

At the FileArea at the top of jausoft, you can download the complete 
development-structure.

\section{Prerequisites}

To \emph{use} the jau package, you need to have installed:
\begin{itemize}
	\item JDK 1.1.5
	\begin{itemize}
		\item JDK 1.1.5 from sun
		\item Netscape Communicator 4.5 (is a 1.1.5 capable browser)
		\item HotJava 1.1.2 (is a 1.1.5 capable browser)
	\end{itemize}
	\item Swing JFC 1.1
\end{itemize}

To \emph{compile} the jau package, you need to have installed:
\begin{itemize}
	\item JDK 1.1.5
	\item Swing JFC 1.1
	\item JavaCC 0.7
	\item a unix - make-tool (gnu-make)
	\begin{itemize}
		\item use linux :-)
		\item use cygnus-win32-b19
	\end{itemize}
\end{itemize}

To \emph{generate} this documentation,  you need to have installed:
\begin{itemize}
	\item /LaTeX/
	\item /LaTeX/-2Html
\end{itemize}


\section{The Used Development Environment}

\subsection{The directory structure}

\begin{center}
\begin{tabular}{ll}
\tt jau & The THISDIR path (see makefile) \\
\tt jau/resources & The resources-area: icons, .... \\
\tt jau/jau & The path of the Jau-Package \\
\tt jau/jau/componentcfg & The jau.componentcfg package \\
\tt jau/jau/awt & The jau.awt package \\
\tt jau/jau/infomisc & The jau.infomisc package \\
\tt jau/jau/timemisc & The jau.timemisc package \\
\tt jau/jau/gfxmisc & The jau.gfxmisc package \\
\tt jau/jau/tool & The jau.tool package \\
\tt jau/jau/netmisc & The jau.netmisc package \\
\tt jau/jau/misc & The jau.misc package \\
\tt jau/tests & The demonstartion path \\
\tt jau/tests/SinusCoss & The shooting game with system infos \\
\tt jau/docs-src &  The source path for the documentation \\
\tt jau/docs & The destination of all generated documentation \\
\tt jau/docs/icons & The javadoc icons\\
\tt jau/docs/images & The /LaTeX/-2Html images \\
\end{tabular}
\end{center}

\subsection{Installation}

If every prerequisites are complete, you can compile and install
the package with:

\begin{enumerate}
\item Edit the makefile to enter YOUR directory structure.
\item Compile java-classes with �make�.
\item Generate the html-doku with �make htmldoc�
\item Copy everything to your classpath with �make classcpy�,
\item assume that the makefile-makro DESTDIR contains your destination-path
\item cd to �test/SinusCoss� and call �javac *.java� to generate the game SinusCoss 1.2 !
\end{enumerate}

If DESTDIR is in your CLASSPATH, you can now invoke
the game either with �java SinusCoss�
or as an applet (with sound) with �appletviewer SinusCoss.html�.

\subsection{The Makefile}
To compile, generate the complete documentation and other tasks,
a central makefile is used.

\begin{verbatim}
# *********************************************************
#
# This is the standard makefile for compilation the java code 
# and to generate the documentation
#
# A korn-shell is assumed to be used as the default shell
#
# This Makefile has the following basic recipes:
#
#    all: generate all Jau-Package's *.class files
#      test: generate all demonstrations
#   htmldoc: generate the documentation
#  classcpy: copy all *.class files to the DESTDIR (define lower)
#     clean: remove all generated files except the documentation
#
# *********************************************************
#
# ! Check these directories to modify !
#

# ... The local directory structure
PREFIX = /usr/local
THISDIR = /usr/local/projects/java-1.1.X/jau

# ... Here we have the java place
JAVA_VERSION = 1.1.X
JDK_HOME = $(PREFIX)/jdk$(JAVA_VERSION)

# ... Some informations for javadoc
SOURCEPATH=$(JDK_HOME)/lib/classes.zip:$(THISDIR)

# ... The place where the *.class files should be copied to, 
# ... Using the recipe �classcpy�
DESTDIR = $(PREFIX)/classes-$(JAVA_VERSION)

# ... The standard java tools and its standard invocation

# ... �javac� is invoked with �-depend�, to compile all needed class-files also
JAVAC = javac -depend

# ... The java compiler compiler (JavaCC)
JAVACC=javacc

# ... The html-document generator of JavaCC
JJDOC=jjdoc

# ! From here - i guess - nothing must be changed ... !

# ... All the sources of the Jau-Package which should be compiled
SRC = \
jau/gfxmisc/EasyTurtle.java \
jau/infomisc/InfoDialog.java \
jau/infomisc/SetupValue.java \
jau/infomisc/SetupWindow.java \
jau/infomisc/SysInfoWin.java \
jau/misc/Test.java \
jau/netmisc/MailTo.java \
jau/timemisc/SimpleTimer.java \
resources/Resources.java \
jau/tool/JauGlobal.java \
jau/componentcfg/ASCII_CharStream.java \
jau/componentcfg/ComponentCfg.java \
jau/componentcfg/ComponentCfgBase.java \
jau/componentcfg/ComponentCfgBaseConstants.java \
jau/componentcfg/ComponentCfgBaseTokenManager.java \
jau/componentcfg/ComponentCfgException.java \
jau/componentcfg/ComponentCheckOpt.java \
jau/componentcfg/ComponentData.java \
jau/componentcfg/WinComponentData.java \
jau/componentcfg/ParseError.java \
jau/componentcfg/Password.java \
jau/componentcfg/PasswordBlock.java \
jau/componentcfg/Token.java \
jau/componentcfg/ComponentMgr.java \
jau/awt/JauHtmlPanel.java 

# ... All packages included in the Jau-Package, needed for javadoc
PACKAGES = \
resources \
jau.awt \
jau.componentcfg \
jau.gfxmisc \
jau.infomisc \
jau.misc \
jau.netmisc \
jau.timemisc \
jau.tool \
jau.tree

# ... The demonstration programs for the Jau-Package
TSTSRC = \
tests/SinusCoss/SinusCoss.java 

# ... The path of all demonstration programs, needed for javadoc
TSTDIRS=tests:tests/SinusCoss

# ... Here we have the implicite (suffix) rules
# ... We do save all outputs to the �msg� file

.SUFFIXES:    .jj .java .class 

# ... We have to invoke JavaCC from the path where the source resides !
.jj.java:
    cd ${<D}; $(JAVACC) ${<F} 2>&1 | tee -a msg
    cat ${<D}/msg >> msg

.java.class:
    $(JAVAC) $< 2>&1 | tee -a msg

# ... Here we have the default recipe, which will generate all
# ... *.class files for the Jau-Package
# ... The documents and other things must be invoked explicite, see the header! 
all: ${SRC:java=class}

# ... Generate the demostrations
test:
    cd tests; $(JAVAC) *.java 2>&1 | tee -a msg
    cd tests/SinusCoss; $(JAVAC) *.java 2>&1 | tee -a msg

# ... Copy all *.class files to DESTDIR
classcpy:
    for i in $$(find . -name \*.class -a -not -path ./tests/\* ) ; do \
        if [ ! -e $(DESTDIR)/$$(dirname $$i) ] ; then \
          mkdir -p $(DESTDIR)/$$(dirname $$i) ; \
        fi ; \
        cp $$i $(DESTDIR)/$$i ; \
    done 
    echo classes copied
    cp -Rf jauimages jaudata $(DESTDIR)/../.

# ... Generate the HTML documentation
htmldoc:
    rm -f docs/*.html docs/*.css 
    cd docs-src; UpdateHtml
    cd jau/componentcfg ; \
    $(JJDOC) -OUTPUT_FILE=$(THISDIR)/docs/ComponentCfgBaseEBNF.html ComponentCfgBase.jj
    javadoc -d docs \
    -sourcepath $(SOURCEPATH):$(TSTDIRS) \
    -author -version \
    $(PACKAGES) $(TSTSRC)

rmmsg:
    rm -f $$(find . -name msg)

rmclass:
    rm -f $$(find . -name \*.class)

# ... Clean up all generated files, except the documentation
clean: rmmsg rmclass
    rm -f jau/componentcfg/ASCII_CharStream.* \
       jau/componentcfg/ComponentCfgBase.java \
       jau/componentcfg/ComponentCfgBase.class \
       jau/componentcfg/ComponentCfgBaseConstants.* \
       jau/componentcfg/ComponentCfgBaseTokenManager.* \
       jau/componentcfg/ParseError.*

# ... Special dependencies

jau/componentcfg/ASCII_CharStream.java: jau/componentcfg/ComponentCfgBase.java
jau/componentcfg/ComponentCfgBaseConstants.java: jau/componentcfg/ComponentCfgBase.java
jau/componentcfg/ComponentCfgBaseTokenManager.java: jau/componentcfg/ComponentCfgBase.java
jau/componentcfg/ParseError.java: jau/componentcfg/ComponentCfgBase.java

\end{verbatim}

\section{Using a ASCII-Parser for Runtime-Configuration}

\label{latexhtml}
Because Jau-Packages is in java, a java parser generator is needed.
In C and C++ you used to use Lex \& Yacc. Java has JavaCC\cite{3}.

The package \emph{jau.componentcfg} supports the Jau-Package with runtime
configuration. The solution is to parse a text file with a specified grammar.
The result is saved in a object of the type \emph{ComponentCfg}.

You can have a look at the generated file \htmladdnormallink{ComponentCfgBase.java}{jau.componentcfg.ComponentCfgBase.html}. The grammar, source, is specified in \htmladdnormallink{ComponentCfgBase.jj}{ComponentCfgBaseEBNF.html}.
If you view the HTML version, you are able to follow the above links. The latter links to a generated grammar description (without terminal-symbols) named \emph{ComponentCfgBaseEBNF.html}. This file is generated with \emph{jjdoc}, which is also a part of JavaCC.
You can look at a demonstration config-file at 
\htmladdnormallink{../resources/SinusCoss12/SinusCoss.en.cfg}{../resources/SinusCoss12/SinusCoss.en.cfg}.

To affect a java application or applet, we can use the \htmladdnormallink{ComponentMgr.java}{jau.componentcfg.ComponentMgr.html}.
The \emph{ComponentMgr} can add single awt-components or complete 
awt-container to be affected by the runtime-configuration.
The following can be configurated:

\begin{minipage}{15cm}
\renewcommand{\thempfootnote}{\alph{mpfootnote}}

\begin{enumerate}
	\item Bubble-Help (ToolTips for Swing-Components)
	\item HTML-Online-Manual\footnote[1]{Uses jau.awt.JauHtmlBrowser if not started within a Html-Browser!}
	\item GUI-Text settings (e.g. for language)
	\item Runtime configuration with text files (e.g. for the above)
	\item Error, Warning and Info CheckWindows
	\item Tree-Browser configuration\footnote[2]{Not completly implemented yet}
	\item Mandatory input fields, with auto checking and CheckWindows invocation\footnotemark{1}. 
	\item Action-Call definitions\footnotemark[2]
	\item Fontsize changing (automatic if screen-resolution changed or manualy)
\end{enumerate}

\end{minipage}

\section{The HTML Packages-Documentation} 

If you view the HTML version of this documentation, you can easily 
go to the HTML package documentation by following this link:
\htmladdnormallink{packages.html}{packages.html}.

\section{The Demonstration-Applets and -Applications}

Befor you try the listed Applets, please be sure to use an Java 1.1.X capable
Browser like HotJava. You also have the JFC (Swing package) 1.1 being installed.

\htmladdnormallink{SinusCoss V1.3}{../../tests/SinusCoss/SinusCoss.html}.
\htmladdnormallink{JauHtmlBrowser V0.3}{../../tests/JauBrowser/JauHtmlBrowser.html}.

You can reach the Online-Help with F1 :-) !

It is possible that your the JauHtmlBrowser cannot be started as an applet
out of Netscape :-(, so you can try also the appletviewer:
\begin{verbatim}
	appletviewer http://jausoft.goethel.de/Files/Java/1.1.X/JauPackage/jau/tests/JauBrowser/JauHtmlBrowser.html
	appletviewer http://jausoft.goethel.de/Files/Java/1.1.X/JauPackage/jau/tests/SinusCoss/SinusCoss.html
\end{verbatim}

If you want to try the JauHtmlBrowser as an application,
download \htmladdnormallink{jau.jar}{../../jau.jar} and type on
the command shell:
\begin{verbatim}
	java jau.awt.JauHtmlBrowserFrame [<a optional start-url>]
\end{verbatim}

\section{License}
\input{../LICENSE.txt}

\begin{thebibliography}{99}
	\bibitem{1} Wilfred J. Hansen, Bison, http://www.cs.cmu.edu/afs/cs/project/atk-ftp/bison
	\bibitem{2} Mary Campione and Kathy Walrath, The Java Tutorial, Sun Microsystems, http://www.javasoft.com/docs/books/tutorial/index.html
	\bibitem{3} Sun Microsystems, JavaCC Version 0.7, http://www.suntest.com/JavaCC/index.html
	\bibitem{4} Cygnus Solutions, GNU-Win32 Project Version b18, http://www.cygnus.com/misc/gnu-win32
	\bibitem{5} Warren Pfeffer, JavaDepend Version 2.4.3, http://pluto.njcc.com/~slinky/land\_of\_science.html
	\bibitem{Kopka} Helmut Kopka: \LaTeX\ : Eine Einf"uhrung; Addison-Wesley 1991; ISBN 3-89319-338-3 
	\bibitem{Dragos96} Nikos Drakos (nikos@cbl.leeds.ac.uk): /LaTeX/-2Html; \htmladdnormallink{http://cbl.leeds.ac.uk/nikos/tex2html/doc/latex2html/latex2html.html}{http://cbl.leeds.ac.uk/nikos/tex2html/doc/latex2html/latex2html.html}
\end{thebibliography}

\end{document}


