2009/05/20 - Apache Shale has been retired.

 /*

  * 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.

  */

 package org.apache.shale.tiles;

 import java.io.IOException;

 import java.text.MessageFormat;

 import java.util.Locale;

 import java.util.MissingResourceException;

 import java.util.ResourceBundle;

 import javax.faces.FacesException;

 import javax.faces.application.ViewHandler;

 import javax.faces.component.UIViewRoot;

 import javax.faces.context.ExternalContext;

 import javax.faces.context.FacesContext;

 import org.apache.commons.logging.Log;

 import org.apache.commons.logging.LogFactory;

 import org.apache.tiles.ComponentContext;

 import org.apache.tiles.ComponentDefinition;

 import org.apache.tiles.DefinitionsFactoryException;

 import org.apache.tiles.NoSuchDefinitionException;

 import org.apache.tiles.TilesRequestContext;

 import org.apache.tiles.TilesUtil;

 import org.apache.tiles.context.BasicTilesContextFactory;

 /**

  * This view handler strips the suffix off of the view ID and looks

  * for a tile whose name matches the resulting string. For example, if the

  * view ID is /tiles/test.jsp, this view handler will look for a tile named

  * /tiles/test. If the tile is found, it is rendered; otherwise, this view handler 

  * delegates to the default JSF view handler.

  * <p/>

  * To render a tile, this view handler first locates the tile by name. Then it

  * creates or accesses the Tile Context, and stores the tile's attributes

  * in the context. Finally, it dispatches the request to the tile's layout

  * by calling JSF's <code>ExternalContext.dispatch()</code>. Layouts typically

  * contain <tiles:insert> tags that include dynamic content.

  * <p/>

  * If the request does not reference a tile, this view handler delegates

  * view rendering to the default view handler. That means that URLs like this:

  * <code>http://localhost:8080/example/index.faces</code> will work as 

  * expected.

  *<p/>

  * Most of the methods in this class simply delegate to the default view

  * handler, which JSF passes to this view handler's constructor. The only

  * method that has a meaningful implementation is <code>void 

  * renderView(FacesContext, UIViewRoot)</code>, which renders the current

  * view in accordance with the algorithm discussed above.

  *

  * <strong>Note:</strong> This Tiles view handler is tied to the standalone 

  * version of Tiles, which resides in the Struts sandbox. This view handler

  * will not work with Struts Tiles.

  */

 public class TilesViewHandler extends ViewHandler {

    // ------------------------------------------------------------- Constructor

    /**

     * <p>Stores the reference to the default view handler for later use.</p>

     * 

     * @param defaultViewHandler The default view handler

     */

    public TilesViewHandler(ViewHandler defaultViewHandler) {

       this.defaultViewHandler = defaultViewHandler;

    }

    // -------------------------------------------------------- Static Variables

    /**

     * <p><code>MessageFormat</code> used to perform parameter substitution.</p>

     */

    private MessageFormat format = new MessageFormat("");

    /**

     * <p>Log instance for this class.</p>

     */

    private static final Log log = LogFactory.getLog(

                                             TilesViewHandler.class.getName());

    /**

     * <p>Message resources for this class.</p>

     */

    private static ResourceBundle bundle =

       ResourceBundle.getBundle("org.apache.shale.tiles.Bundle",

                                Locale.getDefault(),

                                TilesViewHandler.class.getClassLoader());

     /**

      * <p>The default JSF view handler.</p>

      */

    private ViewHandler defaultViewHandler = null;

    // ----------------------------------------------------- ViewHandler Methods

    /**

     * <p>Render a view according to the algorithm described in this class's

     * description: Based on the view Id of the <code>viewToRender</code>, 

     * this method either renders a tile or delegates rendering to the default 

     * view handler, which takes care of business as usual.</p>

     *

     * @param facesContext The faces context object for this request

     * @param viewToRender The view that we're rendering

     */

    public void renderView(FacesContext facesContext, UIViewRoot viewToRender) 

                                         throws IOException, FacesException {

       String viewId = viewToRender.getViewId();

       String tileName = getTileName(viewId);

       ComponentDefinition tile = getTile(tileName);

       if (log.isDebugEnabled()) {

          String message = null;

          try {

              message = bundle.getString("tiles.renderingView");

          } catch (MissingResourceException e) {

              message = "Rendering view {0}, looking for tile {1}";

          }

          synchronized(format) {

             format.applyPattern(message);

             message = format.format(new Object[] { viewId, tileName });

          }

          log.debug(message);

       }

       if (tile != null) {

          if (log.isDebugEnabled()) {

             String message = null;

             try {

                 message = bundle.getString("tiles.dispatchingToTile");

             } catch (MissingResourceException e) {

                 message = "Dispatching to tile {0}";

             }

             synchronized(format) {

                format.applyPattern(message);

                message = format.format(new Object[] { tileName });

             }

             log.debug(message);

          }

          dispatchToTile(facesContext.getExternalContext(), tile);

       }

       else {

          if (log.isDebugEnabled()) {

             String message = null;

             try {

                 message = bundle.getString("tiles.dispatchingToViewHandler");

             } catch (MissingResourceException e) {

                 message = "Dispatching {0} to the default view handler";

             }

             synchronized(format) {

                format.applyPattern(message);

                message = format.format(new Object[] { viewId });

             }

             log.debug(message);

          }

          defaultViewHandler.renderView(facesContext, viewToRender);

       }

    }

    /**

     * <p>Pass through to the default view handler.</p>

     * 

     */

    public UIViewRoot createView(FacesContext context, String viewId) {

       return defaultViewHandler.createView(context, viewId);

    }

    /**

     * <p>Pass through to the default view handler.</p>

     * 

     */

    public Locale calculateLocale(FacesContext context) {

       return defaultViewHandler.calculateLocale(context);

    }

    /**

     * <p>Pass through to the default view handler.</p>

     * 

     */

    public String calculateRenderKitId(FacesContext context) {

       return defaultViewHandler.calculateRenderKitId(context);

    }

    /**

     * <p>Pass through to the default view handler.</p>

     * 

     */

    public String getActionURL(FacesContext context, String viewId) {

       return defaultViewHandler.getActionURL(context, viewId);

    }

    /**

     * <p>Pass through to the default view handler.</p>

     * 

     */

    public String getResourceURL(FacesContext context, String path) {

       return defaultViewHandler.getResourceURL(context, path);

    }

    /**

     * <p>Pass through to the default view handler.</p>

     * 

     */

    public UIViewRoot restoreView(FacesContext context, String viewId) {

       return defaultViewHandler.restoreView(context, viewId);

    }

    /**

     * <p>Pass through to the default view handler.</p>

     * 

     */

    public void writeState(FacesContext context) throws IOException {

       defaultViewHandler.writeState(context);

    }

    // --------------------------------------------------------- Private Methods

    /**

     * <p>Looks up a tile, given a name. If the tile does not exist, and the

     * <code>name</code> begins with a slash ('/'), look for a tile

     * without the slash. If no tile is found, return <code>null</code>.</p>

     * 

     * @param name The tile to lookup

     */

    private ComponentDefinition getTile(String name) {

       if (name == null) 

          return null;

       ExternalContext externalContext = FacesContext.getCurrentInstance()

                                                     .getExternalContext();

       Object request = externalContext.getRequest();

       Object context = externalContext.getContext();

       Object response = externalContext.getResponse();

       ComponentDefinition tile = null;

       try {

         TilesRequestContext tilesContext =

             new BasicTilesContextFactory().createRequestContext(context,

             request, response);

         tile = TilesUtil.getDefinition(name, tilesContext);

       } catch (NoSuchDefinitionException nsex) {

           log.error("Couldn't find Tiles definition.", nsex);

       } catch (DefinitionsFactoryException dex) {

           log.error("Tiles error", dex);

       }

       return tile;

    }

    /**

     * <p>Given a view ID, returns the name of the corresponding tile. For 

     * example, for a view ID of /tiles/example/main.jsp, the tile name 

     * returned by this method would be /tiles/example/main.</p>

     * 

     * @param viewId The view ID

     */

    private String getTileName(String viewId) {

       int suffixIndex = viewId.lastIndexOf('.');

       return suffixIndex != -1 ? viewId.substring(0, suffixIndex)

                                : viewId;

    }

    /**

     * <p>Dispatches to a tile's layout. Layouts typically contain

     * <tiles:insert> tags that include content, so dispatching

     * to the tile's layout will automatically build the tile.</p>

     * <p>

     * Before dispatching to the tile, this method sets up the Tile

     * context.</p>

     * 

     * @param externalContext The JSF external context

     * @param tile The tile definition

     */

    private void dispatchToTile(ExternalContext externalContext,

                                ComponentDefinition tile) 

                                throws java.io.IOException {

       Object request = externalContext.getRequest();

       Object context = externalContext.getContext();

       Object response = externalContext.getResponse();

       TilesRequestContext tilesContext =

           new BasicTilesContextFactory().createRequestContext(context,

           request, response);

       ComponentContext tileContext = ComponentContext.getContext(tilesContext);

       if (tileContext == null) {

          tileContext = new ComponentContext(tile.getAttributes());

          ComponentContext.setContext(tileContext, tilesContext);

       }

       else

          tileContext.addMissing(tile.getAttributes());

       // dispatch to the tile's layout

       externalContext.dispatch(tile.getPath());

    }

 }