Added support for slots, which is a powerful new way to inject and override view content from the controller.

Author: shannah

.idea/workspace.xml

@@ -0,0 +1,10 @@
+package com.codename1.rad.attributes;
+
+import com.codename1.rad.controllers.ViewController;
+import com.codename1.rad.models.Attribute;
+
+public class ViewControllerAttribute extends Attribute<ViewController> {
+    public ViewControllerAttribute(ViewController value) {
+        super(value);
+    }
+}

common/src/main/java/com/codename1/rad/attributes/ViewControllerAttribute.java

@@ -85,6 +85,13 @@ public static void dispatchEvent(ActionEvent evt) {
             }
         }
     }
+
+    public static <T extends ActionEvent>  T as(ActionEvent e, Class<T> type) {
+        if (type.isAssignableFrom(e.getClass())) {
+            return (T)e;
+        }
+        return null;
+    }
 
 
 

common/src/main/java/com/codename1/rad/controllers/ActionSupport.java

@@ -160,4 +160,36 @@ public Form getCurrentForm() {
     }
     public static class StopEvent extends ApplicationEvent{}
     public static class DestroyEvent extends ApplicationEvent{}
+
+    public FormController getCurrentFormController() {
+        Form f = CN.getCurrentForm();
+        if (f == null) {
+            return null;
+        }
+        ViewController vc = ViewController.getViewController(f);
+        if (vc == null) {
+            return null;
+        }
+        return vc.getFormController();
+    }
+
+    public String getCurrentPath() {
+        FormController fc = getCurrentFormController();
+        if (fc == null) {
+            return "";
+        }
+        return fc.getPathString("/");
+    }
+
+    private FormController currentFormController;
+
+    @Override
+    public void actionPerformed(ControllerEvent evt) {
+        super.actionPerformed(evt);
+        if (!evt.isConsumed()) {
+            evt.as(FormController.FormShownEvent.class, fse -> {
+                currentFormController = fse.getSourceFormController();
+            });
+        }
+    }
 }

common/src/main/java/com/codename1/rad/controllers/ApplicationController.java

@@ -5,14 +5,19 @@
  */
 package com.codename1.rad.controllers;
 
+import com.codename1.rad.events.FillSlotEvent;
 import com.codename1.rad.models.Entity;
+import com.codename1.rad.models.Tag;
 import com.codename1.rad.nodes.ActionNode;
 import com.codename1.rad.nodes.ActionNode.ActionNodeEvent;
-import com.codename1.rad.nodes.Node;
 import com.codename1.rad.nodes.ViewNode;
 import com.codename1.rad.ui.EntityView;
+import com.codename1.rad.ui.Slot;
+import com.codename1.ui.Component;
 import com.codename1.ui.events.ActionListener;
 import com.codename1.ui.util.EventDispatcher;
+import com.codename1.util.SuccessCallback;
+
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;
@@ -142,6 +147,8 @@ public void addActionListener(ActionNode action, ActionListener<ActionNodeEvent>
         addEventListener(h.wrapperListener);
 
     }
+
+
 
     public void removeActionListener(ActionNode action, ActionListener<ActionNodeEvent> l) {
         ActionHandler h = findActionHandler(action, l);
@@ -303,6 +310,12 @@ public <T> T lookup(Class<T> type) {
         return null;
     }
 
+    /**
+     * Obtains a lookup as an entity.  This is a a convenient wrapper around {@link #lookup(Class)} that can
+     * be used in cases where you expect to receive an Entity.
+     * @param type
+     * @return
+     */
     public Entity lookupEntity(Class type) {
         return (Entity)lookup(type);
     }
@@ -319,13 +332,117 @@ public void addLookup(Object obj) {
         lookups.put(obj.getClass(), obj);
     }
 
+    /**
+     * Adds a lookup with a specific clas as a key.
+     * @param type The class to use as the key of the lookup.
+     * @param object The value of the lookup.
+     * @param <T> The type of object.
+     */
     public <T> void addLookup(Class<T> type, T object) {
         if (object == null) return;
         if (lookups == null) {
             lookups = new HashMap<>();
         }
         lookups.put(type, object);
     }
+
+    /**
+     * Looks up an object starting at the parent controller.
+     * @param type The type of object to lookup.
+     * @param <T> The type of object to lookup.
+     * @return A matching object or null.
+     */
+    public <T> T parentLookup(Class<T> type) {
+        if (parent == null) {
+            return null;
+        }
+        return parent.lookup(type);
+    }
+
+    /**
+     * Looks up an entity starting at the parent controller.
+     * @param type The type of the entity to look for.
+     * @return A matching Entity or null.
+     */
+    public Entity parentLookupEntity(Class type) {
+        if (parent == null) return null;
+        return parent.lookupEntity(type);
+    }
+
+    /**
+     * Calls {@link #withLookup(Class, SuccessCallback)} on the parent controller.
+     * @param type The type of object we're looking for.
+     * @param callback Callback executed only if lookup finds something.
+     * @param <T> The type of object to look for.
+     * @return True if lookup finds something.
+     */
+    public <T> boolean withParentLookup(Class<T> type, SuccessCallback<T> callback) {
+        T o = parentLookup(type);
+        if (o == null) return false;
+        callback.onSucess(o);
+        return true;
+    }
+
+    /**
+     * Calls {@link #lookupEntity(Class)} on the Parent controller.
+     * @param type The typeof entity to look for.  This may also be an Interface.
+     * @param callback Callback executed only if a matching entity is found.
+     * @return True if entity is found.
+     */
+    public boolean withParentLookupEntity(Class type, SuccessCallback<Entity> callback) {
+        Entity o = parentLookupEntity(type);
+        if (o == null) return false;
+        callback.onSucess(o);
+        return true;
+
+    }
+
+    /**
+     * Does lookup for object of given type.  If found, it passes it to the given callback.
+     * @param type The type of object to lookup.
+     * @param callback Callback executed only if the lookup is found.
+     * @param <T> The type of object to look for.
+     * @return True if the lookup is found.
+     */
+    public <T> boolean withLookup(Class<T> type, SuccessCallback<T> callback) {
+        T o = lookup(type);
+        if (o == null) return false;
+        callback.onSucess(o);
+        return true;
+    }
+
+    /**
+     * Looks up an entity of a given class, and executes the provided callback with it if the
+     * entity is found.
+     * @param type A type of entity.  This may be a Class or an Interface.
+     * @param callback  Call back that is only called if the lookup finds a match.
+     * @return Boolean returns true if the lookup was found.
+     */
+    public boolean withLookupEntity(Class type, SuccessCallback<Entity> callback) {
+        Entity o = lookupEntity(type);
+        if (o == null) return false;
+        callback.onSucess(o);
+        return true;
+
+    }
+
+    /**
+     * Adds a listener to be notified when the Slot placeholder with the given ID is requesting to be filled.
+     * @param slotId The ID of the slot that you wish to fill with this handler.
+     * @param l Listener that is called when a slot with the given ID is requesting to be filled.  To set content in the slot
+     *          you can obtain a reference to the slot via {@link FillSlotEvent#getSlot()} and call {@link Slot#setContent(Component)}
+     *          on it.  *Make sure you call {@link FillSlotEvent#consume()} if you set the content to prevent the event
+     *          from bubbling up the controller hierarchy and being overridden by another controller.*
+     */
+    public void fillSlot(Tag slotId, ActionListener<FillSlotEvent> l) {
+        addEventListener(evt -> {
+            FillSlotEvent fse = evt.as(FillSlotEvent.class);
+            if (fse != null && fse.getSlot().getId() == slotId) {
+                l.actionPerformed(fse);
+            }
+        });
+    }
+
 
 
 }

common/src/main/java/com/codename1/rad/controllers/Controller.java

@@ -5,14 +5,21 @@
  */
 package com.codename1.rad.controllers;
 
+import com.codename1.ui.CN;
+import com.codename1.ui.Component;
+import com.codename1.ui.Form;
 import com.codename1.ui.events.ActionEvent;
+import com.codename1.util.AsyncResource;
+import com.codename1.util.SuccessCallback;
 
 /**
  * A base event for all controller events.  This is the fundamental building block for how information
  * propagates up the controller hierarchy from views or child-controllers.
  * @author shannah
  */
 public class ControllerEvent extends ActionEvent {
+
+    private AsyncResource asyncResource;
 
     /**
      * Creates a new controller event.
@@ -41,5 +48,63 @@ public <T extends ControllerEvent> T as(Class<T> type) {
         }
         return null;
     }
+
+    public <T extends ControllerEvent> boolean as(Class<T> type, SuccessCallback<T> callback) {
+        T cevt = as(type);
+        if (cevt == null) return false;
+        callback.onSucess(cevt);
+        return true;
+    }
+
+    public <T extends AsyncResource> T getAsyncResource(Class<T> type) {
+        if (!isConsumed() || asyncResource == null || !type.isAssignableFrom(asyncResource.getClass())) {
+           return null;
+        }
+        return (T) asyncResource;
+    }
+
+    public void setAsyncResource(AsyncResource task) {
+        asyncResource = task;
+    }
+
+    public AsyncResource getAsyncResource() {
+        return asyncResource;
+    }
+
+    public ViewController getViewController() {
+        Component cmp = getComponent();
+        if (cmp == null) {
+            return null;
+        }
+        return ViewController.getViewController(cmp);
+    }
+
+    public FormController getFormController() {
+        ViewController ctl = getViewController();
+        if (ctl == null) return null;
+        return ctl.getFormController();
+    }
+
+    public AppSectionController getAppSectionController() {
+        ViewController ctl = getViewController();
+        if (ctl == null) return null;
+        return ctl.getSectionController();
+    }
+
+    public ApplicationController getApplicationController() {
+        ViewController ctl = getViewController();
+        if (ctl == null) {
+            Form f = CN.getCurrentForm();
+            if (f == null) {
+                return null;
+            }
+            ctl = ViewController.getViewController(f);
+
+        }
+
+        if (ctl == null) return null;
+        return ctl.getApplicationController();
+    }
+
 
 }