/*
* 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.util.List;
import java.util.Map;
import javax.faces.component.UIComponent;
import javax.faces.context.FacesContext;
import javax.faces.event.FacesEvent;
import javax.faces.event.PhaseId;
import org.apache.myfaces.trinidad.event.DisclosureEvent;
import org.apache.myfaces.trinidad.event.FocusEvent;
import org.apache.myfaces.trinidad.event.RangeChangeEvent;
import org.apache.myfaces.trinidad.event.RowDisclosureEvent;
import org.apache.myfaces.trinidad.event.SelectionEvent;
import org.apache.myfaces.trinidad.event.SortEvent;
import org.apache.myfaces.trinidad.logging.TrinidadLogger;
import org.apache.myfaces.trinidad.model.ModelUtils;
import org.apache.myfaces.trinidad.model.RowKeySet;
import org.apache.myfaces.trinidad.model.SortStrength;
import org.apache.myfaces.trinidad.model.TreeModel;
/**
* utility methods for dealing with tables.
*/
public final class TableUtils
{
/**
* Gets the index of the last visible row that should be
* displayed by the given table. This is usually
* {@link CollectionComponent#getFirst} added to
* {@link CollectionComponent#getRows} minus 1, but it changes if
* {@link CollectionComponent#getRowCount} returns
* insufficient rows.
* @return if this table is empty, this returns
* {@link CollectionComponent#getFirst()} - 1
*/
public static int getLast(CollectionComponent table)
{
return getLast(table, table.getFirst());
}
/**
* Gets the index of the last visible row that should be
* displayed by the given table. This is usually
* rangeStart added to
* {@link CollectionComponent#getRows} minus 1, but it changes if
* {@link CollectionComponent#getRowCount} returns
* insufficient rows.
* @return if this table is empty, this returns
* rangeStart - 1
*/
public static int getLast(CollectionComponent table, int rangeStart)
{
final int rangeEnd;
int blockSize = table.getRows();
// if the blockSize is zero, that means show everthing.
if (blockSize <= 0)
{
rangeEnd = Integer.MAX_VALUE;
}
else
{
rangeEnd = rangeStart + blockSize;
}
return ModelUtils.findLastIndex(table, rangeStart, rangeEnd) - 1;
}
/**
* Sets up an EL variable on the requestScope.
* @param name The name of the EL variable
* @param value The value of the EL variable
* @return any old value that was bound to the EL variable, or null
* if there was no old value.
*/
@SuppressWarnings("unchecked")
public static Object setupELVariable(FacesContext context, String name, Object value)
{
Map<String, Object> requestMap = context.getExternalContext().getRequestMap();
if (value == null)
return requestMap.remove(name);
else
return requestMap.put(name, value);
}
/**
* Perform a safe expand all.
* Checks to make sure that a complete expand-all operation won't result in
* too many nodes being displayed to the user. If too many nodes will end
* up being displayed, this method only expands the immediate children before
* terminating. Otherwise, a complete expand-all operation is performed.
* @param maxSize the maximum number of nodes to display. A complete expand-all
* operation will not take place if more than this number of nodes
* will end up being displayed.
* @param model this tree model must have its path pointing to a particular
* node which must be a container.
*/
static void __doSafeExpandAll(
TreeModel model,
RowKeySet state,
int maxSize)
{
int size = _getSizeOfTree(model, maxSize);
if ((size < 0) || (size > maxSize))
{
// not safe to do expand all.
// first expand the current node:
state.add();
// now only expand immediate children:
model.enterContainer();
int i=0;
while(true)
{
model.setRowIndex(i++);
if (!model.isRowAvailable())
break;
state.add();
}
model.exitContainer();
}
else // safe to do expand all:
state.addAll();
}
/**
* Computes the number of nodes in a subtree.
* @param model the path must point to a node.
* @param maxSize the maximum number of nodes that will be searched.
* this method returns once this limit is reached.
* @return -1 if the number of nodes is unknown.
* If the limit is hit, then returns the number of nodes that are known
* to exist at the time the limit was hit. This number may be larger than
* maxSize.
*/
static int _getSizeOfTree(TreeModel model, int maxSize)
{
if (model.isRowAvailable() && model.isContainer())
{
model.enterContainer();
try
{
int size = model.getRowCount();
for(int i=0, sz=size; i<sz; i++)
{
if (size > maxSize)
return size;
model.setRowIndex(i);
int kidSize = _getSizeOfTree(model, maxSize - size);
if (kidSize < 0)
return -1;
size += kidSize;
}
return size;
}
finally
{
model.exitContainer();
}
}
return 0;
}
/**
* This method sets the phaseID of the event
* according to the "immediate" property of this
* component.
* If "immediate" is set to true, this calls
* {@link FacesContext#renderResponse}
*/
static void __handleQueueEvent(UIComponent comp, FacesEvent event)
{
if (_isImmediateEvent(comp, event))
{
String immediateAttr = UIXTree.IMMEDIATE_KEY.getName();
Object isImmediate = comp.getAttributes().get(immediateAttr);
if (Boolean.TRUE.equals(isImmediate))
{
event.setPhaseId(PhaseId.ANY_PHASE);
FacesContext context = FacesContext.getCurrentInstance();
context.renderResponse();
}
else
{
// the event should not execute before model updates are done.
// otherwise, the updates will be done to the wrong rows.
// we can't do this at the end of the UPDATE_MODEL phase because
// if there are errors during that phase, then we want to immediately render
// the response, and not deliver this ui event:
event.setPhaseId(PhaseId.INVOKE_APPLICATION);
}
}
}
/**
* Process all the facets of a component; these are
* generally not processed once per row.
* @param skipFacet the name of any facet that should not be processed
* at this time.
*/
@SuppressWarnings("unchecked")
public static void processFacets(
FacesContext context,
final UIXCollection table,
UIComponent component,
final PhaseId phaseId,
String skipFacet)
{
Map<String, UIComponent> facets = component.getFacets();
final UIComponent skip = (skipFacet != null)
? (UIComponent) facets.get(skipFacet)
: null;
new ChildLoop()
{
@Override
protected void process(FacesContext context, UIComponent facet, ComponentProcessingContext cpContext)
{
if (facet != skip)
table.processComponent(context, facet, phaseId);
}
}.runAlways(context, facets.values());
}
/**
* Process all the facets of any children that are columns; these are
* generally not processed once per row.
*/
public static void processColumnFacets(
FacesContext context,
final UIXCollection table,
UIComponent column,
final PhaseId phaseId)
{
new ChildLoop()
{
@Override
protected void process(FacesContext context, UIComponent child, ComponentProcessingContext cpContext)
{
if (child instanceof UIXColumn && child.isRendered())
{
// process any facets of the child column:
processFacets(context, table, child, phaseId, null);
// recursively process the facets of any grandchild columns:
processColumnFacets(context, table, child, phaseId);
}
}
}.runAlways(context, column);
}
/**
* Process all the children of the given table
*/
public static void processStampedChildren(
FacesContext context,
final UIXCollection table,
final PhaseId phaseId)
{
new ChildLoop()
{
@Override
protected void process(FacesContext context, UIComponent child, ComponentProcessingContext cpContext)
{
// make sure that any cached clientIds are cleared so that
// the clientIds are recalculated with the new row index
UIXComponent.clearCachedClientIds(child);
table.processComponent(context, child, phaseId);
}
}.runAlways(context, table);
}
/**
* Retrieves the sort strength for the column with the given sort property from the given table.
* @param parent the Collection object whose columns are searched for matching sortProperty and retrieving
* sort strength from.
* @param sortProperty sort property value to match against column's sortProperty property.
* @return sort strength for the column with the given sort property from the given table.
*/
public static SortStrength findSortStrength(UIXCollection parent, String sortProperty)
{
SortStrength sortStrength = null;
if (sortProperty == null || sortProperty.isEmpty())
return null;
List<UIComponent> children = parent.getChildren();
for (UIComponent child : children)
{
if (child instanceof UIXColumn)
{
UIXColumn targetColumn = (UIXColumn)child;
if (sortProperty.equals(targetColumn.getSortProperty()))
{
String strength = targetColumn.getSortStrength();
sortStrength = _toSortStrength(strength);
break;
}
}
}
return sortStrength;
}
/**
* Convert the string value of sort strength to the SortStrength type.
*/
private static SortStrength _toSortStrength(String strength)
{
SortStrength sortStrength = null;
if (strength != null && !strength.isEmpty())
{
try
{
sortStrength = SortStrength.valueOf(strength.toUpperCase());
}
catch (IllegalArgumentException iae)
{
_LOG.warning("INVALID_SORT_STRENGTH_PROPERTY", strength);
}
}
return sortStrength;
}
/**
* Process all the children of the given table
*/
@SuppressWarnings("unchecked")
static void __processChildren(
FacesContext context,
final UIXCollection comp,
final PhaseId phaseId)
{
// process the children
int childCount = comp.getChildCount();
if (childCount != 0)
{
List<UIComponent> children = comp.getChildren();
for (int i = 0; i < childCount; i++)
{
UIComponent child = children.get(i);
comp.processComponent(context, child, phaseId);
}
}
}
static void cacheHeaderFooterFacets(UIComponent parent, Map<UIComponent, Boolean> cache)
{
// grab the header facet and it's children
UIComponent headerFacet = parent.getFacets().get("header");
if (headerFacet != null)
{
_cacheDescendants(headerFacet, cache, true);
}
// grab the footer facet and it's children
UIComponent footerFacet = parent.getFacets().get("footer");
if (footerFacet != null)
{
_cacheDescendants(footerFacet, cache, true);
}
}
static void cacheColumnHeaderFooterFacets(UIComponent parent, Map<UIComponent, Boolean> cache)
{
List<UIComponent> children = parent.getChildren();
for (UIComponent child : children)
{
if (child instanceof UIXColumn)
{
cacheHeaderFooterFacets(child, cache);
cacheColumnHeaderFooterFacets(child, cache);
}
}
}
private static void _cacheDescendants(UIComponent parent, Map<UIComponent, Boolean> cache, boolean inclusive)
{
if(inclusive)
cache.put(parent, Boolean.TRUE);
List<UIComponent> children = parent.getChildren();
for (UIComponent child : children)
{
_cacheDescendants(child, cache, true);
}
}
/**
* Checks to see if the given event could possible be affected by the
* "immediate" property of the given component.
*/
private static boolean _isImmediateEvent(UIComponent comp, FacesEvent event)
{
if (event.getComponent() == comp)
{
return
(event instanceof RangeChangeEvent) ||
(event instanceof DisclosureEvent) ||
(event instanceof RowDisclosureEvent) ||
(event instanceof SelectionEvent) ||
(event instanceof SortEvent) ||
(event instanceof FocusEvent);
}
return false;
}
private TableUtils()
{
}
private static final TrinidadLogger _LOG = TrinidadLogger.createTrinidadLogger(TableUtils.class);
}