ConversionApplet Code

// A G E N T
// .   .   .

// ConversionApplet.java

// (c) Andy Wood, Anind Dey ... 1996


// ****************************************************************************

package cyberdesk.acton.convert;

import java.awt.*;
import java.util.*; 
import java.applet.*;

import cyberdesk.cameo.*;


// ****************************************************************************

public abstract class ConversionApplet extends Applet
                                       implements CameoObject, CameoSubject, CameoHandler
  {
  private CameoCommunicate   comm;
  private CameoObjectImpl    cameo;
  private CameoLocator       locator;
  private Vector             selects;
  private Object             selectref = null;

  public void init()
    {
    CameoInterface[] interfaces = new CameoInterface[ 1 ];  
    interfaces[ 0 ] = new CameoInterface( "select", null );  
    cameo = new CameoObjectImpl( this, interfaces, true );
    System.out.println("CONVERSIONAPPLET: cameo set - "+this);
  
    locator = cameo.getLocator();
    comm = new CameoCommunicate( this );
    comm.observing( locator, new CameoMessage(), this );
    selects = locateInterfaces( "select" );
    startObserving();
    }


  protected Vector locateInterfaces( String interfaze )
    {
    Vector interfaces = null;

    CameoMessage msg = new CameoMessage();
    msg.setField( msg.PROPERTY, "locate" );
    msg.setField( locator.INTERFACES, interfaze );
    msg = comm.manipulate( locator, msg );

    Object obj = msg.getField( locator.ID );

    if ( obj != null )
      {
      if ( obj instanceof Vector )
        {
        interfaces = (Vector)obj;
        System.out.println("ConversionApplet: lots of " + interfaze + "s" );
        }
      else
        {
        interfaces = new Vector();
        interfaces.addElement( obj );
        System.out.println("ConversionApplet: one " + interfaze );
        }
      }
    else
      {
      // No objects with that interface found - just create empty Vector
      interfaces = new Vector();
      System.out.println("ConversionApplet: no " + interfaze + "s" );
      }

    return interfaces;
    }

// not observing service applets

  protected void startObserving()
    {
    Enumeration f = selects.elements();
    for ( Enumeration e = selects.elements(); e.hasMoreElements(); )
      {
      System.out.println("ConversionApplet: observing "+f.nextElement() );
      if ( selectref == null )
        selectref = comm.observing( (CameoObject)e.nextElement(), new CameoMessage(), this );
      else
        comm.observing( (CameoObject)e.nextElement(), new CameoMessage(), selectref );
      }
    }


  protected abstract boolean weCanConvert( Object data );

  protected abstract boolean potentialLoop( ConversionInfo pathelement );

  protected abstract Object  tryToConvert( Object data ) throws CouldNotConvertException;


  protected void convert( CameoMessage msg )
    {
StringBuffer sb = new StringBuffer(this +" ConversionApplet: SELECTS\n");
for ( Enumeration f = selects.elements(); f.hasMoreElements(); ) {
  sb.append(f.nextElement() + " ");
}
sb.append("\n");

sb.append(this+ " ConversionApplet: OBSERVERS\n");
CameoObservers ob = cameo.getObservers();
Hashtable hs = ob.getHash();
for (Enumeration f = hs.keys(); f.hasMoreElements(); ) {
  sb.append(f.nextElement() + " ");
}
sb.append("\n");
System.out.println(sb);

    Object data = msg.getField( msg.DATA );

    if ( weCanConvert( data ) )
      {
      boolean convert = true;
      Vector path = ( Vector )msg.getField( msg.PATH );
    
      // Loop through looking for previous instances of the same type
      // to stop us getting into a continuous loop.

      if ( path != null )
        {
        for ( Enumeration e = path.elements(); e.hasMoreElements(); )
          {
          if ( potentialLoop( (ConversionInfo)e.nextElement() ) )
            convert = false;
          }
        }

      // If we're OK to convert - do it!

      if ( convert )
        {
        try
          {
          CameoMessage converted = new CameoMessage();
          converted.setField( converted.PROPERTY, "selection" );
          converted.setField( converted.DATA, tryToConvert( data ) );

          Vector newpath;
          ConversionInfo info = new ConversionInfo( data, this );

          if ( path == null )
            newpath = new Vector();
          else
            // We clone here because there maybe many data conversion paths being followed
            newpath = (Vector)path.clone();

          newpath.addElement( info );
          converted.setField( converted.PATH, newpath );

          System.out.println("ConversionApplet: called observed " + data );
          CameoObservers obs = cameo.getObservers();
          cameo.getObservers().observed( converted );
          }
        catch ( CouldNotConvertException e )
          {
          // Oh well, we tried!
          }
        }
      }
    }


  public void handle( CameoMessage msg )
    {
    if ( msg.getField( msg.INREPLYTO ).equals( selectref ) )
      {
      // when "select" OBSERVED
      convert( (CameoMessage)msg.getField( msg.CONTENT ) );
      }
    else
      {
      CameoMessage content = (CameoMessage)msg.getField( msg.CONTENT );

      if ( content.getField( msg.PROPERTY ).equals( "insert" ) )
        {
        Object app = content.getField( locator.ID );
        System.out.println("ConversionApplet: new entity added - " + app );
        // different entity added to the system
        // add to selects? - and start observing?
        // or add to methods, for use in buttons...
        }     
      else if ( content.getField( msg.PROPERTY ).equals( "remove" ) )
        {
        Object app = content.getField( locator.ID );
        // different entity removed from the system
        // if in selects stop observing? - but it does that anyway
        // by its destruction? - remove from selects though
        }
      }
    }


  public void observed( CameoMessage msg )
    {
    System.out.println("ConversionApplet has observed" );
    try { comm.handleMessage( msg ); } catch (NullInReplyToException e) {}
    }

  public void examined( CameoMessage msg )
    {
    System.out.println("ConversionApplet has examined" );
    try { comm.handleMessage( msg ); } catch (NullInReplyToException e) {}
    }
    
  public void manipulated( CameoMessage msg )
    {
    System.out.println("ConversionApplet has manipulated" );
    try { comm.handleMessage( msg ); } catch (NullInReplyToException e) {}
    }

  public void manipulate( CameoMessage msg )
    {
    }

  public void examine( CameoMessage msg )
    {
    System.out.println("EXAMINED: " + this);
    cameo.examine( msg );
    }


  public void observe(CameoMessage msg)
    {
    cameo.observe(msg);
    }


  public void observing(CameoMessage msg)
    {
    System.out.println("#####being observed: "+this);
    cameo.observing(msg);
    }


  public void notobserving(CameoMessage msg)
    {
    cameo.notobserving(msg);
    }


  public boolean action(Event event, Object what)
    {
    return false;
    }
  }

// ****************************************************************************