~~ $Id$
~~
~~ 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.
~~
         -----------
         Migration from Struts-Tiles
         -----------

Migration from Struts-Tiles

  This tutorial is intended to provide a help when migrating from the previous
  version of Tiles, known as
  <<{{{http://struts.apache.org/1.3.8/struts-tiles/index.html}Struts-Tiles}}>>.

  To use Tiles you need to put in your web application library directory:

  * <<<tiles-api.jar>>>: it contains the API to manipulate and render Tiles.

  * <<<tiles-core.jar>>>: it contains the "engine" of Tiles, and the basic
  implementation of the APIs.

  * <<<tiles-servlet.jar>>>: it contains the servlet support in Tiles.

  * <<<tiles-jsp.jar>>>: it contains the JSP support to Tiles, i.e. JSP specific
  classes and the tag library.

  * <<<tiles-compat.jar>>>: it contains the compatibility layer of Tiles to
  support Struts-Tiles 1.x XML definition files.

* Further steps

   * {{{./configuration.html}Tiles configuration files}}: How to migrate Tiles
   configuration files, the file usually named <<<tiles-defs.xml>>>.

   * {{{./tags.html}Tiles JSP tags}}: How to migrate Tiles JSP tags, the
   <<<\<tiles:...\>>>> tags.

   * {{{./apis.html}Java APIs considerations}}: Some information and warnings on
   the different behaviour of the Tiles Java API.

   * {{{./extension.html}Tiles extensions}}: How to migrate Tiles
   extensions, with explanation of main changes in the code structure.
