tapestry/tapestry-framework/src/java/org/apache/tapestry/services/impl/ComponentEventConnectionWorker.java

// Copyright May 20, 2006 The Apache Software Foundation
//
// Licensed 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.tapestry.services.impl;

import org.apache.hivemind.ClassResolver;
import org.apache.hivemind.PoolManageable;
import org.apache.hivemind.Resource;
import org.apache.hivemind.util.ClasspathResource;
import org.apache.tapestry.*;
import org.apache.tapestry.dojo.IWidget;
import org.apache.tapestry.engine.DirectEventServiceParameter;
import org.apache.tapestry.engine.IEngineService;
import org.apache.tapestry.engine.IScriptSource;
import org.apache.tapestry.html.Body;
import org.apache.tapestry.internal.Component;
import org.apache.tapestry.internal.event.ComponentEventProperty;
import org.apache.tapestry.internal.event.EventBoundListener;
import org.apache.tapestry.internal.event.IComponentEventInvoker;
import org.apache.tapestry.services.ComponentRenderWorker;
import org.apache.tapestry.util.ScriptUtils;

import java.util.*;


/**
 * Implementation that handles connecting events to listener
 * method invocations.
 *
 * @author jkuhnert
 */
public class ComponentEventConnectionWorker implements ComponentRenderWorker, PoolManageable
{
    /** Stored in {@link IRequestCycle} with associated forms. */
    public static final String FORM_NAME_LIST =  "org.apache.tapestry.services.impl.ComponentEventConnectionFormNames-";

    // holds mapped event listener info
    private IComponentEventInvoker _invoker;

    // generates links for scripts
    private IEngineService _eventEngine;

    // handles resolving and loading different component event 
    // connection script types
    private IScriptSource _scriptSource;

    // script path references
    private String _componentScript;
    private String _widgetScript;
    private String _elementScript;

    // resolves classpath relative resources
    private ClassResolver _resolver;

    // wrappers around resolved script templates
    private ClasspathResource _componentResource;
    private ClasspathResource _widgetResource;
    private ClasspathResource _elementResource;

    /**
     * For event connections referencing forms that have not been rendered yet.
     */
    private Map _deferredFormConnections = new HashMap(24);

    /**
     * Used to store deferred form connection information, but most importantly is used
     * to provide unique equals/hashcode semantics.
     */
    class DeferredFormConnection {

        String _formId;
        Map _scriptParms;
        Boolean _async;
        Boolean _validate;
        String _uniqueHash;

        public DeferredFormConnection(String formId, Map scriptParms, Boolean async,
                                      Boolean validate, String uniqueHash)
        {
            _formId = formId;
            _scriptParms = scriptParms;
            _async = async;
            _validate = validate;
            _uniqueHash = uniqueHash;
        }

        public boolean equals(Object o)
        {
            if (this == o) return true;
            if (o == null || getClass() != o.getClass()) return false;

            DeferredFormConnection that = (DeferredFormConnection) o;

            if (_uniqueHash != null ? !_uniqueHash.equals(that._uniqueHash) : that._uniqueHash != null) return false;

            return true;
        }

        public int hashCode()
        {
            return (_uniqueHash != null ? _uniqueHash.hashCode() : 0);
        }
    }

    public void activateService()
    {
        _deferredFormConnections.clear();
    }

    public void passivateService()
    {
    }

    /**
     * {@inheritDoc}
     */
    public void renderComponent(IRequestCycle cycle, IComponent component)
    {
        if (cycle.isRewinding())
            return;

        if (Component.class.isInstance(component) && !((Component)component).hasEvents() && !IForm.class.isInstance(component))
            return;

        if (TapestryUtils.getOptionalPageRenderSupport(cycle) == null)
            return;

        // Don't render fields being pre-rendered, otherwise we'll render twice
        IComponent field = (IComponent)cycle.getAttribute(TapestryUtils.FIELD_PRERENDER);
        if (field != null && field == component)
            return;

        linkComponentEvents(cycle, component);

        linkElementEvents(cycle, component);

        if (IForm.class.isInstance(component))
            mapFormNames(cycle, (IForm)component);

        if (isDeferredForm(component))
            linkDeferredForm(cycle, (IForm)component);
    }

    void linkComponentEvents(IRequestCycle cycle, IComponent component)
    {
        ComponentEventProperty[] props = _invoker.getEventPropertyListeners(component.getExtendedId());
        if (props == null)
            return;

        for (int i=0; i < props.length; i++) {

            String clientId = component.getClientId();

            Map parms = new HashMap();
            parms.put("clientId", clientId);
            parms.put("component", component);

            Object[][] events = getEvents(props[i], clientId);
            Object[][] formEvents = filterFormEvents(props[i], parms, cycle);

            if (events.length < 1 && formEvents.length < 1)
                continue;

            DirectEventServiceParameter dsp =
              new DirectEventServiceParameter((IDirectEvent)component, new Object[] {}, new String[] {}, false);

            parms.put("url", _eventEngine.getLink(false, dsp).getURL());
            parms.put("events", events);
            parms.put("formEvents", formEvents);

            PageRenderSupport prs = TapestryUtils.getPageRenderSupport(cycle, component);
            Resource resource = getScript(component);

            _scriptSource.getScript(resource).execute(component, cycle, prs, parms);
        }
    }

    void linkElementEvents(IRequestCycle cycle, IComponent component)
    {
        if (!component.getSpecification().hasElementEvents())
            return;

        DirectEventServiceParameter dsp =
          new DirectEventServiceParameter((IDirectEvent)component, new Object[] {}, new String[] {}, false);

        String url = _eventEngine.getLink(false, dsp).getURL();

        PageRenderSupport prs = TapestryUtils.getPageRenderSupport(cycle, component);
        Resource resource = getElementScript();

        Map elements = component.getSpecification().getElementEvents();
        Iterator keys = elements.keySet().iterator();

        // build our list of targets / events
        while (keys.hasNext()) {

            Map parms = new HashMap();

            String target = (String)keys.next();

            ComponentEventProperty prop = (ComponentEventProperty)elements.get(target);

            parms.put("component", component);
            parms.put("target", target);
            parms.put("url", url);
            parms.put("events", getEvents(prop, target));
            parms.put("formEvents", filterFormEvents(prop, parms, cycle));

            _scriptSource.getScript(resource).execute(component, cycle, prs, parms);
        }
    }

    /**
     * {@inheritDoc}
     */
    public void renderBody(IRequestCycle cycle, Body component)
    {
        if (cycle.isRewinding())
            return;

        renderComponent(cycle, component);

        // just in case
        _deferredFormConnections.clear();
    }

    void mapFormNames(IRequestCycle cycle, IForm form)
    {
        List names = (List)cycle.getAttribute(FORM_NAME_LIST + form.getExtendedId());

        if (names == null) {
            names = new ArrayList();

            cycle.setAttribute(FORM_NAME_LIST + form.getExtendedId(), names);
        }

        names.add(form.getName());
    }

    void linkDeferredForm(IRequestCycle cycle, IForm form)
    {
        List deferred = (List)_deferredFormConnections.remove(form.getExtendedId());

        for (int i=0; i < deferred.size(); i++)
        {
            DeferredFormConnection fConn = (DeferredFormConnection)deferred.get(i);
            Map scriptParms = fConn._scriptParms;

            // don't want any events accidently connected again
            scriptParms.remove("events");

            IComponent component = (IComponent)scriptParms.get("component");

            // fire off element based events first

            linkElementEvents(cycle, component);

            ComponentEventProperty[] props = _invoker.getEventPropertyListeners(component.getExtendedId());
            if (props == null)
                continue;

            for (int e=0; e < props.length; e++) {

                Object[][] formEvents = buildFormEvents(cycle, form.getExtendedId(),
                                                        props[e].getFormEvents(), fConn._async,
                                                        fConn._validate, fConn._uniqueHash);

                scriptParms.put("formEvents", formEvents);

                // execute script

                PageRenderSupport prs = TapestryUtils.getPageRenderSupport(cycle, component);
                Resource resource = getScript(component);

                _scriptSource.getScript(resource).execute(form, cycle, prs, scriptParms);
            }
        }
    }

    /**
     * Generates a two dimensional array containing the event name in the first
     * index and a unique hashcode for the event binding in the second.
     *
     * @param prop The component event properties object the events are managed in.
     * @return A two dimensional array containing all events, or empty array if none exist.
     */
    Object[][] getEvents(ComponentEventProperty prop, String clientId)
    {
        Set events = prop.getEvents();
        List ret = new ArrayList();

        Iterator it = events.iterator();
        while (it.hasNext())
        {
            String event = (String)it.next();

            int hash = 0;
            List listeners = prop.getEventListeners(event);

            for (int i=0; i < listeners.size(); i++)
                hash += listeners.get(i).hashCode();

            ret.add(new Object[]{ event, ScriptUtils.functionHash(event + hash + clientId) });
        }

        return (Object[][])ret.toArray(new Object[ret.size()][2]);
    }

    Object[][] buildFormEvents(IRequestCycle cycle, String formId, Set events,
                               Boolean async, Boolean validate, Object uniqueHash)
    {
        List formNames = (List)cycle.getAttribute(FORM_NAME_LIST + formId);
        List retval = new ArrayList();

        Iterator it = events.iterator();

        while (it.hasNext())
        {
            String event = (String)it.next();

            retval.add(new Object[]{event, formNames, async, validate,
                                    ScriptUtils.functionHash(new String(uniqueHash + event)) });
        }

        return (Object[][])retval.toArray(new Object[retval.size()][5]);
    }

    Resource getScript(IComponent component)
    {
        if (IWidget.class.isInstance(component)) {

            if (_widgetResource == null)
                _widgetResource = new ClasspathResource(_resolver, _widgetScript);

            return _widgetResource;
        }

        if (_componentResource == null)
            _componentResource = new ClasspathResource(_resolver, _componentScript);

        return _componentResource;
    }

    Resource getElementScript()
    {
        if (_elementResource == null)
            _elementResource = new ClasspathResource(_resolver, _elementScript);

        return _elementResource;
    }

    boolean isDeferredForm(IComponent component)
    {
        if (IForm.class.isInstance(component)
            && _deferredFormConnections.get(((IForm)component).getExtendedId()) != null)
            return true;

        return false;
    }

    /**
     * For each form event attempts to find a rendered form name list that corresponds
     * to the actual client ids that the form can be connected to. If the form hasn't been
     * rendered yet the events will be filtered out and deferred for execution <i>after</i>
     * the form has rendererd.
     *
     * @param prop
     *          The configured event properties.
     * @param scriptParms
     *          The parameters to eventually be passed in to the javascript tempate.
     * @param cycle
     *          The current cycle.
     *
     * @return A set of events that can be connected now because the form has already rendered.
     */
    Object[][] filterFormEvents(ComponentEventProperty prop, Map scriptParms, IRequestCycle cycle)
    {
        Set events = prop.getFormEvents();

        if (events.size() < 1)
            return new Object[0][0];

        List retval = new ArrayList();

        Iterator it = events.iterator();
        while (it.hasNext())
        {
            String event = (String)it.next();
            Iterator lit = prop.getFormEventListeners(event).iterator();

            while (lit.hasNext())
            {
                EventBoundListener listener = (EventBoundListener)lit.next();

                String formId = listener.getFormId();
                List formNames = (List)cycle.getAttribute(FORM_NAME_LIST + formId);

                // defer connection until form is rendered
                if (formNames == null)
                {
                    deferFormConnection(formId, scriptParms,
                                        listener.isAsync(),
                                        listener.isValidateForm(),
                                        ScriptUtils.functionHash(listener.hashCode() + (String) scriptParms.get("clientId")));
                    
                    /*deferFormConnection(formId, scriptParms,
                                        listener.isAsync(),
                                        listener.isValidateForm(),
                                        ScriptUtils.functionHash(listener.hashCode() + (String) scriptParms.get("clientId")));*/

                    // re-looping over the same property -> event listener list would
                    // result in duplicate bindings so break out 
                    break;
                }

                // form has been rendered so go ahead
                retval.add(new Object[] {
                  event, formNames,
                  Boolean.valueOf(listener.isAsync()),
                  Boolean.valueOf(listener.isValidateForm()),
                  ScriptUtils.functionHash(listener)
                });
            }
        }

        return (Object[][])retval.toArray(new Object[retval.size()][5]);
    }

    /**
     * Temporarily stores the data needed to perform script evaluations that
     * connect a component event to submitting a particular form that hasn't
     * been rendered yet. We can't reliably connect to a form until its name has
     * been set by a render, which could happen multiple times if it's in a list.
     *
     * <p>
     * The idea here is that when the form actually ~is~ rendered we will look for 
     * any pending deferred operations and run them while also clearing out our
     * deferred list.
     * </p>
     *
     * @param formId The form to defer event connection for.
     * @param scriptParms The initial map of parameters for the connection @Script component.
     * @param async Whether or not the action taken should be asynchronous.
     * @param validate Whether or not the form should have client side validation run befor submitting.
     * @param uniqueHash Represents a hashcode() value that will help make client side function name
     *                  unique.
     */
    void deferFormConnection(String formId, Map scriptParms,
                             boolean async, boolean validate, String uniqueHash)
    {
        List deferred = (List)_deferredFormConnections.get(formId);
        if (deferred == null)
        {
            deferred = new ArrayList();
            _deferredFormConnections.put(formId, deferred);
        }

        DeferredFormConnection connection = new DeferredFormConnection(formId, scriptParms, Boolean.valueOf(async),
                                                                       Boolean.valueOf(validate), uniqueHash);

        if (!deferred.contains(connection))
            deferred.add(connection);
    }

    // for testing
    Map getDefferedFormConnections()
    {
        return _deferredFormConnections;
    }

    /**
     * Sets the invoker to use/manage event connections.
     * @param invoker Manages component event invocations.
     */
    public void setEventInvoker(IComponentEventInvoker invoker)
    {
        _invoker = invoker;
    }

    /**
     * Sets the engine service that will be used to construct callback
     * URL references to invoke the specified components event listener.
     *
     * @param eventEngine Engine used to create client side urls for updating things async.
     */
    public void setEventEngine(IEngineService eventEngine)
    {
        _eventEngine = eventEngine;
    }

    /**
     * The javascript that will be used to connect the component
     * to its configured events. (if any)
     * @param script The component script functions.
     */
    public void setComponentScript(String script)
    {
        _componentScript = script;
    }

    /**
     * The javascript that will be used to connect the widget component
     * to its configured events. (if any)
     * @param script The dojo widget based script.
     */
    public void setWidgetScript(String script)
    {
        _widgetScript = script;
    }

    /**
     * The javascript that connects html elements to direct
     * listener methods.
     * @param script Event element target scripts.
     */
    public void setElementScript(String script)
    {
        _elementScript = script;
    }

    /**
     * The service that parses script files.
     * @param scriptSource Service.
     */
    public void setScriptSource(IScriptSource scriptSource)
    {
        _scriptSource = scriptSource;
    }

    public void setClassResolver(ClassResolver resolver)
    {
        _resolver = resolver;
    }
}