moparisthebest
/
JdbcMapper
mirror of https://github.com/moparisthebest/JdbcMapper
1
0
Fork 0
Code Issues Releases Wiki Activity
JdbcMapper/beehive-netui-tags/src/main/java/org/apache/beehive/netui/tags/html/CheckBoxGroup.java

647 lines
24 KiB
Java
Raw Blame History

/*
* 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.
*
* $Header:$
*/
package org.apache.beehive.netui.tags.html;
import org.apache.beehive.netui.util.internal.InternalStringBuilder;
import org.apache.beehive.netui.pageflow.ProcessPopulate;
import org.apache.beehive.netui.script.common.DataAccessProviderStack;
import org.apache.beehive.netui.tags.naming.FormDataNameInterceptor;
import org.apache.beehive.netui.tags.naming.IndexedNameInterceptor;
import org.apache.beehive.netui.tags.naming.PrefixNameInterceptor;
import org.apache.beehive.netui.tags.rendering.*;
import org.apache.beehive.netui.util.Bundle;
import org.apache.beehive.netui.util.iterator.IteratorFactory;
import org.apache.beehive.netui.util.logging.Logger;
import org.apache.beehive.netui.util.tags.GroupOption;
import javax.servlet.ServletRequest;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.jsp.JspException;
import java.util.*;
/**
* Groups a collection of CheckBoxOptions, and handles databinding of their values.
*
* CheckBoxGroup binds to an Iterator of Strings.
*
* If CheckBoxGroup uses any Format tags, it must have those tags come before any nested
* CheckBoxOption tags.
* @jsptagref.tagdescription Renders a collection of checkbox options as <input type="checkbox">
* and handles the data binding.
*
* <p><b>Submitting Data</b></p>
* <p>The &lt;netui:checkBoxGroup> submits data in the form of a String[] object.
* For example, if the &lt;netui:checkBoxGroup> submits data to a Form Bean field...
*
* <pre> &lt;netui:checkBoxGroup
* dataSource="actionForm.userSelections"
* optionsDataSource="${pageFlow.availableSelections}" /></pre>
*
* ...then the Form Bean field must be a String[] object...
*
* <pre> public static class SubmitForm extends FormData
* {
* private String[] userSelections;
*
* public void setUserSelections(String[] userSelections)
* {
* this.userSelections = userSelections;
* }
*
* public String[] getUserSelections()
* {
* return this.userSelections;
* }
* }</pre>
*
* <p><b>Dynamically Defined Checkboxes</b></p>
* You can dynamically define a set of checkboxes by pointing the <code>optionsDataSource</code> attribute
* at a String[] object. When the &lt;netui:checkBoxGroup> is rendered in the browser, a
* corresponding set of
* checkboxes will be genereated from the String[] object.
*
* <p>For example, if you define a String[] object and get method in the Controller file...
*
* <pre> public String[] availableSelections = {"option1", "option2", "option3"};
*
* public String[] getavailableSelections()
* {
* return this.availableSelections;
* }</pre>
*
* ...and reference this String[] from the <code>optionsDataSource</code> attribute...
*
* <pre> &lt;netui:checkBoxGroup
* dataSource="actionForm.userSelections"
* optionsDataSource="${pageFlow.availableSelections}" /></pre>
*
* ...then the appropriate checkboxes will be rendered in the browser.
*
* <pre> &lt;input type="checkbox" name="wlw-checkbox_group_key:{actionForm.userSelections}" value="option1">option1&lt;/input>
* &lt;input type="checkbox" name="wlw-checkbox_group_key:{actionForm.userSelections}" value="option2">option2&lt;/input>
* &lt;input type="checkbox" name="wlw-checkbox_group_key:{actionForm.userSelections}" value="option3">option3&lt;/input></pre>
*
* For checkboxes to be rendered, either the <code>optionsDataSource</code> attribute must be provided
* (and point to a String[] object) or the &lt;netui:checkBoxGroup> must have children
* &lt;netuiCheckBoxOption> tags.
*
* <p><b>Setting Default Options</b></p>
* <p>The <code>defaultValue</code> attribute can be used to determine which checkboxs are checked
* when they are first rendered in the browser. The <code>defaultValue</code> attribute
* should point to a String, if only one checkbox should appear checked, or to a String[] object,
* if multiple checkboxes should appear checked.
* @example In this first sample, the &lt;netui:checkBoxGroup>
* submits data to the Form Bean field <code>preferredColors</code>.
*
* <pre> &lt;netui:checkBoxGroup
* dataSource="actionForm.preferredColors"
* optionsDataSource="${pageFlow.colors}" /></pre>
*
* The <code>optionsDataSource</code> attribute points to a get method for a String[] on the Controller file:
*
* <pre> String[] colors = new String[] {"Red", "Blue", "Green", "Yellow", "White", "Black"};
*
* public String[] getColors()
* {
* return colors;
* }</pre>
*
* This automatically renders the appropriate set of checkbox options within the &lt;checkBoxGroup>:
*
* <pre> &lt;input type="checkbox" name="wlw-checkbox_group_key:{actionForm.preferredColors}" value="Red">Red&lt;/input>
* &lt;input type="checkbox" name="wlw-checkbox_group_key:{actionForm.preferredColors}" value="Blue">Blue&lt;/input>
* &lt;input type="checkbox" name="wlw-checkbox_group_key:{actionForm.preferredColors}" value="Green">Green&lt;/input>
* &lt;input type="checkbox" name="wlw-checkbox_group_key:{actionForm.preferredColors}" value="Yellow">Yellow&lt;/input>
* &lt;input type="checkbox" name="wlw-checkbox_group_key:{actionForm.preferredColors}" value="White">White&lt;/input>
* &lt;input type="checkbox" name="wlw-checkbox_group_key:{actionForm.preferredColors}" value="Black">Black&lt;/input></pre>
*
* The <code>defaultValue</code> attribute may point to a String or a String[].
*
* <pre> &lt;netui:checkBoxGroup
* dataSource="actionForm.preferredColors"
* optionsDataSource="${pageFlow.colors}"
* defaultValue="${pageFlow.defaultColor}" /></pre>
*
* And in the Controller:
* <pre> String defaultColor = new String ("Blue");
* ...</pre>
* or
* <pre> String[] defaultColor = new String[] {"Red", "Blue"};
* ...</pre>
*
* In either case, the appropriate
* checkbox options will appear checked in the browser.
*
* <pre> &lt;input type="checkbox" name="wlw-checkbox_group_key:{actionForm.preferredColors}" value="Red" checked="true">Red&lt;/input>
* &lt;input type="checkbox" name="wlw-checkbox_group_key:{actionForm.preferredColors}" value="Blue" checked="true">Blue&lt;/input>
* &lt;input type="checkbox" name="wlw-checkbox_group_key:{actionForm.preferredColors}" value="Green">Green&lt;/input>
* &lt;input type="checkbox" name="wlw-checkbox_group_key:{actionForm.preferredColors}" value="Yellow">Yellow&lt;/input>
* &lt;input type="checkbox" name="wlw-checkbox_group_key:{actionForm.preferredColors}" value="White">White&lt;/input>
* &lt;input type="checkbox" name="wlw-checkbox_group_key:{actionForm.preferredColors}" value="Black">Black&lt;/input></pre>
* @netui:tag name="checkBoxGroup" description="Groups a collection of CheckBoxOptions, and handles databinding of their values."
*/
public class CheckBoxGroup
extends HtmlGroupBaseTag
{
// @todo: seems like we should write out the hidden field even if the option is disabled.
private static final Logger logger = Logger.getInstance(CheckBoxGroup.class);
/**
* This is the name of the prefixHandler for the checkbox grup.
*/
public static final String CHECKBOXGROUP_KEY = "checkbox_group_key";
private static final String OLDVALUE_SUFFIX = "OldValue";
private InputHiddenTag.State _state = new InputHiddenTag.State();
private InputHiddenTag.State _hiddenState = new InputHiddenTag.State();
private List _defaultSelections;
private boolean _defaultSingleton = false;
private boolean _defaultSingleValue = false;
private String[] _match; // The actual values we will match against, calculated in doStartTag().
private Object _dynamicAttrs; // the Object
private InternalStringBuilder _saveBody;
private static final List _internalNamingChain;
private WriteRenderAppender _writer;
static
{
List l = new ArrayList(3);
l.add(new FormDataNameInterceptor());
l.add(new IndexedNameInterceptor());
l.add(new PrefixNameInterceptor(CHECKBOXGROUP_KEY));
_internalNamingChain = Collections.unmodifiableList(l);
}
static
{
org.apache.beehive.netui.pageflow.ProcessPopulate.registerPrefixHandler(CHECKBOXGROUP_KEY, new CheckboxGroupPrefixHandler());
}
/**
* The handler for naming and indexing the CheckBoxGroup.
*/
public static class CheckboxGroupPrefixHandler
implements org.apache.beehive.netui.pageflow.RequestParameterHandler
{
/**
* Determines the current state of the CheckBoxGroup based on the Request.
*/
public void process(HttpServletRequest request, String key, String expr,
ProcessPopulate.ExpressionUpdateNode node)
{
String[] returnArray = null;
if (!key.endsWith(OLDVALUE_SUFFIX)) {
//This select has values and should stay that way
returnArray = request.getParameterValues(key);
}
else {
//Check the request to see if select also exists
String newKey = key.substring(0, key.indexOf(OLDVALUE_SUFFIX));
String[] select = request.getParameterValues(newKey);
if (select != null) {
returnArray = select;
}
else {
returnArray = new String[0]; //null;
}
}
if (node.expression.endsWith(OLDVALUE_SUFFIX)) {
node.expression = node.expression.substring(0, node.expression.indexOf(OLDVALUE_SUFFIX));
}
node.values = returnArray;
if (logger.isDebugEnabled()) {
logger.debug("\n*********************************************\n" +
"process with key \"" + key + "\" and expression \"" + node.expression + "\"" + "and result size: "
+ (returnArray != null ? "" + returnArray.length : null) + "\n" +
"*********************************************\n");
}
}
}
public CheckBoxGroup()
{
super();
}
/**
* Return the name of the Tag.
*/
public String getTagName()
{
return "CheckBoxGroup";
}
/**
* Return an <code>ArrayList</code> which represents a chain of <code>INameInterceptor</code>
* objects. This method by default returns <code>null</code> and should be overridden
* by objects that support naming.
* @return an <code>ArrayList</code> that will contain <code>INameInterceptor</code> objects.
*/
protected List getNamingChain()
{
return _internalNamingChain;
}
/**
* Overrided method to return a list of the possible default values. The method always return either
* a <code>List</code> or null.
* @return a <code>List</code> that represents the default value.
*/
private Object evaluateDefaultValue()
{
Object val = _defaultValue;
List defaults = null;
if (val instanceof String) {
if ("checked".equals(val)) {
_defaultSingleton = true;
_defaultSingleValue = true;
return null;
}
else if ("unchecked".equals(val)) {
_defaultSingleton = true;
_defaultSingleValue = false;
return null;
}
defaults = new ArrayList();
defaults.add(val);
return defaults;
}
Iterator optionsIterator = null;
optionsIterator = IteratorFactory.createIterator(val);
// log an error, default value is optional so only warn
if (optionsIterator == null && _defaultValue != null) {
logger.warn(Bundle.getString("Tags_IteratorError",
new Object[]{getTagName(), "defaultValue", _defaultValue}));
}
if (optionsIterator == null)
optionsIterator = IteratorFactory.EMPTY_ITERATOR;
defaults = new ArrayList();
while (optionsIterator.hasNext()) {
defaults.add(optionsIterator.next());
}
return defaults;
}
/**
* Checks whether the given value matches one of the CheckBoxGroup's selected
* CheckBoxOptions.
* @param value Value to be compared
*/
public boolean isMatched(String value, Boolean defaultValue)
{
if (value == null)
return false;
if (_match != null) {
for (int i = 0; i < _match.length; i++) {
if (value.equals(_match[i]))
return true;
}
}
else {
// a provided default value will override the group
if (defaultValue != null)
return defaultValue.booleanValue();
// if we have a singleton definition then use that
if (_defaultSingleton)
return _defaultSingleValue;
// check to see if we have a default arraylist with the value in it
if (_defaultSelections != null)
return _defaultSelections.contains(value);
}
return false;
}
/**
* Determine the set of matches for the CheckBoxGroup
* @throws JspException if a JSP exception has occurred
*/
public int doStartTag() throws JspException
{
ServletRequest req = pageContext.getRequest();
if (_cr == null)
_cr = TagRenderingBase.Factory.getConstantRendering(req);
// get the evaluated dataSource and default values
Object val = evaluateDataSource();
_defaultSelections = (List) evaluateDefaultValue();
if (hasErrors()) {
return SKIP_BODY;
}
// process the default values and create the matching array...
if (val != null) {
buildMatch(val);
if (hasErrors()) {
return SKIP_BODY;
}
}
// if the checkbox group is disabled do not write out the
// hidden field.
_writer = new WriteRenderAppender(pageContext);
if (!_repeater && !_disabled) {
//Create hidden field for state tracking
_state.clear();
String hiddenParamName = null;
hiddenParamName = getQualifiedDataSourceName() + OLDVALUE_SUFFIX;
_state.name = hiddenParamName;
_state.value = "true";
TagRenderingBase hiddenTag = TagRenderingBase.Factory.getRendering(TagRenderingBase.INPUT_HIDDEN_TAG, req);
hiddenTag.doStartTag(_writer, _state);
hiddenTag.doEndTag(_writer);
}
if (isVertical())
_cr.TABLE(_writer);
// if this is a repeater then we shouid prime the pump...
_dynamicAttrs = evaluateOptionsDataSource();
assert (_dynamicAttrs != null);
assert (_dynamicAttrs instanceof Map ||
_dynamicAttrs instanceof Iterator);
if (_repeater) {
if (_dynamicAttrs instanceof Map) {
_dynamicAttrs = ((Map) _dynamicAttrs).entrySet().iterator();
}
if (!(_dynamicAttrs instanceof Iterator)) {
String s = Bundle.getString("Tags_OptionsDSIteratorError");
registerTagError(s, null);
return SKIP_BODY;
}
while (((Iterator) _dynamicAttrs).hasNext()) {
_repCurItem = ((Iterator) _dynamicAttrs).next();
if (_repCurItem != null)
break;
}
if (isVertical())
_cr.TR_TD(_writer);
DataAccessProviderStack.addDataAccessProvider(this, pageContext);
}
_saveBody = new InternalStringBuilder(128);
// Continue processing this page
return EVAL_BODY_BUFFERED;
}
/**
* Save any body content of this tag, which will generally be the
* option(s) representing the values displayed to the user.
* @throws JspException if a JSP exception has occurred
*/
public int doAfterBody() throws JspException
{
StringBuilderRenderAppender writer = new StringBuilderRenderAppender(_saveBody);
if (bodyContent != null) {
String value = bodyContent.getString();
bodyContent.clearBody();
if (value == null)
value = "";
_saveBody.append(value);
}
if (_repeater) {
ServletRequest req = pageContext.getRequest();
if (_cr == null)
_cr = TagRenderingBase.Factory.getConstantRendering(req);
if (isVertical())
_cr.end_TD_TR(writer);
while (((Iterator) _dynamicAttrs).hasNext()) {
_repCurItem = ((Iterator) _dynamicAttrs).next();
if (_repCurItem != null) {
_repIdx++;
if (isVertical())
_cr.TR_TD(writer);
return EVAL_BODY_AGAIN;
}
}
}
return SKIP_BODY;
}
/**
* Render the set of CheckBoxOptions.
* @throws JspException if a JSP exception has occurred
*/
public int doEndTag()
throws JspException
{
if (hasErrors())
return reportAndExit(EVAL_PAGE);
ServletRequest req = pageContext.getRequest();
if (_cr == null)
_cr = TagRenderingBase.Factory.getConstantRendering(req);
String idScript = null;
String altText = null;
char accessKey = 0x00;
// Render a tag representing the end of our current form
if (_saveBody != null)
write(_saveBody.toString());
// if this is a repeater then we have created the content in the body so we write that
if (_repeater) {
// Render a tag representing the end of our current form
if (isVertical())
_cr.end_TABLE(_writer);
if (idScript != null)
write(idScript);
localRelease();
return EVAL_PAGE;
}
// non repeater working against the options data source
assert(_dynamicAttrs != null);
if (_dynamicAttrs instanceof Map) {
Map dynamicCheckboxesMap = (Map) _dynamicAttrs;
Iterator keyIterator = dynamicCheckboxesMap.keySet().iterator();
int idx = 0;
while (keyIterator.hasNext()) {
Object optionValue = keyIterator.next();
String optionDisplay = "";
if (dynamicCheckboxesMap.get(optionValue) != null)
optionDisplay = dynamicCheckboxesMap.get(optionValue).toString();
if (optionValue != null) {
addOption(_writer, INPUT_CHECKBOX, optionValue.toString(), optionDisplay, idx++, altText, accessKey, _disabled);
}
if (hasErrors()) {
reportErrors();
if (isVertical()) {
_cr.end_TABLE(_writer);
}
localRelease();
return EVAL_PAGE;
}
write("\n");
}
}
else {
assert(_dynamicAttrs instanceof Iterator);
Iterator it = (Iterator) _dynamicAttrs;
int idx = 0;
while (it.hasNext()) {
Object o = it.next();
if (o == null)
continue;
if (o instanceof GroupOption) {
GroupOption go = (GroupOption) o;
addOption(_writer, INPUT_CHECKBOX, go.getValue(), go.getName(), idx++, go.getAlt(), go.getAccessKey(), _disabled);
}
else {
String checkboxValue = o.toString();
addOption(_writer, INPUT_CHECKBOX, checkboxValue, checkboxValue, idx++, altText, accessKey, _disabled);
}
if (hasErrors()) {
reportErrors();
if (isVertical()) {
_cr.end_TABLE(_writer);
}
localRelease();
return EVAL_PAGE;
}
write("\n");
}
}
if (isVertical())
_cr.end_TABLE(_writer);
if (idScript != null)
write(idScript);
localRelease();
return EVAL_PAGE;
}
public void createHiddenField(AbstractRenderAppender results)
throws JspException
{
if (_repIdx == 0 && !_disabled) {
ServletRequest req = pageContext.getRequest();
//Create hidden field for state tracking
String hiddenParamName = null;
hiddenParamName = getQualifiedDataSourceName() + OLDVALUE_SUFFIX;
_hiddenState.name = hiddenParamName;
_hiddenState.value = "true";
TagRenderingBase hiddenTag = TagRenderingBase.Factory.getRendering(TagRenderingBase.INPUT_HIDDEN_TAG, req);
hiddenTag.doStartTag(results, _hiddenState);
hiddenTag.doEndTag(results);
}
}
/**
* Release any acquired resources.
*/
protected void localRelease()
{
// cleanup the context variables used for binding during repeater
if (_repeater)
DataAccessProviderStack.removeDataAccessProvider(pageContext);
super.localRelease();
_defaultSelections = null;
_match = null;
_dynamicAttrs = null;
_saveBody = null;
_defaultSingleton = false;
_defaultSingleValue = false;
_writer = null;
_state.clear();
_hiddenState.clear();
}
// This method will build the match list, should this be a hashmap?
private void buildMatch(Object val)
{
if (val instanceof String[]) {
_match = (String[]) val;
}
else {
Iterator matchIterator = null;
// this should return null, but we should handle it it does
matchIterator = IteratorFactory.createIterator(val);
if (matchIterator == null)
matchIterator = IteratorFactory.EMPTY_ITERATOR;
List matchList = new ArrayList();
while (matchIterator.hasNext()) {
Object o = matchIterator.next();
if (o != null)
matchList.add(o.toString());
}
int size = matchList.size();
_match = new String[size];
for (int i = 0; i < size; i++) {
_match[i] = matchList.get(i).toString();
}
}
if (logger.isDebugEnabled()) {
logger.debug("****** CheckboxGroup Matches ******");
if (_match != null) {
for (int i = 0; i < _match.length; i++) {
logger.debug(i + ": " + _match[i]);
}
}
}
}
}
Reference in New Issue View Git Blame Copy Permalink