Java FacesEvent类代码示例

import javax.faces.event.FacesEvent; //导入依赖的package包/类
/**
 * 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);
    }
  }
}
 

import javax.faces.event.FacesEvent; //导入依赖的package包/类
/**
 * Broadcast an event to a MethodExpression.
 * This can be used to support MethodBindings such as the "actionListener"
 * binding on ActionSource components:
 * <tr:commandButton actionListener="#{mybean.myActionListener}">
 */
protected final void broadcastToMethodExpression(
  FacesEvent event,
  MethodExpression method) throws AbortProcessingException
{
  if (method != null)
  {
    try
    {
      FacesContext context = getFacesContext();
      method.invoke(context.getELContext(), new Object[] { event });
    }
    catch (ELException ee)
    {
      Throwable t = ee.getCause();
      // Unwrap AbortProcessingExceptions
      if (t instanceof AbortProcessingException)
        throw ((AbortProcessingException) t);
      throw ee;
    }
  }
}
 

import javax.faces.event.FacesEvent; //导入依赖的package包/类
/**
 * Queues an event. If there is a currency set on this table, then
 * the event will be wrapped so that when it is finally delivered, the correct
 * currency will be restored.
 * @param event a FacesEvent
 */
@Override
public void queueEvent(FacesEvent event)
{
  if (event.getSource() == this)
  {
    // Remember non-SelectionEvents on ourselves.  This
    // is a hack to support validation in tableSelectXyz.
    if (!(event instanceof SelectionEvent))
    {
      InternalState iState = _getInternalState(true);
      iState._hasEvent = true;
    }
  }

  // we want to wrap up
  // the event so we can execute it in the correct context (with the correct
  // rowKey/rowData):
  Object currencyKey = getRowKey();
  event = new TableRowEvent(this, event, currencyKey);

  // Queue a CollectionContextEvent in order to allow this class to setup the component change
  // before sub-classes attempt to process the table row event instance.
  super.queueEvent(new CollectionContextEvent(this, event));
}
 

import javax.faces.event.FacesEvent; //导入依赖的package包/类
static void __handleBroadcast(
  UIXHierarchy  comp,
  FacesEvent    event,
  RowKeySet     state,
  MethodExpression method) throws AbortProcessingException
{
  // Notify the specified disclosure listener method (if any)
  if (event instanceof RowDisclosureEvent)
  {
    RowDisclosureEvent dEvent = (RowDisclosureEvent) event;
    state.removeAll(dEvent.getRemovedSet());
    state.addAll(dEvent.getAddedSet());
    //pu: Implicitly record a Change for 'disclosedRowKeys' attribute
    comp.addAttributeChange("disclosedRowKeys", state);
    comp.broadcastToMethodExpression(event, method);
  }
}
 

import javax.faces.event.FacesEvent; //导入依赖的package包/类
public UndisclosureCallbackState(
  FacesEvent facesEvent,
  String     clientIdBeingDisclosed)
{
  this.facesEvent = facesEvent;
  this.clientIdBeingDisclosed = clientIdBeingDisclosed;
}
 

import javax.faces.event.FacesEvent; //导入依赖的package包/类
@Override
public void broadcast(FacesEvent event) throws AbortProcessingException
{
  super.broadcast(event);

  // Notify the specified action listener method (if any),
  // and the default action listener
  if (event instanceof ActionEvent)
  {
    FacesContext context = getFacesContext();
    MethodBinding mb = getActionListener();
    if (mb != null)
      mb.invoke(context, new Object[] { event });

    ActionListener defaultActionListener =
      context.getApplication().getActionListener();
    if (defaultActionListener != null)
    {
      defaultActionListener.processAction((ActionEvent) event);
    }
  }
}
 

import javax.faces.event.FacesEvent; //导入依赖的package包/类
@Override
public void broadcast(FacesEvent event)
  throws AbortProcessingException
{
  if (event instanceof WrapperEvent)
  {
    final WrapperEvent wrapper = (WrapperEvent) event;
    final FacesContext context = FacesContext.getCurrentInstance();
    Runnable runner = new Runnable()
    {
      public void run()
      {
        wrapper.broadcastWrappedEvent(context);
      }
    };
    _processPhase(context, runner);
  }
  else
  {
    super.broadcast(event);
  }
}
 

import javax.faces.event.FacesEvent; //导入依赖的package包/类
/**
 * Delivers an event.
 * @param event
 * @throws javax.faces.event.AbortProcessingException
 */
@Override
public void broadcast(FacesEvent event) throws AbortProcessingException
{
  if (event instanceof SelectionEvent)
  {
    //pu: Implicitly record a Change for 'selectionState' attribute
    //=-=pu: This ain't getting restored. Check with Arj or file a bug.
    addAttributeChange("selectedRowKeys",
                       getSelectedRowKeys());
    broadcastToMethodExpression(event, getSelectionListener());
  }

  HierarchyUtils.__handleBroadcast(this,
                                    event,
                                    getDisclosedRowKeys(),
                                    getRowDisclosureListener());
  super.broadcast(event);
}
 

import javax.faces.event.FacesEvent; //导入依赖的package包/类
@Override
public void queueEvent(FacesEvent e)
{
  if ((e instanceof PollEvent) && (e.getSource() == this))
  {
    if (isImmediate())
    {
      e.setPhaseId(PhaseId.ANY_PHASE);
    }
    else
    {
      e.setPhaseId(PhaseId.INVOKE_APPLICATION);
    }
  }

  super.queueEvent(e);
}
 

import javax.faces.event.FacesEvent; //导入依赖的package包/类
@Override
public void broadcast(FacesEvent event) throws AbortProcessingException
{
  // Notify the specified RangeChanged listener method (if any)
  if (event instanceof RangeChangeEvent)
  {
    RangeChangeEvent gtEvent = (RangeChangeEvent)event;
    // update first when the event is delivered
    setFirst(gtEvent.getNewStart());

    broadcastToMethodExpression(event, getRangeChangeListener());
  }

  // Perform standard superclass processing
  super.broadcast(event);
}
 

import javax.faces.event.FacesEvent; //导入依赖的package包/类
/**
 * * We don't want to update model if we have validation errors
 * on the page, so if not immediate, queue the event in
 * INVOKE_APPLICATION phase.
 */
@Override
public void queueEvent(FacesEvent e)
{
  if ((e instanceof RangeChangeEvent) && (e.getSource() == this))
  {
    if (isImmediate())
    {
      e.setPhaseId(PhaseId.ANY_PHASE);
    }
    else
    {
      e.setPhaseId(PhaseId.INVOKE_APPLICATION);
    }
  }

  super.queueEvent(e);
}
 

import javax.faces.event.FacesEvent; //导入依赖的package包/类
/**
 * {@inheritDoc}
 *
 * Overridden to handle broadcast of the selection and the row disclosure events
 */

@Override
public void broadcast(FacesEvent event)
  throws AbortProcessingException
{
  if (event instanceof SelectionEvent)
  {
    //vg: Implicitly record a Change for 'selectionState' attribute
    addAttributeChange("selectedRowKeys", getSelectedRowKeys());
    broadcastToMethodExpression(event, getSelectionListener());
  }
  else if (event instanceof RowDisclosureEvent)
  {
    RowDisclosureEvent dEvent = (RowDisclosureEvent) event;
    RowKeySet          state = getGroupDisclosedRowKeys();

    state.removeAll(dEvent.getRemovedSet());
    state.addAll(dEvent.getAddedSet());
    //vg: Implicitly record a Change for 'groupDisclosedRowKeys' attribute
    addAttributeChange("groupDisclosedRowKeys", state);
    broadcastToMethodExpression(event, getGroupDisclosureListener());
  }
  super.broadcast(event);
}
 

import javax.faces.event.FacesEvent; //导入依赖的package包/类
@Override
public void queueEvent(FacesEvent e)
{
  if ((e instanceof DisclosureEvent) && (e.getSource() == this))
  {
    if (isImmediate())
    {
      e.setPhaseId(PhaseId.ANY_PHASE);
    }
    else
    {
      e.setPhaseId(PhaseId.INVOKE_APPLICATION);
    }
  }

  super.queueEvent(e);
}
 

import javax.faces.event.FacesEvent; //导入依赖的package包/类
/**
 * <p>Intercept <code>queueEvent</code> and mark the phaseId for the
 * event to be <code>PhaseId.APPLY_REQUEST_VALUES</code> if the
 * <code>immediate</code> flag is true,
 * <code>PhaseId.INVOKE_APPLICATION</code> otherwise.</p>
 */
@Override
public void queueEvent(FacesEvent e)
{
  if (this == e.getComponent() && ((e instanceof ActionEvent) || (e instanceof ReturnEvent)))
  {
    if (isImmediate())
    {
      e.setPhaseId(PhaseId.ANY_PHASE);
    }
    else
    {
      e.setPhaseId(PhaseId.INVOKE_APPLICATION);
    }
  }

  super.queueEvent(e);
}
 

import javax.faces.event.FacesEvent; //导入依赖的package包/类
@Override
public void broadcast(FacesEvent event) throws AbortProcessingException
{
  // Notify the specified disclosure listener method (if any)
  if (event instanceof FocusEvent)
  {
    setFocusRowKey(getRowKey());
    //pu: Implicitly record a Change for 'focusPath' attribute
    addAttributeChange("focusPath",
                       getFocusRowKey());
    // it is nice to expand the focused item:
    getDisclosedRowKeys().add();

    broadcastToMethodExpression(event, getFocusListener());
  }
  else if (event instanceof RangeChangeEvent)
  {
    RangeChangeEvent rce = (RangeChangeEvent) event;
    setFirst(rce.getNewStart());
    broadcastToMethodExpression(event, getRangeChangeListener());
  }

  // Perform standard superclass processing
  super.broadcast(event);
}