public class GroupEventQueue<T extends Event> extends java.lang.Object implements EventQueue<T>, java.io.Serializable
EventQueues.DESKTOP.| Constructor and Description |
|---|
GroupEventQueue() |
| Modifier and Type | Method and Description |
|---|---|
void |
close()
Closes the event queue.
|
boolean |
isClose()
Returns whether it is closed.
|
boolean |
isSubscribed(EventListener<T> listener)
Returns if an event listener is subscribed.
|
void |
publish(T event)
Publishes an event to the queue.
|
void |
subscribe(EventListener<T> listener)
Subscribes a listener to this queue.
|
void |
subscribe(EventListener<T> listener,
boolean async)
Subscribes a synchronous or asynchronous listener to this event queue.
|
void |
subscribe(EventListener<T> listener,
EventListener<T> callback)
Subscribes a synchronous or asynchronous listener to this event queue.
|
boolean |
unsubscribe(EventListener<T> listener)
Unsubscribes a listener from the queue.
|
public void publish(T event)
EventQueueIf the scope of a event queue is desktop or group,
this method must be called within an activated execution
(i.e., Executions.getCurrent() not null),
or in an asynchronous listener (see EventQueue).
On the other hand, if the scope is session or application, it is OK to be called without the current execution.
publish in interface EventQueue<T extends Event>event - the event to publish.publish(new Event("", null, data)).public void subscribe(EventListener<T> listener)
EventQueuesubscribe(listener, false)
(EventQueue.subscribe(EventListener,boolean). In other words,
it subscribes a synchronous listener.
Note: this method must be called within an activated execution
(i.e., Executions.getCurrent() not null),
no matter what scope the event queue is.
Note: the listener could access the component associated with the event
(Event.getTarget()), only if this is an EventQueues.DESKTOP
event queue.
An event listener can be subscribed multiple times, and it will be invoked multiple times if an event is published.
Even if this is a EventQueues.GROUP, EventQueues.SESSION,
or EventQueues.APPLICATION event queue,
the listener is subscribed for the current desktop only, i.e.,
it can only access the components belong to the subscribed desktop.
If you want to use the same listener to manipulate multiple desktops,
you have to subscribe them separately when the corresponding
execution is available.
subscribe in interface EventQueue<T extends Event>EventQueue.subscribe(EventListener,EventListener),
EventQueue.subscribe(EventListener,boolean)public void subscribe(EventListener<T> listener, EventListener<T> callback)
EventQueueHere is an example,
<window title="long operation" border="normal">
<zscript>
void print(String msg) {
new Label(msg).setParent(inf);
}
</zscript>
<button label="async long op">
<attribute name="onClick"><![CDATA[
if (EventQueues.exists("longop")) {
print("It is busy. Please wait");
return; //busy
}
EventQueue eq = EventQueues.lookup("longop"); //create a queue
String result;
//subscribe async listener to handle long operation
eq.subscribe(new EventListener() {
public void onEvent(Event evt) { //asynchronous
org.zkoss.lang.Threads.sleep(3000); //simulate a long operation
result = "success"; //store the result
}
}, new EventListener() { //callback
public void onEvent(Event evt) {
print(result); //show the result to the browser
EventQueues.remove("longop");
}
});
print("Wait for 3 seconds");
eq.publish(new Event("whatever")); //kick off the long operation
]]></attribute>
</button>
<vbox id="inf"/>
</window>
Notice that, though an asynchronous listener cannot access
the desktop and has no current execution, it can invoke
EventQueue.publish(T) to publish the events. Refer to
another example in EventQueue.subscribe(EventListener,boolean).
subscribe in interface EventQueue<T extends Event>listener - the asynchronous listener to invoke when an event
is receivedcallback - the callback listener, which will be invoked if
the asynchronous listen has been invoked.
Unlike the asynchronous listener, the callback listener works
like a normal listener. You can access the current execution,
and update the desktop.listener. In the prior version,
it is always null for the callback listener.EventQueue.subscribe(EventListener),
EventQueue.subscribe(EventListener,boolean)public void subscribe(EventListener<T> listener, boolean async)
EventQueueThe use of synchronous listeners is straightforward -- they are just the same a normal event listener. Here is an example of using an asynchronous listener. In this example, we use an asynchronous listener to execute a long operation, a synchronous listener to update the desktop, and they communicate with each other with events.
There is another way to do the same job, callback, refer
to EventQueue.subscribe(EventListener,EventListener) for example.
<window title="long operation" border="normal">
<zscript>
void print(String msg) {
new Label(msg).setParent(inf);
}
</zscript>
<button label="async long op">
<attribute name="onClick"><![CDATA[
if (EventQueues.exists("longop")) {
print("It is busy. Please wait");
return; //busy
}
EventQueue eq = EventQueues.lookup("longop"); //create a queue
String result;
//subscribe async listener to handle long operation
eq.subscribe(new EventListener() {
public void onEvent(Event evt) {
if ("doLongOp".equals(evt.getName())) {
org.zkoss.lang.Threads.sleep(3000); //simulate a long operation
result = "success"; //store the result
eq.publish(new Event("endLongOp")); //notify it is done
}
}
}, true); //asynchronous
//subscribe a normal listener to show the result to the browser
eq.subscribe(new EventListener() {
public void onEvent(Event evt) {
if ("endLongOp".equals(evt.getName())) {
print(result); //show the result to the browser
EventQueues.remove("longop");
}
}
}); //synchronous
print("Wait for 3 seconds");
eq.publish(new Event("doLongOp")); //kick off the long operation
]]></attribute>
</button>
<vbox id="inf"/>
</window>
The asynchronous event listener requires Server Push
(ServerPush).
If you want to show a busy message to cover a portion of the desktop,
use Clients.showBusy(org.zkoss.zk.ui.Component,String)
Note: this method must be called within an activated execution,
i.e., Executions.getCurrent() not null.
An event listener can be subscribed multiple times, and it will be invoked multiple times if an event is published.
Even if this is an application-level or session-level event queue, the listener is subscribed for the current desktop only. If you want to use the same listener for multiple desktops, you have to subscribe them separately when the corresponding execution is available.
subscribe in interface EventQueue<T extends Event>listener - the listenerasync - whether the listener is asynchronousEventQueue.subscribe(EventListener),
EventQueue.subscribe(EventListener, EventListener)public boolean unsubscribe(EventListener<T> listener)
EventQueueNote: this method must be called within an activated execution,
i.e., Executions.getCurrent() not null.
Notice that this method only unsubscribes the listener subscribed for this desktop. It doesn't check the listeners for other desktops even if this is an application-level or session-level event queue.
unsubscribe in interface EventQueue<T extends Event>public boolean isSubscribed(EventListener<T> listener)
EventQueueNotice that this method only checks the listeners subscribed for this desktop. It doesn't check the listeners for other desktops even if this is an application-level or session-level event queue.
isSubscribed in interface EventQueue<T extends Event>public void close()
EventQueueDon't call this method directly. It is called only internally.
Rather, use EventQueues.remove(java.lang.String) instead.
close in interface EventQueue<T extends Event>public boolean isClose()
EventQueueisClose in interface EventQueue<T extends Event>Copyright © 2005-2018 Potix Corporation. All Rights Reserved.