javax.faces.component.UICommand Maven / Gradle / Ivy
/*
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
*
* Copyright (c) 1997-2017 Oracle and/or its affiliates. All rights reserved.
*
* The contents of this file are subject to the terms of either the GNU
* General Public License Version 2 only ("GPL") or the Common Development
* and Distribution License("CDDL") (collectively, the "License"). You
* may not use this file except in compliance with the License. You can
* obtain a copy of the License at
* https://glassfish.dev.java.net/public/CDDL+GPL_1_1.html
* or packager/legal/LICENSE.txt. See the License for the specific
* language governing permissions and limitations under the License.
*
* When distributing the software, include this License Header Notice in each
* file and include the License file at packager/legal/LICENSE.txt.
*
* GPL Classpath Exception:
* Oracle designates this particular file as subject to the "Classpath"
* exception as provided by Oracle in the GPL Version 2 section of the License
* file that accompanied this code.
*
* Modifications:
* If applicable, add the following below the License Header, with the fields
* enclosed by brackets [] replaced by your own identifying information:
* "Portions Copyright [year] [name of copyright owner]"
*
* Contributor(s):
* If you wish your version of this file to be governed by only the CDDL or
* only the GPL Version 2, indicate your decision by adding "[Contributor]
* elects to include this software in this distribution under the [CDDL or GPL
* Version 2] license." If you don't indicate a single choice of license, a
* recipient has the option to distribute your version of this file under
* either the CDDL, the GPL Version 2 or to extend the choice of license to
* its licensees as provided above. However, if you add GPL Version 2 code
* and therefore, elected the GPL Version 2 license, then the option applies
* only if the new code is made subject to such option by the copyright
* holder.
*/
package javax.faces.component;
import static javax.faces.event.PhaseId.APPLY_REQUEST_VALUES;
import static javax.faces.event.PhaseId.INVOKE_APPLICATION;
import javax.el.MethodExpression;
import javax.faces.application.Application;
import javax.faces.context.FacesContext;
import javax.faces.el.MethodBinding;
import javax.faces.event.AbortProcessingException;
import javax.faces.event.ActionEvent;
import javax.faces.event.ActionListener;
import javax.faces.event.FacesEvent;
import javax.faces.render.Renderer;
import com.sun.faces.application.MethodBindingMethodExpressionAdapter;
import com.sun.faces.application.MethodExpressionMethodBindingAdapter;
/**
*
* UICommand is a {@link UIComponent} that represents a user interface component
* which, when activated by the user, triggers an application specific "command" or "action". Such a
* component is typically rendered as a push button, a menu item, or a hyperlink.
*
*
*
* When the decode() method of this {@link UICommand}, or its corresponding
* {@link Renderer}, detects that this control has been activated, it will queue an
* {@link ActionEvent}. Later on, the broadcast() method will ensure that this event is
* broadcast to all interested listeners.
*
*
*
* Listeners will be invoked in the following order:
*
* - {@link ActionListener}s, in the order in which they were registered.
*
- The "actionListener" {@link MethodExpression} (which will cover the "actionListener" that was
* set as a
MethodBinding).
* - The default {@link ActionListener}, retrieved from the {@link Application} - and therefore,
* any attached "action" {@link MethodExpression}.
*
*
*
* By default, the rendererType property must be set to
* "javax.faces.Button". This value can be changed by calling the
* setRendererType() method.
*
*/
public class UICommand extends UIComponentBase implements ActionSource2 {
// ------------------------------------------------------ Manifest Constants
/**
*
* The standard component type for this component.
*
*/
public static final String COMPONENT_TYPE = "javax.faces.Command";
/**
*
* The standard component family for this component.
*
*/
public static final String COMPONENT_FAMILY = "javax.faces.Command";
/**
* Properties that are tracked by state saving.
*/
enum PropertyKeys {
value, immediate, methodBindingActionListener, actionExpression,
}
// ------------------------------------------------------------ Constructors
/**
*
* Create a new {@link UICommand} instance with default property values.
*
*/
public UICommand() {
super();
setRendererType("javax.faces.Button");
}
// -------------------------------------------------------------- Properties
@Override
public String getFamily() {
return COMPONENT_FAMILY;
}
// ------------------------------------------------- ActionSource/ActionSource2 Properties
/**
*
* The immediate flag.
*
*/
@Override
public boolean isImmediate() {
return (Boolean) getStateHelper().eval(PropertyKeys.immediate, false);
}
@Override
public void setImmediate(boolean immediate) {
getStateHelper().put(PropertyKeys.immediate, immediate);
}
/**
*
* Returns the value property of the UICommand. This is most often
* rendered as a label.
*
*
* @return The object representing the value of this component.
*/
public Object getValue() {
return getStateHelper().eval(PropertyKeys.value);
}
/**
*
* Sets the value property of the UICommand. This is most often
* rendered as a label.
*
*
* @param value the new value
*/
public void setValue(Object value) {
getStateHelper().put(PropertyKeys.value, value);
}
// ---------------------------------------------------- ActionSource / ActionSource2 Methods
@Override
public MethodExpression getActionExpression() {
return (MethodExpression) getStateHelper().get(PropertyKeys.actionExpression);
}
@Override
public void setActionExpression(MethodExpression actionExpression) {
getStateHelper().put(PropertyKeys.actionExpression, actionExpression);
}
/**
* @throws NullPointerException {@inheritDoc}
*/
@Override
public void addActionListener(ActionListener listener) {
addFacesListener(listener);
}
@Override
public ActionListener[] getActionListeners() {
return (ActionListener[]) getFacesListeners(ActionListener.class);
}
/**
* @throws NullPointerException {@inheritDoc}
*/
@Override
public void removeActionListener(ActionListener listener) {
removeFacesListener(listener);
}
// ----------------------------------------------------- UIComponent Methods
/**
*
* In addition to to the default {@link UIComponent#broadcast} processing, pass the
* {@link ActionEvent} being broadcast to the method referenced by actionListener
* (if any), and to the default {@link ActionListener} registered on the
* {@link javax.faces.application.Application}.
*
*
* @param event {@link FacesEvent} to be broadcast
*
* @throws AbortProcessingException Signal the JavaServer Faces implementation that no further
* processing on the current event should be performed
* @throws IllegalArgumentException if the implementation class of this {@link FacesEvent} is
* not supported by this component
* @throws NullPointerException if event is null
*/
@Override
public void broadcast(FacesEvent event) throws AbortProcessingException {
// Perform standard superclass processing (including calling our
// ActionListeners)
super.broadcast(event);
if (event instanceof ActionEvent) {
FacesContext context = event.getFacesContext();
// Notify the specified action listener method (if any)
notifySpecifiedActionListener(context, event);
// Invoke the default ActionListener
ActionListener listener = context.getApplication().getActionListener();
if (listener != null) {
listener.processAction((ActionEvent) event);
}
}
}
/**
*
*
* Intercept queueEvent and take the following action. If the event is an
* {@link ActionEvent}, obtain the UIComponent instance from the
* event. If the component is an {@link ActionSource} obtain the value of its
* "immediate" property. If it is true, mark the phaseId for the event to be
* PhaseId.APPLY_REQUEST_VALUES otherwise, mark the phaseId to be
* PhaseId.INVOKE_APPLICATION. The event must be passed on to
* super.queueEvent() before returning from this method.
*
*
*/
@Override
public void queueEvent(FacesEvent event) {
UIComponent component = event.getComponent();
if (event instanceof ActionEvent && component instanceof ActionSource) {
if (((ActionSource) component).isImmediate()) {
event.setPhaseId(APPLY_REQUEST_VALUES);
} else {
event.setPhaseId(INVOKE_APPLICATION);
}
}
super.queueEvent(event);
}
// ---------------------------------------------------------- Deprecated code
/**
* {@inheritDoc}
*
* @deprecated This has been replaced by {@link #getActionExpression}.
*/
@Override
public MethodBinding getAction() {
MethodBinding result = null;
MethodExpression me;
if (null != (me = getActionExpression())) {
// if the MethodExpression is an instance of our private
// wrapper class.
if (me.getClass().equals(MethodExpressionMethodBindingAdapter.class)) {
result = ((MethodExpressionMethodBindingAdapter) me).getWrapped();
} else {
// otherwise, this is a real MethodExpression. Wrap it
// in a MethodBinding.
result = new MethodBindingMethodExpressionAdapter(me);
}
}
return result;
}
/**
* {@inheritDoc}
*
* @deprecated This has been replaced by
* {@link #setActionExpression(javax.el.MethodExpression)}.
*/
@Override
public void setAction(MethodBinding action) {
MethodExpressionMethodBindingAdapter adapter;
if (null != action) {
adapter = new MethodExpressionMethodBindingAdapter(action);
setActionExpression(adapter);
} else {
setActionExpression(null);
}
}
/**
* {@inheritDoc}
*
* @deprecated Use {@link #getActionListeners} instead.
*/
@Override
public MethodBinding getActionListener() {
return (MethodBinding) getStateHelper().get(PropertyKeys.methodBindingActionListener);
}
/**
* {@inheritDoc}
*
* @deprecated This has been replaced by
* {@link #addActionListener(javax.faces.event.ActionListener)}.
*/
@Override
public void setActionListener(MethodBinding actionListener) {
getStateHelper().put(PropertyKeys.methodBindingActionListener, actionListener);
}
private void notifySpecifiedActionListener(FacesContext context, FacesEvent event) {
MethodBinding mb = getActionListener();
if (mb != null) {
mb.invoke(context, new Object[] { event });
}
}
}