// WARNING: This file was automatically generated. Do not edit it directly,
// or you will lose your changes.
/*
* 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.trinidad.component;
import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.IdentityHashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import javax.el.MethodExpression;
import javax.faces.component.UIComponent;
import javax.faces.context.FacesContext;
import javax.faces.el.MethodBinding;
import javax.faces.event.AbortProcessingException;
import javax.faces.event.FacesEvent;
import javax.faces.event.PhaseId;
import org.apache.myfaces.trinidad.bean.FacesBean;
import org.apache.myfaces.trinidad.bean.PropertyKey;
import org.apache.myfaces.trinidad.event.RangeChangeEvent;
import org.apache.myfaces.trinidad.event.RangeChangeListener;
import org.apache.myfaces.trinidad.event.RowDisclosureEvent;
import org.apache.myfaces.trinidad.event.RowDisclosureListener;
import org.apache.myfaces.trinidad.event.SelectionEvent;
import org.apache.myfaces.trinidad.event.SelectionListener;
import org.apache.myfaces.trinidad.event.SortEvent;
import org.apache.myfaces.trinidad.event.SortListener;
import org.apache.myfaces.trinidad.model.CollectionModel;
import org.apache.myfaces.trinidad.model.RowKeySet;
import org.apache.myfaces.trinidad.model.RowKeySetImpl;
import org.apache.myfaces.trinidad.model.SortCriterion;
import org.apache.myfaces.trinidad.util.ComponentUtils;
/**
*
* <h4>Events:</h4>
* <table border="1" width="100%" cellpadding="3" summary="">
* <tr bgcolor="#CCCCFF" class="TableHeadingColor">
* <th align="left">Type</th>
* <th align="left">Phases</th>
* <th align="left">Description</th>
* </tr>
* <tr class="TableRowColor">
* <td valign="top"><code>org.apache.myfaces.trinidad.event.RowDisclosureEvent</code></td>
* <td valign="top" nowrap>Apply<br>Request<br>Values<br>Invoke<br>Application</td>
* <td valign="top">The expansion event is generated for a table when the detail facet of a row is expanded or collapsed. For tree or a treeTable, the expansion
event is generated when tree nodes are expanded or collapsed.</td>
* </tr>
* <tr class="TableRowColor">
* <td valign="top"><code>org.apache.myfaces.trinidad.event.SelectionEvent</code></td>
* <td valign="top" nowrap>Apply<br>Request<br>Values<br>Invoke<br>Application</td>
* <td valign="top">The selection event is delivered when the table selection
changes.</td>
* </tr>
* <tr class="TableRowColor">
* <td valign="top"><code>org.apache.myfaces.trinidad.event.RangeChangeEvent</code></td>
* <td valign="top" nowrap>Apply<br>Request<br>Values<br>Invoke<br>Application</td>
* <td valign="top">The range change event is delivered when the user
navigates.</td>
* </tr>
* <tr class="TableRowColor">
* <td valign="top"><code>org.apache.myfaces.trinidad.event.SortEvent</code></td>
* <td valign="top" nowrap>Apply<br>Request<br>Values<br>Invoke<br>Application</td>
* <td valign="top">The sort event is delivered when the table column sort
criteria is changed.</td>
* </tr>
* <tr class="TableRowColor">
* <td valign="top"><code>org.apache.myfaces.trinidad.event.AttributeChangeEvent</code></td>
* <td valign="top" nowrap>Invoke<br>Application<br>Apply<br>Request<br>Values</td>
* <td valign="top">Event delivered to describe an attribute change. Attribute change events are not delivered for any programmatic change to a property. They are only delivered when a renderer changes a property without the application's specific request. An example of an attribute change event might include the width of a column that supported client-side resizing.</td>
* </tr>
* </table>
*/
public class UIXTable extends UIXIterator
implements CollectionComponent
{
static public final FacesBean.Type TYPE = new FacesBean.Type(
UIXIterator.TYPE);
static public final PropertyKey ROW_DISCLOSURE_LISTENER_KEY =
TYPE.registerKey("rowDisclosureListener", MethodExpression.class);
static public final PropertyKey DISCLOSED_ROW_KEYS_KEY =
TYPE.registerKey("disclosedRowKeys", RowKeySet.class, null, 0, PropertyKey.Mutable.OFTEN);
static public final PropertyKey SELECTION_LISTENER_KEY =
TYPE.registerKey("selectionListener", MethodExpression.class);
static public final PropertyKey SELECTED_ROW_KEYS_KEY =
TYPE.registerKey("selectedRowKeys", RowKeySet.class, null, 0, PropertyKey.Mutable.OFTEN);
static public final PropertyKey IMMEDIATE_KEY =
TYPE.registerKey("immediate", Boolean.class, Boolean.FALSE);
static public final PropertyKey SORT_LISTENER_KEY =
TYPE.registerKey("sortListener", MethodExpression.class);
static public final PropertyKey RANGE_CHANGE_LISTENER_KEY =
TYPE.registerKey("rangeChangeListener", MethodExpression.class);
static public final PropertyKey SHOW_ALL_KEY =
TYPE.registerKey("showAll", Boolean.class, Boolean.FALSE);
static public final String DETAIL_STAMP_FACET = "detailStamp";
static public final String COMPONENT_FAMILY =
"org.apache.myfaces.trinidad.Table";
static public final String COMPONENT_TYPE =
"org.apache.myfaces.trinidad.Table";
/**
* Construct an instance of the UIXTable.
*/
public UIXTable()
{
super("org.apache.myfaces.trinidad.Table");
}
// These are "fake" properties that allow the table to get the disclosed row keys and the
// selected row key without triggering the call to getCollectionModel from the
// RowKeyFacesBeanWrapper class. See the stamp state saving code for its usage.
static private final PropertyKey _DISCLOSED_ROW_KEYS_WITHOUT_MODEL_KEY =
TYPE.registerKey("disclosedRowKeysWithoutModel", RowKeySet.class);
static private final PropertyKey _SELECTED_ROW_KEYS_WITHOUT_MODEL_KEY =
TYPE.registerKey("selectedRowKeysWithoutModel", RowKeySet.class);
/**
* Override to update the container client id cache before decode
*/
@Override
public void decode(FacesContext context)
{
_resetContainerClientIdCache();
super.decode(context);
}
/**
* Override to update the container client id cache before validations
*/
@Override
public void processValidators(FacesContext context)
{
_resetContainerClientIdCache();
super.processValidators(context);
}
/**
* Override to update the container client id cache before updates
*/
@Override
public void processUpdates(FacesContext context)
{
_resetContainerClientIdCache();
super.processUpdates(context);
}
/**
* Override to update the container client id cache before encode
*/
@Override
void __encodeBegin(FacesContext context) throws IOException
{
_resetContainerClientIdCache();
super.__encodeBegin(context);
}
/**
* Override to return clientd ids with no currency for items in header/footer facets
*/
@Override
public String getContainerClientId(FacesContext context, UIComponent child)
{
String id;
if (_containerClientIdCache == null || _isStampedChild(child))
{
// call the UIXCollection getContainerClientId, which attaches currency string to the client id
id = getContainerClientId(context);
}
else
{
// The target is not a stamped child, so return a client id with no currency string
id = getClientId(context);
}
return id;
}
@Override
public void setSortCriteria(List<SortCriterion> criteria)
{
_sortCriteria = criteria;
super.setSortCriteria(criteria);
}
/**
* Sets the phaseID of UI events depending on the "immediate" property.
*/
@Override
public void queueEvent(FacesEvent event)
{
TableUtils.__handleQueueEvent(this, event);
super.queueEvent(event);
}
/**
* Delivers an event to the appropriate listeners.
* @param event
* @throws javax.faces.event.AbortProcessingException
*/
@Override
public void broadcast(FacesEvent event)
throws AbortProcessingException
{
// the order of processing is
// 1. do any default action handling
// 2. invoke any actionListener method binding
// 3. call all the registered ActionListener instances.
// Deliver to the default RangeChangeListener
if (event instanceof RangeChangeEvent)
{
RangeChangeEvent rEvent = (RangeChangeEvent) event;
int first = rEvent.getNewStart();
setFirst(first);
//pu: Implicitly record a Change for 'first' attribute
addAttributeChange("first", Integer.valueOf(first));
if ((first == 0) && (rEvent.getNewEnd() == getRowCount()))
{
setShowAll(true);
//pu: Implicitly record a Change for 'showAll' attribute
addAttributeChange("showAll", Boolean.TRUE);
}
else if (isShowAll())
{
setShowAll(false);
//pu: Implicitly record a Change for 'showAll' attribute
addAttributeChange("showAll", Boolean.FALSE);
}
// since the range is now different we can clear the currency cache:
clearCurrencyStringCache();
broadcastToMethodExpression(event, getRangeChangeListener());
}
else if (event instanceof RowDisclosureEvent)
{
RowDisclosureEvent eEvent = (RowDisclosureEvent) event;
RowKeySet set = getDisclosedRowKeys();
set.addAll(eEvent.getAddedSet());
set.removeAll(eEvent.getRemovedSet());
addAttributeChange("disclosedRowKeys", set);
broadcastToMethodExpression(event, getRowDisclosureListener());
}
else if (event instanceof SortEvent)
{
SortEvent sEvent = (SortEvent) event;
setSortCriteria(sEvent.getSortCriteria());
broadcastToMethodExpression(event, getSortListener());
}
else if (event instanceof SelectionEvent)
{
//pu: Implicitly record a Change for 'selectionState' attribute
addAttributeChange("selectedRowKeys",
getSelectedRowKeys());
broadcastToMethodExpression(event, getSelectionListener());
}
super.broadcast(event);
}
@Deprecated
public void setRangeChangeListener(MethodBinding binding)
{
setRangeChangeListener(adaptMethodBinding(binding));
}
@Deprecated
public void setSortListener(MethodBinding binding)
{
setSortListener(adaptMethodBinding(binding));
}
@Deprecated
public void setRowDisclosureListener(MethodBinding binding)
{
setRowDisclosureListener(adaptMethodBinding(binding));
}
@Deprecated
public void setSelectionListener(MethodBinding binding)
{
setSelectionListener(adaptMethodBinding(binding));
}
@Override
@SuppressWarnings("unchecked")
public Object saveState(FacesContext context)
{
Object o = super.saveState(context);
if ((o == null) &&
((_sortCriteria == null) || _sortCriteria.isEmpty()))
return null;
return new Object[]{o, _sortCriteria};
}
@Override
@SuppressWarnings("unchecked")
public void restoreState(FacesContext context, Object state)
{
Object[] array = (Object[]) state;
super.restoreState(context, array[0]);
// Get the sort criteria - but *don't* call setSortCriteria()
// here; doing so would require getting the collection model,
// and that may invoke client code that isn't quite in a state
// to be invoked, in part because component "binding"s have not been
// evaluated yet.
List<SortCriterion> criteria = (List<SortCriterion>) array[1];
_sortCriteria = criteria;
}
/**
* Gets the data for the first selected row.
* This is useful when using EL to get at column data for the selected
* row when using a table with single selection.
* @return null if there is nothing selected in the table.
*/
public Object getSelectedRowData()
{
RowKeySet state = getSelectedRowKeys();
Iterator<Object> keys = state.iterator();
if (keys.hasNext())
{
Object key = keys.next();
CollectionModel model = getCollectionModel();
Object old = model.getRowKey();
try
{
model.setRowKey(key);
if (isRowAvailable())
return model.getRowData();
}
finally
{
model.setRowKey(old);
}
}
return null;
}
@Override
protected void processFacetsAndChildren(
FacesContext context,
PhaseId phaseId)
{
// process all the facets of this table just once
// (except for the "detailStamp" facet which must be processed once
// per row):
TableUtils.processFacets(context, this, this, phaseId,
UIXTable.DETAIL_STAMP_FACET);
// process all the facets of this table's column children:
TableUtils.processColumnFacets(context, this, this, phaseId);
// process all the children and the detailStamp as many times as necessary
processStamps(context, phaseId);
}
/**
* Gets the stamps. This returns the children of this component plus
* the detail stamp (if any).
*/
// TODO cache the result
@Override
protected final List<UIComponent> getStamps()
{
List<UIComponent> children = super.getStamps();
UIComponent detail = getDetailStamp();
if (detail != null)
{
List<UIComponent> stamps = new ArrayList<UIComponent>(children.size() + 1);
stamps.addAll(children);
stamps.add(detail);
return stamps;
}
return children;
}
/**
* Saves the state for the given stamp.
* This method avoids changing the state of facets on columns.
*/
@Override
protected final Object saveStampState(FacesContext context, UIComponent stamp)
{
if (stamp instanceof UIXColumn)
{
// if it is a column, we don't want the facets processed.
// Only the children:
return StampState.saveChildStampState(context, stamp, this);
}
else
{
Object stampState = super.saveStampState(context, stamp);
// Support for column stamping. Before this fix, nested UIXCollection can never be processed without setting
// currency on the outer iterator. The inner collection's stamp state is only created if it is null. The inner
// collection depends on the outer collection to save and restore the nested stamp state to null as it moves it
// currency during saveStampState and restoreStampState.
// Now if the columns are stamped using an iterator, there could be state associated with the column headers,
// footers etc and this is when the currency is null. So it is possible to process/iterate the af:iterator when
// the currency on the outer table is null. This could be for layout of columns etc.
// The following fix uses the internal _movingToNonNullCurrency variable to know that we are ready to start
// iterating the stamps. If so, it saves off the state associated with the null currency in a temporary map that
// is restored when we are done processing our stamps (also see restoreStampState).
if(stamp instanceof UIXIterator && _movingToNonNullCurrency)
{
// JIT create our temporary map
if(_iteratorStampMap == null)
{
_iteratorStampMap = new HashMap<String, Object>();
}
// save off the state associated with the null currency
_iteratorStampMap.put(stamp.getClientId(context), stampState);
// reset the state of the iterator to the prestine state for null currency
((UIXIterator)stamp).__resetMyStampState();
// now save the pristine state to the null currency so that when fresh stamp states can be created if necessary
stampState = super.saveStampState(context, stamp);
}
return stampState;
}
}
/**
* Restores the state for the given stamp.
* This method avoids changing the state of facets on columns.
*/
@Override
protected final void restoreStampState(FacesContext context, UIComponent stamp, Object stampState)
{
if (stamp instanceof UIXColumn)
{
// if it is a column, we don't want the facets processed.
// Only the children:
StampState.restoreChildStampState(context, stamp, this, stampState);
}
else
{
// If we are done processing our stamps and are moving back to null currency, restore the stamp state to the
// one saved off before processing our stamps
if(stamp instanceof UIXIterator && _movingBackToNullCurrency && _iteratorStampMap != null)
{
// clear the cached client id of the iterator so that we can get the one without currency
stamp.setId(stamp.getId());
stampState = _iteratorStampMap.get(stamp.getClientId(context));
}
super.restoreStampState(context, stamp, stampState);
}
}
@Override
protected final CollectionModel createCollectionModel(
CollectionModel current,
Object value)
{
return super.createCollectionModel(current, value);
}
@Override
protected void postCreateCollectionModel(CollectionModel model)
{
RowKeySet selectedRowKeys = getSelectedRowKeys();
if (selectedRowKeys == null)
{
selectedRowKeys = new RowKeySetImpl();
setSelectedRowKeys(selectedRowKeys);
}
RowKeySet disclosedRowKeys = getDisclosedRowKeys();
if (disclosedRowKeys == null)
{
disclosedRowKeys = new RowKeySetImpl();
setDisclosedRowKeys(disclosedRowKeys);
}
selectedRowKeys.setCollectionModel(model);
disclosedRowKeys.setCollectionModel(model);
// If we were perviously sorted, restore the sort order:
if (_sortCriteria != null)
{
model.setSortCriteria(_sortCriteria);
}
}
/**
* Gets the internal state of this component.
*/
@Override
Object __getMyStampState()
{
Object[] state = new Object[6];
state[0] = _sortCriteria;
state[1] = super.__getMyStampState();
state[2] = Integer.valueOf(getFirst());
state[3] = Boolean.valueOf(isShowAll());
// Use "hidden" property keys to allow the row key sets to be retrieved without the
// RowKeyFacesBeanWrapper trying to resolve the collection model to be set into the row key
// set. This is needed to stop the unnecessary lookup of the collection model when it is not
// needed during stamp state saving of the table.
RowKeySet selectedRowKeys = (RowKeySet)getProperty(_SELECTED_ROW_KEYS_WITHOUT_MODEL_KEY);
RowKeySet disclosedRowKeys = (RowKeySet)getProperty(_DISCLOSED_ROW_KEYS_WITHOUT_MODEL_KEY);
state[4] = selectedRowKeys;
state[5] = disclosedRowKeys;
return state;
}
/**
* Sets the internal state of this component.
* @param stampState the internal state is obtained from this object.
*/
@Override
@SuppressWarnings("unchecked")
void __setMyStampState(Object stampState)
{
Object[] state = (Object[]) stampState;
_sortCriteria = (List<SortCriterion>) state[0];
super.__setMyStampState(state[1]);
setFirst(((Integer) state[2]).intValue());
setShowAll(Boolean.TRUE == state[3]);
setSelectedRowKeys((RowKeySet) state[4]);
setDisclosedRowKeys((RowKeySet) state[5]);
}
@Override
void __resetMyStampState()
{
super.__resetMyStampState();
_sortCriteria = null;
setFirst((Integer)FIRST_KEY.getDefault());
setShowAll(Boolean.TRUE == SHOW_ALL_KEY.getDefault());
setSelectedRowKeys(null);
setDisclosedRowKeys(null);
}
protected void processStamps(
FacesContext context,
PhaseId phaseId)
{
// Process all the children
CollectionModel tableData = getCollectionModel();
if (tableData.getRowCount() != 0)
{
int startIndex = getFirst();
int endIndex = isShowAll() ? getRowCount()-1 : TableUtils.getLast(this);
UIComponent detail = getDetailStamp();
RowKeySet disclosureState =
(detail == null) ? null : getDisclosedRowKeys();
for (int i = startIndex; i <= endIndex; i++)
{
setRowIndex(i);
if (isRowAvailable())
{
TableUtils.processStampedChildren(context, this, phaseId);
if ((disclosureState != null) && disclosureState.isContained())
{
assert getRowIndex() == i;
processComponent(context, detail, phaseId);
}
}
}
setRowIndex(-1);
}
}
/**
* Is target a stamped child UIComponent in the table body
*/
private boolean _isStampedChild(UIComponent target)
{
assert _containerClientIdCache != null;
return !_containerClientIdCache.containsKey(target);
}
/**
* Reset the cache of child components used in getContainerClientId
*/
private void _resetContainerClientIdCache()
{
if(_containerClientIdCache == null)
_containerClientIdCache = new IdentityHashMap<UIComponent, Boolean>();
else
_containerClientIdCache.clear();
TableUtils.cacheHeaderFooterFacets(this, _containerClientIdCache);
TableUtils.cacheColumnHeaderFooterFacets(this, _containerClientIdCache);
}
@Override
void __init()
{
super.__init();
if (getSelectedRowKeys() == null)
setSelectedRowKeys(new RowKeySetImpl());
if (getDisclosedRowKeys() == null)
setDisclosedRowKeys(new RowKeySetImpl());
// if "first" is valueBound, we can't deal with it changing
// during the lifecycle. So stash it as a local value.
// see bug 4537121:
setFirst(getFirst());
}
@Override
protected FacesBean createFacesBean(String rendererType)
{
return new RowKeyFacesBeanWrapper(super.createFacesBean(rendererType));
}
private class RowKeyFacesBeanWrapper
extends FacesBeanWrapper
{
private boolean _retrievingDisclosedRows = false;
private boolean _retrievingSelectedRows = false;
RowKeyFacesBeanWrapper(FacesBean bean)
{
super(bean);
}
@Override
public Object getProperty(PropertyKey key)
{
if (key == _DISCLOSED_ROW_KEYS_WITHOUT_MODEL_KEY)
{
// This case is only true if the table is trying to serialize the disclosed row keys to
// the stamp state of a parent UIXCollection. This work-around prevents EL evaluation to
// get the collection model during stamp state saving. This should be permissible as the
// state saving code does not need the collection model to be set in the row key set in
// order to save its state.
return super.getProperty(DISCLOSED_ROW_KEYS_KEY);
}
else if (key == _SELECTED_ROW_KEYS_WITHOUT_MODEL_KEY)
{
// This case is only true if the table is trying to serialize the selected row keys to
// the stamp state of a parent UIXCollection. This work-around prevents EL evaluation to
// get the collection model during stamp state saving. This should be permissible as the
// state saving code does not need the collection model to be set in the row key set in
// order to save its state.
return super.getProperty(SELECTED_ROW_KEYS_KEY);
}
Object value = super.getProperty(key);
if (key == DISCLOSED_ROW_KEYS_KEY)
{
if (!_retrievingDisclosedRows && value instanceof RowKeySet)
{
// Ensure that when we are retrieving and setting the collection model, this property
// is not asked for which would create an infinite loop
_retrievingDisclosedRows = true;
try
{
RowKeySet rowKeys = (RowKeySet) value;
// row key sets need the most recent collection model, but there is no one common entry
// point to set this on the set besides when code asks for the value from the bean
__flushCachedModel(); //insist that we populate with the very lastest instance of the collection model
rowKeys.setCollectionModel(getCollectionModel());
}
finally
{
_retrievingDisclosedRows = false;
}
}
}
else if (key == SELECTED_ROW_KEYS_KEY)
{
if (!_retrievingSelectedRows && value instanceof RowKeySet)
{
// Ensure that when we are retrieving and setting the collection model, this property
// is not asked for which would create an infinite loop
_retrievingSelectedRows = true;
try
{
RowKeySet rowKeys = (RowKeySet) value;
// row key sets need the most recent collection model, but there is no one common entry
// point to set this on the set besides when code asks for the value from the bean
__flushCachedModel(); //insist that we populate with the very lastest instance of the collection model
rowKeys.setCollectionModel(getCollectionModel());
}
finally
{
_retrievingSelectedRows = false;
}
}
}
return value;
}
@Override
public Object saveState(FacesContext context)
{
RowKeySet rowKeys = (RowKeySet)super.getProperty(DISCLOSED_ROW_KEYS_KEY);
if (rowKeys != null)
{
// make sure the set does not pin the model in memory
rowKeys.setCollectionModel(null);
}
rowKeys = (RowKeySet)super.getProperty(SELECTED_ROW_KEYS_KEY);
if (rowKeys != null)
{
// make sure the set does not pin the model in memory
rowKeys.setCollectionModel(null);
}
return super.saveState(context);
}
}
@Override
public void setRowKey(Object rowKey)
{
_preCurrencyChange(rowKey == null);
try
{
super.setRowKey(rowKey);
}
finally
{
_postCurrencyChange();
}
}
@Override
public void setRowIndex(int rowIndex)
{
_preCurrencyChange(rowIndex == -1);
try
{
super.setRowIndex(rowIndex);
}
finally
{
_postCurrencyChange();
}
}
/**
* When the currency changes keep track of the fact that we are ready to start iterating the stamps vs setting
* currency to process headers etc. If the new curency is not null but the old one was,
* we are ready to start processing the stamps.
*
* Similary keep track of the fact that we are done processing the our stamps. In this case the currency moves back to
* null after being set previously
*/
private void _preCurrencyChange(boolean isNewCurrencyNull)
{
Object currencyObj = getRowKey();
if(currencyObj == null && !isNewCurrencyNull)
{
_movingToNonNullCurrency = true;
}
if(currencyObj != null && isNewCurrencyNull)
{
_movingBackToNullCurrency = true;
}
}
/**
* Clean up variables setup during _preCurrencyChange.
*/
private void _postCurrencyChange()
{
_movingToNonNullCurrency = false;
if(_movingBackToNullCurrency)
{
_iteratorStampMap = null;
}
_movingBackToNullCurrency = false;
}
transient private List<SortCriterion> _sortCriteria = null;
// cache of child components inside this table header/footer facets and column header/footer
// facets
transient private IdentityHashMap<UIComponent, Boolean> _containerClientIdCache = null;
// transient variables used to track when are going to start processing the stamps and when we are done.
transient private boolean _movingToNonNullCurrency = false;
transient private boolean _movingBackToNullCurrency = false;
// map used to support iterator stamping of columns
transient private Map<String, Object> _iteratorStampMap = null;
/**
* the component to stamp below every row which is disclosed. Adding a
* detail facet will automatically cause the detail column to be displayed.
*/
final public UIComponent getDetailStamp()
{
return getFacet(DETAIL_STAMP_FACET);
}
/**
* the component to stamp below every row which is disclosed. Adding a
* detail facet will automatically cause the detail column to be displayed.
*/
@SuppressWarnings("unchecked")
final public void setDetailStamp(UIComponent detailStampFacet)
{
getFacets().put(DETAIL_STAMP_FACET, detailStampFacet);
}
/**
* Gets a method reference to an ExpansionListener
*
* @return the new rowDisclosureListener value
*/
final public MethodExpression getRowDisclosureListener()
{
return (MethodExpression)getProperty(ROW_DISCLOSURE_LISTENER_KEY);
}
/**
* Sets a method reference to an ExpansionListener
*
* @param rowDisclosureListener the new rowDisclosureListener value
*/
final public void setRowDisclosureListener(MethodExpression rowDisclosureListener)
{
setProperty(ROW_DISCLOSURE_LISTENER_KEY, (rowDisclosureListener));
}
/**
* Gets the set of disclosed rows for this component.
* Each entry in the set is a rowKey.
*
* @return the new disclosedRowKeys value
*/
final public RowKeySet getDisclosedRowKeys()
{
return (RowKeySet)getProperty(DISCLOSED_ROW_KEYS_KEY);
}
/**
* Sets the set of disclosed rows for this component.
* Each entry in the set is a rowKey.
*
* @param disclosedRowKeys the new disclosedRowKeys value
*/
final public void setDisclosedRowKeys(RowKeySet disclosedRowKeys)
{
setProperty(DISCLOSED_ROW_KEYS_KEY, (disclosedRowKeys));
}
/**
* Gets a method reference to a selection listener
*
* @return the new selectionListener value
*/
final public MethodExpression getSelectionListener()
{
return (MethodExpression)getProperty(SELECTION_LISTENER_KEY);
}
/**
* Sets a method reference to a selection listener
*
* @param selectionListener the new selectionListener value
*/
final public void setSelectionListener(MethodExpression selectionListener)
{
setProperty(SELECTION_LISTENER_KEY, (selectionListener));
}
/**
* Gets the selection state for this component.
*
* @return the new selectedRowKeys value
*/
final public RowKeySet getSelectedRowKeys()
{
return (RowKeySet)getProperty(SELECTED_ROW_KEYS_KEY);
}
/**
* Sets the selection state for this component.
*
* @param selectedRowKeys the new selectedRowKeys value
*/
final public void setSelectedRowKeys(RowKeySet selectedRowKeys)
{
setProperty(SELECTED_ROW_KEYS_KEY, (selectedRowKeys));
}
/**
* Gets whether or not data validation - client-side or
* server-side -
* should take place when
* events are generated by this component.
*
* When immediate is true, the default ActionListener
* provided by the JavaServer Faces implementation
* should be executed during Apply Request Values phase
* of the request processing lifecycle, rather than
* waiting until the Invoke Application phase.
*
* @return the new immediate value
*/
final public boolean isImmediate()
{
return ComponentUtils.resolveBoolean(getProperty(IMMEDIATE_KEY), false);
}
/**
* Sets whether or not data validation - client-side or
* server-side -
* should take place when
* events are generated by this component.
*
* When immediate is true, the default ActionListener
* provided by the JavaServer Faces implementation
* should be executed during Apply Request Values phase
* of the request processing lifecycle, rather than
* waiting until the Invoke Application phase.
*
* @param immediate the new immediate value
*/
final public void setImmediate(boolean immediate)
{
setProperty(IMMEDIATE_KEY, immediate ? Boolean.TRUE : Boolean.FALSE);
}
/**
* Gets a method reference to a sort listener
*
* @return the new sortListener value
*/
final public MethodExpression getSortListener()
{
return (MethodExpression)getProperty(SORT_LISTENER_KEY);
}
/**
* Sets a method reference to a sort listener
*
* @param sortListener the new sortListener value
*/
final public void setSortListener(MethodExpression sortListener)
{
setProperty(SORT_LISTENER_KEY, (sortListener));
}
/**
* Gets a method reference to a rangeChange listener that
* will be called when a new range is selected.
*
* @return the new rangeChangeListener value
*/
final public MethodExpression getRangeChangeListener()
{
return (MethodExpression)getProperty(RANGE_CHANGE_LISTENER_KEY);
}
/**
* Sets a method reference to a rangeChange listener that
* will be called when a new range is selected.
*
* @param rangeChangeListener the new rangeChangeListener value
*/
final public void setRangeChangeListener(MethodExpression rangeChangeListener)
{
setProperty(RANGE_CHANGE_LISTENER_KEY, (rangeChangeListener));
}
/**
* Gets whether the "Show All" option is selected. The "Show All" option
* is available if there are less than 30 options and the row count in
* the data model is known.
*
* @return the new showAll value
*/
final public boolean isShowAll()
{
return ComponentUtils.resolveBoolean(getProperty(SHOW_ALL_KEY), false);
}
/**
* Sets whether the "Show All" option is selected. The "Show All" option
* is available if there are less than 30 options and the row count in
* the data model is known.
*
* @param showAll the new showAll value
*/
final public void setShowAll(boolean showAll)
{
setProperty(SHOW_ALL_KEY, showAll ? Boolean.TRUE : Boolean.FALSE);
}
/**
* Adds a rowDisclosure listener.
*
* @param listener the rowDisclosure listener to add
*/
final public void addRowDisclosureListener(
RowDisclosureListener listener)
{
addFacesListener(listener);
}
/**
* Removes a rowDisclosure listener.
*
* @param listener the rowDisclosure listener to remove
*/
final public void removeRowDisclosureListener(
RowDisclosureListener listener)
{
removeFacesListener(listener);
}
/**
* Returns an array of attached rowDisclosure listeners.
*
* @return an array of attached rowDisclosure listeners.
*/
final public RowDisclosureListener[] getRowDisclosureListeners()
{
return (RowDisclosureListener[])getFacesListeners(RowDisclosureListener.class);
}
/**
* Adds a selection listener.
*
* @param listener the selection listener to add
*/
final public void addSelectionListener(
SelectionListener listener)
{
addFacesListener(listener);
}
/**
* Removes a selection listener.
*
* @param listener the selection listener to remove
*/
final public void removeSelectionListener(
SelectionListener listener)
{
removeFacesListener(listener);
}
/**
* Returns an array of attached selection listeners.
*
* @return an array of attached selection listeners.
*/
final public SelectionListener[] getSelectionListeners()
{
return (SelectionListener[])getFacesListeners(SelectionListener.class);
}
/**
* Adds a rangeChange listener.
*
* @param listener the rangeChange listener to add
*/
final public void addRangeChangeListener(
RangeChangeListener listener)
{
addFacesListener(listener);
}
/**
* Removes a rangeChange listener.
*
* @param listener the rangeChange listener to remove
*/
final public void removeRangeChangeListener(
RangeChangeListener listener)
{
removeFacesListener(listener);
}
/**
* Returns an array of attached rangeChange listeners.
*
* @return an array of attached rangeChange listeners.
*/
final public RangeChangeListener[] getRangeChangeListeners()
{
return (RangeChangeListener[])getFacesListeners(RangeChangeListener.class);
}
/**
* Adds a sort listener.
*
* @param listener the sort listener to add
*/
final public void addSortListener(
SortListener listener)
{
addFacesListener(listener);
}
/**
* Removes a sort listener.
*
* @param listener the sort listener to remove
*/
final public void removeSortListener(
SortListener listener)
{
removeFacesListener(listener);
}
/**
* Returns an array of attached sort listeners.
*
* @return an array of attached sort listeners.
*/
final public SortListener[] getSortListeners()
{
return (SortListener[])getFacesListeners(SortListener.class);
}
@Override
public String getFamily()
{
return COMPONENT_FAMILY;
}
@Override
protected FacesBean.Type getBeanType()
{
return TYPE;
}
/**
* Construct an instance of the UIXTable.
*/
protected UIXTable(
String rendererType
)
{
super(rendererType);
}
static
{
TYPE.lockAndRegister("org.apache.myfaces.trinidad.Table","org.apache.myfaces.trinidad.Table");
}
}