/**
* License Agreement.
*
* Rich Faces - Natural Ajax for Java Server Faces (JSF)
*
* Copyright (C) 2007 Exadel, Inc.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License version 2.1 as published by the Free Software Foundation.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
package org.richfaces.taglib;
import java.lang.reflect.Field;
import java.util.Collection;
import java.util.Enumeration;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import javax.el.ELContext;
import javax.el.ELException;
import javax.el.ELResolver;
import javax.el.FunctionMapper;
import javax.el.MethodExpression;
import javax.el.ValueExpression;
import javax.el.VariableMapper;
import javax.faces.component.UIComponent;
import javax.faces.context.FacesContext;
import javax.faces.webapp.UIComponentClassicTagBase;
import javax.servlet.jsp.JspException;
import javax.servlet.jsp.JspTagException;
import javax.servlet.jsp.PageContext;
import javax.servlet.jsp.tagext.IterationTag;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.richfaces.component.UIColumn;
import org.richfaces.component.html.HtmlColumn;
import org.richfaces.el.ELBuilder;
import org.richfaces.iterator.ForEachIterator;
import org.richfaces.iterator.SimpleForEachIterator;
import org.richfaces.renderkit.CellRenderer;
@SuppressWarnings("unused")
public class ColumnsTag extends UIComponentClassicTagBase implements
IterationTag {
private static final Log log = LogFactory.getLog(ColumnsTag.class);
/** Data table */
private UIComponent dataTable;
private static final String J_GENERATION_SERIES_ATTRIBUTE = "org.richfaces.J_COLUMNS_GENERATION_SERIES";
/** Prefix before id to be assigned for column */
private static final String COLUMN_ID_PREFIX = "rf";
/** Flag indicates if columns are already created */
private boolean created = false;
/** Current column counter */
private Integer index = -1;
/** Iterator for columns's tag value attribute */
protected ForEachIterator items; // our 'digested' items
/** Value attribute value */
protected Object rawItems; // our 'raw' items
/** End attribute - defines count of column if value attr hasn't been defined */
private ValueExpression __columns;
/** Begin attribute - defines the first iteration item */
private ValueExpression __begin;
/** Begin attribute - defines the last iteration item */
private ValueExpression __end;
/** Index attr - defines page variable for current column counter */
private ValueExpression _index;
/** Var attr - defines page variable for current item */
private String indexId;
/** Integer value of end attr. */
private Integer columns;
/** Integer value of begin attr. */
private Integer begin;
/** Integer value of end attr. */
private Integer end;
/** String value of var attr */
private String itemId = null;
/** Expression for var item */
private IteratedExpression iteratedExpression;
/** Column incrementer */
private Integer counter = 0;
private String jspId;
private String pageId;
/**
* style CSS style(s) is/are to be applied when this component is rendered
*/
private ValueExpression _style;
/*
* sortBy Attribute defines a bean property which is used for sorting of a
* column
*/
private ValueExpression _sortBy;
/**
* sortOrder SortOrder is an enumeration of the possible sort orderings.
*/
private ValueExpression _sortOrder;
/**
* value The current value for this component
*/
private ValueExpression __value;
/**
* var A request-scope attribute via which the data object for the current
* row will be used when iterating
*/
private ValueExpression __var;
/**
* breakBefore if "true" next column begins from the first row
*/
private ValueExpression _breakBefore;
/**
* colspan Corresponds to the HTML colspan attribute
*/
private ValueExpression _colspan;
/**
* Dir attr
*/
private ValueExpression _dir;
/*
* filterDefaultLabel
*
*/
private ValueExpression _filterDefaultLabel;
/**
* comparator
*
*/
private ValueExpression _comparator;
/*
* filterEvent Event for filter input that forces the filtration (default =
* onchange)
*/
private ValueExpression _filterEvent;
/*
* filterExpression Attribute defines a bean property which is used for
* filtering of a column
*/
private ValueExpression _filterExpression;
/*
* filterMethod
*
*/
private MethodExpression _filterMethod;
/*
* filterValue
*
*/
private ValueExpression _filterValue;
/*
* filterBy
*
*/
private ValueExpression _filterBy;
/**
* footerClass Space-separated list of CSS style class(es) that are be
* applied to any footer generated for this table
*/
private ValueExpression _footerClass;
/**
* headerClass Space-separated list of CSS style class(es) that are be
* applied to any header generated for this table
*/
private ValueExpression _headerClass;
/**
* rowspan Corresponds to the HTML rowspan attribute
*/
private ValueExpression _rowspan;
/**
* selfSorted
*
*/
private ValueExpression _selfSorted;
/**
* sortable Boolean attribute. If "true" it's possible to sort the column
* content after click on the header. Default value is "true"
*/
private ValueExpression _sortable;
/**
* sortExpression Attribute defines a bean property which is used for
* sorting of a column
*/
private ValueExpression _sortExpression;
/**
* styleClass Corresponds to the HTML class attribute
*/
private ValueExpression _styleClass;
/*
* width Attribute defines width of column. Default value is "100px".
*/
private ValueExpression _width;
/**
* Attribute defines if component should be rendered.
*/
private ValueExpression _rendered;
private ValueExpression _sortIcon;
private ValueExpression _sortIconAscending;
private ValueExpression _sortIconDescending;
/**
* SortOrder is an enumeration of the possible sort orderings. Setter for
* sortOrder
*
* @param sortOrder -
* new value
*/
public void setSortOrder(ValueExpression sortOrder) {
this._sortOrder = sortOrder;
}
/**
* Attribute defines a bean property which is used for sorting of a column
* Setter for sortBy
*
* @param sortBy -
* new value
*/
public void setSortBy(ValueExpression sortBy) {
this._sortBy = sortBy;
}
/**
* CSS style(s) is/are to be applied when this component is rendered Setter
* for style
*
* @param style -
* new value
*/
public void setStyle(ValueExpression style) {
this._style = style;
}
/*
* (non-Javadoc)
*
* @see javax.faces.webapp.UIComponentClassicTagBase#doStartTag()
*/
@Override
public int doStartTag() throws JspException {
pageId = getId();
prepare();
if (hasNext()) {
next();
exposeVariables();
super.doStartTag();
} else {
return SKIP_BODY;
}
return EVAL_BODY_BUFFERED;
}
/*
* (non-Javadoc)
*
* @see javax.faces.webapp.UIComponentClassicTagBase#doAfterBody()
*/
@Override
public int doAfterBody() throws JspException {
try {
if (hasNext()) {
super.doAfterBody();
super.doEndTag();
setId(pageId);
next();
exposeVariables();
super.doStartTag();
return EVAL_BODY_AGAIN;
} else {
super.doAfterBody();
exposeVariables();
return EVAL_BODY_INCLUDE;
}
} catch (Exception e) {
throw new JspException(e);
}
}
/*
* (non-Javadoc)
*
* @see javax.faces.webapp.UIComponentClassicTagBase#doEndTag()
*/
@Override
public int doEndTag() throws JspException {
if (!atFirst()) {
return super.doEndTag();
}
return EVAL_PAGE;
}
/*
* (non-Javadoc)
*
* @see javax.faces.webapp.UIComponentClassicTagBase#doInitBody()
*/
@Override
public void doInitBody() throws JspException {
}
@Override
protected UIComponent createComponent(FacesContext context, String newId)
throws JspException {
UIComponent c = getFacesContext().getApplication().createComponent(
getComponentType());
c.setId(newId);
c.setTransient(false);
setProperties(c);
c.getAttributes().put(J_GENERATION_SERIES_ATTRIBUTE, RequestUniqueIdGenerator.generateId(context));
return c;
}
@Override
protected boolean hasBinding() {
return false;
}
@Override
protected void setProperties(UIComponent component) {
ELContext elContext = getContext(pageContext.getELContext());
Field[] fields = this.getClass().getDeclaredFields();
for (Field field : fields) {
try {
Object o = field.get(this);
if (o != null && o instanceof ValueExpression) {
String fieldName = field.getName();
if (fieldName != null && fieldName.startsWith("_")) {
String attributeName = fieldName.replace("_", "");
if (ColumnsAttributes.FILTER_ATTRIBUTES.indexOf(attributeName) == -1 &&
ColumnsAttributes.SORT_ATTRIBUTES.indexOf(attributeName) == -1) {
ValueExpression ex = (ValueExpression) o;
ex = createValueExpression(elContext, ex);
component.setValueExpression(attributeName, ex);
} else {
ValueExpression ex = (ValueExpression) o;
ValueExpression expr = null;
if (!ex.isLiteralText()) {
expr = ELBuilder.createValueExpression(ex.getExpressionString(), ex.getExpectedType(),
getFacesContext().getApplication().getExpressionFactory(), pageContext.getELContext(), itemId, indexId,
getVarReplacement(), String.valueOf(index));
}else {
expr = ex;
}
component.setValueExpression(attributeName, expr);
}
}
}
} catch (Exception e) {
continue;
}
}
// Set filterMethod attribute
if (_filterMethod != null) {
MethodExpression mexpr = getFacesContext().getApplication()
.getExpressionFactory().createMethodExpression(elContext,
_filterMethod.getExpressionString(), Object.class,
new Class[] { Object.class });
((HtmlColumn) component).setFilterMethod(mexpr);
}
// Set SortExpression attribute especially for scrollable data table
if (_sortExpression != null) {
ValueExpression expr = ELBuilder.createValueExpression(_sortExpression.getExpressionString(), _sortExpression.getExpectedType(),
getFacesContext().getApplication().getExpressionFactory(), pageContext.getELContext(), itemId, indexId,
getVarReplacement(), String.valueOf(index));
component.setValueExpression("sortExpression", expr);
}
}
private String getVarReplacement() {
if (this.__value == null) {
return String.valueOf(index);
} else if (items.getVarReplacement() != null) {
return items.getVarReplacement();
}
String varReplacement = ELBuilder.getVarReplacement(this.__value.getExpressionString())
+ "[" + index + "]";
return varReplacement;
}
/**
* Evaluates expression string for SortExpression attribute using resolved vars nodes.
* @return
*/
private String createSortExpression() {
String expr = null;
try {
String orig = _sortExpression.getExpressionString()
.replaceAll("[\\#\\{\\}]", "").trim();
String varReplacement = __value.getExpressionString()
.replaceAll("[#{}]", "")+ "[" + index + "]";
if (itemId.equals(orig)) {
expr = varReplacement;
} else {
String indexReplacement = String.valueOf(index);
String varPatter1 = "^" + itemId + "([\\.\\[\\]])";
String varPatter2 = "([\\s\"$%#\\^|]+)" + itemId
+ "([\\.\\[\\]])";
String indexPattern = "([\\[\\]]{1})" + indexId
+ "([\\[\\]]{1})";
orig = orig.replaceAll(varPatter1, varReplacement + "$1");
orig = orig
.replaceAll(varPatter2, "$1" + varReplacement + "$2");
orig = orig.replaceAll(indexPattern, "$1" + indexReplacement
+ "$2");
expr = orig;
}
} catch (Exception e) {
}
expr = "#{" + expr + "}";
return expr;
}
/**
* Creates value expression to be out into column
*
* @param context
* @param orig
* @return
*/
private ValueExpression createValueExpression(ELContext context,
ValueExpression orig) {
ValueExpression vexpr = getFacesContext().getApplication()
.getExpressionFactory().createValueExpression(context,
orig.getExpressionString(), orig.getExpectedType());
return vexpr;
}
/**
* Deletes dynamic rich columns created before
*/
private void deleteRichColumns() {
List<UIComponent> children = dataTable.getChildren();
Integer generatedId = RequestUniqueIdGenerator.generateId(getFacesContext());
Iterator<UIComponent> it = children.iterator();
while (it.hasNext()) {
UIComponent child = it.next();
Object generationSeries = child.getAttributes().get(J_GENERATION_SERIES_ATTRIBUTE);
if (generationSeries != null && !generationSeries.equals(generatedId)) {
it.remove();
}
}
}
/**
* Method prepares all we need for starting of tag rendering
*
* @throws JspTagException
*/
private void prepare() throws JspTagException {
dataTable = getParentUIComponentClassicTagBase(pageContext)
.getComponentInstance();
created = (dataTable.getChildCount() > 0);
if (created) {
deleteRichColumns();
}
initVariables();
// produce the right sort of ForEachIterator
if (__value != null) {
// If this is a deferred expression, make a note and get
// the 'items' instance.
if (__value instanceof ValueExpression) {
rawItems = __value.getValue(pageContext.getELContext());
}
// extract an iterator over the 'items' we've got
items = SimpleForEachIterator
.supportedTypeForEachIterator(rawItems);
} else {
// no 'items', so use 'begin' and 'end'
items = SimpleForEachIterator.beginEndForEachIterator(columns - 1);
}
correctFirst();
/*
* ResultSet no more supported in <c:forEach> // step must be 1 when
* ResultSet is passed in if (rawItems instanceof ResultSet && step !=
* 1) throw new JspTagException(
* Resources.getMessage("FOREACH_STEP_NO_RESULTSET"));
*/
}
/**
* Extracts tags attributes values
*/
private void initVariables() {
initColumnsCount();
initIndex();
initVar();
initBegin();
initEnd();
}
private void initItarationId() {
jspId = (jspId == null) ? getJspId() : jspId;
if (jspId != null) {
setJspId(jspId); // We need it twice!
setJspId(jspId);
}
}
/**
* Extracts integer value from end attr
*/
private void initColumnsCount() {
if (__columns != null) {
if (__columns instanceof ValueExpression)
try {
String t = (String) __columns.getValue(getELContext());
columns = Integer.parseInt(t);
if (columns < 0) {
columns = 0; // If end is negative set up zero
}
} catch (Exception e) {
columns = 0;
}
} else {
columns = 0;
}
}
/**
* Extracts string value from var attr
*/
private void initVar() {
if (__var != null) {
try {
itemId = (String) __var.getValue(getELContext());
} catch (ClassCastException e) {
itemId = null;
}
}
}
/**
* Extracts string value from index attr
*/
private void initIndex() {
if (_index != null) {
try {
indexId = (String) _index.getValue(getELContext());
} catch (ClassCastException e) {
indexId = null;
}
}
}
/**
* Extracts string value from index attr
*/
private void initBegin() {
begin = 0;
if (__begin != null) {
try {
Object o = __begin.getValue(getELContext());
if (o instanceof Number) {
begin = ((Number) o).intValue();
} else if (o instanceof String) {
begin = Integer.parseInt((String) o);
}
begin--; // correct begin value
if (begin < 0) {
begin = 0;
}
} catch (ClassCastException e) {
begin = 0;
}
}
}
/**
* Extracts string value from index attr
*/
private void initEnd() {
end = 0;
if (__end != null) {
try {
Object o = __end.getValue(getELContext());
if (o instanceof Number) {
end = ((Number) o).intValue();
} else if (o instanceof String) {
end = Integer.parseInt((String) o);
}
if (end < 0) {
end = 0;
}
} catch (ClassCastException e) {
end = 0;
}
}
}
/**
* Inits first iteration item
*/
private void correctFirst() {
try {
if (items != null) {
if (begin > 0 && (index < (begin - 1))) {
while ((index < (begin - 1)) && hasNext()) {
next();
}
}
}
} catch (Exception e) {
log.error(e.getLocalizedMessage(), e);
// TODO: handle exception
}
}
/**
* Return true if we didn't complete column's count
*
* @return
* @throws JspTagException
*/
private boolean hasNext() throws JspTagException {
if (end != 0) {
return (index < (end - 1)) ? items.hasNext() : false;
} else {
return items.hasNext();
}
}
/**
* Iterate to next column
*
* @return
* @throws JspTagException
*/
private Object next() throws JspTagException {
Object o = items.next();
initItarationId();
index++;
return o;
}
/**
* Returns true if this is the first loop of columns tag
*
* @return
*/
private boolean atFirst() {
return (index == begin - 1);
}
private String generateColumnId() {
String id = getId();
if (id == null) {
id = getFacesJspId();
}
return id;
}
/**
* Create custom context with VariableMapper override.
*
* @param cont
* @return
*/
private ELContext getContext(final ELContext cont) {
return new ELContext() {
@Override
public Object getContext(Class key) {
return cont.getContext(key);
}
@Override
public ELResolver getELResolver() {
return cont.getELResolver();
}
@Override
public FunctionMapper getFunctionMapper() {
return cont.getFunctionMapper();
}
@Override
public VariableMapper getVariableMapper() {
return new VariableMapper() {
@Override
public ValueExpression resolveVariable(String variable) {
if (variable.equals(itemId)) {
return new IndexedValueExpression(__value, index);
} else if (variable.equals(indexId)) {
return new IteratedIndexExpression(index);
}
return cont.getVariableMapper().resolveVariable(
variable);
}
@Override
public ValueExpression setVariable(String variable,
ValueExpression expression) {
return cont.getVariableMapper().setVariable(variable,
expression);
}
};
}
};
}
@Override
public String getComponentType() {
return UIColumn.COMPONENT_TYPE;
}
@Override
public String getRendererType() {
return CellRenderer.class.getName();
}
/**
* Sets page request variables
*
* @throws JspTagException
*/
private void exposeVariables() throws JspTagException {
/*
* We need to support null items returned from next(); we do this simply
* by passing such non-items through to the scoped variable as
* effectively 'null' (that is, by calling removeAttribute()).
*
* Also, just to be defensive, we handle the case of a null 'status'
* object as well.
*
* We call getCurrent() and getLoopStatus() (instead of just using
* 'item' and 'status') to bridge to subclasses correctly. A subclass
* can override getCurrent() or getLoopStatus() but still depend on our
* doStartTag() and doAfterBody(), which call this method
* (exposeVariables()), to expose 'item' and 'status' correctly.
*/
// Set up var variable
if (itemId != null) {
if (index == null)
pageContext.removeAttribute(itemId, PageContext.PAGE_SCOPE);
else if (__value != null) {
VariableMapper vm = pageContext.getELContext()
.getVariableMapper();
if (vm != null) {
ValueExpression ve = getVarExpression(__value);
vm.setVariable(itemId, ve);
}
} else
pageContext.setAttribute(itemId, index);
}
// Set up index variable
if (indexId != null) {
if (index == null)
pageContext.removeAttribute(indexId, PageContext.PAGE_SCOPE);
else {
IteratedIndexExpression indexExpression = new IteratedIndexExpression(
index);
VariableMapper vm = pageContext.getELContext()
.getVariableMapper();
if (vm != null) {
vm.setVariable(indexId, indexExpression);
}
}
}
}
/**
* Return expression for page variables
*
* @param expr
* @return
*/
private ValueExpression getVarExpression(ValueExpression expr) {
Object o = expr.getValue(pageContext.getELContext());
if (o.getClass().isArray() || o instanceof List) {
return new IndexedValueExpression(__value, index);
}
if (o instanceof Collection || o instanceof Iterator
|| o instanceof Enumeration || o instanceof Map
|| o instanceof String) {
if (iteratedExpression == null) {
iteratedExpression = new IteratedExpression(__value,
getDelims());
}
return new IteratedValueExpression(iteratedExpression, index);
}
throw new ELException("FOREACH_BAD_ITEMS: [" + o.getClass().getName() + "] is not iterable item. Only [List, Array, Collection, Enumeration, Map, String] are supported.");
}
/*
* Get the delimiter for string tokens. Used only for constructing the
* deferred expression for it.
*/
protected String getDelims() {
return ",";
}
/**
* @param end
* the end to set
*/
public void setEnd(ValueExpression end) {
this.__end = end;
}
/**
* @param begin
* the begin to set
*/
public void setBegin(ValueExpression begin) {
this.__begin = begin;
}
/**
* @param columns
* the columns to set
*/
public void setColumns(ValueExpression columns) {
this.__columns = columns;
}
/**
* @param index
* the index to set
*/
public void setIndex(ValueExpression index) {
this._index = index;
}
/**
* The current value for this component Setter for value
*
* @param value -
* new value
*/
public void setValue(ValueExpression value) {
this.__value = value;
}
/**
* A request-scope attribute via which the data object for the current row
* will be used when iterating Setter for var
*
* @param var -
* new value
*/
public void setVar(ValueExpression var) {
this.__var = var;
}
/**
* Corresponds to the HTML colspan attribute Setter for colspan
*
* @param colspan -
* new value
*/
public void setColspan(ValueExpression colspan) {
this._colspan = colspan;
}
/**
* Corresponds to the HTML class attribute Setter for styleClass
*
* @param styleClass -
* new value
*/
public void setStyleClass(ValueExpression styleClass) {
this._styleClass = styleClass;
}
/**
* Attribute defines width of column. Default value is "100px". Setter for
* width
*
* @param width -
* new value
*/
public void setWidth(ValueExpression width) {
this._width = width;
}
/**
* if "true" next column begins from the first row Setter for breakBefore
*
* @param breakBefore -
* new value
*/
public void setBreakBefore(ValueExpression breakBefore) {
this._breakBefore = breakBefore;
}
/**
*
* Setter for comparator
*
* @param comparator -
* new value
*/
public void setComparator(ValueExpression comparator) {
this._comparator = comparator;
}
/**
* Sets dir attr
*
* @param dir
*/
public void setDir(ValueExpression dir) {
_dir = dir;
}
/**
*
* Setter for filterBy
*
* @param filterBy -
* new value
*/
public void setFilterBy(ValueExpression filterBy) {
this._filterBy = filterBy;
}
/**
*
* Setter for filterDefaultLabel
*
* @param filterDefaultLabel -
* new value
*/
public void setFilterDefaultLabel(ValueExpression filterDefaultLabel) {
this._filterDefaultLabel = filterDefaultLabel;
}
/**
* Event for filter input that forces the filtration (default = onchange)
* Setter for filterEvent
*
* @param filterEvent -
* new value
*/
public void setFilterEvent(ValueExpression filterEvent) {
this._filterEvent = filterEvent;
}
/**
* Attribute defines a bean property which is used for filtering of a column
* Setter for filterExpression
*
* @param filterExpression -
* new value
*/
public void setFilterExpression(ValueExpression filterExpression) {
this._filterExpression = filterExpression;
}
/**
*
* Setter for filterMethod
*
* @param filterMethod -
* new value
*/
public void setFilterMethod(MethodExpression filterMethod) {
this._filterMethod = filterMethod;
}
/**
*
* Setter for filterValue
*
* @param filterValue -
* new value
*/
public void setFilterValue(ValueExpression filterValue) {
this._filterValue = filterValue;
}
/**
* Space-separated list of CSS style class(es) that are be applied to any
* footer generated for this table Setter for footerClass
*
* @param footerClass -
* new value
*/
public void setFooterClass(ValueExpression footerClass) {
this._footerClass = footerClass;
}
/**
* Space-separated list of CSS style class(es) that are be applied to any
* header generated for this table Setter for headerClass
*
* @param headerClass -
* new value
*/
public void setHeaderClass(ValueExpression headerClass) {
this._headerClass = headerClass;
}
/**
* Corresponds to the HTML rowspan attribute Setter for rowspan
*
* @param rowspan -
* new value
*/
public void setRowspan(ValueExpression rowspan) {
this._rowspan = rowspan;
}
/**
*
* Setter for selfSorted
*
* @param selfSorted -
* new value
*/
public void setSelfSorted(ValueExpression selfSorted) {
this._selfSorted = selfSorted;
}
/**
* Boolean attribute. If "true" it's possible to sort the column content
* after click on the header. Default value is "true" Setter for sortable
*
* @param sortable -
* new value
*/
public void setSortable(ValueExpression sortable) {
this._sortable = sortable;
}
/**
* Attribute defines a bean property which is used for sorting of a column
* Setter for sortExpression
*
* @param sortExpression -
* new value
*/
public void setSortExpression(ValueExpression sortExpression) {
this._sortExpression = sortExpression;
}
/**
* Attribute defines whether to render component or not
* Setter for rendered
*
* @param rendered - new value
*/
public void setRendered(ValueExpression rendered) {
this._rendered = rendered;
}
/**
* Defines sort icon. The value for the attribute is context related
* @param icon
*/
public void setSortIcon(ValueExpression icon) {
_sortIcon = icon;
}
/**
* Defines sort icon for ascending order. The value for the attribute is context related
* @param iconAscending
*/
public void setSortIconAscending(ValueExpression iconAscending) {
_sortIconAscending = iconAscending;
}
/**
* Defines sort icon for descending order. The value for the attribute is context related
* @param iconDescending
*/
public void setSortIconDescending(ValueExpression iconDescending) {
_sortIconDescending = iconDescending;
}
}