<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<!--
  Licensed to the Apache Software Foundation (ASF) under one or more
  contributor license agreements.  See the NOTICE file distributed with
  this work for additional information regarding copyright ownership.
  The ASF licenses this file to You under the Apache License, Version 2.0
  (the "License"); you may not use this file except in compliance with
  the License.  You may obtain a copy of the License at

      http://www.apache.org/licenses/LICENSE-2.0

  Unless required by applicable law or agreed to in writing, software
  distributed under the License is distributed on an "AS IS" BASIS,
  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  See the License for the specific language governing permissions and
  limitations under the License.
-->
<!--
Please note that this HTML file was _not_ created by Forrest.
-->
<html>
  <head>
    <title>Apache Forrest - quick start</title>
  </head>
  <body>
    <img src="site-author/resources/images/apache-forrest.png" alt="forrest" />
    <br /><a href="http://www.apache.org/" class="title">Apache</a>
   &gt;<a href="http://xml.apache.org/" class="title">XML</a>
   &gt;<a href="http://forrest.apache.org/" class="title">Forrest</a>
    <hr />
    <h2>What is this?</h2>
    <p>
      Apache Forrest is a publishing framework that transforms input from
      various sources into a unified presentation in one or more output formats.
      The modular and extensible plugin architecture is based on Apache Cocoon
      and relevant standards, which separates presentation from content. Forrest
      can generate static documents, or be used as a dynamic server, or be
      deployed by its automated facility.
    </p>
    <h2>What do I do now?</h2>
    <p>
      Apache Forrest requires that Java 1.4 (or newer) be installed on your
      system. If you need help with that, then see the Forrest FAQ. Basically,
      if you are only going to use Forrest as-is then you need only the Java
      Runtime Environment (JRE) and if you intend to enhance and rebuild Forrest
      then you need the full JDK.
    </p>
    <p>
      With a downloaded distribution, Forrest is already built. Just set the
      environment variables for convenience: FORREST_HOME to refer to this
      top-level of the distribution and add FORREST_HOME/bin to your PATH. That
      is it, ready.
    </p>
    <p>
      The source code is also provided, so you can alter it or extend it, and
      then re-build by doing <tt>'cd main; build.bat clean; build.bat'</tt>
      (Windows) or <tt>'cd main; ./build.sh clean; ./build.sh'</tt> (Unix). If
      you need more instructions, then see the
      <a href="http://forrest.apache.org/docs/build.html">Building Forrest</a>
      document.
    </p>
    <p>
      Forrest is ready to go! Here are some things to try ...
    </p>
    <h3>Run a webapp of the Apache Forrest documentation</h3>
    <p>
      Type <tt>'forrest run'</tt> in the <code>site-author</code> directory. You
      can then point your browser to
      <a href="http://localhost:8888/">http://localhost:8888/</a> and view the
      Forrest documentation generated dynamically. To stop Apache Forrest just
      press Ctrl+C.
    </p>
    <h3>Render the Forrest core documentation</h3>
    <p>
      Simply type <tt>'forrest'</tt> in the <code>site-author</code> directory.
      This will render all of the HTML and PDFs for the Forrest documentation
      into the <tt>build/site/</tt> directory. Point your web browser to the
      index.html file there.
    </p>
    <h3>Generate your own site</h3>
    <p>
      Create a new (empty) directory in your home space, cd to it, and type
      <tt>'forrest seed'</tt> which will generate a skeleton directory structure
      and template XML. If you like, edit the XML in the
      <tt>src/documentation/content/xdocs/</tt> directory. Now type
      <tt>'forrest'</tt> to render your new site, or <tt>'forrest run'</tt> to
      generate a <a href="http://localhost:8888/">webapp</a> then experiment
      with editing docs in <tt>src/documentation/content/xdocs/</tt> and watch
      them be instantly rendered.
    </p>
    <h2>Further information</h2>
    <p>
      Type 'forrest -projecthelp' to list the available Forrest commands. NOTE:
      use the 'forrest.bat' version when running under Cygwin!
    </p>
    <p>
      Your distribution has a copy of the Apache Forrest core documentation.
      Refer to the online or SVN version for the up-to-date documentation.
    </p>
    <p>
      Release notes are available at
      <a href="etc/RELEASE-NOTES-0.8.txt">etc/RELEASE-NOTES-0.8.txt</a>
    </p>
    <p>
      People upgrading from previous versions should see the
      <a href="http://forrest.apache.org/docs/upgrading_08.html">Upgrading notes</a>.
    </p>
    <p>
      For further information please read the
      <a href="http://forrest.apache.org/docs/your-project.html">Using Forrest</a>
      guide. If you have any questions or suggestions, please subscribe to the
      <a href="http://forrest.apache.org/mail-lists.html">Forrest mailing
      lists</a>.
    </p>
    <p>
      Thanks for using Apache Forrest.
    </p>
    <hr />
    <p>
      Copyright 2002-2007 Apache Software Foundation. All rights reserved.
    </p>
  </body>
</html>
