htmldatatable.java

一个使用struts+hibernate+spring开发的完的网站源代码。

/*
 * Copyright 2004 The Apache Software Foundation.
 * 
 * Licensed 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.myfaces.component.html.ext;

import org.apache.myfaces.component.UserRoleAware;
import org.apache.myfaces.component.UserRoleUtils;
import org.apache.myfaces.component.UIColumns;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

import javax.faces.component.EditableValueHolder;
import javax.faces.component.UIComponent;
import javax.faces.context.FacesContext;
import javax.faces.el.ValueBinding;
import javax.faces.event.AbortProcessingException;
import javax.faces.event.FacesEvent;
import javax.faces.model.DataModel;
import javax.faces.render.Renderer;

import java.io.IOException;
import java.sql.ResultSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

/**
 * @author Thomas Spiegl (latest modification by $Author: matzew $)
 * @author Manfred Geiler
 * @version $Revision: 1.20 $ $Date: 2005/03/29 11:40:50 $
 * $Log: HtmlDataTable.java,v $
 * Revision 1.20  2005/03/29 11:40:50  matzew
 * added new crosstable component (x:columns). Contributed by Mathias Broekelmann
 *
 * Revision 1.19  2005/03/21 12:33:46  svieujot
 * Set x:dataTable preserveDataModel default value to false.
 *
 * Revision 1.18  2005/03/19 04:27:55  svieujot
 * Align default values for preserveDataModel and preserveSort between HtmlDataTable.java, HtmlDataTableTag.java and the TLD.
 *
 * Revision 1.17  2005/03/04 01:21:22  mmarinschek
 * reverted bug fix as it introduced several new bugs with data-table
 *
 * Revision 1.15  2004/10/13 11:50:56  matze
 * renamed packages to org.apache
 *
 * Revision 1.14  2004/09/13 15:59:44  manolito
 * fixed problems with nested UIData and HtmlDataTable components
 *
 * Revision 1.13  2004/09/10 14:15:00  manolito
 * new previousRowDataVar attribute in extended HtmlDataTable
 *
 * Revision 1.12  2004/08/20 07:14:39  manolito
 * HtmlDataTable now also supports rowIndexVar and rowCountVar
 *
 * Revision 1.11  2004/08/10 13:29:59  manolito
 * full revision of extended HtmlDataTable so that there is no more cache problem
 *
 * Revision 1.10  2004/07/01 21:53:05  mwessendorf
 * ASF switch
 *
 * Revision 1.9  2004/06/22 14:33:29  royalts
 * no message
 *
 * Revision 1.8  2004/06/21 16:01:57  royalts
 * setSortAscending(...) and setSortColumn have to update model their own, because processUdates won't be executed.
 *
 * Revision 1.7  2004/06/21 14:43:20  manolito
 * no more calls to getRowCount to determine if list is empty before encodeBegin was called
 *
 * Revision 1.6  2004/06/21 12:15:29  manolito
 * encodeBegin in UIData examines descendants valid flag recursivly now before refreshing DataModel
 *
 * Revision 1.5  2004/05/21 10:39:26  manolito
 * new renderedIfEmpty attribute in ext. HtmlDataTable component
 *
 * Revision 1.4  2004/05/18 14:31:36  manolito
 * user role support completely moved to components source tree
 *
 * Revision 1.3  2004/05/18 11:22:44  manolito
 * optimized local value handling, so that getValue of UIData is only called when needed
 *
 */
public class HtmlDataTable
        extends HtmlDataTableHack
        implements UserRoleAware
{
    private static final Log log = LogFactory.getLog(HtmlDataTable.class);

    private static final int PROCESS_DECODES = 1;
    private static final int PROCESS_VALIDATORS = 2;
    private static final int PROCESS_UPDATES = 3;

    private static final boolean DEFAULT_SORTASCENDING = true;
    private static final Class OBJECT_ARRAY_CLASS = (new Object[0]).getClass();

    private transient boolean _isDataModelRestored = false;

    //Flag to detect if component is rendered for the first time (restoreState sets it to false)
    transient private boolean _firstTimeRendered = true;

    private String _sortColumn = null;
    private Boolean _sortAscending = null;


    public void setValue(Object value)
    {
        _dataModel = null;
        _isDataModelRestored = false;
        super.setValue(value);
    }


    public void setRowIndex(int rowIndex)
    {
        String rowIndexVar = getRowIndexVar();
        String rowCountVar = getRowCountVar();
        String previousRowDataVar = getPreviousRowDataVar();
        if (rowIndexVar != null || rowCountVar != null || previousRowDataVar != null)
        {
            Map requestMap = FacesContext.getCurrentInstance().getExternalContext().getRequestMap();

            if (previousRowDataVar != null && rowIndex >= 0) //we only need to provide the previousRowDataVar for a valid rowIndex
            {
                if (isRowAvailable())
                {
                    //previous row is available
                    requestMap.put(previousRowDataVar, getRowData());
                }
                else
                {
                    //no previous row available
                    requestMap.put(previousRowDataVar, null);
                }
            }

            super.setRowIndex(rowIndex);

            if (rowIndex >= 0)
            {
                //regular row index, update request scope variables
                if (rowIndexVar != null)
                {
                    requestMap.put(rowIndexVar, new Integer(rowIndex));
                }

                if (rowCountVar != null)
                {
                    requestMap.put(rowCountVar, new Integer(getRowCount()));
                }
            }
            else
            {
                //rowIndex == -1 means end of loop --> remove request scope variables
                if (rowIndexVar != null)
                {
                    requestMap.remove(rowIndexVar);
                }

                if (rowCountVar != null)
                {
                    requestMap.remove(rowCountVar);
                }

                if (previousRowDataVar != null)
                {
                    requestMap.remove(previousRowDataVar);
                }
            }
        }
        else
        {
            // no extended var attributes defined, no special treatment
            super.setRowIndex(rowIndex);
        }
    }


    public void processRestoreState(FacesContext context, Object state)
    {
        super.processRestoreState(context, state);
    }

    public void processDecodes(FacesContext context)
    {
        if(!isRendered())
        {
          return;
        }
        super.processDecodes(context);
        setRowIndex(-1);
        processColumnsFacets(context, PROCESS_DECODES);
        processColumnsChildren(context, PROCESS_DECODES);
        setRowIndex(-1);
    }

    /**
     * @param context
     * @param processAction
     */
    private void processColumnsChildren(FacesContext context, int processAction)
    {
      int first = getFirst();
      int rows = getRows();
      int last;
      if (rows == 0)
      {
        last = getRowCount();
      }
      else
      {
        last = first + rows;
      }
      for (int rowIndex = first; rowIndex < last; rowIndex++)
      {
        setRowIndex(rowIndex);
        if (isRowAvailable())
        {
          for (Iterator it = getChildren().iterator(); it.hasNext();)
          {
            UIComponent child = (UIComponent) it.next();
            if (child instanceof UIColumns)
            {
              if (child.isRendered())
              {
                UIColumns columns = (UIColumns) child;
                for (int colIndex = 0, size = columns.getRowCount(); colIndex < size; colIndex++)
                {
                  columns.setRowIndex(colIndex);
                  for (Iterator columnChildIter = child.getChildren().iterator(); columnChildIter
                      .hasNext();)
                  {
                    UIComponent columnChild = (UIComponent) columnChildIter.next();
                    process(context, columnChild, processAction);
                  }
                }
                columns.setRowIndex(-1);
              }
            }
          }
        }
      }
    }


    /**
     * @param context
     * @param processAction
     */
    private void processColumnsFacets(FacesContext context, int processAction)
    {
      for (Iterator childIter = getChildren().iterator(); childIter.hasNext();)
      {
        UIComponent child = (UIComponent) childIter.next();
        if (child instanceof UIColumns)
        {
          if(child.isRendered())
          {
            UIColumns columns = (UIColumns) child;
            for (int i = 0, size = columns.getRowCount(); i < size; i++)
            {
              columns.setRowIndex(i);
              for (Iterator facetsIter = child.getFacets().values().iterator(); facetsIter.hasNext();)
              {
                UIComponent facet = (UIComponent) facetsIter.next();
                process(context, facet, processAction);
              }
            }
            columns.setRowIndex(-1);
          }
        }
      }
    }

    private void process(FacesContext context, UIComponent component, int processAction)
    {
      switch (processAction)
      {
        case PROCESS_DECODES :
          component.processDecodes(context);
          break;
        case PROCESS_VALIDATORS :
          component.processValidators(context);
          break;
        case PROCESS_UPDATES :
          component.processUpdates(context);
          break;
      }
    }

    public void processValidators(FacesContext context)
    {
      if(!isRendered())
      {
        return;
      }
      super.processValidators(context);
      setRowIndex(-1);
      processColumnsFacets(context, PROCESS_VALIDATORS);
      processColumnsChildren(context, PROCESS_VALIDATORS);
      setRowIndex(-1);
    }

    public Object processSaveState(FacesContext context)
    {
        return super.processSaveState(context);
    }

    public void broadcast(FacesEvent event) throws AbortProcessingException
    {
        super.broadcast(event);
    }

    public void processUpdates(FacesContext context)
    {
        if(!isRendered())
        {
          return;
        }
        super.processUpdates(context);
        setRowIndex(-1);
        processColumnsFacets(context, PROCESS_UPDATES);
        processColumnsChildren(context, PROCESS_UPDATES);
        setRowIndex(-1);

        if (_isDataModelRestored)
        {
            updateModelFromPreservedDataModel(context);
        }

        if (isPreserveSort())
        {
            if (_sortColumn != null)
            {
                ValueBinding vb = getValueBinding("sortColumn");
                if (vb != null)
                {
                    vb.setValue(context, _sortColumn);
                    _sortColumn = null;
                }
            }

            if (_sortAscending != null)
            {
                ValueBinding vb = getValueBinding("sortAscending");
                if (vb != null)
                {
                    vb.setValue(context, _sortAscending);
                    _sortAscending = null;
                }
            }
        }
    }


    private void updateModelFromPreservedDataModel(FacesContext context)
    {
        ValueBinding vb = getValueBinding("value");
        if (vb != null && !vb.isReadOnly(context))
        {
            _SerializableDataModel dm = (_SerializableDataModel)_dataModel;
            Class type = vb.getType(context);
            if (DataModel.class.isAssignableFrom(type))
            {
                vb.setValue(context, dm);
            }
            else if (List.class.isAssignableFrom(type))
            {
                vb.setValue(context, (List)dm.getWrappedData());
            }
            else if (OBJECT_ARRAY_CLASS.isAssignableFrom(type))
            {
                List lst = (List)dm.getWrappedData();
                vb.setValue(context, lst.toArray(new Object[lst.size()]));
            }
            else if (ResultSet.class.isAssignableFrom(type))
            {
                throw new UnsupportedOperationException(this.getClass().getName() + " UnsupportedOperationException");
            }
            else
            {
                //Assume scalar data model
                List lst = (List)dm.getWrappedData();
                if (lst.size() > 0)
                {
                    vb.setValue(context, lst.get(0));
                }
                else
                {
                    vb.setValue(context, null);
                }
            }
        }
    }


    /**
     * TODO: We could perhaps optimize this if we know we are derived from MyFaces UIData implementation
     */
    private boolean isAllChildrenAndFacetsValid()
    {
        int first = getFirst();
        int rows = getRows();
        int last;
        if (rows == 0)
        {
            last = getRowCount();