<?xml version="1.0"?>
<!DOCTYPE document SYSTEM "./dtd/document-v10.dtd">

<!-- ========================================================================= -->
<!-- Copyright (C) The Apache Software Foundation. All rights reserved.        -->
<!--                                                                           -->
<!-- This software is published under the terms of the Apache Software License -->
<!-- version 1.1, a copy of which has been included with this distribution in  -->
<!-- the LICENSE file.                                                         -->
<!-- ========================================================================= -->

<!-- ========================================================================= -->
<!-- version $Id$ -->
<!-- ========================================================================= -->
<document>
    <header>
        <title>Installing Batik</title>
        <authors>
            <person name="Christophe Jolif" email="cjolif@ilog.fr"/>
            <person name="Vincent Hardy" email="vincent.hardy@eng.sun.com"/>
        </authors>
    </header>

    <body>

        <s1 title="Introduction">

            <p>This page discusses the following Batik installation issues:</p>
            <ul>
                <li><link href="#systemRequirements">System Requirements</link></li>
                <li><link href="#distributions">Choosing a download from the distribution</link></li>
                <li><link href="#optionalComponents">OptionalComponents</link></li>
            </ul>
        </s1>

        <anchor id="systemRequirements" />
        <s1 title="System Requirements">
            <p>
            Batik requires the following systems to be already installed in your
            system:
            </p>
            <ul>
                <li><strong>Java Virtual Machine</strong>
                A Java 1.2 or greater compatible virtual machine must be present. Batik
                works best with Java 1.3.
                </li>
            </ul>
        </s1>

        <anchor id="distributions" />
        <s1 title="Choosing a download from the distribution">

            <p>To install Batik, you will need to go to the <link href="dist">download area</link>
            and download one or more ZIP file containing the distribution of your choice. Here are
            the various components you will find in the download area and their intended use:</p>
            <ul>
                <li><strong>batik-</strong><em>version</em><strong>.zip</strong> contains a binary distribution 
                of Batik with executable JAR files that let you get started with Batik easily. This 
                is the recommended distribution if you want to look at Batik's features, or you want to
                experiment with SVG and see the fun things you can do with Batik. The binary distribution 
                comes with a set of sample SVG files. The very first version 
                of Batik's binary distribution is <em>batik-1.0beta.zip.</em></li>

                <li><strong>batik-</strong><em>version</em><strong>-dev.zip</strong> contains a complete 
                snapshot of the Batik source code, documentation, regression tools and utilities as
                well as the script for building Batik. That distribution is a snapshot of 
                the CVS repository. This is the recommended distribution for developers who want 
                to dive into the code and understand how Batik can be integrated in 
                their applications or how Batik can be extended. The very first version 
                of Batik's developer distribution is <em>batik-1.0beta-dev.zip.</em></li>

                <li><strong>batik-docs-</strong><em>version</em><strong>.zip</strong>. That file contains a copy of 
                the Javadoc for the Batik source code.</li>
            </ul>

            <p>In all cases, the user should:</p>
            <ul>
                <li>Make sure a Java Development Kit (JDK) is installed on the computer
                    where Batik will be installed. See <link href="requirements">System Requirements</link>.
                    Make sure that the <code>java</code> runtime is in the <code>PATH</code> environment
                    variable.</li>
                <li>Select the directory where he/she wants to download the distribution</li>
                <li>Download the desired distribution from the <link href="dist">download area</link></li>
                <li>Open a console and go to the directory where the distribution was downloaded.</li>
                <li>Unpack the distribution with Java's JAR utility:<br />
                    <code>jar xvf &lt;distribution&gt;</code><br />
                    For example, if you have downloaded batik-1.0beta.zip into /home/IamHere, type the
                    following at the command prompt:<br />
                    <code>cd /home/IamHere</code><br />
                    <code>jar xvf batik-1.0beta.zip</code><br />
                    <strong>IMPORTANT:</strong> UNIX users, do not use the <code>unzip</code> utility to
                    unpack the various Batik zip files, as this would not set the directories access rights
                    properly.
                    </li>
                <li>From there, following the instructions specific to the application you want to use.
                    For example, see the <link href="svgviewer.html">SVG Viewer</link> page or the
                    <link href="svgrasterizer.html">SVG Rasterizer</link> page for an explanation on
                    how to use these tools.</li>
            </ul>

        </s1>

        <anchor id="optionalComponents" />
        <s1 title="Optional Components">
	    <p>
	    By default, Batik developer distribution comes with the <link href="http://www.mozilla.org/rhino">Mozilla Rhino</link> JavaScript Engine. 
	    </p>
	    <p>
	    To enable other scripting languages support, you will only need to install
	    the correct jar files in <code>lib</code> directory of Batik and to 
	    recompile your distribution.
	    </p>
	    <ul>
	        <li>
		For Python, you need to download JPython distribution at the following
		URL <link href="http://www.jpython.org">http://www.jpython.org</link>. 
		Then you put the <code>jpython.jar</code> file in the Batik <code>
		lib</code> directory.
		</li>
	        <li>
		For Tcl, you need to download Jacl &amp; TclBlend distribution at
		the following URL <link href="http://dev.scriptics.com/software/java/">http://dev.scriptics.com/software/java</link>. 
		Then you put the <code>jacl.jar</code> &amp; <code>tcljava.jar</code>
		files in the Batik <code>lib</code> directory.
		</li>
	    </ul>
	    <p>
	    Conversely, you can remove the <code>js.jar</code> of the Batik 
	    <code>lib</code> directory to remove JavaScript support and have a smaller
	    distribution.
	    </p>
        </s1>
    </body>
</document>
