catch (Exception e)
        {
            log.error(e.getMessage(),e);
        }
    }

    /**
     * @param page2
     * @return
     */
    private String prefPlus(String page2)
    {
        if (prefix != null)
        {
            return prefix + page2;
        }
        
        return page2;
    }

    /**
     * This method retrieves the preference data for this list. It sets up
     * which columns are visible, the default sort column and direction.
     *  
     * @param pref  the preferences to use to configure the renderer.
     */
    protected void processPreference(RenderPreference pref)
    {
        currentPage = 0;

        if (pref == null)
        {
            throw new RuntimeException("Preference must not be null.");
        }
        
        if (pref.getColumns() != null)
        {
            StringTokenizer tok = new StringTokenizer(pref.getColumns(), ":");
            int size = tok.countTokens();

            visibleColumns = new int[size];
	        for (int i=0;i<visibleColumns.length;i++)
	        {
	            visibleColumns[i] = Integer.parseInt(tok.nextToken());
	        }
        }
        
        if (pref.getSort() != null)
        {
            sort = pref.getSort();
        }
        
        if (pref.isAsc() != null)
        {
            asc = pref.isAsc().booleanValue();
        }
        
        if (pref.getPageSize() != null)
        {
            pageSize = pref.getPageSize().intValue();
        }
            
        if (visibleColumns == null)
        {
	        // configure column selectable
	        visibleColumns = new int[getTotalColumnCount()];
	        for (int i=0;i<visibleColumns.length;i++)
	        {
	            visibleColumns[i] = i;
	        }
        }
    }
    
    protected void addSearchField(SearchFieldRenderer data, String secResource)
    {
        searches.add(data.getKey());
        searchRenderers.put(data.getKey(), data);
        
        if (secResource != null)
        {
            searchSecurity.put(data.getKey(), secResource);
        }
    }

    protected void addSearchField(SearchFieldRenderer data)
    {
        addSearchField(data, null);
    }
    
    public int getSearchFieldCount()
    {
        return searches.size();
    }
    
    public String getSearchFieldKey(int i)
    {
        return (String)searches.get(i);
    }
    
    public SearchFieldRenderer getSearchFieldRenderer(int i)
    {
        return (SearchFieldRenderer) searchRenderers.get(getSearchFieldKey(i));
    }
    
    public String getSearchFieldSecurity(int col)
    {
        return (String) searchSecurity.get(getSearchFieldKey(col));
    }
    
    public String getSearchFieldRequestValue(int i)
    {
        String key = (String) searches.get(i);
        return getString(prefPlus(FILTER_PREFIX+key));
    }

    protected void addSearchFieldToList(String key, String value, SearchFieldRenderer data) // throws SearchFieldException

    protected abstract Listable<T> configureList(String sortKey, boolean isAscending); 
    public abstract boolean isHeadingSortable(int column);
    protected abstract String renderHeading(int column);

    /**
     * @param columnKey
     * @return
     */
    protected abstract Object getValue(int column);


    public boolean isColumnSortable(int column)
    {
        return isHeadingSortable(displayToActual(column));
    }
    
    public void setRenderPreferencable(RenderPreferencable prefs)
    {
        this.prefs = prefs;
    }
    
    public void configure()
    {
        configure(false, false);
    }
    
    /**
     * This method is called by the Table tag to setup and load the data,
     * the list at this stage should not have been loaded, as it is up to 
     * this method to add in the sort options and filter fields.<br>
     * This method also looks after loading the correct page for the multipage
     * logic. 
     */
    public void configure(boolean ignoreSort, boolean showAll)
    {
        if (isAddedToCommand() && !ignoreSort)
        {
            // Setup the sort
            if (getString(prefPlus(SORT)) != null)
            {
                sort = getString(prefPlus(SORT));
            }
            
            if (getBoolean(prefPlus(ASC)) != null)
            {
                asc = getBoolean(prefPlus(ASC)).booleanValue();
            }
        }
        
        list = configureList(sort, asc);
        
        if (isAddedToCommand() && !showAll)
        {
            // Setup the page
            if (getInteger(prefPlus(COUNT)) != null)
            {
                pageSize = getInteger(prefPlus(COUNT)).intValue();
            }
            
            if (getInteger(prefPlus(PAGE)) != null)
            {
                currentPage = getInteger(prefPlus(PAGE)).intValue();
            }
        }

        // Only partially load if we have paging enabled.
        if (!showAll)
        {
            int start = pageSize * currentPage;
            list.setStartIndex(start);
            list.setLoadLength(pageSize);
        }
        
        try
        {
        	if (isAddedToCommand()) 
        	{
	            // Configure the search fields
	            for (int i=0; i<searches.size(); i++)
	            {
	                String key = (String) searches.get(i);
	                SearchFieldRenderer ren = (SearchFieldRenderer) searchRenderers.get(key);
	                
	                String val = getString(prefPlus(FILTER_PREFIX+key));
	                
	                if (val != null)
	                {
	                    addSearchFieldToList(key, val, ren);
	                }
	            }
        	}
            
            list.loadEntries();
        }
        catch (Exception e)

    {
        list.addSearchField(key, data.getConstraint(), value);
    }
    
    protected void addColumn(String key, ElementRenderer data, String secResource)
    {
        columns.add(key);
        columnRenderers.put(key, data);
        
        addRequestParameter(prefPlus(FILTER_PREFIX+key), RequestParameter.STRING, false, prefPlus(FILTER_PREFIX+key));
        
        if (secResource != null)
        {
            columnSecurity.put(key, secResource);
        }
    }

    protected void addColumn(String key, ElementRenderer data)
    {
        addColumn(key, data, null);
    }

    protected int getTotalColumnCount()
    {
        return columns.size();
    }

    public int getColumnCount()
    {
        return visibleColumns.length;
    }
    
    // To support column selectable
    protected int displayToActual(int col)
    {
        return visibleColumns[col];
    }
    
    public String renderColumnHeading(int col)
    {
        return renderHeading(displayToActual(col));
    }
    
    public String getColumnKey(int col)
    {
        return (String) columns.get(displayToActual(col));
    }

    protected String getColumnKeyAct(int col)
    {
        return (String) columns.get(col);
    }

    public String getColumnSecurity(int col)
    {
        return (String) columnSecurity.get(getColumnKey(col));
    }

    protected String getColumnSecurityAct(int col)
    {
        return (String) columnSecurity.get(getColumnKeyAct(col));
    }
    
    public String renderColumn(int col)
    {
        return getDataRenderer(col).render(getElement(col));
    }

    public String renderTextColumn(int col)
    {
        return getDataRenderer(col).renderText(getElement(col));
    }

    public RendererMetaData getMetaData()
    {
        return new DefaultMetaData(this);
    }
    
    /**
     * @param col
     * @return
     */
    private Object getElement(int col)
    {
        return getValue(displayToActual(col));
    }

    public T getCurrentBO()

        if (list.getTotalAvailable()%pageSize !=0)
        {
            numPages++;
        }

        return numPages;
    }

    public String getLayout()
    {
        return activeLayout;
    }
    
    /**
     * @param layoutStyle
     */
    public void switchLayout(String layoutStyle)
    {
        activeLayout = layoutStyle;
        
        RenderPreference pref = null;
        if (prefs != null)
        {
            pref = prefs.getPreference(layoutStyle, getClass().getName());
        }
        
        if (pref == null)
        {
            pref = getDefaultPreference(layoutStyle);
        }

        processPreference(pref);
    }    
    /**
     * @param layoutStyle
     * @return
     */
    protected abstract RenderPreference getDefaultPreference(String layoutStyle);

    /**
     * @return Returns the asc.
     */
    public boolean isAsc()
    {
        return asc;
    }
    /**
     * @return Returns the sort.
     */
    public String getSort()
    {
        return sort;
    }

    /**
     * @param i
     * @return
     */
    public String renderPageLink(int i)
    {
        StringBuffer sbuf = new StringBuffer();
        
        sbuf.append("<a href=\"javascript:document.");
        sbuf.append(form.getName());
        sbuf.append(".");
        if (getPrefix() != null)
        {
            sbuf.append(getPrefix());
        }
        sbuf.append(ListRenderer.PAGE);
        sbuf.append(".value='");
        sbuf.append(i);
        
        sbuf.append("';document.");	               
        sbuf.append(form.getName());
        sbuf.append(".submit();");
        sbuf.append("\">");

        return sbuf.toString();
    }

    /**
     * @param form
     */
    public void setFormTag(FormRendererTag form)
    {
        this.form = form;
    }
    
    /**
     * This method is to be overwridden in sub-classes to enable action
     * items to be rendered.  The value returned from this method is the
     * maximum number of actions that could be displayed, it depends on
     * the return values from the other associated methods as to how many
     * actions are actually rendered.<br>
     * <br>
     * The logic of what is rendered is as follows:<br>
     * For each row, iterate through the ItemActionCount()<br>
     * Get the SecurityResource for the specific ItemAction<br>
     * If it is null then its valid, otherwise check the resource against
     * a ResourceAccessor.<br>
     * If invalid, then render nothing and iterate to the next ItemAction.<br>
     * If valid then get the Action Name, ImageURL and URL.<br>
     * If the Action name and ImageURL are null then render nothing and iterate to the next ItemAction.<br>
     * Otherwise either render a link (href) if a URL exists, or just text if 
     * it doesn't.  If there is an ImageURL then render an Image tag with the
     * name as the alt, or just the name if there is no ImageURL.<br>
     * Then iterate to the next ItemAction.<br>
     *  
     * @return the number of actions for each row.
     */
    public int getItemActionCount()
    {
        return 0;
    }

    /**
     * This method is to be overwridden in sub-classes to enable action
     * items to be rendered.  The value returned from this method is the security
     * resource key for the selected ItemAction.  If the action is availiable
     * to all, then the result should be null, otherwise it should be a resource
     * key specific to the ItemAction.<br>
     * <br>
     * The logic of what is rendered is as follows:<br>
     * For each row, iterate through the ItemActionCount()<br>
     * Get the SecurityResource for the specific ItemAction<br>
     * If it is null then its valid, otherwise check the resource against
     * a ResourceAccessor.<br>
     * If invalid, then render nothing and iterate to the next ItemAction.<br>
     * If valid then get the Action Name, ImageURL and URL.<br>
     * If the Action name and ImageURL are null then render nothing and iterate to the next ItemAction.<br>
     * Otherwise either render a link (href) if a URL exists, or just text if 
     * it doesn't.  If there is an ImageURL then render an Image tag with the
     * name as the alt, or just the name if there is no ImageURL.<br>
     * Then iterate to the next ItemAction.<br>
     * 
     * @param i	the ItemAction to get the security resource for.
     * @return	the Security Resource key for the given ItemAction.
     */
    public String getItemActionSecurityResource(int i, T theBO)

    private Listable<T> list;

    // For the columns
    protected List columns = new ArrayList();
    protected Map columnRenderers = new HashMap();
    protected Map columnSecurity = new HashMap();

    // For the SearchFields
    protected List searches = new ArrayList();
    protected Map searchRenderers = new HashMap();
    protected Map searchSecurity = new HashMap();
    
    protected int count;

    // Column Selectable
    protected int [] visibleColumns;
    
    // Multipage stuff
    protected int pageSize = 10;
    protected int currentPage = 0;

    protected String prefix = null;
    
    // Sort
    protected boolean asc;
    protected String sort;

    // Customisation
    private RenderPreferencable prefs;
    protected ResourceAccessor accessor;
    private String activeLayout;

    private FormRendererTag form;
    
    public ListRenderer()
    {
        this(null);
    }

    /**
     * 
     */
    public ListRenderer(String prefix)
    {
        super();

        this.prefix = prefix;
        
        addRequestParameter(prefPlus(PAGE), RequestParameter.INTEGER, false, prefPlus(PAGE));
        addRequestParameter(prefPlus(COUNT), RequestParameter.INTEGER, false, prefPlus(COUNT));
        addRequestParameter(prefPlus(SORT), RequestParameter.STRING, false, prefPlus(SORT));
        addRequestParameter(prefPlus(ASC), RequestParameter.BOOLEAN, false, prefPlus(ASC));
    }
    
    protected abstract Listable<T> configureList(String sortKey, boolean isAscending); 

		            {
                        buffer.append("<a ");
                        
                        // Check to see if some sort of style has been applied to the links
                        // If a column renderer has been defined with a class,
                        // then inherit that style into the <a> tag.
                        // if not then see if a global heading linkstyle has been defined.
                        if (colR != null && colR.clazz != null)
                        {
                            buffer.append("class='");
                            buffer.append(colR.clazz);
                            buffer.append("' ");
                        }
                        else if (linkStyle != null)
                        {
                            buffer.append("class='");
                            buffer.append(linkStyle);
                            buffer.append("' ");
                        }
                        
                        buffer.append("href=\"javascript:document.");
		                buffer.append(formName);
		                buffer.append(".");
		                if (renderer.getPrefix() != null)
		                {
		                    buffer.append(renderer.getPrefix());
		                }
		                buffer.append(ListRenderer.SORT);
		                buffer.append(".value='");
		                buffer.append(key);
		                
		                buffer.append("';document.");
		                buffer.append(formName);
		                buffer.append(".");
		                if (renderer.getPrefix() != null)
		                {
		                    buffer.append(renderer.getPrefix());
		                }
		                buffer.append(ListRenderer.ASC);
		                buffer.append(".value='true';document.");  // default sort true

public class DefaultMetaData implements RendererMetaData
{
    private final ListRenderer renderer;

    /**
     * @param renderer
     */
    public DefaultMetaData(ListRenderer renderer)
    {
        this.renderer = renderer;
    }

    /**
     * @see au.com.whitesquare.waf.renderer.RendererMetaData#getColumnCount()
     */
    public int getColumnCount()
    {
        return renderer.getTotalColumnCount();
    }

    /**
     * @see au.com.whitesquare.waf.renderer.RendererMetaData#isColumnAccessible(int)
     */
    public boolean isColumnAccessible(int i)
    {
        String sec = renderer.getColumnSecurityAct(i);
        
        if (sec == null || 
           (renderer.getAccessor() != null && renderer.getAccessor().isAuthorised(sec)))
        {
            return true;
        }
        
        return false;
    }

    /**
     * @see au.com.whitesquare.waf.renderer.RendererMetaData#getColumnKey(int)
     */
    public String getColumnKey(int i)
    {
        return renderer.getColumnKeyAct(i);
    }

    /**
     * @see au.com.whitesquare.waf.renderer.RendererMetaData#getColumnName(int)
     */
    public String getColumnName(int i)
    {
        return renderer.renderHeading(i);
    }
    
    public int getColumnIndex(String key)
    {
        for (int i=0; i<renderer.columns.size(); i++)
        {
            if (renderer.columns.get(i).equals(key))
            {
                return i;
            }
        }
        
        return -1;
    }
}

    public NumericSRenderer(String key, String name)
    {
        super(key, name);
    }
    
    /**
     * @throws JspException 
     * @see au.com.whitesquare.waf.renderer.search.SearchFieldRenderer#actualRender(java.lang.Object)
     */
    public void render(PageContext pageContext, String filterRequestValue, SearchLayoutRenderer renderer)  throws JspException
    {
        try
        {
            if (renderer.getNameStyle() != null)
            {
                pageContext.getOut().print("<span class='");
                pageContext.getOut().print(renderer.getNameStyle());
                pageContext.getOut().print("'>");
            }
            pageContext.getOut().print(getName()+": ");
            if (renderer.getNameStyle() != null)
            {
                pageContext.getOut().print("</span> ");
            }
        }
        catch (IOException e)
        {
            getLogger().error(e.getMessage(), e);
        }

        StringBuffer text = new StringBuffer("<input type=\"radio\" ");

        if (getName(element) != null)
        {
            text.append("name=\"");
            text.append(getName(element));
            text.append("\" ");
        }

        if (getOnclick(element) != null)
        {
            text.append("onclick=\"");
            text.append(getOnclick(element));
            text.append("\" ");
        }
        
        if (isChecked(element))
        {
            text.append("checked");
        }

        text.append(">");
        
        return text.toString();
    }
    
    public abstract String getName(Object element);
    public abstract boolean isChecked(Object element);
    public abstract String getOnclick(Object element);
}

    public TextSRenderer(String key, String name)
    {
        super(key, name);
    }
    
    /**
     * @throws JspException 
     * @see au.com.whitesquare.waf.renderer.search.SearchFieldRenderer#actualRender(java.lang.Object)
     */
    public void render(PageContext pageContext, String filterRequestValue, SearchLayoutRenderer renderer)  throws JspException
    {        
        try
        {
            if (renderer.getNameStyle() != null)
            {
                pageContext.getOut().print("<span class='");
                pageContext.getOut().print(renderer.getNameStyle());
                pageContext.getOut().print("'>");
            }
            pageContext.getOut().print(getName()+": ");
            if (renderer.getNameStyle() != null)
            {
                pageContext.getOut().print("</span>");

                    (i <= (multipage.getCurrentPage() + boundary) || (multipage.getCurrentPage() + boundary) >= multipage.getNumPages()))
                {
	                // This is for each of the links.
	                sbuf.append(" ");
	                
	                if (i != multipage.getCurrentPage())
	                {
	                    sbuf.append("<a href='"+ multipage.getCommandKey() +"?PRE=");
	                    sbuf.append(multipage.getPrefix());
	                    sbuf.append("&"+BaseMultipageCommand.PAGE+"=");
	                    sbuf.append(i);
	                    sbuf.append("'>");
	                }
                
	                sbuf.append((i + 1));
	                
	                if (i != multipage.getCurrentPage())
	                {
	                    sbuf.append("</a>");
	                }
                
	                sbuf.append(" ");
                }
            }