Merge branch 'ActionBuilderActionContext_improvements'

Author: ghidravore

Ghidra/Framework/Docking/src/main/java/docking/action/builder/AbstractActionBuilder.java

@@ -41,8 +41,15 @@
  *
  * @param <T> The type of DockingAction to build
  * @param <B> the Type of action builder
+ * @param <C> The type of ActionContext. By default, the ActionContext type always starts as
+ * the base ActionContext class.  If the client calls the {@link #withContext(Class)} method on 
+ * the builder, then that class (which must be a subclass of ActionContext) becomes the ActionContext
+ * type that will be used for future calls to the builder methods that take predicates with
+ * ActionContext (i.e. {@link #enabledWhen(Predicate)} and {@link #validContextWhen(Predicate)}. 
+ * This works by substituting a builder with a different ActionContext type when chaining after
+ * the {@link #withContext(Class)} call.
  */
-public abstract class AbstractActionBuilder<T extends DockingActionIf, B extends AbstractActionBuilder<T, B>> {
+public abstract class AbstractActionBuilder<T extends DockingActionIf, C extends ActionContext, B extends AbstractActionBuilder<T, C, B>> {
 
 	/**
 	 * Name for the {@code DockingAction}
@@ -54,6 +61,11 @@ public abstract class AbstractActionBuilder<T extends DockingActionIf, B extends
 	 */
 	protected String owner;
 
+	/**
+	 * Specifies the type of ActionContext that the built action works on.
+	 */
+	protected Class<? extends ActionContext> actionContextClass;
+
 	/**
 	 * The {@code KeyBindingType} for this {@code DockingAction}
 	 */
@@ -62,7 +74,7 @@ public abstract class AbstractActionBuilder<T extends DockingActionIf, B extends
 	/**
 	 * The callback to perform when the action is invoked
 	 */
-	protected Consumer<ActionContext> actionCallback;
+	protected Consumer<C> actionCallback;
 
 	/**
 	 * Description for the {@code DockingAction}.  (optional)
@@ -147,17 +159,17 @@ public abstract class AbstractActionBuilder<T extends DockingActionIf, B extends
 	/**
 	 * Predicate for determining if an action is enabled for a given context
 	 */
-	private Predicate<ActionContext> enabledPredicate;
+	private Predicate<C> enabledPredicate;
 
 	/**
 	 * Predicate for determining if an action should be included on the pop-up menu
 	 */
-	private Predicate<ActionContext> popupPredicate;
+	private Predicate<C> popupPredicate;
 
 	/**
 	 * Predicate for determining if an action is applicable for a given context
 	 */
-	private Predicate<ActionContext> validContextPredicate;
+	private Predicate<C> validContextPredicate;
 
 	/**
 	 * Builder constructor
@@ -167,6 +179,7 @@ public abstract class AbstractActionBuilder<T extends DockingActionIf, B extends
 	public AbstractActionBuilder(String name, String owner) {
 		this.name = name;
 		this.owner = owner;
+		this.actionContextClass = ActionContext.class;
 	}
 
 	/**
@@ -370,7 +383,8 @@ public B popupMenuGroup(String group) {
 	 * @see #popupMenuGroup(String)
 	 */
 	public B popupMenuGroup(String group, String subGroup) {
-		popupSubGroup = group;
+		popupGroup = group;
+		popupSubGroup = subGroup;
 		return self();
 	}
 
@@ -446,7 +460,8 @@ public B toolBarGroup(String group) {
 	 * @see #toolBarGroup(String)
 	 */
 	public B toolBarGroup(String group, String subGroup) {
-		toolBarSubGroup = group;
+		toolBarGroup = group;
+		toolBarSubGroup = subGroup;
 		return self();
 	}
 
@@ -484,7 +499,7 @@ public B keyBinding(String keyStrokeString) {
 	 * @param action the callback to execute when the action is invoked
 	 * @return this builder (for chaining)
 	 */
-	public B onAction(Consumer<ActionContext> action) {
+	public B onAction(Consumer<C> action) {
 		actionCallback = action;
 		return self();
 	}
@@ -501,7 +516,7 @@ public B onAction(Consumer<ActionContext> action) {
 	 *        enabled state
 	 * @return this builder (for chaining)
 	 */
-	public B enabledWhen(Predicate<ActionContext> predicate) {
+	public B enabledWhen(Predicate<C> predicate) {
 		enabledPredicate = predicate;
 		return self();
 	}
@@ -524,7 +539,7 @@ public B enabledWhen(Predicate<ActionContext> predicate) {
 	 * @return this builder (for chaining)
 	 * @see #popupMenuPath(String...)
 	 */
-	public B popupWhen(Predicate<ActionContext> predicate) {
+	public B popupWhen(Predicate<C> predicate) {
 		popupPredicate = predicate;
 		return self();
 	}
@@ -540,11 +555,68 @@ public B popupWhen(Predicate<ActionContext> predicate) {
 	 * validity for a given {@link ActionContext}
 	 * @return this builder (for chaining)
 	 */
-	public B validContextWhen(Predicate<ActionContext> predicate) {
+	public B validContextWhen(Predicate<C> predicate) {
 		validContextPredicate = predicate;
 		return self();
 	}
 
+	/**
+	 * Sets the specific ActionContext type to use for the various predicate calls 
+	 * ({@link #validContextWhen(Predicate)}, {@link #enabledWhen(Predicate)}, and 
+	 * {@link #popupWhen(Predicate)}).
+	 * <P>
+	 * In other words, this allows the client to specify the type of ActionContext that is valid for
+	 * the action being built.
+	 * <P>
+	 * To be effective, this method must be called  <b>before</b> setting any of the predicates 
+	 * such as the {@link #enabledWhen(Predicate)}.  Once this method is called you can define your
+	 * predicates using the more specific ActionContext and be assured your predicates will only
+	 * be called when the current action context is the type (or sub-type) of the context you have
+	 * specified here.
+	 * <P>
+	 * For example, assume you have an action that is only enabled when the context is of type
+	 * FooActionContext.  If you don't call this method to set the ActionContext type,  you would have
+	 * to write your predicate something like this:
+	 * <pre>
+	 * builder.enabledWhen(context -> {
+	 *     if (!(context instanceof FooContext)) {
+	 *         return false;
+	 *     }
+	 *     return ((FooContext) context).isAwesome();
+	 * });
+	 * </pre>
+	 * But by first calling the builder method <CODE>withContext(FooContext.class)</CODE>, you can 
+	 * simply write:
+	 *
+	 * <pre>
+	 * builder.enabledWhen(context -> return context.isAwesome() }
+	 * </pre>
+	 *
+	 * @param newActionContextClass the more specific ActionContext type.
+	 * @param <AC2> The new ActionContext type (as determined by the newActionContextClass) that
+	 * the returned builder will have.
+	 * @param <B2> the new builder type.
+	 * @return an ActionBuilder whose generic types have been modified to match the new ActionContext.
+	 * It still contains all the configuration that has been applied so far.
+	 */
+	@SuppressWarnings("unchecked")
+	public <AC2 extends ActionContext, B2 extends AbstractActionBuilder<T, AC2, B2>> B2 withContext(
+			Class<AC2> newActionContextClass) {
+
+		// To make this work, we need to return a builder whose ActionContext is AC2 and not AC
+		//    (which is what this builder is now)
+		//
+		// Since we "know" that the only thing that matters regarding the ActionContext type is that
+		// the template type (AC) must match the type of actionContextClass instance variable, we
+		// can get away with returning this same builder and casting it to be a builder with type 
+		// AC2 instead of AC.  We can do this since we set the actionContextClass below
+
+		actionContextClass = newActionContextClass;
+
+		B2 newSelf = (B2) self();
+		return newSelf;
+	}
+
 	protected void validate() {
 		if (actionCallback == null) {
 			throw new IllegalStateException(
@@ -566,14 +638,34 @@ protected void decorateAction(DockingAction action) {
 		}
 
 		if (enabledPredicate != null) {
-			action.enabledWhen(enabledPredicate);
+			action.enabledWhen(adaptPredicate(enabledPredicate));
 		}
 		if (validContextPredicate != null) {
-			action.validContextWhen(validContextPredicate);
+			action.validContextWhen(adaptPredicate(validContextPredicate));
 		}
 		if (popupPredicate != null) {
-			action.popupWhen(enabledPredicate);
+			action.popupWhen(adaptPredicate(popupPredicate));
+		}
+	}
+
+	/**
+	 * Since the built action will need a predicate that handles any action type, this method 
+	 * creates a predicate that adapts a user supplied predicate for a more specific ActionContext
+	 * to a general predicate that can accept any ActionContext.
+	 * @param predicate the client supplied predicate that expects a more specific ActionContext
+	 * @return a predicate that can handle any ActionContext
+	 */
+	@SuppressWarnings("unchecked")
+	private Predicate<ActionContext> adaptPredicate(Predicate<C> predicate) {
+		if (actionContextClass == ActionContext.class) {
+			// don't wrap the predicate if it doesn't need it
+			return (Predicate<ActionContext>) predicate;
 		}
+		// Convert a sub-classed ActionContext predicate to a plain ActionContext predicate
+		Predicate<ActionContext> predicateAdapter = (ac) -> {
+			return actionContextClass.isInstance(ac) && predicate.test((C) ac);
+		};
+		return predicateAdapter;
 	}
 
 	protected boolean isPopupAction() {

Ghidra/Framework/Docking/src/main/java/docking/action/builder/ActionBuilder.java

@@ -21,7 +21,7 @@
  * Builder for {@link DockingAction}s
  */
 public class ActionBuilder
-		extends AbstractActionBuilder<DockingAction, ActionBuilder> {
+		extends AbstractActionBuilder<DockingAction, ActionContext, ActionBuilder> {
 
 	/**
 	 * Builder constructor

Ghidra/Framework/Docking/src/main/java/docking/action/builder/MultiActionBuilder.java

@@ -26,7 +26,7 @@
  * Builder for {@link MultiActionDockingAction}
  */
 public class MultiActionBuilder
-		extends AbstractActionBuilder<MultiActionDockingAction, MultiActionBuilder> {
+		extends AbstractActionBuilder<MultiActionDockingAction, ActionContext, MultiActionBuilder> {
 	/**
 	 * List of actions for the the MultActionDockingAction
 	 */

Ghidra/Framework/Docking/src/main/java/docking/action/builder/MultiStateActionBuilder.java

@@ -27,7 +27,7 @@
  * @param <T> The action state type
  */
 public class MultiStateActionBuilder<T> extends
-		AbstractActionBuilder<MultiStateDockingAction<T>, MultiStateActionBuilder<T>> {
+		AbstractActionBuilder<MultiStateDockingAction<T>, ActionContext, MultiStateActionBuilder<T>> {
 
 	private BiConsumer<ActionState<T>, EventTrigger> actionStateChangedCallback;
 	private boolean performActionOnButtonClick;
@@ -77,7 +77,7 @@ public MultiStateActionBuilder<T> performActionOnButtonClick(boolean b) {
 	public MultiStateDockingAction<T> build() {
 		validate();
 		MultiStateDockingAction<T> action =
-			new MultiStateDockingAction<T>(name, owner, isToolbarAction()) {
+			new MultiStateDockingAction<>(name, owner, isToolbarAction()) {
 
 				@Override
 				public void actionStateChanged(ActionState<T> newActionState,

Ghidra/Framework/Docking/src/main/java/docking/action/builder/ToggleActionBuilder.java

@@ -21,7 +21,7 @@
  * Builder for {@link ToggleDockingAction}s
  */
 public class ToggleActionBuilder extends
-		AbstractActionBuilder<ToggleDockingAction, ToggleActionBuilder> {
+		AbstractActionBuilder<ToggleDockingAction, ActionContext, ToggleActionBuilder> {
 
 	/**
 	 * The initial toggle state for the action