public EventProcessor(Desktop desktop,
    Component comp,
    Event event) 
{
		if (desktop == null || comp == null || event == null)
			throw new IllegalArgumentException("null");
		final Desktop dt = comp.getDesktop();
		if (dt != null && desktop != dt)
			throw new IllegalStateException("Process events for another desktop? "+comp);
		_desktop = desktop;
		_comp = comp;
		_event = event;
}

Parameters:

comp - the component. Its desktop must be either null or the same as desktop.

 public  void cleanup() 
{
		ExecutionsCtrl.setCurrent(null);
		SessionsCtrl.setCurrent(null);
}

Cleanup this process after processing the event by calling #process .

Note: Don't call this method if the event process executes in the same thread.

 public final Component getComponent() 
{
		return _comp;
}

Returns the component.

 public final Desktop getDesktop() 
{
		return _desktop;
}

Returns the desktop.

 public final Event getEvent() 
{
		return _event;
}

Returns the event.

 public static final boolean inEventListener() 
{
		return (Thread.currentThread() instanceof EventProcessingThread)
			|| (_inEvt != null && _inEvt.get() != null); //used if event thread is disabled
}

Returns whether the current thread is an event listener.

 static final  void inEventListener(boolean in) 
{
		if (in) {
			if (_inEvt == null)
				_inEvt = new ThreadLocal();
			_inEvt.set(Boolean.TRUE);
		} else {
			if (_inEvt != null)
				_inEvt.set(null);
		}
}

Sets whether the current thread is an event listener. It needs to be called only if the event processing thread is disabled.

It is used only internally.

 public  void process() throws Exception 
{
		//Bug 1506712: event listeners might be zscript, so we have to
		//keep built-in variables as long as possible
		final HashMap backup = new HashMap();
		final Namespace ns = Namespaces.beforeInterpret(backup, _comp, true);
			//we have to push since process0 might invoke methods from zscript class
		try {
			Namespaces.backupVariable(backup, ns, "event");
			ns.setVariable("event", _event, true);
			_event = ((DesktopCtrl)_desktop).beforeProcessEvent(_event);
			if (_event != null) {
				ns.setVariable("event", _event, true); //_event might change
				process0(ns);
				((DesktopCtrl)_desktop).afterProcessEvent(_event);
			}
		} finally {
			Namespaces.afterInterpret(backup, ns, true);
		}
}

Process the event. Note: it doesn't invoke EventThreadInit and EventThreadCleanup.

This method is to implement org.zkoss.zk.ui.sys.EventProcessingThread . See also org.zkoss.zk.ui.util.Configuration#isEventThreadEnabled .

 public  void setup() 
{
	                 	 
		SessionsCtrl.setCurrent(_desktop.getSession());
		final Execution exec = _desktop.getExecution();
		ExecutionsCtrl.setCurrent(exec);
		((ExecutionCtrl)exec).setCurrentPage(getPage());
}

Setup this processor before processing the event by calling #process .

Note: it doesn't invoke ExecutionCtrl#onActivate

 public String toString() 
{
		return "[comp: "+_comp+", event: "+_event+']";
}