defaulttextfield3d.java

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

package org.j3de.ui.impl;         

import java.rmi.RemoteException;
                                   
import javax.media.j3d.Bounds;
import javax.media.j3d.BoundingBox;
import javax.media.j3d.BranchGroup;
import javax.media.j3d.Font3D;    
import javax.media.j3d.Node;
import javax.media.j3d.Shape3D;    

import javax.vecmath.Point3d;

import javax.swing.event.ChangeListener;
import javax.swing.event.ChangeEvent;

import org.j3de.action.DocumentManipulator;   
import org.j3de.datamodel.RemoteObjectModel;  
import org.j3de.events.J3deFocusListener;
import org.j3de.exception.ExceptionHandler; 
import org.j3de.ui.Skin;
import org.j3de.ui.SkinException;
import org.j3de.ui.TextField3D;   
import org.j3de.ui.UIElement;
import org.j3de.ui.UIGeometry;
import org.j3de.ui.skin.SkinFontTextField;   
import org.j3de.ui.skin.SkinGeometryTextFieldBox;
import org.j3de.ui.skin.SkinAppearanceTextFieldBox;   
import org.j3de.ui.skin.SkinAppearanceTextFieldText;   
import org.j3de.ui.skin.SkinFontFocusedTextField;   
import org.j3de.ui.skin.SkinGeometryFocusedTextFieldBox;
import org.j3de.ui.skin.SkinAppearanceFocusedTextFieldBox;   
import org.j3de.ui.skin.SkinAppearanceFocusedTextFieldText;   

public class DefaultTextField3D extends AbstractUIText {   
  private static final int BOX_APPEARANCE  = 0;
  private static final int BOX_GEOMETRY    = 1;
  private static final int TEXT_APPEARANCE = 2;
  private static final int TEXT_FONT       = 3;
  
  private static final Class[] NORMAL_SKIN = {  
    SkinAppearanceTextFieldBox.class,
    SkinGeometryTextFieldBox.class,
    SkinAppearanceTextFieldText.class,  
    SkinFontTextField.class
  };
  
  private static final Class[] FOCUSED_SKIN = {  
    SkinAppearanceFocusedTextFieldBox.class,
    SkinGeometryFocusedTextFieldBox.class,
    SkinAppearanceFocusedTextFieldText.class,  
    SkinFontFocusedTextField.class
  };
  
  private Shape3D box;
  private BranchGroup bg;
  private int maxChars;
  private RemoteTextField3D remoteTextField;
  private DefaultTextFieldUserData userData;
  
  private Class[] skinClasses = NORMAL_SKIN;
        
  
  public DefaultTextField3D() {  
    super();
    userData = getUserData();
    box = new Shape3D(); 
    box.setUserData(userData);  
    box.setCapability(Shape3D.ALLOW_APPEARANCE_WRITE);
    box.setCapability(Shape3D.ALLOW_GEOMETRY_WRITE);    
    
    setRemoteObjectModel(userData);
       
    bg = new BranchGroup();
    bg.addChild(box);  
    bg.addChild(super.getNode());
    bg.setBoundsAutoCompute(false);
    bg.setCapability(BranchGroup.ALLOW_BOUNDS_WRITE);
    bg.setCapability(BranchGroup.ALLOW_BOUNDS_READ);
    maxChars = 15;       
      
    remoteTextField = new RemoteTextField3D();  
  } 

  protected DefaultTextFieldUserData getUserData() {
    return new DefaultTextFieldUserData();
  }

  protected void updateBounds() {
    if (bg != null) {
      bg.setBounds(this.getBounds());
    }
    super.updateBounds();
  }

  public UIElement getRemoteElement() {
    return remoteTextField;
  }  
  
  protected Class getTextAppearanceClass() {       
    if (skinClasses == null) 
      skinClasses = NORMAL_SKIN; 

    return skinClasses[TEXT_APPEARANCE]; 
  }
  
  protected Class getTextFontClass() {  
    if (skinClasses == null) 
      skinClasses = NORMAL_SKIN; 
      
    return skinClasses[TEXT_FONT];
  }
  

  public Node getNode() {   
    return bg;
  }
    
  public Bounds  getBounds() {  
    BoundingBox bb = new BoundingBox(); 
    
    if (getFont3D() != null) {
      // 87 is GlyphCode for W, this should be a rather big glyph.
      // there should be a better way, to calculate the size of the biggest glyph !     
      getFont3D().getBoundingBox(87, bb);     
      
      Point3d upper = new Point3d();
      Point3d lower = new Point3d();
      bb.getUpper(upper);             
      bb.getLower(lower);             
      upper.sub(lower);
      upper.x *= maxChars;
      lower.set(0.0, 0.0, 0.0);
    
      bb.setUpper(upper); 
      bb.setLower(lower); 
    }

    return bb;
  }           
 
  public void setSkin(Skin skin) throws SkinException { 
    super.setSkin(skin);  
  
    UIGeometry geometry = skin.getGeometry(skinClasses[BOX_GEOMETRY]);
    box.setGeometry(geometry.getGeometry(getBounds()));
    box.setAppearance(skin.getAppearance(skinClasses[BOX_APPEARANCE]));

    updateBounds();
  }
  
  private class RemoteTextField3D extends RemoteUIText implements TextField3D {  
    public void   setText(String text) {   
      userData.setText(text);
    }           
  }     
  
  protected class DefaultTextFieldUserData implements DocumentManipulator, RemoteObjectModel, J3deFocusListener {    
    private String text;
    private int    cursorPos;
    private ChangeListener listener;
    
    public DefaultTextFieldUserData() {   
      this.text = "";
      this.cursorPos = 0;
    }            
    
    protected void setText(String text) {
      this.text = text;
      this.cursorPos = text.length();
      fireChangeEvent();
    }
     
    public void insertText(String insert) {
      text = text + insert;                               
      cursorPos += insert.length();
      
      if (text.length() > maxChars)
        text = text.substring(0, maxChars);
          
      if (cursorPos > text.length())
        cursorPos = text.length();
      
      fireChangeEvent();     
    }
  
    public void deleteChars(int num) {
    
      try {    
         text = text.substring(0, text.length() + num);
      } catch (IndexOutOfBoundsException ex) {
        ex.printStackTrace();
      }
      fireChangeEvent();     
    }     
  
    public void moveCursor(int rows, int cols) {
    } 
    
    public Object getObject() {
      return text;
    }
    
    public void   addChangeListener(ChangeListener changelistener) { 
      this.listener = changelistener;
    }
    
    public void   removeChangeListener(ChangeListener changelistener) {   
      if (this.listener == changelistener)
        this.listener = null;
    }       
    
    private void fireChangeEvent() {  
     if (listener != null) 
        listener.stateChanged(new ChangeEvent(this));
    } 
    
    public void focusGained() { 
      skinClasses = FOCUSED_SKIN;
      try {
        refreshSkin();
      } catch (SkinException e) {
        // not very good, but probably we can continue, without changing the skin
        ExceptionHandler.handleException(e);
      }
    }
    
    public void focusLost() {  
      skinClasses = NORMAL_SKIN;
      try {
        refreshSkin();
      } catch (SkinException e) {
        // not very good, but probably we can continue, without changing the skin
        ExceptionHandler.handleException(e);
      }
    }  

  }  
  
}