/*
* 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.myfaces.component.html.ext;
import java.io.IOException;
import java.sql.ResultSet;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.StringTokenizer;
import javax.el.ValueExpression;
import javax.faces.FacesException;
import javax.faces.application.Application;
import javax.faces.component.ContextCallback;
import javax.faces.component.EditableValueHolder;
import javax.faces.component.NamingContainer;
import javax.faces.component.UIColumn;
import javax.faces.component.UIComponent;
import javax.faces.component.UINamingContainer;
import javax.faces.context.FacesContext;
import javax.faces.el.ValueBinding;
import javax.faces.model.DataModel;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.apache.myfaces.component.NewspaperTable;
import org.apache.myfaces.component.UserRoleAware;
import org.apache.myfaces.component.UserRoleUtils;
import org.apache.myfaces.custom.column.HtmlSimpleColumn;
import org.apache.myfaces.custom.crosstable.UIColumns;
import org.apache.myfaces.custom.sortheader.HtmlCommandSortHeader;
import org.apache.myfaces.renderkit.html.ext.HtmlTableRenderer;
import org.apache.myfaces.renderkit.html.util.TableContext;
import org.apache.myfaces.shared_tomahawk.renderkit.JSFAttr;
import org.apache.myfaces.shared_tomahawk.util.ClassUtils;
/**
* The MyFacesDataTable extends the standard JSF DataTable by two
* important features:
* <br/>
* <ul>
* <li>Possiblity to save the state of the DataModel.</li>
*
* <li>Support for clickable sort headers (see SortHeader
* component).</li>
* </ul>
* <br/>
* Extended data_table that adds some additional features to the
* standard data_table action: see attribute descriptions for
* preserveDataModel, sortColumn, sortAscending and preserveSort.
* <br/>
* Unless otherwise specified, all attributes accept static values or EL expressions.
*
* @JSFComponent
* name = "t:dataTable"
* class = "org.apache.myfaces.component.html.ext.HtmlDataTable"
* tagClass = "org.apache.myfaces.generated.taglib.html.ext.HtmlDataTableTag"
* @since 1.1.7
* @author Thomas Spiegl (latest modification by $Author: lu4242 $)
* @author Manfred Geiler
* @version $Revision: 986177 $ $Date: 2010-08-16 22:20:38 -0500 (Lun, 16 Ago 2010) $
*/
public abstract class AbstractHtmlDataTable extends HtmlDataTableHack implements UserRoleAware, NewspaperTable
{
private static final Log log = LogFactory.getLog(AbstractHtmlDataTable.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 boolean DEFAULT_SORTABLE = false;
private static final boolean DEFAULT_EMBEDDED = false;
private static final boolean DEFAULT_DETAILSTAMP_EXPANDED = false;
private static final Class OBJECT_ARRAY_CLASS = (new Object[0]).getClass();
private static final Integer DEFAULT_NEWSPAPER_COLUMNS = new Integer(1);
private static final String DEFAULT_NEWSPAPER_ORIENTATION = "vertical";
private static final String DEFAULT_DETAILSTAMP_LOCATION = "after";
/**
* the property names
*/
public static final String NEWSPAPER_COLUMNS_PROPERTY = "newspaperColumns";
public static final String SPACER_FACET_NAME = "spacer";
public static final String NEWSPAPER_ORIENTATION_PROPERTY = "newspaperOrientation";
public static final String DETAIL_STAMP_FACET_NAME = "detailStamp";
private _SerializableDataModel _preservedDataModel;
private String _forceIdIndexFormula = null;
private String _sortColumn = null;
private Boolean _sortAscending = null;
private String _sortProperty = null;
private String _rowStyleClass = null;
private String _rowStyle = null;
private String _varDetailToggler = null;
private int _sortColumnIndex = -1;
private boolean _isValidChildren = true;
private Map _expandedNodes = new HashMap();
//private Map _detailRowStates = new HashMap();
private TableContext _tableContext = null;
public TableContext getTableContext()
{
if (_tableContext == null)
{
_tableContext = new TableContext();
}
return _tableContext;
}
public void setDetailStamp(UIComponent facet)
{
getFacets().put(DETAIL_STAMP_FACET_NAME, facet);
}
/**
* This facet renders an additional row after or before (according
* to detailStampLocation value) the current row, usually containing
* additional information of the related row. It is toggled usually
* using varDetailToggle variable and the method toggleDetail().
*
* @JSFFacet name="detailStamp"
*/
public UIComponent getDetailStamp()
{
return (UIComponent) getFacets().get(DETAIL_STAMP_FACET_NAME);
}
public String getClientId(FacesContext context)
{
String standardClientId = super.getClientId(context);
int rowIndex = getRowIndex();
if (rowIndex == -1)
{
return standardClientId;
}
String forcedIdIndex = getForceIdIndexFormula();
if (forcedIdIndex == null || forcedIdIndex.length() == 0)
return standardClientId;
// Trick : Remove the last part starting with NamingContainer.SEPARATOR_CHAR that contains the rowIndex.
// It would be best to not resort to String manipulation,
// but we can't get super.super.getClientId() :-(
int indexLast_ = standardClientId.lastIndexOf(NamingContainer.SEPARATOR_CHAR);
if (indexLast_ == -1)
{
log.info("Could not parse super.getClientId. forcedIdIndex will contain the rowIndex.");
return standardClientId + NamingContainer.SEPARATOR_CHAR + forcedIdIndex;
}
//noinspection UnnecessaryLocalVariable
String parsedForcedClientId = standardClientId.substring(0, indexLast_ + 1) + forcedIdIndex;
return parsedForcedClientId;
}
public UIComponent findComponent(String expr)
{
if (expr.length() > 0 && Character.isDigit(expr.charAt(0)))
{
int separatorIndex = expr.indexOf(NamingContainer.SEPARATOR_CHAR);
String rowIndexStr = expr;
String remainingPart = null;
if (separatorIndex != -1)
{
rowIndexStr = expr.substring(0, separatorIndex);
remainingPart = expr.substring(separatorIndex + 1);
}
int rowIndex = Integer.valueOf(rowIndexStr).intValue();
if (remainingPart == null)
{
log.error("Wrong syntax of expression : " + expr +
" rowIndex was provided, but no component name.");
return null;
}
UIComponent comp = super.findComponent(remainingPart);
if (comp == null)
return null;
//noinspection UnnecessaryLocalVariable
UIComponentPerspective perspective = new UIComponentPerspective(this, comp, rowIndex);
return perspective;
}
else
{
return super.findComponent(expr);
}
}
@Override
public boolean invokeOnComponent(FacesContext context, String clientId,
ContextCallback callback) throws FacesException
{
if (context == null || clientId == null || callback == null)
{
throw new NullPointerException();
}
final String baseClientId = getClientId(context);
// searching for this component?
boolean returnValue = baseClientId.equals(clientId);
if (returnValue)
{
try
{
callback.invokeContextCallback(context, this);
return true;
}
catch (Exception e)
{
throw new FacesException(e);
}
}
// Now Look throught facets on this UIComponent
for (Iterator<UIComponent> it = this.getFacets().values().iterator(); !returnValue && it.hasNext();)
{
returnValue = it.next().invokeOnComponent(context, clientId, callback);
}
if (returnValue)
{
return returnValue;
}
// is the component an inner component?
if (clientId.startsWith(baseClientId))
{
// Check if the clientId for the component, which we
// are looking for, has a rowIndex attached
char separator = UINamingContainer.SEPARATOR_CHAR;
ValueExpression rowKeyVE = getValueExpression("rowKey");
boolean rowKeyFound = false;
if (rowKeyVE != null)
{
int oldRow = this.getRowIndex();
try
{
// iterate over the rows
int rowsToProcess = getRows();
// if getRows() returns 0, all rows have to be processed
if (rowsToProcess == 0)
{
rowsToProcess = getRowCount();
}
int rowIndex = getFirst();
for (int rowsProcessed = 0; rowsProcessed < rowsToProcess; rowsProcessed++, rowIndex++)
{
setRowIndex(rowIndex);
if (!isRowAvailable())
{
break;
}
if (clientId.startsWith(getContainerClientId(context)))
{
rowKeyFound = true;
break;
}
}
if (rowKeyFound)
{
returnValue = invokeOnComponentTraverseRow(context, clientId, callback);
}
}
finally
{
this.setRowIndex(oldRow);
}
}
if (rowKeyVE == null && clientId.matches(baseClientId + separator+"[0-9]+"+separator+".*"))
{
String subId = clientId.substring(baseClientId.length() + 1);
String clientRow = subId.substring(0, subId.indexOf(separator));
//Now we save the current position
int oldRow = this.getRowIndex();
// try-finally --> make sure, that the old row index is restored
try
{
//The conversion is safe, because its already checked on the
//regular expresion
this.setRowIndex(Integer.parseInt(clientRow));
// check, if the row is available
if (!isRowAvailable())
{
return false;
}
returnValue = invokeOnComponentTraverseRow(context, clientId, callback);
}
finally
{
//Restore the old position. Doing this prevent
//side effects.
this.setRowIndex(oldRow);
}
}
else
{
// MYFACES-2370: search the component in the childrens' facets too.
// We have to check the childrens' facets here, because in MyFaces
// the rowIndex is not attached to the clientId for the children of
// facets of the UIColumns. However, in RI the rowIndex is
// attached to the clientId of UIColumns' Facets' children.
for (Iterator<UIComponent> itChildren = this.getChildren().iterator();
!returnValue && itChildren.hasNext();)
{
UIComponent child = itChildren.next();
// This is the only part different to UIData.invokeOnComponent. Since we have
// an auto wrapping on columns feature, it is necessary to check columns ids
// without row for invokeOnComponent, but do not traverse all elements, so
// save/restore algorithm could be able to remove / add them.
if (child instanceof UIColumn && clientId.equals(child.getClientId(context)))
{
try {
callback.invokeContextCallback(context, child);
} catch (Exception e) {
throw new FacesException(e);
}
returnValue = true;
}
// process the child's facets
for (Iterator<UIComponent> itChildFacets = child.getFacets().values().iterator();
!returnValue && itChildFacets.hasNext();)
{
//recursive call to find the component
returnValue = itChildFacets.next().invokeOnComponent(context, clientId, callback);
}
}
}
}
return returnValue;
}
private boolean invokeOnComponentTraverseRow(FacesContext context, String clientId,
ContextCallback callback)
{
boolean returnValue = false;
for (Iterator<UIComponent> it1 = getChildren().iterator();
!returnValue && it1.hasNext();)
{
//recursive call to find the component
returnValue = it1.next().invokeOnComponent(context, clientId, callback);
}
if (!returnValue)
{
UIComponent detailStampFacet = getFacet(DETAIL_STAMP_FACET_NAME);
if (detailStampFacet != null)
{
returnValue = detailStampFacet.invokeOnComponent(context, clientId, callback);
}
}
return returnValue;
}
public void setRowIndex(int rowIndex)
{
//FacesContext facesContext = FacesContext.getCurrentInstance();
if (rowIndex < -1)
{
throw new IllegalArgumentException("rowIndex is less than -1");
}
//UIComponent facet = getFacet(HtmlTableRenderer.DETAIL_STAMP_FACET_NAME);
/*Just for obtaining an iterator which must be passed to saveDescendantComponentStates()*/
//Set set = new HashSet();
//set.add(facet);
//if (getRowIndex() != -1 && facet != null)
//{
// _detailRowStates.put(getClientId(facesContext), saveDescendantComponentStates(set.iterator(), false));
//}
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);
}
//if (rowIndex != -1 && facet != null)
//{
// Object rowState = _detailRowStates.get(getClientId(facesContext));
// restoreDescendantComponentStates(set.iterator(),
// rowState, false);
//}
if (_varDetailToggler != null)
{
Map requestMap = getFacesContext().getExternalContext().getRequestMap();
requestMap.put(_varDetailToggler, this);
}
}
protected Object saveDescendantComponentStates()
{
if (!getFacets().isEmpty())
{
UIComponent detailStampFacet = getFacet(DETAIL_STAMP_FACET_NAME);
if (detailStampFacet != null)
{
return saveDescendantComponentStates(new _DetailStampFacetAndChildrenIterator(detailStampFacet, getChildren()), false);
}
}
return super.saveDescendantComponentStates();
}
protected void restoreDescendantComponentStates(Object state)
{
if (!getFacets().isEmpty())
{
UIComponent detailStampFacet = getFacet(DETAIL_STAMP_FACET_NAME);
if (detailStampFacet != null)
{
restoreDescendantComponentStates(new _DetailStampFacetAndChildrenIterator(detailStampFacet, getChildren()), state, false);
return;
}
}
super.restoreDescendantComponentStates(state);
}
public void processDecodes(FacesContext context)
{
if (!isRendered())
{
return;
}
// We must remove and then replace the facet so that
// it is not processed by default facet handling code
//
//Object facet = getFacets().remove(HtmlTableRenderer.DETAIL_STAMP_FACET_NAME);
//super.processDecodes(context);
//if ( facet != null ) getFacets().put(HtmlTableRenderer.DETAIL_STAMP_FACET_NAME, (UIComponent)facet);
setRowIndex(-1);
processFacets(context, PROCESS_DECODES);
processColumnFacets(context, PROCESS_DECODES);
processColumnChildren(context, PROCESS_DECODES);
setRowIndex(-1);
try
{
decode(context);
}
catch (RuntimeException e)
{
context.renderResponse();
throw e;
}
setRowIndex(-1);
processColumns(context, PROCESS_DECODES);
setRowIndex(-1);
processDetails(context, PROCESS_DECODES);
setRowIndex(-1);
}
private void processFacets(FacesContext context, int processAction)
{
for (Iterator it = getFacets().entrySet().iterator(); it.hasNext(); )
{
Map.Entry entry = (Map.Entry) it.next();
if (!DETAIL_STAMP_FACET_NAME.equals((String)entry.getKey()))
{
process(context, (UIComponent) entry.getValue(), processAction);
}
}
}
/**
* Invoke the specified phase on all facets of all UIColumn children of this component. Note that no methods are
* called on the UIColumn child objects themselves.
*
* @param context
* is the current faces context.
* @param processAction
* specifies a JSF phase: decode, validate or update.
*/
private void processColumnFacets(FacesContext context, int processAction)
{
for (Iterator childIter = getChildren().iterator(); childIter.hasNext();)
{
UIComponent child = (UIComponent) childIter.next();
if (child instanceof UIColumn)
{
if (!child.isRendered())
{
//Column is not visible
continue;
}
for (Iterator facetsIter = child.getFacets().values()
.iterator(); facetsIter.hasNext();)
{
UIComponent facet = (UIComponent) facetsIter.next();
process(context, facet, processAction);
}
}
}
}
/**
* Invoke the specified phase on all non-facet children of all UIColumn children of this component. Note that no
* methods are called on the UIColumn child objects themselves.
*
* @param context
* is the current faces context.
* @param processAction
* specifies a JSF phase: decode, validate or update.
*/
private void processColumnChildren(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; last==-1 || rowIndex < last; rowIndex++)
{
setRowIndex(rowIndex);
//scrolled past the last row
if (!isRowAvailable())
break;
for (Iterator it = getChildren().iterator(); it.hasNext();)
{
UIComponent child = (UIComponent) it.next();
if (child instanceof UIColumn)
{
if (!child.isRendered())
{
//Column is not visible
continue;
}
for (Iterator columnChildIter = child.getChildren()
.iterator(); columnChildIter.hasNext();)
{
UIComponent columnChild = (UIComponent) columnChildIter
.next();
process(context, columnChild, processAction);
}
}
}
}
}
/**
* @param context
* @param processAction
*/
private void processDetails(FacesContext context, int processAction)
{
UIComponent facet = getFacet(HtmlTableRenderer.DETAIL_STAMP_FACET_NAME);
if (facet != null)
{
int first = getFirst();
int rows = getRows();
int last;
if (rows == 0)
{
last = getRowCount();
}
else
{
last = first + rows;
}
for (int rowIndex = first; last == -1 || rowIndex < last; rowIndex++)
{
setRowIndex(rowIndex);
//scrolled past the last row
if (!isRowAvailable())
{
break;
}
if (!isCurrentDetailExpanded())
{
continue;
}
// If we are in the decode phase, the values restored into our
// facet in setRowIndex() may be incorrect. This will happen
// if some input fields are rendered in some rows, but not
// rendered in others. In this case the input field components
// will still contain the _submittedValue from the previous row
// that had that input field and _submittedValue will not be set to
// null by the process() method if there was no value submitted.
// Thus, an invalid component state for that row will be saved in
// _detailRowStates. The validation phase will not put a null into
// _sumbittedValue either, b/c the component is not rendered, so
// validation code doesn't run. This erroneous value will propagate all the way
// to the render phase, and result in all rows on the current page being
// rendered with the "stuck" _submittedValue, rather than evaluating the
// value to render for every row.
//
// We can fix this by initializing _submittedValue of all input fields in the facet
// to null before calling the process() method below during the decode phase.
//
if (PROCESS_DECODES == processAction)
{
resetAllSubmittedValues(facet);
}
process(context, facet, processAction);
// This code comes from TOMAHAWK-493, but really the problem was caused by
// TOMAHAWK-1534, by a bad comparison of rowIndex. The solution proposed is override
// the default iterator for save/restore on HtmlDataTableHack.setRowIndex(), to
// include the detailStamp. In this way, we'll be sure that the state is correctly
// saved and the component clientId is reset for all components that requires it
//if ( rowIndex == (last - 1) )
//{
// Set set = new HashSet();
// set.add(facet);
// _detailRowStates.put(
// getClientId(FacesContext.getCurrentInstance()),
// saveDescendantComponentStates(set.iterator(),false));
//}
}
}
}
private void resetAllSubmittedValues(UIComponent component)
{
if (component instanceof EditableValueHolder)
{
((EditableValueHolder) component).setSubmittedValue(null);
}
for (Iterator it = component.getFacetsAndChildren(); it.hasNext();)
{
resetAllSubmittedValues((UIComponent) it.next());
}
}
/**
* @param context
* @param processAction
*/
private void processColumns(FacesContext context, int processAction)
{
for (Iterator it = getChildren().iterator(); it.hasNext();)
{
UIComponent child = (UIComponent) it.next();
if (child instanceof UIColumns)
{
process(context, child, processAction);
}
}
}
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;
}
// We must remove and then replace the facet so that
// it is not processed by default facet handling code
//
//Object facet = getFacets().remove(HtmlTableRenderer.DETAIL_STAMP_FACET_NAME);
//super.processValidators(context);
//if ( facet != null ) getFacets().put(HtmlTableRenderer.DETAIL_STAMP_FACET_NAME,(UIComponent) facet);
setRowIndex(-1);
processFacets(context, PROCESS_VALIDATORS);
processColumnFacets(context, PROCESS_VALIDATORS);
processColumnChildren(context, PROCESS_VALIDATORS);
setRowIndex(-1);
processColumns(context, PROCESS_VALIDATORS);
setRowIndex(-1);
processDetails(context, PROCESS_VALIDATORS);
setRowIndex(-1);
if (context.getRenderResponse())
{
_isValidChildren = false;
}
}
public void processUpdates(FacesContext context)
{
if (!isRendered())
{
return;
}
// We must remove and then replace the facet so that
// it is not processed by default facet handling code
//
//Object facet = getFacets().remove(HtmlTableRenderer.DETAIL_STAMP_FACET_NAME);
//super.processUpdates(context);
//if ( facet != null ) getFacets().put(HtmlTableRenderer.DETAIL_STAMP_FACET_NAME,(UIComponent) facet);
setRowIndex(-1);
processFacets(context, PROCESS_UPDATES);
processColumnFacets(context, PROCESS_UPDATES);
processColumnChildren(context, PROCESS_UPDATES);
setRowIndex(-1);
processColumns(context, PROCESS_UPDATES);
setRowIndex(-1);
processDetails(context, PROCESS_UPDATES);
setRowIndex(-1);
if (isPreserveDataModel())
{
updateModelFromPreservedDataModel(context);
}
if (context.getRenderResponse())
{
_isValidChildren = false;
}
}
private void updateModelFromPreservedDataModel(FacesContext context)
{
ValueBinding vb = getValueBinding("value");
if (vb != null && !vb.isReadOnly(context))
{
_SerializableDataModel dm = (_SerializableDataModel) getDataModel();
Class type = (getValueType() == null) ?
vb.getType(context) :
ClassUtils.simpleClassForName(getValueType());
Class dmType = dm.getClass();
if (DataModel.class.isAssignableFrom(type))
{
vb.setValue(context, dm);
}
else if (List.class.isAssignableFrom(type) || _SerializableListDataModel.class.isAssignableFrom(dmType))
{
vb.setValue(context, 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!= null && lst.size() > 0)
{
vb.setValue(context, lst.get(0));
}
else
{
vb.setValue(context, null);
}
}
}
_preservedDataModel = null;
}
public void encodeBegin(FacesContext context) throws IOException
{
if (!isRendered())
return;
if (_isValidChildren && !hasErrorMessages(context))
{
_preservedDataModel = null;
}
for (Iterator iter = getChildren().iterator(); iter.hasNext();)
{
UIComponent component = (UIComponent) iter.next();
if (component instanceof UIColumns)
{
// Merge the columns from the tomahawk dynamic component
// into this object.
((UIColumns) component).encodeTableBegin(context);
}
}
//replace facet header content component of the columns, with a new command sort header component
//if sortable=true, replace it for all, if not just for the columns marked as sortable
for (Iterator iter = getChildren().iterator(); iter.hasNext();)
{
UIComponent component = (UIComponent) iter.next();
if (component instanceof UIColumn)
{
UIColumn aColumn = (UIColumn) component;
UIComponent headerFacet = aColumn.getHeader();
boolean replaceHeaderFacets = isSortable(); //if the table is sortable, all
//header facets can be changed if needed
String columnName = null;
String propertyName = null;
boolean defaultSorted = false;
if (aColumn instanceof HtmlSimpleColumn)
{
HtmlSimpleColumn asColumn = (HtmlSimpleColumn) aColumn;
propertyName = asColumn.getSortPropertyName();
defaultSorted = asColumn.isDefaultSorted();
if (asColumn.isSortable())
replaceHeaderFacets = true;
}
//replace header facet with a sortable header component if needed
if (replaceHeaderFacets && isSortHeaderNeeded(aColumn, headerFacet))
{
propertyName = propertyName != null ? propertyName : getSortPropertyFromEL(aColumn);
if (propertyName == null)
log.warn("Couldn't determine sort property for column [" + aColumn.getId() + "].");
if (headerFacet != null)
{
HtmlCommandSortHeader sortHeader = createSortHeaderComponent(context, aColumn, headerFacet, propertyName);
columnName = sortHeader.getColumnName();
aColumn.setHeader(sortHeader);
sortHeader.setParent(aColumn);
}
}
else if (headerFacet instanceof HtmlCommandSortHeader)
{
//command sort headers are already in place, just store the column name and sort property name
HtmlCommandSortHeader sortHeader = (HtmlCommandSortHeader) headerFacet;
columnName = sortHeader.getColumnName();
propertyName = sortHeader.getPropertyName();
//if the command sort header component doesn't specify a sort property, determine it
if (propertyName == null)
{
propertyName = getSortPropertyFromEL(aColumn);
sortHeader.setPropertyName(propertyName);
}
if (propertyName == null)
log.warn("Couldn't determine sort property for column [" + aColumn.getId() + "].");
}
//make the column marked as default sorted be the current sorted column
if (defaultSorted && getSortColumn() == null)
{
setSortColumn(columnName);
setSortProperty(propertyName);
}
}
}
// Now invoke the superclass encodeBegin, which will eventually
// execute the encodeBegin for the associated renderer.
super.encodeBegin(context);
}
/**
*
*/
protected boolean isSortHeaderNeeded(UIColumn parentColumn, UIComponent headerFacet)
{
return !(headerFacet instanceof HtmlCommandSortHeader);
}
/**
*
*/
protected HtmlCommandSortHeader createSortHeaderComponent(FacesContext context, UIColumn parentColumn, UIComponent initialHeaderFacet, String propertyName)
{
Application application = context.getApplication();
HtmlCommandSortHeader sortHeader = (HtmlCommandSortHeader) application.createComponent(HtmlCommandSortHeader.COMPONENT_TYPE);
String id = context.getViewRoot().createUniqueId();
sortHeader.setId(id);
sortHeader.setColumnName(id);
sortHeader.setPropertyName(propertyName);
sortHeader.setArrow(true);
sortHeader.setImmediate(true); //needed to work when dataScroller is present
sortHeader.getChildren().add(initialHeaderFacet);
initialHeaderFacet.setParent(sortHeader);
return sortHeader;
}
/**
*
*/
protected String getSortPropertyFromEL(UIComponent component)
{
if (getVar() == null)
{
log.warn("There is no 'var' specified on the dataTable, sort properties cannot be determined automaticaly.");
return null;
}
for (Iterator iter = component.getChildren().iterator(); iter.hasNext();)
{
UIComponent aChild = (UIComponent) iter.next();
if (aChild.isRendered())
{
ValueBinding vb = aChild.getValueBinding("value");
if (vb != null)
{
String expressionString = vb.getExpressionString();
int varIndex = expressionString.indexOf(getVar() + ".");
if (varIndex != -1)
{
int varEndIndex = varIndex + getVar().length();
String tempProp = expressionString.substring(varEndIndex + 1, expressionString.length());
StringTokenizer tokenizer = new StringTokenizer(tempProp, " +[]{}-/*|?:&<>!=()%");
if (tokenizer.hasMoreTokens())
return tokenizer.nextToken();
}
}
else
{
String sortProperty = getSortPropertyFromEL(aChild);
if (sortProperty != null)
return sortProperty;
}
}
}
return null;
}
/**
* @return the index coresponding to the given column name.
*/
protected int columnNameToIndex(String columnName)
{
int index = 0;
for (Iterator iter = getChildren().iterator(); iter.hasNext();)
{
UIComponent aChild = (UIComponent) iter.next();
if (aChild instanceof UIColumn)
{
UIComponent headerFacet = ((UIColumn) aChild).getHeader();
if (headerFacet != null && headerFacet instanceof HtmlCommandSortHeader)
{
HtmlCommandSortHeader sortHeader = (HtmlCommandSortHeader) headerFacet;
if (columnName != null && columnName.equals(sortHeader.getColumnName()))
return index;
}
}
index += 1;
}
return -1;
}
/**
* @see javax.faces.component.UIData#encodeEnd(javax.faces.context.FacesContext)
*/
public void encodeEnd(FacesContext context) throws IOException
{
super.encodeEnd(context);
for (Iterator iter = getChildren().iterator(); iter.hasNext();)
{
UIComponent component = (UIComponent) iter.next();
if (component instanceof UIColumns)
{
((UIColumns) component).encodeTableEnd(context);
}
}
}
/**
* The index of the first row to be displayed, where 0 is the first row.
*
* @JSFProperty
*/
public int getFirst()
{
if (_preservedDataModel != null)
{
//Rather get the currently restored DataModel attribute
return _preservedDataModel.getFirst();
}
else
{
return super.getFirst();
}
}
public void setFirst(int first)
{
if (_preservedDataModel != null)
{
//Also change the currently restored DataModel attribute
_preservedDataModel.setFirst(first);
}
super.setFirst(first);
}
/**
* The number of rows to be displayed. Specify zero for all remaining rows in the table.
*
* @JSFProperty
*/
public int getRows()
{
if (_preservedDataModel != null)
{
//Rather get the currently restored DataModel attribute
return _preservedDataModel.getRows();
}
else
{
return super.getRows();
}
}
public void setRows(int rows)
{
if (_preservedDataModel != null)
{
//Also change the currently restored DataModel attribute
_preservedDataModel.setRows(rows);
}
super.setRows(rows);
}
public Object saveState(FacesContext context)
{
boolean preserveSort = isPreserveSort();
Object[] values = new Object[15];
values[0] = super.saveState(context);
values[1] = _preserveDataModel;
if (isPreserveDataModel())
{
_preservedDataModel = getSerializableDataModel();
values[2] = saveAttachedState(context, _preservedDataModel);
}
else
{
values[2] = null;
}
values[3] = _preserveSort;
values[4] = _forceIdIndexFormula;
values[5] = _sortColumn;
values[6] = _sortAscending;
values[7] = _sortProperty;
values[8] = _rowStyleClass;
values[9] = _rowStyle;
values[10] = preserveSort ? getSortColumn() : null;
values[11] = preserveSort ? Boolean.valueOf(isSortAscending()) : null;
values[12] = _varDetailToggler;
values[13] = _expandedNodes;
values[14] = new Integer(_sortColumnIndex);
return values;
}
/**
* @see org.apache.myfaces.component.html.ext.HtmlDataTableHack#getDataModel()
*/
protected DataModel getDataModel()
{
if (_preservedDataModel != null)
{
setDataModel(_preservedDataModel);
_preservedDataModel = null;
}
return super.getDataModel();
}
/**
* @see org.apache.myfaces.component.html.ext.HtmlDataTableHack#createDataModel()
*/
protected DataModel createDataModel()
{
DataModel dataModel = super.createDataModel();
boolean isSortable = isSortable();
if (!(dataModel instanceof SortableModel))
{
//if sortable=true make each column sortable
//if sortable=false, check to see if at least one column sortable case in which
//the current model needs to be wrapped by a sortable one.
for (Iterator iter = getChildren().iterator(); iter.hasNext();)
{
UIComponent component = (UIComponent) iter.next();
if (component instanceof HtmlSimpleColumn)
{
HtmlSimpleColumn aColumn = (HtmlSimpleColumn) component;
if (isSortable())
aColumn.setSortable(true);
if (aColumn.isSortable())
isSortable = true;
if (aColumn.isDefaultSorted() && getSortColumn() == null)
setSortProperty(aColumn.getSortPropertyName());
}
}
if (isSortable)
dataModel = new SortableModel(dataModel);
}
if (isSortable && getSortProperty() != null)
{
SortCriterion criterion = new SortCriterion(getSortProperty(), isSortAscending());
List criteria = new ArrayList();
criteria.add(criterion);
((SortableModel) dataModel).setSortCriteria(criteria);
}
return dataModel;
}
public void restoreState(FacesContext context, Object state)
{
Object[] values = (Object[]) state;
super.restoreState(context, values[0]);
_preserveDataModel = (Boolean) values[1];
if (isPreserveDataModel())
{
_preservedDataModel = (_SerializableDataModel) restoreAttachedState(context, values[2]);
}
else
{
_preservedDataModel = null;
}
_preserveSort = (Boolean) values[3];
_forceIdIndexFormula = (String) values[4];
_sortColumn = (String) values[5];
_sortAscending = (Boolean) values[6];
_sortProperty = (String) values[7];
_rowStyleClass = (String) values[8];
_rowStyle = (String) values[9];
if (isPreserveSort())
{
String sortColumn = (String) values[10];
Boolean sortAscending = (Boolean) values[11];
if (sortColumn != null && sortAscending != null)
{
ValueBinding vb = getValueBinding("sortColumn");
if (vb != null && !vb.isReadOnly(context))
{
vb.setValue(context, sortColumn);
}
vb = getValueBinding("sortAscending");
if (vb != null && !vb.isReadOnly(context))
{
vb.setValue(context, sortAscending);
}
}
}
_varDetailToggler = (String) values[12];
_expandedNodes = (Map) values[13];
_sortColumnIndex = values[14] != null ? ((Integer) values[14]).intValue() : -1;
}
public _SerializableDataModel getSerializableDataModel()
{
DataModel dm = getDataModel();
if (dm instanceof _SerializableDataModel)
{
return (_SerializableDataModel) dm;
}
return createSerializableDataModel();
}
/**
* @return _SerializableDataModel
*/
private _SerializableDataModel createSerializableDataModel()
{
Object value = getValue();
if (value == null)
{
return null;
}
else if (value instanceof DataModel)
{
return new _SerializableDataModel(getFirst(), getRows(), (DataModel) value);
}
else if (value instanceof List)
{
return new _SerializableListDataModel(getFirst(), getRows(), (List) value);
}
// accept a Collection is not supported in the Spec
else if (value instanceof Collection)
{
return new _SerializableListDataModel(getFirst(), getRows(), new ArrayList((Collection) value));
}
else if (OBJECT_ARRAY_CLASS.isAssignableFrom(value.getClass()))
{
return new _SerializableArrayDataModel(getFirst(), getRows(), (Object[]) value);
}
else if (value instanceof ResultSet)
{
return new _SerializableResultSetDataModel(getFirst(), getRows(), (ResultSet) value);
}
else if (value instanceof javax.servlet.jsp.jstl.sql.Result)
{
return new _SerializableResultDataModel(getFirst(), getRows(),
(javax.servlet.jsp.jstl.sql.Result) value);
}
else
{
return new _SerializableScalarDataModel(getFirst(), getRows(), value);
}
}
public boolean isRendered()
{
if (!UserRoleUtils.isVisibleOnUserRole(this))
return false;
return super.isRendered();
}
public void setForceIdIndexFormula(String forceIdIndexFormula)
{
_forceIdIndexFormula = forceIdIndexFormula;
ValueBinding vb = getValueBinding("forceIdIndexFormula");
if (vb != null)
{
vb.setValue(getFacesContext(), _forceIdIndexFormula);
_forceIdIndexFormula = null;
}
}
/**
* A formula that overrides the default row index in the
* construction of table's body components.
*
* Example : #{myRowVar.key} Warning, the EL should
* evaluate to a unique value for each row !
*
* @JSFProperty
*/
public String getForceIdIndexFormula()
{
if (_forceIdIndexFormula != null)
return _forceIdIndexFormula;
ValueBinding vb = getValueBinding("forceIdIndexFormula");
if (vb == null)
return null;
Object eval = vb.getValue(getFacesContext());
return eval == null ? null : eval.toString();
}
/**
* Specify what column the data should be sorted on.
* <p/>
* Note that calling this method <i>immediately</i> stores the value
* via any value-binding with name "sortColumn". This is done because
* this method is called by the HtmlCommandSortHeader component when
* the user has clicked on a column's sort header. In this case, the
* the model getter method mapped for name "value" needs to read this
* value in able to return the data in the desired order - but the
* HtmlCommandSortHeader component is usually "immediate" in order to
* avoid validating the enclosing form. Yes, this is rather hacky -
* but it works.
*/
public void setSortColumn(String sortColumn)
{
_sortColumn = sortColumn;
// update model is necessary here, because processUpdates is never called
// reason: HtmlCommandSortHeader.isImmediate() == true
ValueBinding vb = getValueBinding("sortColumn");
if (vb != null)
{
vb.setValue(getFacesContext(), _sortColumn);
_sortColumn = null;
}
setSortColumnIndex(columnNameToIndex(sortColumn));
}
/**
* Value reference to a model property that gives the current
* sort column name. The target String property is set to
* the "columnName" of whichever column has been chosen
* to sort by, and the method which is bound to the "value"
* attribute of this table (ie which provides the DataModel used)
* is expected to use this property to determine how to sort
* the DataModel's contents.
*
* @JSFProperty
*/
public String getSortColumn()
{
if (_sortColumn != null) return _sortColumn;
ValueBinding vb = getValueBinding("sortColumn");
return vb != null ? (String) vb.getValue(getFacesContext()) : null;
}
public void setSortAscending(boolean sortAscending)
{
_sortAscending = Boolean.valueOf(sortAscending);
// update model is necessary here, because processUpdates is never called
// reason: HtmlCommandSortHeader.isImmediate() == true
ValueBinding vb = getValueBinding("sortAscending");
if (vb != null)
{
vb.setValue(getFacesContext(), _sortAscending);
_sortAscending = null;
}
}
/**
* Value reference to a model property that gives the current
* sort direction. The target Boolean property is set to true
* when the selected sortColumn should be sorted in ascending
* order, and false otherwise. The method which is bound to
* the "value" attribute of this table (ie which provides the
* DataModel used) is expected to use this property to
* determine how to sort the DataModel's contents.
*
* @JSFProperty
* defaultValue = "true"
*/
public boolean isSortAscending()
{
if (_sortAscending != null)
return _sortAscending.booleanValue();
ValueBinding vb = getValueBinding("sortAscending");
Boolean v = vb != null ? (Boolean) vb.getValue(getFacesContext()) : null;
return v != null ? v.booleanValue() : DEFAULT_SORTASCENDING;
}
/**
* The name of a javabean property on which the table is sorted.
* <p>
* The datamodel should contain objects that have this property;
* reflection will be used to sort the datamodel on that property
* using the default comparator for that type.
* <p>
* This value is part of the component state. However it is not
* directly settable by users; instead it is set by other components
* such as a CommandSortHeader.
*/
public void setSortProperty(String sortProperty)
{
_sortProperty = sortProperty;
}
/**
* @JSFProperty
* literalOnly="true"
* tagExcluded="true"
*/
public String getSortProperty()
{
return _sortProperty;
}
/**
* Define if the table is sortable or not
*
* @JSFProperty
* defaultValue="false"
*/
public abstract boolean isSortable();
/**
* Avoids rendering the html table tags, thus, giving you a
* table rendering just rows. You can use this together
* with the detailStamp faces of the parent datatable
* to render child-tables using the same layout as the parent.
*
* Notice: You have to ensure both tables do have the same
* number of columns. Using the colspan attribute of the
* column tag might help alot.
*
* @JSFProperty
* defaultValue="false"
*/
public abstract boolean isEmbedded();
/**
* true|false - true if the detailStamp should be expanded by default. default: false
*
* @JSFProperty
* defaultValue="false"
*/
public abstract boolean isDetailStampExpandedDefault();
/**
* before|after - where to render the detailStamp, before the
* actual row or after it. default: after
*
* @JSFProperty
* defaultValue="after"
*/
public abstract String getDetailStampLocation();
/**
* Defines a JavaScript onmouseover event handler for each table row
*
* @JSFProperty
*/
public abstract String getRowOnMouseOver();
/**
* Defines a JavaScript onmouseout event handler for each table row
*
* @JSFProperty
*/
public abstract String getRowOnMouseOut();
/**
* Defines a JavaScript onclick event handler for each table row
*
* @JSFProperty
*/
public abstract String getRowOnClick();
/**
* Defines a JavaScript ondblclick event handler for each table row
*
* @JSFProperty
*/
public abstract String getRowOnDblClick();
/**
* Defines a JavaScript onkeydown event handler for each table row
*
* @JSFProperty
*/
public abstract String getRowOnKeyDown();
/**
* Defines a JavaScript onkeypress event handler for each table row
*
* @JSFProperty
*/
public abstract String getRowOnKeyPress();
/**
* Defines a JavaScript onkeyup event handler for each table row
*
* @JSFProperty
*/
public abstract String getRowOnKeyUp();
/**
* Corresponds to the HTML class attribute for the row tr tag.
*
* @JSFProperty
*/
public String getRowStyleClass()
{
if (_rowStyleClass != null)
return _rowStyleClass;
// TODO: temporarily support fully-qualified ext. dataTable attribute names.
ValueBinding vb = getValueBinding("org.apache.myfaces.dataTable.ROW_STYLECLASS");
if (vb != null)
log.warn("org.apache.myfaces.dataTable.ROW_STYLECLASS is deprecated. Please use rowStyleClass instead.");
else
vb = getValueBinding(JSFAttr.ROW_STYLECLASS_ATTR);
if(vb == null)
return null;
String bindingValue = (String) vb.getValue(getFacesContext());
if(bindingValue == "")
return null; // Fix for JSF 1.2 EL coercing nulls to empty string
return bindingValue;
}
public void setRowStyleClass(String rowStyleClass)
{
_rowStyleClass = rowStyleClass;
}
/**
* Corresponds to the HTML style attribute for the row tr tag.
*
* @JSFProperty
*/
public String getRowStyle()
{
if (_rowStyle != null)
return _rowStyle;
// TODO: temporarily support fully-qualified ext. dataTable attribute names.
ValueBinding vb = getValueBinding("org.apache.myfaces.dataTable.ROW_STYLE");
if (vb != null)
log.warn("org.apache.myfaces.dataTable.ROW_STYLE is deprecated. Please use rowStyle instead.");
else
vb = getValueBinding(JSFAttr.ROW_STYLE_ATTR);
if(vb == null)
return null;
String bindingValue = (String) vb.getValue(getFacesContext());
if(bindingValue == "")
return null; // Fix for JSF 1.2 EL coercing nulls to empty string
return bindingValue;
}
public void setRowStyle(String rowStyle)
{
_rowStyle = rowStyle;
}
/**
* Defines a JavaScript onmpusedown event handler for each table row
*
* @JSFProperty
*/
public abstract String getRowOnMouseDown();
/**
* Defines a JavaScript onmousemove event handler for each table row
*
* @JSFProperty
*/
public abstract String getRowOnMouseMove();
/**
* Defines a JavaScript onmouseup event handler for each table row
*
* @JSFProperty
*/
public abstract String getRowOnMouseUp();
/**
* @JSFProperty
* tagExcluded = "true"
*/
protected boolean isValidChildren()
{
return _isValidChildren;
}
protected void setIsValidChildren(boolean isValidChildren)
{
_isValidChildren = isValidChildren;
}
protected _SerializableDataModel getPreservedDataModel()
{
return _preservedDataModel;
}
protected void setPreservedDataModel(_SerializableDataModel preservedDataModel)
{
_preservedDataModel = preservedDataModel;
}
public boolean isCurrentDetailExpanded()
{
Boolean expanded = (Boolean) _expandedNodes.get(getClientId(getFacesContext()));
if (expanded != null)
{
return expanded.booleanValue();
}
return isDetailStampExpandedDefault();
}
public void setVarDetailToggler(String varDetailToggler)
{
_varDetailToggler = varDetailToggler;
}
/**
* This variable has the boolean property "currentdetailExpanded"
* which is true if the current detail row is expanded and the
* action method "toggleDetail" which expand/collapse the current
* detail row.
*
* @JSFProperty
*/
public String getVarDetailToggler()
{
if (_varDetailToggler != null)
return _varDetailToggler;
ValueBinding vb = getValueBinding("varDetailToggler");
return vb != null ? (String) vb.getValue(getFacesContext()) : null;
}
/**
* Corresponds to the HTML style attribute for grouped rows.
*
* @JSFProperty
*/
public abstract String getRowGroupStyle();
/**
* StyleClass for grouped rows.
*
* @JSFProperty
*/
public abstract String getRowGroupStyleClass();
/**
* Corresponds to the HTML style attribute for the table body tag
*
* @JSFProperty
*/
public abstract String getBodyStyle();
/**
* Corresponds to the HTML class attribute for the table body tag.
*
* @JSFProperty
*/
public abstract String getBodyStyleClass();
public AbstractHtmlDataTable()
{
setRendererType(DEFAULT_RENDERER_TYPE);
}
/**
* Change the status of the current detail row from collapsed to expanded or
* viceversa.
*/
public void toggleDetail()
{
String derivedRowKey = getClientId(getFacesContext());
// get the current expanded state of the row
boolean expanded = isDetailExpanded();
if (expanded)
{
// toggle to "collapsed"
if (isDetailStampExpandedDefault())
{
// if default is expanded we have to override with FALSE here
_expandedNodes.put(derivedRowKey, Boolean.FALSE);
}
else
{
// if default is collapsed we can fallback to this default
_expandedNodes.remove(derivedRowKey);
}
}
else
{
// toggle to "expanded"
if (isDetailStampExpandedDefault())
{
// if default is expanded we can fallback to this default
_expandedNodes.remove(derivedRowKey);
}
else
{
// if default is collapsed we have to override with TRUE
_expandedNodes.put(derivedRowKey, Boolean.TRUE);
}
}
}
/**
* Return true if the current detail row is expanded.
*
* @return true if the current detail row is expanded.
*/
public boolean isDetailExpanded()
{
Boolean expanded = (Boolean) _expandedNodes.get(getClientId(getFacesContext()));
if (expanded == null)
{
return isDetailStampExpandedDefault();
}
return expanded.booleanValue();
}
public int getSortColumnIndex()
{
if (_sortColumnIndex == -1)
_sortColumnIndex = columnNameToIndex(getSortColumn());
return _sortColumnIndex;
}
public void setSortColumnIndex(int sortColumnIndex)
{
_sortColumnIndex = sortColumnIndex;
}
/**
* The number of columns to wrap the table over. Default: 1
*
* Set the number of columns the table will be divided over.
*
* @JSFProperty
* defaultValue="1"
*/
public abstract int getNewspaperColumns();
/**
* The orientation of the newspaper columns in the newspaper
* table - "horizontal" or "vertical". Default: vertical
*
* @JSFProperty
* defaultValue = "vertical"
*/
public abstract String getNewspaperOrientation();
/**
* Gets the spacer facet, between each pair of newspaper columns.
*
* @JSFFacet
* name="spacer"
*/
public UIComponent getSpacer()
{
return (UIComponent) getFacets().get(SPACER_FACET_NAME);
}
public void setSpacer(UIComponent spacer)
{
getFacets().put(SPACER_FACET_NAME, spacer);
}
/**
* Expand all details
*/
public void expandAllDetails()
{
int rowCount = getRowCount();
_expandedNodes.clear();
if (getRowKey() != null)
{
int oldRow = getRowIndex();
try
{
for (int row = 0; row < rowCount; row++)
{
setRowIndex(row);
_expandedNodes.put(getClientId(getFacesContext()), Boolean.TRUE);
}
}
finally
{
setRowIndex(oldRow);
}
}
else
{
for (int row = 0; row < rowCount; row++)
{
_expandedNodes.put(new Integer(row).toString(), Boolean.TRUE);
}
}
}
/**
* Collapse all details
*/
public void collapseAllDetails()
{
_expandedNodes.clear();
}
/**
* @return true is any of the details is expanded
*/
public boolean isExpandedEmpty()
{
boolean expandedEmpty = true;
if (_expandedNodes != null)
{
expandedEmpty = _expandedNodes.isEmpty();
}
return expandedEmpty;
}
/**
* Clears expanded nodes set if expandedEmpty is true
*
* @param expandedEmpty
*/
public void setExpandedEmpty(boolean expandedEmpty)
{
if (expandedEmpty)
{
if (_expandedNodes != null)
{
_expandedNodes.clear();
}
}
}
//------------------ GENERATED CODE BEGIN (do not modify!) --------------------
public static final String COMPONENT_TYPE = "org.apache.myfaces.HtmlDataTable";
public static final String DEFAULT_RENDERER_TYPE = "org.apache.myfaces.Table";
private static final boolean DEFAULT_PRESERVEDATAMODEL = false;
private static final boolean DEFAULT_PRESERVESORT = true;
private static final boolean DEFAULT_RENDEREDIFEMPTY = true;
private Boolean _preserveDataModel = null;
private Boolean _preserveSort = null;
public void setPreserveDataModel(boolean preserveDataModel)
{
_preserveDataModel = Boolean.valueOf(preserveDataModel);
}
/**
* Indicates whether the state of the whole DataModel should
* be saved and restored. When set to false, the value-binding
* for the "value" attribute of this table is executed each
* time the page is rendered. When set to true, that
* value-binding is only executed when the component is first
* created, and the DataModel state is thereafter saved/restored
* automatically by the component. When column sorting is
* used for a table this property needs to be false so that
* the DataModel can be updated to reflect any changes in the
* sort criteria. Default: false
*
* @JSFProperty
*/
public boolean isPreserveDataModel()
{
if (_preserveDataModel != null)
return _preserveDataModel.booleanValue();
ValueBinding vb = getValueBinding("preserveDataModel");
Boolean v = vb != null ? (Boolean) vb.getValue(getFacesContext()) : null;
return v != null ? v.booleanValue() : DEFAULT_PRESERVEDATAMODEL;
}
public void setPreserveSort(boolean preserveSort)
{
_preserveSort = Boolean.valueOf(preserveSort);
}
/**
* Indicates whether the state of the sortColumn and sortAscending
* attribute should be saved and restored and written back to the
* model during the update model phase. Default: true
*
* @JSFProperty
* defaultValue = "true"
*/
public boolean isPreserveSort()
{
if (_preserveSort != null)
return _preserveSort.booleanValue();
ValueBinding vb = getValueBinding("preserveSort");
Boolean v = vb != null ? (Boolean) vb.getValue(getFacesContext()) : null;
return v != null ? v.booleanValue() : DEFAULT_PRESERVESORT;
}
/**
* Indicates whether this table should be rendered if the
* underlying DataModel is empty. You could as well use
* rendered="#{not empty bean.list}", but this one causes
* the getList method of your model bean beeing called up
* to five times per request, which is not optimal when
* the list is backed by a DB table. Using
* renderedIfEmpty="false" solves this problem, because
* the MyFaces extended HtmlDataTable automatically caches
* the DataModel and calles the model getter only once
* per request. Default: true
*
* @JSFProperty
* defaultValue = "true"
*/
public abstract boolean isRenderedIfEmpty();
/**
* A parameter name, under which the current rowIndex is set
* in request scope similar to the var parameter.
*
* @JSFProperty
*/
public abstract String getRowIndexVar();
/**
* A parameter name, under which the rowCount is set in
* request scope similar to the var parameter.
*
* @JSFProperty
*/
public abstract String getRowCountVar();
/**
* A parameter name, under which the previous RowData Object
* is set in request scope similar to the rowIndexVar and
* rowCountVar parameters. Mind that the value of this
* request scope attribute is null in the first row or
* when isRowAvailable returns false for the previous row.
*
* @JSFProperty
*/
public abstract String getPreviousRowDataVar();
/**
* A parameter name, under which the a boolean is set in request
* scope similar to the var parameter. TRUE for the column that
* is currently sorted, FALSE otherwise.
*
* @JSFProperty
*/
public abstract String getSortedColumnVar();
/**
* HTML: Specifies the horizontal alignment of this element.
* Deprecated in HTML 4.01.
*
* @JSFProperty
*/
public abstract String getAlign();
/**
* The id to use for
*
* @JSFProperty
*/
public abstract String getRowId();
/**
* Reserved for future use.
*
* @JSFProperty
*/
public abstract String getDatafld();
/**
* Reserved for future use.
*
* @JSFProperty
*/
public abstract String getDatasrc();
/**
* Reserved for future use.
*
* @JSFProperty
*/
public abstract String getDataformatas();
/**
* Indicate the expected type of the EL expression pointed
* by value property. It is useful when vb.getType() cannot
* found the type, like when a map value is resolved on
* the expression.
*
* @JSFProperty
*/
public abstract String getValueType();
}