/* -------------------------------------------------------------------
    * Java source file for the class GlyphModeler
    * 
    * Copyright (c), 2003, Masahiro Takatsuka.
    * All Rights Researved.
    * 
    * Original Author: Masahiro Takatsuka (masa@jbeans.net)
    * $Author: takatsukam $
    * 
   * $Date: 2004/03/03 11:53:06 $
   * 
   * $Id: GlyphModeler.java,v 1.3 2004/03/03 11:53:06 takatsukam Exp $
   * 
   * Reference:		Document no:
   * ___				___
   * 
   * To Do:
   * ___
   * 
  ------------------------------------------------------------------- */
  
  /* --------------------------- Package ---------------------------- */
  package net.jbeans.j3d.modeler.scene;
  
  /* ------------------ Import classes (packages) ------------------- *//package-summary/html">class="comment"> ------------------ Import classes (packages) ------------------- *//package-summary.html">class="comment">/* ------------------ Import classes (packages) ------------------- *//package-summary.html">class="comment"> ------------------ Import classes (packages) ------------------- */
  import java.awt.*;
  import java.beans.*;
  import java.io.*;
  import java.lang.reflect.*;
  import java.util.*;
  import javax.media.j3d.*;
  import javax.vecmath.*;
  import com.sun.j3d.utils.geometry.*;
  
  import net.jbeans.bean.*;
  import net.jbeans.data.converter.*;
  import net.jbeans.lang.*;
  import net.jbeans.lang.reflect.*;
  import net.jbeans.j3d.data.*;
  
  import net.jbeans.util.debug.*;
  
  /*====================================================================
                   Implementation of class GlyphModeler                 
  ====================================================================*/
  /***
   * GlyphModeler is a class that creates a javax.media.j3d.BranchGroup
   * object (more specifically net.jbeans.j3d.scenegraph.BranchGroup), which
   * contains a set of geometry (glyph) objects.
   * 
   * @version $Revision: 1.3 $
   * @author Masahiro Takatsuka (masa@jbeans.net)
   * @see SceneModeler
   * @see Pretender, IntexedValueSetter, PropertyChangeListener, Serializable
   */
  
  public class GlyphModeler extends SceneModeler implements Pretender, IndexedValueSetter, PropertyChangeListener, Serializable {
    	private static final boolean DEBUG = Debug.getDebugFlag(GlyphModeler.class);
  
  	private static final int TOTAL_INDEX = 10;
  	private static final int PX = 0; // position x
  	private static final int PY = 1; // position y
  	private static final int PZ = 2; // position z
  	private static final int SCALE = 3;	// scale
  	private static final int OX = 4; // orientation x
  	private static final int OY = 5; // orientation y
  	private static final int OZ = 6; // orientation z
  	private static final int COLOR = 7;	// color
  	private static final int ALPHA = 8;	// transparency
  	private static final int USER_DATA = 9;	// user data.
  
  	/*
  	* Essential attributes to construct a grid surface.
  	*/
  	public static final int[] ESSENTIALS = {PX, PY, PZ};
  	
  	/* ------------------------ not serialized ------------------------ */
  	transient private PropertyChangeSupport changes;
  
  	transient private GlyphSource source;
  	
  	// for Pretender
  	transient private Vector getters;
  	transient private Vector setters;
  	transient private DataConverter[] converters;
  	transient private String[] argTypeStrs;
  	transient private int[] sourceEssentials;
  	transient private String[] setterNames;
  	//transient private String[] getterNames;	
  	transient private Object[] entryArray;
  
  	transient private int entryNum;
  	transient private int oldEntryNum;	
  	
  	transient private double[][] common = new double[TOTAL_INDEX][];
  	transient private Object userData; // must be an array.
  	transient private net.jbeans.j3d.scenegraph.BranchGroup topBranch;
  	transient private TransformGroup[] tGroups;
  	transient private Node[] nodes;
 	transient private Vector3d trans = new Vector3d();
 	transient private Matrix3d rot = new Matrix3d();
 	transient private Transform3D t3d = new Transform3D();
 
 	transient private boolean colorAtSource = false;
 		
 	// these are for translation
 	transient private Matrix3d mat1 = new Matrix3d();
 	transient private Matrix3d mat2 = new Matrix3d();
 	transient private Matrix3d matv1 = new Matrix3d();
 	transient private Vector3d yAxis = new Vector3d(0.0, 1.0, 0.0);
 	transient private Vector3d dstVector = new Vector3d();
 
 	// for color
 	transient private Color3f colorTmp = new Color3f();
 
 	/* -------------------------- serialized -------------------------- */
 	private int transparencyMode = TransparencyAttributes.FASTEST;
 	private int shadeModel = ColoringAttributes.FASTEST;	
 	private ColorLookupTable colorLT;
 	private boolean lightingEnable = true;
 	//private boolean lightingEnable = false;
 	private double defaultScale;
 	private Color defaultColor;	
 	
 	/***
 	 * Construct a new GlyphModeler.
 	 */
 	public GlyphModeler() {
 		super();
 		this.changes = new PropertyChangeSupport(this);
 		addPropertyChangeListener(this);
 		this.topBranch = new net.jbeans.j3d.scenegraph.BranchGroup();
 		initialize();
 	}
 	
 	private void initialize() {
 		// for Pretender
 		this.source = null;
 		this.getters = new Vector();
 		this.setters = new Vector();
 		this.converters = null;
 		this.argTypeStrs = null;		
 		this.setterNames = new String[] {};
 		//this.getterNames = new String[] {};
 
 		this.entryArray = new Object[0];
 		this.colorLT = new ColorLookupTable();
 		this.entryNum = -1;
 		this.oldEntryNum = -1;		
 		this.defaultScale = 1.0;
 		this.defaultColor = Color.white;
 	}
 
 	private void reset() {
 		clearScene();			// remove the topBranch
 		this.topBranch = new net.jbeans.j3d.scenegraph.BranchGroup();
 		this.tGroups = new net.jbeans.j3d.transform.TransformGroup[this.entryNum];
 		this.nodes = new Node[this.entryNum];		
 	}
 
 	/***
 	* Sets the default color used to color glyphs.
 	*
 	* @param color the defautl color.
 	*/
 	public void setDefaultColor(Color color) {
 		Color oldValue = this.defaultColor;
 		this.defaultColor = color;
 		if (DEBUG) {
 			System.out.println("color = " + color);
 		}
 		Object source = (this.source == null) ? this : (Object) this.source;
 		propertyChange(new PropertyChangeEvent(source, "defaultColor", this.defaultColor, oldValue));
 	}
 
 	/***
 	* Returns the defautl color.
 	*
 	* @return the default color.
 	*/
 	public Color getDefaultColor() {
 		return this.defaultColor;
 	}
 
 	/***
 	* Sets the default scaling factor.  All the glyphs are scaled before
 	* individual scaling is applied to each glyph.
 	*
 	* @param scale the default scaling factor.
 	*/
 	public void setDefaultScale(double scale) {
 		Double oldValue = new Double(this.defaultScale);
 		this.defaultScale = scale;
 		if (DEBUG) {
 			System.out.println("scale = " + scale);
 		}
 		Double newValue = new Double(this.defaultScale);
 		Object source = (this.source == null) ? this : (Object) this.source;
 		propertyChange(new PropertyChangeEvent(source, "defaultScale", newValue, oldValue));
 	}
 
 	/***
 	* Returns the defautl scaling factor.
 	*/
 	public double getDefaultScale() {
 		return this.defaultScale;
 	}
 
 	/***
 	* Sets the shading model.
 	*/
 	public void setShadeModel(int model) {
 		Integer oldValue = new Integer(this.shadeModel);
 		this.shadeModel = model;
 
 		Object source = (this.source == null) ? this : (Object) this.source;
 		propertyChange(new PropertyChangeEvent(source, "shadeModel", new Integer(this.shadeModel), oldValue));
 	}
 
 	/***
 	* Returns the current shading model.
 	*/
 	public int getShadeModel() {
 		return this.shadeModel;
 	}
 
 	/***
 	* Sets the transparency Mode.
 	*
 	* @param mode the transparency mode.
 	*/
 	public void setTransparencyMode(int mode) {
 		Integer oldValue = new Integer(this.transparencyMode);
 		this.transparencyMode = mode;
 
 		Object source = (this.source == null) ? this : (Object) this.source;
 		propertyChange(new PropertyChangeEvent(source, "transparencyMode", new Integer(this.transparencyMode), oldValue));		
 	}
 
 	/***
 	* Returns the current transparency mode.
 	*/
 	public int getTransparencyMode() {
 		return this.transparencyMode;
 	}
 
 	/***
 	* Sets the color lookup table.
 	*/
 	public void setColorLookupTable(ColorLookupTable lt) {
 		this.colorLT = lt;
 	}
 
 	public ColorLookupTable getColorLookupTable() {
 		return this.colorLT;
 	}
 
 	public void setLightingEnable(boolean b) {
 		Boolean oldValue = new Boolean(this.lightingEnable);
 		this.lightingEnable = b;
 
 		Object source = (this.source == null) ? this : (Object) this.source;
 		propertyChange(new PropertyChangeEvent(source, "lightingEnable", new Boolean(this.lightingEnable), oldValue));		
 	}
 
 	public boolean getLightingEnable() {
 		return this.lightingEnable;
 	}
 	
 	/***
 	 * Serialization methods
 	 */
 	private void readObject(ObjectInputStream s) throws ClassNotFoundException, IOException {
 		s.defaultReadObject();
 		initialize();
 	}
 	
 	public void addPropertyChangeListener(PropertyChangeListener l) {
 		this.changes.addPropertyChangeListener(l);
 	}
 
 	public void removePropertyChangeListener(PropertyChangeListener l) {
 		this.changes.removePropertyChangeListener(l);		
 	}
 	
 	private synchronized void setCommonValueAt(int index, Object value) {
 		this.common[index] = (double[]) value;
 
 		/*
 		  get number of entries (entryNum).
 		  If the number of entry changes, it will be picked up here.
 		  And it causes to model instead of update.
 		*/
 		if (value != null) {
 			this.entryNum = this.common[index].length;
 		}
 		setSceneData();		
 	}
 
 	public void setXCoordinates(double[] x) {
 		setCommonValueAt(PX, x);
 	}
 	public void setYCoordinates(double[] y) {
 		setCommonValueAt(PY, y);
 	}
 	public void setZCoordinates(double[] z) {
 		setCommonValueAt(PZ, z);
 	}
 	public void setScales(double[] scale) {
 		setCommonValueAt(SCALE, scale);
 	}
 	public void setXOrientations(double[] x) {
 		setCommonValueAt(OX, x);
 	}
 	public void setYOrientations(double[] y) {
 		setCommonValueAt(OY, y);
 	}
 	public void setZOrientations(double[] z) {
 		setCommonValueAt(OZ, z);
 	}
 	public void setColors(double[] color) {
 		setCommonValueAt(COLOR, color);
 	}
 	public void setTransparency(double[] alpha) {
 		setCommonValueAt(ALPHA, alpha);
 	}
 
 	public void setUserData(Object userData) {
 		if (!ClassUtil.isArray(userData)) {
 			return;
 		}
 		this.userData = userData;
 		if (this.userData != null) {
 			this.entryNum = Array.getLength(this.userData);
 		}
 	}
 	
 	/* --------------------- begin : Pretender ---------------------- */
 	private void setPropertyChangeListener(Object source) {
 		// if the source bean implements add/remove propertyChangeListener
 		try {
 			Class[] args = {PropertyChangeListener.class};
 			Class beanClass = source.getClass();
 			Method adder = beanClass.getMethod("addPropertyChangeListener", args);
 			Object[] arg = {this};
 			adder.invoke(source, arg);
 		} catch (Exception ex) {
 			// NOP
 		}
 	}
 
 	public void setSource(Object source) {
 		Object oldSource = this.source;
 		initialize();				// clear the Vector;
 
 		if (source == null) {
 			return;
 		}
 		if ( !(source instanceof GlyphSource)) {
 			setupIndexedValueAccessors();			
 			return;
 		}
 		this.source = (GlyphSource) source;
 		/*
 		* 
 		* Masahiro Takatsuka/2001-Oct-13
 		*/
 		setSetters(this.source.getSetMethods());
 		int[] sessentials = this.source.getEssentials();
 		this.sourceEssentials = (sessentials == null) ? new int[] {}: sessentials;
 		
 //  		Class clazz = source.getClass();
 //  		try {
 //  			// get methods from BeanInfo using getMethodDescriptors.
 //  			BeanInfo binfo = BeanInfoFinder.getBeanInfo(clazz);
 //  			MethodDescriptor[] mds = binfo.getMethodDescriptors();
 //  			for (int i = 0; i < mds.length; i++) {
 //  				Method method = mds[i].getMethod();
 //  				String methodName = method.getName();
 //  				if (methodName.startsWith(SETTER_STR)) {
 //  					/*
 //  					 * In this version, only the method
 //  					 * with one arg is supportetd.
 //  					 */
 //  					Class[] paramTypes = method.getParameterTypes();
 //  					if (paramTypes.length == 1) {
 //  						addSetter(method);
 //  					}
 //  				} else if (methodName.startsWith(GETTER_STR)) {
 //  					/*
 //  					 * null-arg and return something.
 //  					 */
 //  					Class[] paramTypes = method.getParameterTypes();
 //  					Class returnType = method.getReturnType();
 //  					if ((returnType != Void.TYPE) &&
 //  						(paramTypes.length == 0)) {
 //  						addGetter(method);
 //  					}
 //  				}
 //  			}
 //  		} catch (IntrospectionException ex) {
 //  			ex.printStackTrace();
 //  		}
 		setupIndexedValueAccessors();
 
 		// add this to source's property listener list.
 		setPropertyChangeListener(this.source);
 
 		Object[] args = new Object[] {new Double(1.0)};
 		if (ClassUtil.respondsToMethod(this.source, "setColor", args)) {
 			this.colorAtSource = true;
 		}
 		
 		this.changes.firePropertyChange("source", oldSource, this.source);
 	}
 	
 	public Object getSource() {
 		return this.source;
 	}
 	
 	public Method[] getSetters() {
 		Method[] array = new Method[] {};
 		return (Method[]) this.setters.toArray(array);
 	}
 
 	public void setSetters(Method[] methods) {
 		this.setters.clear();
 		if (methods == null || methods.length == 0) {
 			return;
 		}
 		int size = methods.length;
 		for (int i = 0; i < size; i++) {
 			this.setters.add(methods[i]);
 		}
 	}
 
 	public Method getSetterAt(int index) {
 		return (Method) this.setters.get(index);
 	}
 	
 	public void setSetterAt(int index, Method method) {
 		this.setters.add(index, method);		
 	}
 
 	private void addSetter(Method method) {
 		this.setters.add(method);
 	}
 
 	private void addGetter(Method method) {
 		this.getters.add(method);
 	}
 	
 	public Method[] getGetters() {
 		Method[] array = new Method[] {};		
 		return (Method[]) this.getters.toArray(array);
 	}
 	
 	public void setGetters(Method[] methods) {
 		if (this.getters.size() > 0) {
 			this.getters.clear();
 		}
 		int size = methods.length;
 		for (int i = 0; i < size; i++) {
 			this.getters.add(methods[i]);
 		}
 	}
 
 	public Method getGetterAt(int index) {
 		return (Method) this.getters.get(index);		
 	}
 	
 	public void setGetterAt(int index, Method method) {
 		this.getters.add(index, method);		
 	}
 	
 	private void setupIndexedValueAccessors() {
 		int size = this.setters.size();
 		Method method = null;
 		this.setterNames = new String[size];
 		this.entryArray = new Object[size];
 
 		for (int i = 0; i < size; i++) {
 			method = (Method) this.setters.get(i);
 			if (method == null) {
 				continue;
 			}
 			String methodName = ClassUtil.formatMethodSignature(method);
 			int idx = methodName.indexOf(SETTER_STR);
 			if (DEBUG) {
 				System.out.println("setting: " + methodName + " at: " + i);
 			}
 			setSetterNameAt(i, SETTER_PREFIX + methodName.substring(idx + SETTER_STR.length()));
 		}
 		//  		size = this.getters.size();
 		//  		this.getterNames = new String[size];		
 		//  		for (int i = 0; i < size; i++) {
 		//  			method = (Method) this.getters.get(i);
 		//  			String methodName = ClassUtil.formatMethodSignature(method);
 		//  			int idx = methodName.indexOf(GETTER_STR);
 		//  			setGetterNameAt(i, GETTER_PREFIX + methodName.substring(idx + GETTER_STR.length()));			
 		//  		}
 	}
 	/* ---------------------- end : Pretender ----------------------- */
 
 	/* ----------------- begin : IndexedValueSetter ----------------- */
 	/***
 	 * returns the number of available index.
 	 */
 	public int getNumberOfSetter() {
 		return this.setterNames.length;
 	}
 	
 	/***
 	 * sets the number of index.
 	 */
 	public void setNumberOfSetter(int num) {
 		// NOP
 	}
 
 	/***
 	 * set the setter method name for the specified index.
 	 */
 	public void setSetterNameAt(int index, String name) {
 		this.setterNames[index] = name;
 	}
 	
 	/***
 	 * get the setter method name for the specified index.
 	 */
 	public final String getSetterNameAt(int index) {
 		return (this.setterNames != null) ? this.setterNames[index] : null;
 	}
 	
 	/***
 	 * Method to set value at the specified index.
 	 */
 	public void setValueAt(int index, Object value) {
 		this.entryArray[index] = value;
 		setSceneData();
 	}
 
 	public Method getIndexedValueSetter() {
 		Class[] argTypes = new Class[]{Integer.TYPE, Object.class};
 		return ClassUtil.getMethod(this, "setValueAt", argTypes);
 	}
 	
 	/* ------------------ end : IndexedValueSetter ------------------ */
 	
 	/* ---------------- begin: PropertyChangeListener ----------------- */
 	public void propertyChange(PropertyChangeEvent evt) {
 		Object src = evt.getSource();
 
 		if (src != this.source) {
 			return;
 		}
 		Object oldValue = evt.getOldValue();
 		Object newValue = evt.getNewValue();
 		if (newValue.equals(oldValue)) {
 			return;
 		}
 		
 		/*
 		* This will forse setData() to call model() instead of update();
 		* Masahiro Takatsuka/2001-Jul-07
 		*/
 		this.oldEntryNum = -1;
 		setSceneData();
 	}
 	
 	/* ----------------- end: PropertyChangeListener ------------------ */
 
 	public void set(int length, Object array, String methodname) {
 		Method method = findMethod(methodname);
 		if (method == null) {
 			return;
 		}
 		if (this.source != null) {					
 			for (int i = 0; i < length; i++) {
 				Object[] args = {java.lang.reflect.Array.get(array, i)};
 				
 				try {
 					ClassUtil.makeObjectPerform(this.source,
 												  method.getName(),
 												  args
 												  );
 				} catch (Exception e) {
 					e.printStackTrace();
 				}
 			}
 		}
 	}
 
 	private Method findMethod(String name) {
 		int length = this.setters.size();
 		for (int i = 0; i < length; i++) {
 			Method method = (Method) this.setters.get(i);
 			if (method.getName().equals(name)) {
 				return method;
 			}
 		}
 		return null;
 	}
 		
 	private boolean isDataReady() {
 		if (! checkSize()) {
 			return false;
 		}
 		
 		 // need at least PX, PY, PZ
 		for (int i = 0; i < ESSENTIALS.length; i++) {
 			if (this.common[ESSENTIALS[i]] == null) {
 				return false;
 			}
 		}
 		
 		// check Glyph source dependent data.
 		for (int i = 0; i < this.sourceEssentials.length; i++) {
 			if (this.entryArray[this.sourceEssentials[i]] == null) {
 				return false;
 			}
 		}
 		return true;
 	}
 
 	private boolean checkSize() {
 		double[] x = (double[]) this.common[PX];
 		double[] y = (double[]) this.common[PY];
 		double[] z = (double[]) this.common[PZ];
 		double[] scale = (double[]) this.common[SCALE];
 		double[] xo = (double[]) this.common[OX];
 		double[] yo = (double[]) this.common[OY];
 		double[] zo = (double[]) this.common[OZ];
 		double[] color = (double[]) this.common[COLOR];
 		double[] trans = (double[]) this.common[ALPHA];
 
 		int size = this.entryNum;
 
 		if ((x != null && x.length != size) ||
 			(y != null && y.length != size) ||
 			(z != null && z.length != size) ||
 			(scale != null && scale.length != size) ||
 			(xo != null && xo.length != size) ||
 			(yo != null && yo.length != size) ||			
 			(zo != null && zo.length != size) ||
 			(color != null && color.length != size) ||			
 			(trans != null && trans.length != size) ||
 			(this.userData != null && Array.getLength(this.userData) != size)
 			) {
 			return false;
 		}
 		for (int i = 0; i < this.entryArray.length; i++) {
 			if (this.entryArray[i] != null &&
 				Array.getLength(this.entryArray[i]) != size) {
 				return false;
 			}
 		}
 		return true;
 	}
 
 	/***
 	* After setting all necessary infomation, call this method to
 	* construct GlyphModel.
 	*/
 	synchronized private void setSceneData() {
 		if (isDataReady()) {
 			setData();
 		}
 	}
 
 	private void setData() {
 		synchronized (this.scenes) {
 			boolean needModel = false;
 			BranchGroup bg = getScene();
 			if (bg == null) {
 				needModel = true;
 				if (DEBUG) {
 					System.out.println("scene null.");
 				}
 			}
 			
 			if ((this.entryNum != this.oldEntryNum) || needModel) { // if entryNum has changed.
 				/*
 				 * make oldEntryNum and entryNum equal before modeling,
 				 * so that other threads calling setData() do not model...
 				 * Masahiro Takatsuka/2001-Oct-15
 				 */
 				this.oldEntryNum = this.entryNum;
 				if (DEBUG) {
 					System.out.println("modelling...");
 				}
 				reset();
 				model();
 			} else {
 				if (DEBUG) {
 					System.out.println("updating...");
 				}
 				update();
 			}
 		}
 	}
 
 	/* ------------------------ SceneModeler ------------------------ */
 	/***
 	 * Computes a rotation matrix to align the src vector to dst vector.
 	 */
 	private Matrix3d rotationMatrixToAlignVector(Vector3d src,
 												 Vector3d dst,
 												 Matrix3d ra) {
 		if (ra == null) {
 			ra = new Matrix3d();
 		}
 
 		double r1 = Math.sqrt(src.x * src.x + src.y * src.y + src.z * src.z);
 		double r2 = Math.sqrt(dst.x * dst.x + dst.y * dst.y + dst.z * dst.z);
 		double ay1 = Math.atan2(src.x, src.z);
 		double ax1 = Math.acos(src.y / r1);
 		double ay2 = Math.atan2(dst.x, dst.z);
 		double ax2 = Math.acos(dst.y / r2);
 
 		if (DEBUG) {
 			System.out.println("ax1, ay1 = " + ax1 + ", " + ay1);
 			System.out.println("ax2, ay2 = " + ax2 + ", " + ay2);
 		}
 		this.mat1.rotY(ay1);
 		this.mat2.rotX(ax1);
 		this.matv1.mul(this.mat2, this.mat1);
 
 		this.mat1.rotX(-ax2);
 		this.mat2.rotY(-ay2);
 		ra.mul(this.mat2, this.mat1);
 		ra.mul(this.matv1);
 
 		return ra;
 	}
 
 	/*
 	* 2do: set rotation components from orientation vector.
 	* Masahiro Takatsuka/2001-Jul-06
 	*/
 	private void setTransform3D(int index, Transform3D t3d) {
 		// translateion
 		double x = this.common[PX][index];
 		double y = this.common[PY][index];
 		double z = this.common[PZ][index];
 		this.trans.set(x, y, z);
 
 		// scale
 		double scale;
 		if (this.common[SCALE] != null) {
 			scale = this.common[SCALE][index];
 		} else {
 			scale = 1.0;
 		}
 		scale *= this.defaultScale;
 
 		// set rotation
 		if (this.common[OX] != null &&
 			this.common[OY] != null &&
 			this.common[OZ] != null) {
 			x = this.common[OX][index];
 			y = this.common[OY][index];
 			z = this.common[OZ][index];
 			this.dstVector.set(x, y, z);
 			rotationMatrixToAlignVector(this.yAxis, this.dstVector, this.rot);
 			t3d.set(this.rot, this.trans, scale);
 		} else {
 			t3d.set(scale, this.trans);
 		}
 	}
 
 	private void setDataToSource(int index) {
 		int length = this.setters.size();
 		if (this.converters == null || this.converters.length != length) {
 			this.converters = new DataConverter[length];
 			this.argTypeStrs = new String[length];
 		}
 
 		for (int i = 0; i < length; i++) {
 			Object array = this.entryArray[i];
 			if (array == null) {
 				continue;
 			}
 			Object arg = java.lang.reflect.Array.get(array, index);
 			Method method = (Method) this.setters.get(i);
 			Class[] argTypes = method.getParameterTypes();
 			Class argType = argTypes[0];
 			if (argType.isPrimitive()) {
 				argType = ClassUtil.getWrapperClass(argType);
 			}
 			// check the argument types.
 			if (this.converters[i] == null) {
 				Class paramType = arg.getClass();
 				this.converters[i] = DataConverterManager.findConverter(paramType, argType);
 				if (DEBUG) {
 					System.out.println("converter = " + this.converters[i]);
 				}
 				this.argTypeStrs[i] = argType.getName();
 			}
 			try {
 				Object[] args = {this.converters[i].convert(arg, this.argTypeStrs[i])};
 				if (DEBUG) {
 					System.out.println("method = " + method + ", arg = " + args[0]);
 				}
 				ClassUtil.makeObjectPerform(this.source,
 											  method.getName(),
 											  args,
 											  argTypes
 											  );
 			} catch (Exception e) {
 				e.printStackTrace();
 			}
 		}
 	}
 
 	private Node getNodeFromSource(int index) {
 		Node node = this.source.getNode();
 		if (node instanceof Shape3D) {
 			Shape3D shape3d = (Shape3D) node;
 			shape3d.setCapability(Shape3D.ALLOW_APPEARANCE_READ);
 			shape3d.setCapability(Shape3D.ALLOW_APPEARANCE_WRITE);
 			shape3d.setCapability(Shape3D.ALLOW_COLLISION_BOUNDS_READ);
 			shape3d.setCapability(Shape3D.ALLOW_COLLISION_BOUNDS_WRITE);
 			shape3d.setCapability(Shape3D.ALLOW_GEOMETRY_READ);
 			shape3d.setCapability(Shape3D.ALLOW_GEOMETRY_WRITE);
 			shape3d.setCapability(Node.ALLOW_BOUNDS_READ);
 			shape3d.setCapability(Node.ALLOW_BOUNDS_WRITE);
 			shape3d.setCapability(Node.ALLOW_AUTO_COMPUTE_BOUNDS_READ);
 			shape3d.setCapability(Node.ALLOW_AUTO_COMPUTE_BOUNDS_WRITE);
 		}
 
 		return node;
 	}
 	
 	private Node updateNode(Node node) {
 		return this.source.updateNode(node);
 	}
 
 	
 	private ColoringAttributes setColoringAttributes(int index, ColoringAttributes ca) {
 		if (ca == null) {
 			ca = new ColoringAttributes();
 		}
 		try {
 			ca.setCapability(ColoringAttributes.ALLOW_COLOR_READ);
 			ca.setCapability(ColoringAttributes.ALLOW_COLOR_WRITE);			
 			ca.setCapability(ColoringAttributes.ALLOW_SHADE_MODEL_READ);
 			ca.setCapability(ColoringAttributes.ALLOW_SHADE_MODEL_WRITE);
 		} catch (Exception e) {
 			// NOP.
 		}
 		if (this.common[COLOR] != null) {
 			double[] newColor = this.colorLT.mapValue(this.common[COLOR][index]);
 			ca.setColor((float) newColor[0],
 						(float) newColor[1],
 						(float) newColor[2]);
 			ca.setShadeModel(this.shadeModel);
 		} else {
 			float[] newColor = this.defaultColor.getRGBColorComponents(null);
 			ca.setColor(newColor[0], newColor[1], newColor[2]);
 			ca.setShadeModel(this.shadeModel);
 		}
 
 		return ca;
 	}
 
 	private TransparencyAttributes setTransparencyAttributes(int index, TransparencyAttributes ta) {
 		if (ta == null) {
 			ta = new TransparencyAttributes();
 		}
 		try {
 			ta.setCapability(TransparencyAttributes.ALLOW_BLEND_FUNCTION_READ);
 			ta.setCapability(TransparencyAttributes.ALLOW_BLEND_FUNCTION_WRITE);			
 			ta.setCapability(TransparencyAttributes.ALLOW_MODE_READ);
 			ta.setCapability(TransparencyAttributes.ALLOW_MODE_WRITE);
 			ta.setCapability(TransparencyAttributes.ALLOW_VALUE_READ);
 			ta.setCapability(TransparencyAttributes.ALLOW_VALUE_WRITE);
 		} catch (Exception e) {
 			// NOP.
 		}
 		if (this.common[ALPHA] != null) {
 			double alpha = this.common[ALPHA][index];
 			ta.setTransparency((float) alpha);
 			ta.setTransparencyMode(this.transparencyMode);
 		}
 
 		return ta;
 	}
 	
 	private Material setMaterial(int index, Material mat) {
 		if (mat == null) {
 			mat = new Material();
 		}
 		try {
 			mat.setCapability(Material.ALLOW_COMPONENT_READ);
 			mat.setCapability(Material.ALLOW_COMPONENT_WRITE);			
 		} catch (Exception e) {
 			// NOP.
 		}
 
 		// set only Diffuse color.
 		double color;
 		if (this.common[COLOR] != null) {
 			color = this.common[COLOR][index];
 			double[] newColor = this.colorLT.mapValue(color);
 			colorTmp.set((float) newColor[0],
 						 (float) newColor[1],
 						 (float) newColor[2]);
 			mat.setDiffuseColor(colorTmp);
 		} else {
 			float[] newColor = this.defaultColor.getRGBColorComponents(null);
 			colorTmp.set(newColor[0], newColor[1], newColor[2]);
 			mat.setDiffuseColor(colorTmp);			
 		}
 		
 		// set lightingEnable flag.
 		mat.setLightingEnable(this.lightingEnable);
 
 		return mat;
 	}
 	
 	private Appearance setAppearance(int index, Appearance ap) {
 		ap = (ap == null) ? new Appearance() : ap;
 		try {
 			ap.setCapability(Appearance.ALLOW_COLORING_ATTRIBUTES_READ);
 			ap.setCapability(Appearance.ALLOW_COLORING_ATTRIBUTES_WRITE);
 			ap.setCapability(Appearance.ALLOW_MATERIAL_READ);
 			ap.setCapability(Appearance.ALLOW_MATERIAL_WRITE);
 			ap.setCapability(Appearance.ALLOW_TEXTURE_READ);
 			ap.setCapability(Appearance.ALLOW_TEXTURE_WRITE);
 			ap.setCapability(Appearance.ALLOW_TRANSPARENCY_ATTRIBUTES_READ);
 			ap.setCapability(Appearance.ALLOW_TRANSPARENCY_ATTRIBUTES_WRITE);
 		} catch (Exception e) {
 			//e.printStackTrace();
 			// NOP skip..they're already set.
 		}
 		
 		// set color.
 		ColoringAttributes ca = ap.getColoringAttributes();
 		ca = setColoringAttributes(index, ca);
 		if (ap.getColoringAttributes() == null) {
 			ap.setColoringAttributes(ca);
 		}
 		
 		// set Material
 		Material mat = ap.getMaterial();
 		mat = setMaterial(index, mat);
 		if (ap.getMaterial() == null) {
 			ap.setMaterial(mat);
 		}
 		
 		// set transparency.
 		TransparencyAttributes ta = ap.getTransparencyAttributes();
 		ta = setTransparencyAttributes(index, ta);
 		if (ap.getTransparencyAttributes() == null) {
 			ap.setTransparencyAttributes(ta);
 		}
 		
 		return ap;
 	}
 
   	/***
 	 */
   	protected void modelScene() {
 		double x, y, z, scale;
 		for (int i = 0; i < this.entryNum; i++) {
 			// set entryArray to source
 			setDataToSource(i);
 
 			// get shape3d.
 			this.nodes[i] = getNodeFromSource(i);
 
 			// set UserData to Shape3D object.
 			if (this.userData != null) {
 				this.nodes[i].setUserData(Array.get(this.userData, i));
 			}
 
 			// if Shape3D has
 			Appearance ap = this.source.getAppearanceOfNode(this.nodes[i]);
 			
 			// create appearance
 			ap = setAppearance(i, ap);
 			
 			// add appearance to Shape3D
 			this.source.setAppearanceOfNode(this.nodes[i], ap);
 			
 			// create transform3d from this.common		
 			setTransform3D(i, this.t3d);
 			
 			// create TransformGroup.
 			this.tGroups[i] = new net.jbeans.j3d.transform.TransformGroup(this.t3d);
 			
 			// add Shape3D to TransformGroup
 			this.tGroups[i].addChild(this.nodes[i]);
 
 			this.topBranch.addChild(this.tGroups[i]);
 		}
 		setScene(this.topBranch);
 	}
 	
   	/***
   	 *
   	 */
 	protected void updateScene() {
 		for (int i = 0; i < this.entryNum; i++) {
 			// get Transform3D
 			this.tGroups[i].getTransform(this.t3d);
 
 			// compute Transform3D
 			setTransform3D(i, this.t3d);
 
 			// set Transoform3D
 			this.tGroups[i].setTransform(this.t3d);
 
 			// set entryArray to source
 			setDataToSource(i);
 
 			// update shape3d
 			updateNode(this.nodes[i]);
 
 			// set UserData to Shape3D object.
 			if (this.userData != null) {
 				this.nodes[i].setUserData(Array.get(this.userData, i));
 			}
 
 			// get appearance
 			Appearance ap = this.source.getAppearanceOfNode(this.nodes[i]);
 			
 			// create appearance
 			ap = setAppearance(i, ap);
 			
 			// add appearance to Shape3D
 			this.source.setAppearanceOfNode(this.nodes[i], ap);
 		}
 	}
 }