Vendor the org.bushe:eventbus library

We need to fix a bug, but the upstream library is not actively
maintained anymore. Including the code in scijava-common makes
it easier to make changes to the codebase directly.

Author: ctrueden

pom.xml

@@ -167,6 +167,7 @@
 		<license.licenseName>bsd_2</license.licenseName>
 		<license.projectName>SciJava Common shared library for SciJava software.</license.projectName>
 		<license.copyrightOwners>SciJava developers.</license.copyrightOwners>
+		<license.excludes>**/bushe/**</license.excludes>
 	</properties>
 
 	<dependencies>
@@ -176,13 +177,6 @@
 			<artifactId>parsington</artifactId>
 		</dependency>
 
-		<!-- Third-party dependencies -->
-		<dependency>
-			<groupId>org.bushe</groupId>
-			<artifactId>eventbus</artifactId>
-			<version>1.4</version>
-		</dependency>
-
 		<!-- Test scope dependencies -->
 		<dependency>
 			<groupId>junit</groupId>
@@ -193,7 +187,7 @@
 			<groupId>org.mockito</groupId>
 			<artifactId>mockito-core</artifactId>
 			<scope>test</scope>
-			</dependency>
+		</dependency>
 	</dependencies>
 
 	<build>

src/main/java/org/scijava/event/DefaultEventBus.java

@@ -34,18 +34,18 @@
 import java.util.Arrays;
 import java.util.List;
 
-import org.bushe.swing.event.CleanupEvent;
-import org.bushe.swing.event.ThreadSafeEventService;
+import org.scijava.event.bushe.CleanupEvent;
+import org.scijava.event.bushe.ThreadSafeEventService;
 import org.scijava.log.LogService;
 import org.scijava.service.Service;
 import org.scijava.thread.ThreadService;
 
 /**
- * An {@link org.bushe.swing.event.EventService} implementation for SciJava.
+ * An {@link org.scijava.event.bushe.EventService} implementation for SciJava.
  * <p>
  * It is called "DefaultEventBus" rather than "DefaultEventService" to avoid a
  * name clash with {@link DefaultEventService}, which is not an
- * {@link org.bushe.swing.event.EventService} but rather a SciJava
+ * {@link org.scijava.event.bushe.EventService} but rather a SciJava
  * {@link Service} implementation.
  * </p>
  * 
@@ -112,7 +112,7 @@ public void publishLater(final String topicName, final Object eventObj) {
 			getVetoEventListeners(topicName), null);
 	}
 
-	// -- org.bushe.swing.event.EventService methods --
+	// -- org.scijava.event.bushe.EventService methods --
 
 	@Override
 	public void publish(final Object event) {

src/main/java/org/scijava/event/DefaultEventService.java

@@ -40,9 +40,9 @@
 import java.util.Map;
 import java.util.WeakHashMap;
 
-import org.bushe.swing.event.annotation.AbstractProxySubscriber;
-import org.bushe.swing.event.annotation.BaseProxySubscriber;
-import org.bushe.swing.event.annotation.ReferenceStrength;
+import org.scijava.event.bushe.annotation.AbstractProxySubscriber;
+import org.scijava.event.bushe.annotation.BaseProxySubscriber;
+import org.scijava.event.bushe.annotation.ReferenceStrength;
 import org.scijava.Priority;
 import org.scijava.log.LogService;
 import org.scijava.plugin.Parameter;
@@ -263,7 +263,7 @@ private synchronized void keepIt(final Object o, final ProxySubscriber<?> subscr
 	 * Helper class used by {@link #subscribe(Object)}.
 	 * <p>
 	 * Recapitulates some logic from {@link BaseProxySubscriber}, because that
-	 * class implements {@link org.bushe.swing.event.EventSubscriber} as a raw
+	 * class implements {@link org.scijava.event.bushe.EventSubscriber} as a raw
 	 * type, which is incompatible with this class implementing SciJava's
 	 * {@link EventSubscriber} as a typed interface; it becomes impossible to
 	 * implement both {@code onEvent(Object)} and {@code onEvent(E)}.

src/main/java/org/scijava/event/EventHandler.java

@@ -40,10 +40,10 @@
  * handling methods and annotating each with @{@link EventHandler}.
  * <p>
  * Note to developers: This annotation serves exactly the same purpose as
- * EventBus's {@link org.bushe.swing.event.annotation.EventSubscriber}
+ * EventBus's {@link org.scijava.event.bushe.annotation.EventSubscriber}
  * annotation, recapitulating a subset of the same functionality. We do this to
  * avoid third party code depending directly on EventBus. That is, we do not
- * wish to require SciJava developers to {@code import org.bushe.swing.event.*}
+ * wish to require SciJava developers to {@code import org.scijava.event.bushe.*}
  * or similar. In this way, EventBus is isolated as only a transitive dependency
  * of downstream code, rather than a direct dependency. Unfortunately, because
  * Java annotation interfaces cannot utilize inheritance, we have to

src/main/java/org/scijava/event/EventSubscriber.java

@@ -44,7 +44,7 @@
  * @param <E> Type of event for which to listen
  */
 public interface EventSubscriber<E extends SciJavaEvent> extends
-	org.bushe.swing.event.EventSubscriber<E>
+	org.scijava.event.bushe.EventSubscriber<E>
 {
 
 	@Override

src/main/java/org/scijava/event/bushe/AbstractEventServiceEvent.java

@@ -0,0 +1,56 @@
+/**
+ * Copyright 2005 Bushe Enterprises, Inc., Hopkinton, MA, USA, www.bushe.com
+ *
+ * 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.scijava.event.bushe;
+
+/**
+ * Convenience base class for EventServiceEvents in the application. Provides the convenience of
+ * holding the event source publication and event status.  It is not necessary to use this event class when 
+ * using an EventService.
+ *
+ * @author Michael Bushe michael@bushe.com
+ */
+public abstract class AbstractEventServiceEvent implements EventServiceEvent, PublicationStatusTracker {
+
+   private Object source = null;
+   protected final Object stateLock = new Object();
+   private PublicationStatus publicationStatus = PublicationStatus.Unpublished;
+
+   /**
+    * Default constructor
+    *
+    * @param source the source of the event
+    */
+   public AbstractEventServiceEvent(Object source) {
+      this.source = source;
+   }
+
+   /** @return the source of this event */
+   public Object getSource() {
+      return source;
+   }
+
+   public PublicationStatus getPublicationStatus() {
+      synchronized (stateLock) {
+         return publicationStatus;
+      }
+   }
+
+   public void setPublicationStatus(PublicationStatus status) {
+      synchronized (stateLock) {
+         publicationStatus = status;
+      }
+   }
+}

src/main/java/org/scijava/event/bushe/CleanupEvent.java

@@ -0,0 +1,62 @@
+/**
+ * Copyright 2007 Bushe Enterprises, Inc., Hopkinton, MA, USA, www.bushe.com
+ *
+ * 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.scijava.event.bushe;
+
+/**
+ * Published when the ThreadSafeEventService cleans up stale subscribers.
+ * @author Michael Bushe
+ */
+public class CleanupEvent {
+
+   /** The status of the cleanup.*/
+   public enum Status {
+      /** Timer has started the cleanup task. Will be followed by at least one more CleanupEvent.*/
+      STARTING,
+      /** Task has determined there's cleanup to do.*/
+      OVER_STOP_THRESHOLD_CLEANING_BEGUN, 
+      /** Task has determined there's no cleanup to do.*/
+      UNDER_STOP_THRESHOLD_CLEANING_CANCELLED, 
+      /** Finished cleaning up task.*/
+      FINISHED_CLEANING;
+   }
+   
+   private Status status;
+   private int totalWeakRefsAndProxies;
+   private Integer numStaleSubscribersCleaned;
+   
+   public CleanupEvent(Status status, int totalWeakRefsAndProxies, Integer numStaleSubscribersCleaned) {
+      this.status = status;
+      this.totalWeakRefsAndProxies = totalWeakRefsAndProxies;
+      this.numStaleSubscribersCleaned = numStaleSubscribersCleaned;
+   }
+
+   public Status getStatus() {
+      return status;
+   }
+
+   /** Total weak refs and ProxySubscribers subscribed. */
+   public int getTotalWeakRefsAndProxies() {
+      return totalWeakRefsAndProxies;
+   }
+
+   /**
+    * Null unless status is FINISHED_CLEANING.
+    * @return the number of stale subscribers cleaned during the cleanup run.
+    */
+   public Integer getNumStaleSubscribersCleaned() {
+      return numStaleSubscribersCleaned;
+   }
+}

src/main/java/org/scijava/event/bushe/ContainerEventServiceAction.java

@@ -0,0 +1,71 @@
+/**
+ * Copyright 2005 Bushe Enterprises, Inc., Hopkinton, MA, USA, www.bushe.com
+ *
+ * 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.scijava.event.bushe;
+
+import java.awt.Component;
+import java.awt.event.ActionEvent;
+import javax.swing.ImageIcon;
+
+/**
+ * When fired, this action publishes an ActionEvent on a Container EventService.
+ * See {@link EventServiceAction} for more information.
+ * <p/>
+ * By default, the Container EventService is found by asking the ContainerEventServiceFinder to find the EventService
+ * for the source of the fired ActionEvent, which must be a java.awt.Component and contained in a hierarchy (the source
+ * must have been added to another Swing container).  If the action was on a button, this means the container hierarchy
+ * of the button is walked (up) until a ContainerEventServiceSupplier is found or until the top of the hierarchy is
+ * reached, at which point a ContainerEventService is created automatically on the fly via the top container's
+ * putClientProperty() method using the key {@link ContainerEventServiceFinder#CLIENT_PROPERTY_KEY_TOP_LEVEL_EVENT_SERVICE}.
+ * If the event is from a JPopupMenu then the popup menu's invoker's hierarchy is walked.
+ * <p/>
+ * To exhibit other behavior, override the getSwingEventService() to return another EventService. For example, the
+ * creator of a popup menu may pass itself to the ContainerEventServiceFinder to return a parent's EventService.
+ * <p/>
+ *
+ * @author Michael Bushe michael@bushe.com
+ * @see EventServiceAction for further documentation
+ * @see ContainerEventServiceFinder on how the service is found
+ */
+public class ContainerEventServiceAction extends EventServiceAction {
+   public ContainerEventServiceAction() {
+   }
+
+   public ContainerEventServiceAction(String actionName, ImageIcon icon) {
+      super(actionName, icon);
+   }
+
+   protected EventService getEventService(ActionEvent event) {
+      Component comp = null;
+      try {
+         if (event.getSource() instanceof Component) {
+            comp = (Component) event.getSource();
+         }
+         if (comp == null) {
+            if (getThrowsExceptionOnNullEventService()) {
+               throw new RuntimeException("ActionEvent source was null, could not find event bus, must override getContainerEventService in action with id:" + getName());
+            }
+         } else {
+            return ContainerEventServiceFinder.getEventService(comp);
+         }
+      } catch (ClassCastException ex) {
+         if (getThrowsExceptionOnNullEventService()) {
+            throw new RuntimeException("ActionEvent source was not a component (" + (comp == null ? "null" : comp.getClass() + "") + "), must override getContainerEventService in action with id:" + getName(), ex);
+         }
+      }
+      return null;
+   }
+}
+

src/main/java/org/scijava/event/bushe/ContainerEventServiceFinder.java

@@ -0,0 +1,84 @@
+/**
+ * Copyright 2005 Bushe Enterprises, Inc., Hopkinton, MA, USA, www.bushe.com
+ *
+ * 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.scijava.event.bushe;
+
+import java.awt.Component;
+import javax.swing.JComponent;
+import javax.swing.JPopupMenu;
+import javax.swing.RootPaneContainer;
+
+/**
+ * This class finds a component's container event service, and creates one if necessary and possible.
+ * <p/>
+ * A Container EventService is, unlike the EventBus, an EventService that is container specific, in other words, it is
+ * shared only amongst components within a container.  For example, a Form component can supply an EventService used
+ * only by components in the form.  The Form's components can publish value change events on their Container's Event
+ * Service.  The Form's Model and Validator may listen to these events to collect data and show errors, respectively.
+ * <p/>
+ * Most importantly, Container EventService's cuts down event traffic, avoid naming and listener clashes, promotes
+ * componentization, and splits events usage into logical subsets.
+ * <p/>
+ * The finder will walk up a component's hierarchy searching for a parent that implements ContainerEventServiceSupplier.
+ * If it find one, it returns it.  If it doesn't find one, the top level JComponent (specifically, the highest parent in
+ * the hierarchy, typically a JRootPane) has a client property added to it (if not already set) that has the value of a
+ * new SwingEventService, which is then returned.  The EventBus is never returned.
+ *
+ * @author Michael Bushe michael@bushe.com
+ */
+public class ContainerEventServiceFinder {
+   /** The client property used to put a new SwingEventService on top-level components. */
+   public static final String CLIENT_PROPERTY_KEY_TOP_LEVEL_EVENT_SERVICE = "ContainerEventServiceFinder.createdService";
+
+   /**
+    * Walks the component's parents until it find an ContainerEventServiceSupplier and returns the supplier's
+    * EventService.  If the component in the tree is a JPopupMenu, then the menu's invoker is walked.
+    *
+    * @param component any component
+    *
+    * @return the ContainerEventService of the nearest parent
+    */
+   public static EventService getEventService(Component component) {
+      while (component != null) {
+         if (component instanceof ContainerEventServiceSupplier) {
+            return ((ContainerEventServiceSupplier) component).getContainerEventService();
+         }
+         if (component instanceof JPopupMenu) {
+            component = ((JPopupMenu) component).getInvoker();
+         } else {
+            if (component.getParent() == null) {
+               //There is no supplier.  Instead of returning null, make an event service
+               //and stick it in the client properties of the top level container.
+               if (component instanceof RootPaneContainer) {
+                  component = ((RootPaneContainer) component).getRootPane();
+               }
+               if (!(component instanceof JComponent)) {
+                  return null;
+               }
+               JComponent jComp = ((JComponent) component);
+               SwingEventService eventService = (SwingEventService) jComp.getClientProperty(CLIENT_PROPERTY_KEY_TOP_LEVEL_EVENT_SERVICE);
+               if (eventService == null) {
+                  eventService = new SwingEventService();
+                  jComp.putClientProperty(CLIENT_PROPERTY_KEY_TOP_LEVEL_EVENT_SERVICE, eventService);
+               }
+               return eventService;
+            } else {
+               component = component.getParent();
+            }
+         }
+      }
+      return null;
+   }
+}