The next step is, of course, to retrieve the list of Tweet entities from a Query entity. We do this by implementing the "createKeys" method from the ChildFactory class, like so:

  /**
    * Populate "list" with the Tweet entities corresponding
    * to the Query entity.
    * Note: this method is invoked automatically in a worker thread.
    * @param list the List of Tweet to populate.
    * @return true if we're all set, false to be called again later
    *   to fetch even more results.
    */
 @Override
  protected boolean createKeys(List<Tweet> list) {
    
    // Retrieve the "Reloadable" ability from the query object
    // (now, abilities are cool, aren't they?)
    Reloadable r = query.getLookup().lookup( Reloadable.class ); 

    if ( r != null )
    {
      try
      {
        r.reload(); 
      }
      catch( Exception e )
      {
        // Empty
      }
    }

    // Add all the tweets in the query to the list
    list.addAll( query.getTweets() ); 
    // Indicate that we're done
    return true; 
  }
  

So we have populated a list of Tweets entities from the Query entity. What now? Of course, we need to create visual representation for those, i.e., actually creating the list of children nodes from the list of entities. How do we do this? By overriding one more method of the ChildFactory class, of course, like so:

  @Override
  protected Node createNodeForKey(Tweet key) {
    return new TweetNode(key);
  }

Simple: for each Tweet entity that we added in the list in the "createKeys" method, the NetBeans Platform will invoke the "createNodeForKey" method and pass it the Tweet entity. All we have to do is to create a TweetNode from the Tweet entity, by using the TweetNode constructor that we built in the previous section. Oh, well, it isn't that complex, is it?

The final step is to associate the QueryNode with the QueryNodeChildFactory. We do this in the QueryNode constructor, passing it the QueryNodeChildFactory instead of the Children.LEAF constant we used previously for leaf nodes. The code looks like this.

**
 * QueryNode is a node that represents a query. The children of this
 *   node are the results of the query.
 * @author Antonio Vieiro (antonio@antonioshome.net)
 */
public final class QueryNode
  extends AbstractNode {

  private Query query;
  private InstanceContent instanceContent;

  /**
   * Public constructor from an entity.
   * @param query The entity that this node represents visually.
   */
  public QueryNode(Query query) { 
    this(query, new InstanceContent());
  }

  /**
   * Private constructor from an entity and an InstanceContent
   * @param query The entity that this node represents visually.
   * @param ic The InstanceContent object that keeps this node's abilities.
   */
  private QueryNode(Query query, InstanceContent ic) {
    // Invoke the super constructor, passing it a list of children 
    // to be retrieved with a QueryNodeChildFactory, and
    // a ProxyLookup that combines this node's abilities with the entity's
    super(Children.create(new QueryNodeChildFactory(query), true), 
      new ProxyLookup( // Combination of lookups 
        query.getLookup(), // The entitie's abilities
        new AbstractLookup(ic))); // This node's abilities
    // Keep the entity and the instancecontent on member variables
    this.query = query;
    this.instanceContent = ic;
    // Add a new ability for this node to be reloaded
    this.instanceContent.add(new ReloadableNode()  { 
      public void reloadChildren() throws Exception {
        // To reload this node just set a new set of children
        // using a QueryNodeChildFactory object, that retrieves
        // children asynchronously
        setChildren(
          Children.create(
            new QueryNodeChildFactory(QueryNode.this.query), 
            true));
      }
    });
  }