keyboardeventsource.java

Java 3D Desktop Environment旨在使用Java 3D来创建一个3D桌面环境。功能包括：分布式的应用程序

package org.j3de.events;

import java.awt.AWTEvent;
import java.awt.event.KeyEvent;
import java.util.Enumeration;
import java.util.Map;

import javax.media.j3d.BoundingSphere;
import javax.media.j3d.Behavior;
import javax.media.j3d.WakeupCondition;     
import javax.media.j3d.WakeupCriterion;
import javax.media.j3d.WakeupOnAWTEvent;    
import javax.media.j3d.WakeupOr;

import javax.swing.event.EventListenerList;

import javax.vecmath.Point3d;

import org.w3c.dom.NamedNodeMap;
import org.w3c.dom.Node; 
import org.w3c.dom.Document;
import org.w3c.dom.Element;

import org.j3de.action.Action;
import org.j3de.action.DocumentManipulationAction;
import org.j3de.action.DocumentManipulator;
import org.j3de.exception.ExceptionHandler;
import org.j3de.input.HasBehavior;
import org.j3de.util.AbstractComponent;
import org.j3de.util.ConfigurationException;     
import org.j3de.util.EntryFactory;

public class KeyboardEventSource extends AbstractComponent implements EventSource, HasBehavior {
  private EventListenerList dispatcherList;
  private Map               actions;
  private WakeupCondition   keyCriterion;
  
  public KeyboardEventSource() {
    dispatcherList = new EventListenerList();
  }
  
  public void addJ3deEventDispatcher(J3deEventDispatcher dispatcher) {     
    dispatcherList.add(J3deEventDispatcher.class, dispatcher);
  }
  
  public void removeJ3deEventDispatcher(J3deEventDispatcher dispatcher) {
    dispatcherList.remove(J3deEventDispatcher.class, dispatcher);
  }
  
  protected void fireActionEvent(Action event) {
    // Guaranteed to return a non-null array
    Object[] listeners = dispatcherList.getListenerList();
    
    // Process the listeners last to first, notifying
    // those that are interested in this event
    for (int i = listeners.length-2; i>=0; i-=2) {
      if (listeners[i]==J3deEventDispatcher.class) {         
        try {                 
          ((J3deEventDispatcher)listeners[i+1]).dispatchEvent(event); 
        } catch (Exception e) {
          ExceptionHandler.handleException(e);
        }
      }
    }
  }          

  private void processKeyEvent(KeyEvent event) {  
    int modifiers = event.getModifiers();
    String keytext;
    
    // if (modifiers != 0)
    // The line above causes problems on linux, where modifiers == 16, but modifiers text is empty :(
  
    if (!KeyEvent.getKeyModifiersText(modifiers).equals(""))
      keytext = KeyEvent.getKeyModifiersText(modifiers) + "+" + KeyEvent.getKeyText(event.getKeyCode());
    else
      keytext = KeyEvent.getKeyText(event.getKeyCode());
    
    DocumentManipulationAction action = (DocumentManipulationAction)actions.get(keytext);
    
    if (action != null) 
      fireActionEvent(action);  
    else
      System.out.println("key-event not handled : " + keytext);
    
  }     
 
  public void configure(Node node, Document nodeFactory)  throws ConfigurationException {  
    super.configure(node, nodeFactory);     
    
    actions = helper.getMap("keyactions", 
      new EntryFactory() {
        public Object createEntry(Node node) {     
          NamedNodeMap attributes = node.getAttributes();    
          String value = attributes.getNamedItem("action").getNodeValue();   
          
          
          if (value.equals("stringinput")) {
            String text = attributes.getNamedItem("value").getNodeValue();
            return new TypeAction(text);
          } else if (value.equals("delete")) {
            int numChars = Integer.parseInt(attributes.getNamedItem("value").getNodeValue());
            return new DeleteAction(numChars);
          }
          
          return null; 
        }
      }); 
      
  }
  
  public Behavior getBehavior() {
    return new Behavior() {  
    
      public void initialize() {
        setSchedulingBounds(new BoundingSphere(new Point3d(0.0,0.0,0.0), 100.0));
        
        WakeupCriterion[] keyEvents = new WakeupCriterion[1];

        keyEvents[0] = new WakeupOnAWTEvent(KeyEvent.KEY_RELEASED);
        keyCriterion = new WakeupOr(keyEvents);
        wakeupOn(keyCriterion); 
      } 
   
      public synchronized void processStimulus(Enumeration criteria) {     
        WakeupCriterion wakeup;
        AWTEvent[] event;
      
        while(criteria.hasMoreElements()) {
          wakeup = (WakeupCriterion) criteria.nextElement();
        
          if( !(wakeup instanceof WakeupOnAWTEvent) )
            continue;
      
          event = ((WakeupOnAWTEvent)wakeup).getAWTEvent();
          for (int i=0; i<event.length; i++) {
            if ((event[i].getID() == KeyEvent.KEY_RELEASED)) {
              processKeyEvent((KeyEvent)event[i]);
            }
          }
        }
        wakeupOn(keyCriterion);
      } 
    }; 
    
  }               
  
  private class TypeAction extends DocumentManipulationAction {
    private String text;
    
    public TypeAction(String text) {
      this.text = text;
    }                  
    
    public void performAction(DocumentManipulator document) {
      document.insertText(text);
    }
  }  
  
  private class DeleteAction extends DocumentManipulationAction {
    private int numChars;
    
    public DeleteAction(int numChars) {
      this.numChars = numChars;
    }                          
    
    public void performAction(DocumentManipulator document) {
      document.deleteChars(numChars);
    }
  }    
 
}