//
// PROTO definitions used in example
//
/*
PROTO StartButton [
    eventOut     SFTime  startTime
] { ... }

PROTO StopButton [
    eventOut     SFTime  stopTime 
] { ... }

PROTO Glow [
   eventOut  SFFloat transparency 
] { ... }

PROTO SpinBox [
    field    SFFloat   radius  2
    exposedField SFFloat transparency  0.0
    eventIn SFFloat set_glow                     
    exposedField SFTime  startTime     0.0
    exposedField SFTime  stopTime      0.0
] { ... }
*/

/*
#
# Main scene - Composition
#
Group {
    children [

      Transform {
        translation 0.0 -2.0 0.0 
          children [
            DEF Spin SpinBox {
              radius  2
              transparency  0.0
              startTime     0.0
              stopTime      0.0
            }
          ]
        }

      Transform {
        translation 0.0 3.0 0.0 
          children [
            DEF GL Glow { transparency 0 }
          ]
      }

      Transform {
        translation -4.0 0.0 0.0
          children [
            DEF Start StartButton { startTime 0.0 }
          ]
      }

      Transform {
        translation 4.0 0.0 0.0
        children [
          DEF Stop StopButton { stopTime 0.0 }
        ]
      }

    ]
}


ROUTE Start.startTime        TO Spin.set_startTime
ROUTE Stop.stopTime         TO Spin.set_stopTime
ROUTE GL.transparency        TO Spin.set_transparency
ROUTE GL.transparency        TO Spin.set_glow
*/


//----------------------------------------------------// 
// Connecting StartButton button StartTimeEvent event to SpinBox.
// To receive start time events SpinBox registers itself as 
// StartTimeEventListener in StartButton bean :

StartButton startButton = new StartButton(protoNode);
SpinBox spinBox = new SpinBox(protoNode);

// the following implements: "ROUTE Start.startTime  TO Spin.set_startTime"
startButton.addStartTimeEventListener(spinBox);

//----StartButton bean----//

/**
 * Concrete bean class (auto-generated).
 * Implements StartButton vrml-PROTO interface
 *
 * Vrml interface :
 * PROTO StartButton [
 *   eventOut     SFTime                 startTime
 *   #..... other EventOuts, such as :
 *   #eventOut    someOtherEventOutType  someOtherEventOutName
 * ] { ... }
 *
 * 
 */
 */
public class StartButtonImpl implements EventOutObserver {

  // Listener vectors. One vector for each listener type. 
  // ** Different EventOut types have different event listener types ** :

  Vector startTimeListenerVec = new Vector();
  //...
  //Vector someEventNameListenerVec = new Vector();

  // Proto bean costructor initialized with corresponding proto node object:

  public StartButtonImpl(Node protoNode) {
    // A set of "advise(this, ...)" methods which
    // create "startTime" and other EventOut observers,
    // one "advise" method for each EventOut observer

    protoNode.getEventOut("startTime_changed").advise(this, "startTime");
    //...
    protoNode.getEventOut("<someOtherEventOut>_changed").advise(this, "someOtherEventOut");
  } 

  /**
   * EAI EventOut Observer. Used to observe all Proto Bean EventOut-s
   */
  public void callback(EventOut value, 
		       double timeStamp, 
		       Object data) {

    if(data.equals("startTime")) {
      double time = ((EventOutSFTime)value).getValue();
      StartTimeEvent evt = StartTimeEvent(this, time);
      fireStartTimeEvent(evt);
    } else if(data.equals("someOtherEventOut")) {
      //...
    }
  }

  // A set of "fireEventName" methods to notify listeners that
  // that corresponding "EventOut" has generated a new event 
  
  //public void fireSomeEventName(SomeEventName evt) {..}
  //...
  /**
   * Fire StartTimeEvent to the listener
   */
  public void fireStartTimeEvent(StartTimeEvent evt) {

    // enumerate listeners 
    for (Enumeration e = startTimeListenerVec.elements(); 
	 e.hasMoreElements();) {
      StartTimeEventListener l = (StartTimeEventListener)e.nextElement();

      // notify listener
      l.handleStartTimeEventIn(evt);
    }
  }

  // EventListener registration methods 
  // conform to the following design patterns :
  //
  // public void add< ListenerType>(< ListenerType> listener);
  // public void remove< ListenerType>(< ListenerType> listener);
 
  public void addStartTimeEventListener(StartTimeEventListener l) {
    //...
  }

  public void removeStartTimeEventListener(StartTimeEventListener l) {
    //...
  }
}


/**
 * StartTimeEvent 
 * Concrete class (auto-generated). 
 */
public class StartTimeEvent extends SFTimeEvent {

  // constructs a new StartTimeEvent
  StartTimeEvent(java.awt.Component source, double time) {
    super(source, time);
  }
}

/**
 * Interface for a listener of StartTimeEvent events. 
 */
public inetrface StartTimeEventListener extends java.util.EventListener {

  /**
   * Event handling method.
   * This method is called by **event source** to set new time value in EventIn,  
   * specified by "eventIn SFTime set_startTime" declaration in VRML PROTO interface.
   * Default implementation calls "setStartTime(SFTime time)", 
   * thus sending new value to EventIn
   */
  void handleStartTimeEventIn(StartTimeEvent evt);
}

//----SpinBox bean----//
/*

*/

/**
 * Concrete bean class (auto-generated). 
 * Implements SpinBox vrml-PROTO interface.
 *
 * PROTO SpinBox [
 *   exposedField SFFloat transparency  0.0
 *   eventIn SFFloat set_glow                     
 *   exposedField SFTime  startTime     0.0
 *   exposedField SFTime  stopTime      0.0
 * ] { ... }
 *
 * Example below shows only code generated for "set_startTime" EventIn
 */
public class SpinBoxImpl implements StartTimeEventListener {

  // Proto bean costructor initialized with corresponding proto node object:
  public SpinBoxImpl(Node protoNode) {
    //...
  }

  // StartTimeEventListener event handling method implementation

  void handleStartTimeEventIn(StartTimeEvent evt) {
    SFTime time = evt.getSFTime(); //get SFTime value of this event
    setStartTime(time); //send new value to EventIn
  }

/**
 * This methods sends new value to set_startTime EventIn
 *
 * When eventIn "setter" method is called, input event is sent to the eventIn of
 * the corresponding node. Design pattern for setting EventIn :
 *
 * public void set<EventInName>(<EventInType> eventInValue); 
 */
  public void setStartTime(SFTime time) {
    // generated code here obtains instance of set_startTime EventIn (by means of EAI)
    // and sends new value to it
  }

}

/**
 * VRML Time Event
 */
public class SFTimeEvent extends java.util.EventObject {

  // constructs a new SFTimeEvent
  SFTimeEvent(java.awt.Component source, double time) {
    super(source);
    this.value = time;
  }

  /**
   * @return  VRML "Time" value ( may be set from EventOutSFTime)
   */
  public SFTime getSFTime() {
    ...
  }
}