/*
* Copyright (c) 2011, 2013, Oracle and/or its affiliates. All rights reserved.
* ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*/
package javafx.concurrent;
import com.sun.javafx.event.
EventHandlerManager;
import javafx.beans.property.
ObjectProperty;
import javafx.beans.property.
SimpleObjectProperty;
import javafx.event.*;
import static javafx.concurrent.
WorkerStateEvent.*;
import static javafx.concurrent.
WorkerStateEvent.
WORKER_STATE_CANCELLED;
import static javafx.concurrent.
WorkerStateEvent.
WORKER_STATE_FAILED;
/**
* This utility class is used both to bucketize the event handler related
* methods and state in Service and Task, but also (and more importantly)
* to consolidate the implementation into one place.
*/
class
EventHelper {
private final
EventTarget target;
private final
ObjectProperty<
EventHandler<
WorkerStateEvent>>
onReady;
final
ObjectProperty<
EventHandler<
WorkerStateEvent>>
onReadyProperty() { return
onReady; }
final
EventHandler<
WorkerStateEvent>
getOnReady() { return
onReady.
get(); }
final void
setOnReady(
EventHandler<
WorkerStateEvent>
value) {
onReady.
set(
value); }
private final
ObjectProperty<
EventHandler<
WorkerStateEvent>>
onScheduled;
final
ObjectProperty<
EventHandler<
WorkerStateEvent>>
onScheduledProperty() { return
onScheduled; }
final
EventHandler<
WorkerStateEvent>
getOnScheduled() { return
onScheduled.
get(); }
final void
setOnScheduled(
EventHandler<
WorkerStateEvent>
value) {
onScheduled.
set(
value); }
private final
ObjectProperty<
EventHandler<
WorkerStateEvent>>
onRunning;
final
ObjectProperty<
EventHandler<
WorkerStateEvent>>
onRunningProperty() { return
onRunning; }
final
EventHandler<
WorkerStateEvent>
getOnRunning() { return
onRunning.
get(); }
final void
setOnRunning(
EventHandler<
WorkerStateEvent>
value) {
onRunning.
set(
value); }
private final
ObjectProperty<
EventHandler<
WorkerStateEvent>>
onSucceeded;
final
ObjectProperty<
EventHandler<
WorkerStateEvent>>
onSucceededProperty() { return
onSucceeded; }
final
EventHandler<
WorkerStateEvent>
getOnSucceeded() { return
onSucceeded.
get(); }
final void
setOnSucceeded(
EventHandler<
WorkerStateEvent>
value) {
onSucceeded.
set(
value); }
private final
ObjectProperty<
EventHandler<
WorkerStateEvent>>
onCancelled;
final
ObjectProperty<
EventHandler<
WorkerStateEvent>>
onCancelledProperty() { return
onCancelled; }
final
EventHandler<
WorkerStateEvent>
getOnCancelled() { return
onCancelled.
get(); }
final void
setOnCancelled(
EventHandler<
WorkerStateEvent>
value) {
onCancelled.
set(
value); }
private final
ObjectProperty<
EventHandler<
WorkerStateEvent>>
onFailed;
final
ObjectProperty<
EventHandler<
WorkerStateEvent>>
onFailedProperty() { return
onFailed; }
final
EventHandler<
WorkerStateEvent>
getOnFailed() { return
onFailed.
get(); }
final void
setOnFailed(
EventHandler<
WorkerStateEvent>
value) {
onFailed.
set(
value); }
private
EventHandlerManager internalEventDispatcher;
EventHelper(
EventTarget bean) {
this.
target =
bean;
onReady = new
SimpleObjectProperty<
EventHandler<
WorkerStateEvent>>(
bean, "onReady") {
@
Override protected void
invalidated() {
EventHandler<
WorkerStateEvent>
handler =
get();
setEventHandler(
WORKER_STATE_READY,
handler);
}
};
onScheduled = new
SimpleObjectProperty<
EventHandler<
WorkerStateEvent>>(
bean, "onScheduled") {
@
Override protected void
invalidated() {
EventHandler<
WorkerStateEvent>
handler =
get();
setEventHandler(
WORKER_STATE_SCHEDULED,
handler);
}
};
onRunning = new
SimpleObjectProperty<
EventHandler<
WorkerStateEvent>>(
bean, "onRunning") {
@
Override protected void
invalidated() {
EventHandler<
WorkerStateEvent>
handler =
get();
setEventHandler(
WORKER_STATE_RUNNING,
handler);
}
};
onSucceeded = new
SimpleObjectProperty<
EventHandler<
WorkerStateEvent>>(
bean, "onSucceeded") {
@
Override protected void
invalidated() {
EventHandler<
WorkerStateEvent>
handler =
get();
setEventHandler(
WORKER_STATE_SUCCEEDED,
handler);
}
};
onCancelled = new
SimpleObjectProperty<
EventHandler<
WorkerStateEvent>>(
bean, "onCancelled") {
@
Override protected void
invalidated() {
EventHandler<
WorkerStateEvent>
handler =
get();
setEventHandler(
WORKER_STATE_CANCELLED,
handler);
}
};
onFailed = new
SimpleObjectProperty<
EventHandler<
WorkerStateEvent>>(
bean, "onFailed") {
@
Override protected void
invalidated() {
EventHandler<
WorkerStateEvent>
handler =
get();
setEventHandler(
WORKER_STATE_FAILED,
handler);
}
};
}
/**
* Registers an event handler to this task. Any event filters are first
* processed, then the specified onFoo event handlers, and finally any
* event handlers registered by this method. As with other events
* in the scene graph, if an event is consumed, it will not continue
* dispatching.
*
* @param <T> the specific event class of the handler
* @param eventType the type of the events to receive by the handler
* @param eventHandler the handler to register
*/
final <T extends
Event> void
addEventHandler(
final
EventType<T>
eventType,
final
EventHandler<? super T>
eventHandler) {
getInternalEventDispatcher()
.
addEventHandler(
eventType,
eventHandler);
}
/**
* Unregisters a previously registered event handler from this task. One
* handler might have been registered for different event types, so the
* caller needs to specify the particular event type from which to
* unregister the handler.
*
* @param <T> the specific event class of the handler
* @param eventType the event type from which to unregister
* @param eventHandler the handler to unregister
*/
final <T extends
Event> void
removeEventHandler(
final
EventType<T>
eventType,
final
EventHandler<? super T>
eventHandler) {
getInternalEventDispatcher()
.
removeEventHandler(
eventType,
eventHandler);
}
/**
* Registers an event filter to this task. Registered event filters get
* an event before any associated event handlers.
*
* @param <T> the specific event class of the filter
* @param eventType the type of the events to receive by the filter
* @param eventFilter the filter to register
*/
final <T extends
Event> void
addEventFilter(
final
EventType<T>
eventType,
final
EventHandler<? super T>
eventFilter) {
getInternalEventDispatcher()
.
addEventFilter(
eventType,
eventFilter);
}
/**
* Unregisters a previously registered event filter from this task. One
* filter might have been registered for different event types, so the
* caller needs to specify the particular event type from which to
* unregister the filter.
*
* @param <T> the specific event class of the filter
* @param eventType the event type from which to unregister
* @param eventFilter the filter to unregister
*/
final <T extends
Event> void
removeEventFilter(
final
EventType<T>
eventType,
final
EventHandler<? super T>
eventFilter) {
getInternalEventDispatcher()
.
removeEventFilter(
eventType,
eventFilter);
}
/**
* Sets the handler to use for this event type. There can only be one such
* handler specified at a time. This handler is guaranteed to be called
* first. This is used for registering the user-defined onFoo event
* handlers.
*
* @param <T> the specific event class of the handler
* @param eventType the event type to associate with the given eventHandler
* @param eventHandler the handler to register, or null to unregister
*/
final <T extends
Event> void
setEventHandler(
final
EventType<T>
eventType,
final
EventHandler<? super T>
eventHandler) {
getInternalEventDispatcher()
.
setEventHandler(
eventType,
eventHandler);
}
private
EventHandlerManager getInternalEventDispatcher() {
if (
internalEventDispatcher == null) {
internalEventDispatcher = new
EventHandlerManager(
target);
}
return
internalEventDispatcher;
}
/**
* Fires the specified event. Any event filter encountered will
* be notified and can consume the event. If not consumed by the filters,
* the event handlers on this task are notified. If these don't consume the
* event either, then all event handlers are called and can consume the
* event.
* <p>
* This method must be called on the FX user thread.
*
* @param event the event to fire
*/
final void
fireEvent(
Event event) {
Event.
fireEvent(
target,
event);
}
EventDispatchChain buildEventDispatchChain(
EventDispatchChain tail) {
return
internalEventDispatcher == null ?
tail :
tail.
append(
getInternalEventDispatcher());
}
}