//******************************************************************************
// jvb.java:	Applet
//
// Conversion of DDVectorBalls. A.J.Buchanan 5/98. First Java program!
//
// Still under development!!!
//
//******************************************************************************

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

import java.net.URL;
import java.util.*;
import java.awt.image.*;

// todo: make quicker!!!!
//
class VbSprite
{
	int	sx,sy;
	int fr;

	Image imSpriteA[];	
	int w,h;

	int	numFrames;

	// Construct sprite from array of frames
	VbSprite( Image im[], int iFrames )
	{
		numFrames = iFrames;

		w = im[0].getWidth( null );
		h = im[0].getHeight( null );

		imSpriteA = new Image[iFrames];

		for ( int i=0; i<iFrames; i++ )
		{
			imSpriteA[i] = im[i];
		}
	}

	// Construct sprite from single image, 'splitting' it into frames
	// (Frames are placed sequentionally in image horizontally and must
	// be of the same size)
	VbSprite( Image im, int iFrames, Component cOwner )
	{
		imSpriteA = new Image[iFrames];

		numFrames = iFrames;

		w = im.getWidth( null );
		h = im.getHeight( null );

		w /= iFrames;

		// Build the sub-images
		for ( int i=0; i<iFrames; i++ )
		{
			int pix[] = new int[w*h];	// why cant this be outside the loop? cos grabPixels is async??
			PixelGrabber pg = new PixelGrabber( im, w*i, 0, w, h, pix, 0, w );
			try
			{
				pg.grabPixels();
			}
			catch(InterruptedException e ){}

			imSpriteA[i] = cOwner.createImage( new MemoryImageSource( w, h, pix, 0, w ) );
		}
	}

	void Draw( Graphics g, int x, int y, int frame )
	{
		g.drawImage( imSpriteA[frame], x-(w/2), y-(h/2), w, h, null );
	}

	void Draw( Graphics g )
	{
		Draw( g, sx, sy, fr );
	}
}

//
class SineTable
{
	final static int SINTABSIZE = 4096;

	static float value[] = new float[SINTABSIZE];

	static
	{
		// Build The Table
		for ( int i=0; i<SINTABSIZE; i++ )
		{
			value[i] = (float)Math.sin( ((double)(i))/SINTABSIZE * 2.0 * Math.PI );
		}
	}
}

//
class VbMatrix
{
	public final static int A=0;
	public final static int B=1;
	public final static int C=2;
	public final static int D=3;
	public final static int E=4;
	public final static int F=5;
	public final static int G=6;
	public final static int H=7;
	public final static int I=8;
		
	public float El[];

	VbMatrix()
	{
		// Default to Identity matrix
		El = new float[I+1];

		El[A] = El[E] = El[I] = 1.0f;
	}

	void RotX( float Angle )
	{
		El[A]= 1.0f;
		El[B]= 0.0f;
		El[C]= 0.0f;

		El[D]= 0.0f;
		El[E]= (float)Math.cos(Angle);
		El[F]= (float)Math.sin(Angle);

		El[G]= (float)0.0;
		El[H]= (float)-Math.sin(Angle);
		El[I]= (float)Math.cos(Angle);
	}

	void RotY( float Angle )
	{
		El[A]= (float)Math.cos(Angle);
		El[B]= 0.0f;
		El[C]= (float)-Math.sin(Angle);

		El[D]= 0.0f;
		El[E]= 1.0f;
		El[F]= 0.0f;

		El[G]= (float)Math.sin(Angle);
		El[H]= 0.0f;
		El[I]= (float)Math.cos(Angle);
	}

	void RotZ( float Angle )
	{
		El[A]= (float)Math.cos(Angle);
		El[B]= (float)Math.sin(Angle);
		El[C]= 0.0f;

		El[D]= (float)-Math.sin(Angle);
		El[E]= (float)Math.cos(Angle);
		El[F]= 0.0f;

		El[G]= 0.0f;
		El[H]= 0.0f;
		El[I]= 1.0f;
	}

	// this = a.b
	void Concat( VbMatrix Ma, VbMatrix Mb )
	{
		El[A] = (Ma.El[A] * Mb.El[A]) + 
				(Ma.El[B] * Mb.El[D]) + 
				(Ma.El[C] * Mb.El[G]);
		El[B] = (Ma.El[A] * Mb.El[B]) + 
				(Ma.El[B] * Mb.El[E]) + 
				(Ma.El[C] * Mb.El[H]);
		El[C] = (Ma.El[A] * Mb.El[C]) + 
				(Ma.El[B] * Mb.El[F]) + 
				(Ma.El[C] * Mb.El[I]);

		El[D] = (Ma.El[D] * Mb.El[A]) + 
				(Ma.El[E] * Mb.El[D]) + 
				(Ma.El[F] * Mb.El[G]);
		El[E] = (Ma.El[D] * Mb.El[B]) + 
				(Ma.El[E] * Mb.El[E]) + 
				(Ma.El[F] * Mb.El[H]);
		El[F] = (Ma.El[D] * Mb.El[C]) + 
				(Ma.El[E] * Mb.El[F]) + 
				(Ma.El[F] * Mb.El[I]);

		El[G] = (Ma.El[G] * Mb.El[A]) + 
				(Ma.El[H] * Mb.El[D]) + 
				(Ma.El[I] * Mb.El[G]);
		El[H] = (Ma.El[G] * Mb.El[B]) + 
				(Ma.El[H] * Mb.El[E]) + 
				(Ma.El[I] * Mb.El[H]);
		El[I] = (Ma.El[G] * Mb.El[C]) + 
				(Ma.El[H] * Mb.El[F]) + 
				(Ma.El[I] * Mb.El[I]);
	}
	//
	// A B C	a b c		Aa+Bd+Cg	Ab+Be+Ch	Ac+Bf+Ci
	// D E F	d e f	=	Da+Ed+Fg	Db+Ee+Fh	Dc+Ef+Fi
	// G H I	g h i		Ga+Hd+Ig	Gb+He+Ih	Gc+Hf+Ii
	//

}

//
class VbBall
{
	float				x;			// 3D Coord
	float				y;
	float				z;
	int					Xz;			// Xfrms Z Coord
	int					ScrX;		// Screen Coord;
	int					ScrY;
	int					frame;
	int					res1;		// Reserved;
	int					res2;		// Reserved;
	VbSprite			Sprite;		// Sprite.

	private VbBall		pLeft;		// Tree Children
	private VbBall		pRight;

	VbBall( float xCoord, float yCoord, float zCoord, int iFrame, int iRes1, int iRes2 )
	{
		x = xCoord; y = yCoord; z = zCoord;
		frame = iFrame;
		res1 = iRes1;
		res2 = iRes2;
	}

	// Add To Draw Tree
	void TreeAdd( VbBall Root )
	{
		pLeft	= null;
		pRight	= null;

		if ( this==Root ) return;	// Do not Add, we are the Root node!

		VbBall CurNode = Root;
		while ( null != CurNode )
		{
			if ( Xz <= CurNode.Xz )
			{
				if ( null != CurNode.pLeft )
				{
					CurNode = CurNode.pLeft;
					continue;
				}
				else
				{
					CurNode.pLeft = this;
					break;
				}
			}
			else
			{
				if ( null != CurNode.pRight )
				{
					CurNode = CurNode.pRight;
					continue;
				}
				else
				{
					CurNode.pRight = this;
					break;
				}
			}

		} // End while

	}

	// Render Balls in Tree. (Recursive - DOH!)
	void TreeWalkAndDraw( Graphics gContext )
	{
		// Walk Right side ( > z )
		if ( null != pRight )
		{
			pRight.TreeWalkAndDraw( gContext );
		}

		// Draw. // DBG Version
		//Color cc[] = { Color.blue, Color.magenta, Color.red, Color.white, Color.green, Color.yellow };
		//gContext.setColor( cc[frame] );	// DBG!!
		//gContext.fillRect( ScrX-1, ScrY-1, 2, 2 );
		//gContext.fillOval( ScrX-8, ScrY-8, 16, 16);	// Shoulb be 32 not 16!

		// Draw
		Sprite.Draw( gContext, ScrX, ScrY, frame );
		
		// Walk Left Side ( < z )
		if ( null != pLeft ) 
		{
			pLeft.TreeWalkAndDraw( gContext );
		}
	}

}

// Null Object, You must create an object, using one of the derived classes
abstract class VbObject
{
	final static int ANIM_NONE = 0;
	final static int ANIM_SINUS = 1;
	final static int ANIM_SWOOSH = 2;
	final static int ANIM_WOBBLE = 3;

	private final static int VB_ZOFF = 520;
	private final static int VB_K = 512;

	protected int		iNumBalls;	// No Of Balls
	protected VbBall	Balls[];	// Pointer to balls
	protected int		Animate;	// Animation constant
	protected int		value1;		// Misc
	protected int		value2;		// Misc
	protected int		value3;		// Misc
	protected int		value4;		// Misc
	protected int		value5;		// Misc

	void SetSprite( VbSprite Sprite )
	{
		// Sets same for all balls
		for ( int i=0; i<iNumBalls; i++ )
		{
			Balls[i].Sprite = Sprite;
		}
	}

	void SetAnimation( int iType, int v1, int v2, int v3, int v4, int v5 )
	{
		Animate = iType;
		value1 = v1; value2 = v2;
		value3 = v3; value4 = v4;
		value5 = v5;
	}

	void TransformAndAnimate( VbMatrix M )
	{
		int	k = VB_K;

		for ( int i=0; i<iNumBalls; i++ )
		{
			float x,y,z;
			float savedz=0;

			// todo: animation stuff
			switch ( Animate )
			{
				case ANIM_SINUS:
					// Sinus Animate Balls
					Balls[i].z = value1*SineTable.value[ Balls[i].res1 ]
						+ value1*SineTable.value[ Balls[i].res2 ];
					Balls[i].res1 += value2;
					Balls[i].res2 += value3;
					Balls[i].res1 %= SineTable.SINTABSIZE;
					Balls[i].res2 %= SineTable.SINTABSIZE;
					break;

				case ANIM_SWOOSH:
					// Throw around screen
					Balls[i].z += value1*SineTable.value[ Balls[i].res1 ];
					Balls[i].res1 += value2;
					Balls[i].res1 %= SineTable.SINTABSIZE;
					break;

				case ANIM_WOBBLE:
					// perturb Z
					savedz = Balls[i].z;
					Balls[i].z += value1*SineTable.value[ Balls[i].res1 ]*(value3*SineTable.value[ Balls[i].res2 ]);
					Balls[i].res1 += value2;
					Balls[i].res1 %= SineTable.SINTABSIZE;
					break;

			}

			// Xfrm Point
			float xBall = Balls[i].x;
			float yBall = Balls[i].y;
			float zBall = Balls[i].z;

			x = xBall * M.El[VbMatrix.A] +
				yBall * M.El[VbMatrix.B] +
				zBall * M.El[VbMatrix.C];
			y = xBall * M.El[VbMatrix.D] +
				yBall * M.El[VbMatrix.E] +
				zBall * M.El[VbMatrix.F];
			z = xBall * M.El[VbMatrix.G] +
				yBall * M.El[VbMatrix.H] +
				zBall * M.El[VbMatrix.I];

			// Perspect Point
			z += VB_ZOFF;

			Balls[i].ScrX =	(int)(( x * k ) / z);
			Balls[i].ScrY =	(int)(( y * k ) / z);
			Balls[i].Xz	= (int)(z);

			// Animate point? Tidy up if req.
			switch ( Animate )
			{
				case ANIM_SINUS:
				case ANIM_SWOOSH:
					break;
				case ANIM_WOBBLE:
					Balls[i].z = savedz;
					break;
			}

			// Insert in tree!
			Balls[i].TreeAdd( Balls[0] );

		} // End for i

	}

}

// Square
class VbObject_Rectangle extends VbObject
{
	// Constructor for each type of object
	VbObject_Rectangle( int w, int h, int xExtent, int yExtent, boolean bStriped, boolean bSiney, int zExtent )
 	{
		int	xinc = xExtent/w;
		int yinc = yExtent/h;

		iNumBalls = w*h;
		Balls = new VbBall[iNumBalls];

		int c = 0;
		int y = -(yExtent/2);

		for ( int i=0; i<h; i++ )
		{
			int x = -(xExtent/2);

			for ( int j=0; j<w; j++ )
			{
				float z = 0.0f;
				int frame;

				if ( bSiney )
					z = zExtent*SineTable.value[(int)(i/((float)h)*SineTable.SINTABSIZE)] 
						+ zExtent*SineTable.value[(int)(j/((float)w)*SineTable.SINTABSIZE)];

				if ( bStriped )
					frame = i%6;
				else
					frame = c%6;

				int res1 = (i*SineTable.SINTABSIZE)/h;
				int res2 = (j*SineTable.SINTABSIZE)/w;

				Balls[c] = new VbBall( x, y, z, frame, res1, res2 );

				x += xinc;
				c++;
			} // End for j

			y += yinc;
		} // End for i
	}
}

// Cube
class VbObject_Cube extends VbObject
{
	// Constructor for each type of object
	VbObject_Cube( int w, int xExtent, boolean bHollow, boolean bStripey )
	{
		if ( bHollow )
		{
			int tw=w-2;
			iNumBalls = w*w*w - tw*tw*tw;
		}
		else
		{
			iNumBalls = w*w*w;
		}
		Balls = new VbBall[iNumBalls];

		int	xinc = xExtent/w;

		int c = 0;
		int z = -(xExtent/2);

		for ( int k=0; k<w; k++ )
		{
			int y = -(xExtent/2);

			for ( int i=0; i<w; i++ )
			{
				int x = -(xExtent/2);

				for ( int j=0; j<w; j++ )
				{
					if ( bHollow && (k!=0) && (k!=(w-1)) && (j!=0) && (j!=(w-1)) && (i!=0) && (i!=(w-1)) )
					{
						// Skip this ball!
					}
					else
					{
						int frame;

						if ( bStripey )
						{
							frame	= ((k*w*w)+(i*w)+j)%6;
						}
						else
						{
							frame	= j%6;
						}

						int res2	= (j*SineTable.SINTABSIZE)/w;

						Balls[c] = new VbBall( x, y, z, frame, 0, res2 );

						c++;
					}

					x += xinc;
				} // End for j

				y += xinc;
			} // End for i

			z += xinc;
		} // End for k

	}
}

// ABLogo
class VbObject_ABLogo extends VbObject
{
	private final static int FrameBk = 5;
	private final static int FrameFg = 3;

	// Constructor for each type of object
	VbObject_ABLogo( int xExtent )
	{
		int i,j;

		int w = 8;
		int h = 8;

		iNumBalls = w*h;
		Balls = new VbBall[iNumBalls];

		int xinc = xExtent/w;

		int c = 0;
		int y = -(xExtent/2);

		for ( i=0; i<h; i++, y += xinc )
		{
			int x = -(xExtent/2);

			for ( j=0; j<w; j++, x += xinc )
			{
				Balls[c++] = new VbBall( x, y, 0, FrameBk, 0, 0 );
			}
		}

		i = 1;
		for ( j=1; j<(w-1); j++ )
		{
			Balls[(i*w)+j].frame = FrameFg;
		}

		i = (h-2);
		for ( j=1; j<(w-1); j++ )
		{
			Balls[(i*w)+j].frame = FrameFg;
		}

		j = 2;
		for ( i=1; i<(h-1); i++ )
		{
			Balls[(i*w)+j].frame = FrameFg;
		}

		j = (h-3);
		for ( i=1; i<(h-1); i++ )
		{
			Balls[(i*w)+j].frame = FrameFg;
		}

	}
}


//==============================================================================
// Main Class for applet jvb
//
//==============================================================================
public class jvb extends Applet implements Runnable
{
	private final static int SINTABINCX = 280;
	private final static int SINTABINCY = 100;

	private final static int MAXOBJECTS = 9;

	private boolean		bInit = false;		// Applet initialised for drawing?

	private int			wScreen, hScreen;	// Dimensions of render area
	private Image		imRender;			// Render Target - Offscreen surface
	private Graphics	gRender;			// Context for Render Target

	private VbObject	pObject;			// Ptr to current object
	private int			iObject;			// Index Of Object
	private VbObject	Objects[];			// MAXOBJECTS
	private int			cObjects;			// Count Of Objects

	private VbSprite	GlobalSprite;		// Only using one sprite for now

	private float	xrot = 0;
	private float	yrot = 0;
	private float	zrot = 0;

	private float	xinc = 0;
	private float	yinc = 0;
	private float	zinc = 0;

	//
	private Random	 m_rand = new Random();
	private Thread	 m_jvb = null;

	private String m_Object = "Apple";
	private final String PARAM_Object = "Object";

	public jvb() {}

	public String getAppletInfo()
	{
		return "Name: jvb\r\n" + "Author: Andy Buchanan\r\n" + "Created with Microsoft Visual J++ Version 1.1";
	}

	public String[][] getParameterInfo()
	{
		String[][] info =
		{
			{ PARAM_Object, "String", "ID Object: 0..1 (Currently) " },
		};
		return info;		
	}

	public void init()
	{
		String param;
		param = getParameter(PARAM_Object);
		if (param != null)
			m_Object = param;

		wScreen = 480;	// Fixed Size, for now at least
		hScreen = 300;

		setBackground( Color.black ); 
		resize( wScreen, hScreen );	

		// Applet Initialization code here...

		// Interpret m_object
		int useOb = Integer.parseInt( m_Object );

		// Setup Objects
		Objects = new VbObject[MAXOBJECTS];
		cObjects=0;

		// 0. Sinus Square
		Objects[cObjects] = new VbObject_Rectangle( 11, 11, 242, 242, false, true, 40 );
		Objects[cObjects].SetAnimation( VbObject.ANIM_SINUS, 40, SINTABINCX, SINTABINCY, 0, 0 );
		cObjects++;

		// 1. Exploded Cube
		Objects[cObjects] = new VbObject_Cube( 6, 264, false, false );
		cObjects++;

		// 2. Hollow Cube
		Objects[cObjects] = new VbObject_Cube( 6, 132, true, true );
		cObjects++;

		// 3. AfterBurner Logo
		Objects[cObjects] = new VbObject_ABLogo( 224 );
		cObjects++;

		// 4. Exploded Cube #2
		Objects[cObjects] = new VbObject_Cube( 5, 125, false, true );
		cObjects++;

		// 5. Hollow Cube #2
		Objects[cObjects] = new VbObject_Cube( 7, 160, true, true );
		cObjects++;

		// 6. Sinus Square #2
		Objects[cObjects] = new VbObject_Rectangle( 12, 12, 264, 264, true, true, 60 );
		Objects[cObjects].SetAnimation( VbObject.ANIM_SINUS, 20, SINTABINCX/2, SINTABINCY/2, 0, 0 );
		cObjects++;

		// 7. Exploded Cube #3
		Objects[cObjects] = new VbObject_Cube( 5, 130, false, true );
		Objects[cObjects].SetAnimation( VbObject.ANIM_SWOOSH, 15, SINTABINCX/4, 0, 0, 0 );
		cObjects++;

		// 8. Hollow Cube #3
		Objects[cObjects] = new VbObject_Cube( 6, 150, true, true );
		Objects[cObjects].SetAnimation( VbObject.ANIM_WOBBLE, 10, SINTABINCX/6, 3, 0, 0 );
		cObjects++;

	
		// Select Initial Object
		iObject = useOb;
		pObject = Objects[iObject];

		// Set initial rotations etc
		xrot = 0; yrot = 0; zrot = 0;

		xinc = (float)(Math.PI/180.0f);
		yinc = (float)(Math.PI/90.0f);
		zinc = (float)(-Math.PI/90.0f);


		// Setup Render Surface
		imRender = createImage( wScreen, hScreen );
		gRender = imRender.getGraphics();

		gRender.setColor( Color.black );
		gRender.fillRect( 0, 0, wScreen, hScreen );

		// Move origin, save us doing it in projection!
		gRender.translate( wScreen/2, hScreen/2 );

		// Since this is an applet, this will only be shown if the Java Console is active
		// but thats ok, 'cos now we have our 'OutputDebugString' equivalent :-)
		System.out.println( "Applet Initialised OK" );
	}

	public void destroy()
	{
		// TODO: Place applet cleanup code here
	}

	// We Override update to stop the background being cleared
	// In concert with the double bufferring this stops
	// any annoying flicker
	public void update( Graphics g )
	{
		paint( g );
	}

	public void paint(Graphics g)
	{
		if ( bInit )
		{
			gRender.setColor( Color.white );
			gRender.drawString( "Java VectorBalls (c)Obi. Press +/- for shapes.", 2-(wScreen/2), (hScreen/2)-2 );

			g.drawImage( imRender, 0, 0, this );
		}
		else
		{
			Color cc[] = { Color.blue, Color.magenta, Color.red, Color.white, Color.green, Color.yellow };
			g.setColor( cc[ m_rand.nextInt() % cc.length ] );
			g.drawString( "Loading Graphics...", 5, 15 );
		}
	}

	public void start()
	{
		// Start thread now so we can show the "Loading Graphics.." Message
		if (m_jvb == null)
		{
			m_jvb = new Thread(this);
			m_jvb.start();
		}

		// Applet start code here

		// Load up Sprites

		// New Method
		Image imSprite = ImageLoader( getDocumentBase(), "orb_all.gif" );
		GlobalSprite = new VbSprite( imSprite, 6, this );

/*		// Old Method
		Image imSpriteFrames[] = new Image[6];
		imSpriteFrames[0] = ImageLoader( getDocumentBase(), "orb_blue.gif" );
		imSpriteFrames[2] = ImageLoader( getDocumentBase(), "orb_purple.gif" );
		imSpriteFrames[3] = ImageLoader( getDocumentBase(), "orb_red.gif" );
		imSpriteFrames[4] = ImageLoader( getDocumentBase(), "orb_white.gif" );
		imSpriteFrames[1] = ImageLoader( getDocumentBase(), "orb_green.gif" );
		imSpriteFrames[5] = ImageLoader( getDocumentBase(), "orb_yellow.gif" );
		GlobalSprite = new VbSprite( imSpriteFrames, 6 );
*/
		// Attach Sprite to object(s)
		for ( int i=0; i<cObjects; i++ )
		{
			//System.out.println( "Assigning "+GlobalSprite+" to "+Objects[i] );
			Objects[i].SetSprite( GlobalSprite );
		}

		bInit = true;
	}
	
	public void stop()
	{
		if (m_jvb != null)
		{
			m_jvb.stop();
			m_jvb = null;
		}

		// Applet stop code here...

		bInit = false;
	}

	public void run()
	{
		while (true)
		{
			try
			{
				if ( bInit )
				{
					UpdateVBFrame();
					DrawVBFrame( gRender );
				}

				repaint();
				Thread.sleep(10);	// Max out at 100 frames/sec!
			}
			catch (InterruptedException e)
			{
				// TODO: Place exception-handling code here in case an
				//       InterruptedException is thrown by Thread.sleep(),
				//		 meaning that another thread has interrupted this one
				stop();
			}
		}
	}

	private void DrawVBFrame( Graphics gContext )
	{
		if ( !bInit ) return;

		gContext.setColor( Color.black );
		gContext.fillRect( -wScreen/2, -hScreen/2, wScreen, hScreen );

		pObject.Balls[0].TreeWalkAndDraw( gContext );
	}

	private void UpdateVBFrame()
	{
		if ( !bInit ) return;				// Not set up
		if ( null == pObject ) return;		// No Object!

		float x,y,z;

		// Calculate Xfrm
		VbMatrix Ma = new VbMatrix();
		VbMatrix Mb = new VbMatrix();
		VbMatrix Mc = new VbMatrix();
		Ma.RotX( xrot );
		Mb.RotY( yrot );
		Mc.RotZ( zrot );

		VbMatrix Mt = new VbMatrix();
		Mt.Concat( Mb, Ma );

		VbMatrix Mtransform = new VbMatrix();
		Mtransform.Concat( Mc, Mt );

		pObject.TransformAndAnimate( Mtransform );

		// Update Angles
		xrot += xinc;
		yrot += yinc;
		zrot += zinc;
	}

	private Image ImageLoader( URL url, String sFilename )
	{
		// Loads specified image. Waits for Load to complete
		MediaTracker mt = new MediaTracker( this );

		Image im = getImage( url, sFilename );

		mt.addImage( im, 0 );
		
		try
		{
			mt.waitForAll();
		}
		catch (InterruptedException e) {}

		return im;
	}

	// User Interaction. Limited but at least it's here!!
	public boolean keyUp( Event  evt, int  key )
	{
		switch ( key )
		{
			case '+':
				iObject = (iObject+1)%cObjects;
				pObject = Objects[iObject];
				//System.out.println( "New Ob "+iObject+" ("+pObject+")" );
				break;
			case '-':
				iObject = (iObject-1+cObjects)%cObjects;
				pObject = Objects[iObject];
				//System.out.println( "New Ob "+iObject+" ("+pObject+")" );
				break;
		}

		return true;
	}

}