/*
* 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.tobago.component;
import org.apache.myfaces.tobago.ajax.AjaxUtils;
import org.apache.myfaces.tobago.compat.InvokeOnComponent;
import org.apache.myfaces.tobago.context.ClientProperties;
import org.apache.myfaces.tobago.internal.ajax.AjaxInternalUtils;
import org.apache.myfaces.tobago.internal.ajax.AjaxResponseRenderer;
import org.apache.myfaces.tobago.internal.component.AbstractUIPage;
import org.apache.myfaces.tobago.internal.util.FacesContextUtils;
import org.apache.myfaces.tobago.util.ApplyRequestValuesCallback;
import org.apache.myfaces.tobago.util.ComponentUtils;
import org.apache.myfaces.tobago.util.FacesVersion;
import org.apache.myfaces.tobago.util.ProcessValidationsCallback;
import org.apache.myfaces.tobago.util.TobagoCallback;
import org.apache.myfaces.tobago.util.UpdateModelValuesCallback;
import org.apache.myfaces.tobago.util.VariableResolverUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import javax.faces.FacesException;
import javax.faces.component.ContextCallback;
import javax.faces.component.UIComponent;
import javax.faces.context.FacesContext;
import javax.faces.event.AbortProcessingException;
import javax.faces.event.FacesEvent;
import javax.faces.event.PhaseId;
import java.io.IOException;
import java.util.ArrayList;
import java.util.ConcurrentModificationException;
import java.util.List;
import java.util.ListIterator;
import java.util.Locale;
import java.util.Map;
public class UIViewRoot extends javax.faces.component.UIViewRoot implements InvokeOnComponent {
private static final Logger LOG = LoggerFactory.getLogger(UIViewRoot.class);
private static final TobagoCallback APPLY_REQUEST_VALUES_CALLBACK = new ApplyRequestValuesCallback();
private static final ContextCallback PROCESS_VALIDATION_CALLBACK = new ProcessValidationsCallback();
private static final ContextCallback UPDATE_MODEL_VALUES_CALLBACK = new UpdateModelValuesCallback();
private List<FacesEvent> events;
// XXX check if TOBAGO-811 is still an issue
// private int nextUniqueId;
@Override
public void setLocale(Locale locale) {
super.setLocale(locale);
ClientProperties clientProperties = VariableResolverUtils.resolveClientProperties(getFacesContext());
clientProperties.setLocale(locale);
clientProperties.updateUserAgent(getFacesContext());
}
/*
// XXX check if TOBAGO-811 is still an issue
@Override
public Object saveState(FacesContext facesContext) {
if (FacesVersion.supports12()) {
return super.saveState(facesContext);
} else {
Object[] state = new Object[2];
state[0] = super.saveState(facesContext);
state[1] = nextUniqueId;
return state;
}
}
@Override
public void restoreState(FacesContext facesContext, Object o) {
if (FacesVersion.supports12()) {
super.restoreState(facesContext, o);
} else {
Object[] state = (Object[]) o;
super.restoreState(facesContext, state[0]);
nextUniqueId = (Integer) state[1];
}
}
@Override
public String createUniqueId() {
if (FacesVersion.supports12()) {
return super.createUniqueId();
} else {
ExternalContext extCtx = FacesContext.getCurrentInstance().getExternalContext();
return extCtx.encodeNamespace(UNIQUE_ID_PREFIX + nextUniqueId++);
}
}
*/
// XXX begin of JSF 2.0 like code
public void broadcastEventsForPhase(FacesContext context, PhaseId phaseId) {
broadcastForPhase(phaseId);
if (context.getRenderResponse() || context.getResponseComplete()) {
clearEvents();
}
}
// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//
// The following code is copied from myfaces implementation!
// In suns jsf-api 1.1.01 are the events not cleared if renderResponse is true
// after processUpdates, seems to be a bug. This is fixed at least in
// Nightly Snapshot from 15.08.2005, but not in stable yet.
// Events are private member of UIViewRoot, so we have to copy anny code
// accessing them.
//
// TODO: remove if fixed in stable release! In 1.1_02 this seems to be fixed.
public void queueEvent(FacesEvent event) {
if (event == null) {
throw new NullPointerException("event");
}
if (events == null) {
events = new ArrayList<FacesEvent>();
}
events.add(event);
}
private void broadcastForPhase(PhaseId phaseId) {
if (events == null) {
return;
}
boolean abort = false;
int phaseIdOrdinal = phaseId.getOrdinal();
for (ListIterator<FacesEvent> listiterator = events.listIterator(); listiterator.hasNext();) {
FacesEvent event = listiterator.next();
int ordinal = event.getPhaseId().getOrdinal();
if (ordinal == PhaseId.ANY_PHASE.getOrdinal() || ordinal == phaseIdOrdinal) {
UIComponent source = event.getComponent();
try {
source.broadcast(event);
} catch (FacesException e) {
Throwable fe = e;
while (fe != null) {
if (fe instanceof AbortProcessingException) {
if (LOG.isTraceEnabled()) {
LOG.trace("AbortProcessingException caught!");
}
// abort event processing
// Page 3-30 of JSF 1.1 spec: "Throw an AbortProcessingException, to tell the JSF implementation
// that no further broadcast of this event, or any further events, should take place."
abort = true;
break;
}
fe = fe.getCause();
}
if (!abort) {
throw e;
} else {
break;
}
} finally {
try {
listiterator.remove();
} catch (ConcurrentModificationException cme) {
int eventIndex = listiterator.previousIndex();
events.remove(eventIndex);
//listiterator = events.listIterator();
}
}
}
}
if (abort) {
// TODO: abort processing of any event of any phase or just of any event of the current phase???
clearEvents();
}
}
private void clearEvents() {
events = null;
}
@Override
public void processDecodes(FacesContext context) {
if (context == null) {
throw new NullPointerException("context");
}
Map<String, UIComponent> ajaxComponents = AjaxInternalUtils.parseAndStoreComponents(context);
if (ajaxComponents != null) {
// first decode the page
AbstractUIPage page = ComponentUtils.findPage(context);
page.decode(context);
page.markSubmittedForm(context);
FacesContextUtils.setAjax(context, true);
// decode the action if actionComponent not inside one of the ajaxComponents
// otherwise it is decoded there
decodeActionComponent(context, page, ajaxComponents);
// and all ajax components
for (Map.Entry<String, UIComponent> entry : ajaxComponents.entrySet()) {
FacesContextUtils.setAjaxComponentId(context, entry.getKey());
invokeOnComponent(context, entry.getKey(), APPLY_REQUEST_VALUES_CALLBACK);
}
} else {
super.processDecodes(context);
}
broadcastForPhase(PhaseId.APPLY_REQUEST_VALUES);
if (context.getRenderResponse() || context.getResponseComplete()) {
clearEvents();
}
}
private void decodeActionComponent(FacesContext facesContext, AbstractUIPage page, Map<String,
UIComponent> ajaxComponents) {
String actionId = page.getActionId();
UIComponent actionComponent = null;
if (actionId != null) {
actionComponent = findComponent(actionId);
if (actionComponent == null && FacesVersion.supports20() && FacesVersion.isMyfaces()) {
String bugActionId = actionId.replaceAll(":\\d+:", ":");
try {
actionComponent = findComponent(bugActionId);
//LOG.info("command = \"" + actionComponent + "\"", new Exception());
} catch (Exception e) {
// ignore
}
}
}
if (actionComponent == null) {
return;
}
for (UIComponent ajaxComponent : ajaxComponents.values()) {
UIComponent component = actionComponent;
while (component != null) {
if (component == ajaxComponent) {
return;
}
component = component.getParent();
}
}
invokeOnComponent(facesContext, actionId, APPLY_REQUEST_VALUES_CALLBACK);
}
@Override
public void processValidators(FacesContext context) {
if (context == null) {
throw new NullPointerException("context");
}
Map<String, UIComponent> ajaxComponents = AjaxInternalUtils.getAjaxComponents(context);
if (ajaxComponents != null) {
for (Map.Entry<String, UIComponent> entry : ajaxComponents.entrySet()) {
FacesContextUtils.setAjaxComponentId(context, entry.getKey());
invokeOnComponent(context, entry.getKey(), PROCESS_VALIDATION_CALLBACK);
}
} else {
super.processValidators(context);
}
broadcastForPhase(PhaseId.PROCESS_VALIDATIONS);
if (context.getRenderResponse() || context.getResponseComplete()) {
clearEvents();
}
}
@Override
public void processUpdates(FacesContext context) {
if (context == null) {
throw new NullPointerException("context");
}
Map<String, UIComponent> ajaxComponents = AjaxInternalUtils.getAjaxComponents(context);
if (ajaxComponents != null) {
for (Map.Entry<String, UIComponent> entry : ajaxComponents.entrySet()) {
invokeOnComponent(context, entry.getKey(), UPDATE_MODEL_VALUES_CALLBACK);
}
} else {
super.processUpdates(context);
}
broadcastForPhase(PhaseId.UPDATE_MODEL_VALUES);
if (context.getRenderResponse() || context.getResponseComplete()) {
clearEvents();
}
}
@Override
public void processApplication(FacesContext context) {
if (context == null) {
throw new NullPointerException("context");
}
broadcastForPhase(PhaseId.INVOKE_APPLICATION);
if (context.getRenderResponse() || context.getResponseComplete()) {
clearEvents();
}
}
// XXX end of JSF 2.0 like code
@Override
public boolean getRendersChildren() {
if (AjaxUtils.isAjaxRequest(FacesContext.getCurrentInstance())) {
return true;
} else {
return super.getRendersChildren();
}
}
@Override
public void encodeChildren(FacesContext context) throws IOException {
if (AjaxUtils.isAjaxRequest(context)) {
new AjaxResponseRenderer().renderResponse(context);
} else {
super.encodeChildren(context);
}
}
@Override
public boolean invokeOnComponent(FacesContext context, String clientId, ContextCallback callback)
throws FacesException {
return ComponentUtils.invokeOnComponent(context, this, clientId, callback);
}
}