/**

* Xelfi

*/

package xelfi.design.components.xawt;

import java.awt.*;

import java.io.*;

import java.util.Vector;

import xelfi.awt.Panel3D;

import xelfi.design.components.*;

import xelfi.design.components.property.*;

import xelfi.design.forms.XelfiDesignForm;

import xelfi.design.forms.layouts.XAbsoluteLayout;

import xelfi.design.util.*;

import xelfi.util.XelfiPath;

import xelfi.util.Debug;

import xelfi.top.TopLevel;

/**

 * @version	1.03 31 Mar 1997

 *   1.00 clone from XPanel 2.10 (24 Feb 1997)

 * @author 	Petr Hamernik, Ian Formanek

 */

public class XPanel3D extends Panel3D implements XelfiVisualContainer {

	// property constants

	private static final int GRID = 0; 

	private static final int BACKGROUNDCOLOR = 1; 

	private static final int FOREGROUNDCOLOR = 2; 

	private static final int ENABLED = 3; 

	private static final int VISIBLE = 4; 

	private static final int FONT = 5; 

	private static final int PARENTCOLOR = 6; 

	private static final int PARENTFONT = 7; 

	private static final int DESIGNSIZE = 8; 

	private static final int BEVELINNER = 9;

	private static final int BEVELOUTER = 10;

	private static final int BEVELWIDTH = 11;

	private static final int BORDERWIDTH = 12;

	private static final int BORDERCOLOR = 13;

	private static final int CAPTION = 14;

	private static int propertyCount = 15;

	private static Object propDef[];	// default values of properties

	// set-up default property values

	private static boolean propDefSet = false;

	private static void propertiesSetDefault() {

		propDef = new Object[propertyCount];

		propDefSet = true;

		propDef[GRID] = null;

		propDef[BACKGROUNDCOLOR] = null;

		propDef[FOREGROUNDCOLOR] = null;

		propDef[ENABLED] = Boolean.TRUE;

		propDef[VISIBLE] = Boolean.TRUE;

		propDef[FONT] = null;

		propDef[PARENTCOLOR] = Boolean.TRUE;

		propDef[PARENTFONT] = Boolean.TRUE;

		propDef[DESIGNSIZE] = Boolean.TRUE;

		propDef[BEVELINNER] = new Integer(defaultBevelInner);

		propDef[BEVELOUTER] = new Integer(defaultBevelOuter);

		propDef[BEVELWIDTH] = new Integer(defaultBevelWidth);

		propDef[BORDERWIDTH] = new Integer(defaultBorderWidth);

		propDef[BORDERCOLOR] = defaultBorderColor;

		propDef[CAPTION] = null;

	}

	private static final int DEFWIDTH = 100;

	private static final int DEFHEIGHT = 100;

	private Point position;

	private Dimension size;

	private String name = "";

	private XelfiDesignLayout xLayout;

	private boolean parentColor = true;

	private boolean parentFont = true;

//	private boolean showBorder = true;

	private boolean designSize = true;

	private boolean bVisible = true;

	private boolean backgroundChanged = false;

	private boolean foregroundChanged = false;

	private boolean fontChanged = false;

	private static int eventCount = 12;

	private String events[] = new String[eventCount];

	private static Image icon = null;

	private XelfiDesignForm parentForm = null;

	protected int sel = XFDesignConstants.SEL_UNSELECT;

	// U=Up, D=Down, L=Left, R=Right, M=Middle

	protected final static int DM_NONE	= 0;

	protected final static int DM_UL	= 1;

	protected final static int DM_ML	= 2;

	protected final static int DM_DL	= 3;

	protected final static int DM_UM	= 4;

	protected final static int DM_DM	= 6;

	protected final static int DM_UR	= 7;

	protected final static int DM_MR	= 8;

	protected final static int DM_DR	= 9;

	protected Point dragOrigin = null;

	protected int dragMode = DM_NONE;

	private GridInfo grid = new GridInfo(XFDesignOptions.gridX, XFDesignOptions.gridX);

//////////////////

// constructors //

//////////////////

	public XPanel3D() { 

		if (!propDefSet) propertiesSetDefault();

		position = new Point(0,0); 

		size = null;

		xLayout = new XAbsoluteLayout();

		setLayout((LayoutManager)xLayout);

		if (icon == null)

			loadIcon();

	}

	public Insets insets() {

		Insets ins = super.insets();

		int i = XFDesignOptions.selectionSize;

		if (sel != XFDesignConstants.SEL_UNSELECT) {

			ins.left += i;

			ins.right += i;

			ins.top += i;

			ins.bottom += i;

		}

		return ins;

	}

	public void setParentForm(XelfiDesignForm form) {

		parentForm = form;

	}

	public XelfiDesignForm getParentForm() {

		return parentForm;

	}

	protected void repaintComponent() {

		((Component)this).invalidate();

		if (((Component)this).getParent() != null)

			((Component)this).getParent().validate();

	}

	protected void regenForm(int what) {

		if (parentForm != null)

			parentForm.regenerateCode(this, what);

	}

	protected boolean allowsDrag() {

		return ((XelfiVisualContainer)getParent()).getDesignLayout().allowsDragging();

	}

///////////////////////////

// common implementation //

///////////////////////////

	public String getName() { return name; }

	public int setDesignName(String aName) { 

		name = aName;

		return XFDesignConstants.RSP_OK;

	}

	public Point getPosition() { 

		return new Point(position.x,position.y);

	}

	public int setPosition(int x, int y) { 

		if (position == null)

			position = new Point(x, y);

		else {

			position.x = x;

			position.y = y;

		}

		regenForm(XFDesignConstants.GEN_RESHAPE);

		repaintComponent();

		return XFDesignConstants.RSP_OK;

	}

	public boolean handleEvent(Event evt) {

		if (XFDesignOptions.designMode==XFDesignConstants.DM_DESIGN) {

			if ((sel == XFDesignConstants.SEL_SELECT) && (evt.id == Event.MOUSE_DOWN)) {

				dragMode = resolveMode(evt.x, evt.y);

				if (dragMode != DM_NONE) {

					dragOrigin = new Point(evt.x, evt.y);

					if (!allowsDrag()) {

						dragMode = DM_NONE;

						repaint();

						return false;

					}

					repaint();

					return true;

				}

			}

			else if ((sel == XFDesignConstants.SEL_SELECT) && (evt.id == Event.MOUSE_UP)) {

				if (dragMode != DM_NONE) {

					Dimension d = getSize();

					Point p = getPosition();

					boolean changePos = false;

					if ((dragMode != DM_UM) && (dragMode != DM_DM)) {

						if ((dragMode == DM_UL) || (dragMode == DM_ML) || (dragMode == DM_DL)) {

							d.width += dragOrigin.x - evt.x;

							p.x += evt.x - dragOrigin.x;

							changePos = true;

						}

						else d.width -= dragOrigin.x - evt.x;

						if (d.width < 0) d.width = 0;

					}

					if ((dragMode != DM_ML) && (dragMode != DM_MR)) {

						if (d.height < 0)

							d.height = 0;

						if ((dragMode == DM_UL) || (dragMode == DM_UM) || (dragMode == DM_UR)) {

							p.y += evt.y - dragOrigin.y;

							d.height += dragOrigin.y - evt.y;

							changePos = true;

						}

						else d.height -= dragOrigin.y - evt.y;

						if (d.height < 0) d.height = 0;

					}

					if (changePos)

						setPosition(p.x, p.y);

					setDesignSize(d.width, d.height);

					TopLevel.getInspector().selectionChanged();

					dragMode = DM_NONE;

				}

			}

			return false;

		}

		else return super.handleEvent(evt);

	}

	private int resolveMode(int x, int y) {

		int res = 0;

		int df = XFDesignOptions.selectionSize;

		Dimension d = size();

		if (x < df)

			res = 0;

		else if (x >= d.width - df)

			res = 6;

		else if ((x >= (d.width-df)/2) && (x < (d.width-df)/2+df) && (d.width >= 3*df+2))

			res = 3;

		else return DM_NONE;

		if (y <= df)

			res += 1;

		else if (y >= d.height - df)

			res += 3;

		else if ((y >= (d.height-df)/2) && (y < (d.height-df)/2+df) && (d.height >= 3*df+2))

			res += 2;

		else return DM_NONE;

		if (res == 5)

			return DM_NONE;

		else

			return res;

	}

	private boolean propertyDefault(int i) throws XFPropertyIndexOutOfBoundsException {

		switch (i) {

			case GRID: return false;

			case BACKGROUNDCOLOR: return !backgroundChanged; // ((Color) propDef[i]).equals(getBackground());

			case FOREGROUNDCOLOR: return !foregroundChanged; // ((Color) propDef[i]).equals(getForeground());

			case ENABLED: return (((Boolean) propDef[i]).booleanValue() == isEnabled());

			case VISIBLE: return (((Boolean) propDef[i]).booleanValue() == bVisible);

			case FONT: return !fontChanged; // ((Font) propDef[i]).equals(getFont());

			case PARENTCOLOR: return (((Boolean) propDef[i]).booleanValue() == parentColor);

			case PARENTFONT: return (((Boolean) propDef[i]).booleanValue() == parentFont);

			case DESIGNSIZE: return (((Boolean) propDef[i]).booleanValue() == designSize);

			case BEVELINNER: return (((Integer) propDef[i]).intValue() == defaultBevelInner);

			case BEVELOUTER: return (((Integer) propDef[i]).intValue() == defaultBevelOuter);

			case BEVELWIDTH: return (((Integer) propDef[i]).intValue() == defaultBevelWidth);

			case BORDERWIDTH: return (((Integer) propDef[i]).intValue() == defaultBorderWidth);

			case BORDERCOLOR: return ((Color) propDef[i]).equals(defaultBorderColor);

			case CAPTION: return (captionEmpty());

			default: throw new XFPropertyIndexOutOfBoundsException();

		}

	}

///////////////////////////////////////

// component specific implementation //

///////////////////////////////////////

	public Dimension preferredSize() {

		if (XFDesignOptions.designMode == XFDesignConstants.DM_REAL || (!designSize))

			return super.preferredSize();

		if (size == null) size = new Dimension(DEFWIDTH, DEFHEIGHT);

		Dimension sz = new Dimension(size);

		if (sel != XFDesignConstants.SEL_UNSELECT) {

			sz.height += 2*XFDesignOptions.selectionSize;

			sz.width += 2*XFDesignOptions.selectionSize;

		}

		return new Dimension(sz);

	}

	public Dimension getDesignSize() { 

		if (size == null) size = new Dimension(DEFWIDTH, DEFHEIGHT);

		Dimension sz = new Dimension(size);

		if (sel != XFDesignConstants.SEL_UNSELECT) {

			sz.height += 2*XFDesignOptions.selectionSize;

			sz.width += 2*XFDesignOptions.selectionSize;

		}

		return sz;

	}

	public Dimension getSize() { 

		Dimension sz = preferredSize();

		if (size == null)

			size = sz;

		return new Dimension(size);

	}

	public int setDesignSize(int w, int h) { 

		if (size == null)

			size = new Dimension(w,h);

		else {

			size.width = w;  

			size.height = h;

		}

		grid.gridImage = null;

		resize(size);

		regenForm(XFDesignConstants.GEN_RESHAPE);

		repaintComponent();

		return XFDesignConstants.RSP_OK;

	}

	public int getPropertyCount() { return propertyCount; }

	public Object getProperty(int index) throws XFPropertyIndexOutOfBoundsException { 

		switch (index) {

			case GRID: return grid;

			case BACKGROUNDCOLOR: return getBackground();

			case FOREGROUNDCOLOR: return getForeground();

			case ENABLED: return (isEnabled()) ? Boolean.TRUE : Boolean.FALSE;

			case VISIBLE: return (isVisible()) ? Boolean.TRUE : Boolean.FALSE;

			case FONT: return getFont();

			case PARENTCOLOR: return (parentColor) ? Boolean.TRUE : Boolean.FALSE;

			case PARENTFONT: return (parentFont) ? Boolean.TRUE : Boolean.FALSE;

			case DESIGNSIZE: return (designSize) ? Boolean.TRUE : Boolean.FALSE;

			case BEVELINNER: return new Integer(getBevelInner());

			case BEVELOUTER: return new Integer(getBevelOuter());

			case BEVELWIDTH: return new Integer(getBevelWidth());

			case BORDERWIDTH: return new Integer(getBorderWidth());

			case BORDERCOLOR: return getBorderColor();

			case CAPTION: return getCaption();

			default: throw new XFPropertyIndexOutOfBoundsException();

		}

	}

	public String[] getPropertyNames() { 

		String list[] = new String[propertyCount];

		list[GRID] = new String("Grid"); 

		list[BACKGROUNDCOLOR] = new String("Background Color"); 

		list[FOREGROUNDCOLOR] = new String("Foreground Color"); 

		list[ENABLED] = new String("Enabled"); 

		list[VISIBLE] = new String("Visible"); 

		list[FONT] = new String("Font"); 

		list[PARENTCOLOR] = new String("Parent Color"); 

		list[PARENTFONT] = new String("Parent Font"); 

		list[DESIGNSIZE] = new String("DesignSize"); 

		list[BEVELINNER] = new String("Bevel Inner");

		list[BEVELOUTER] = new String("Bevel Outer");

		list[BEVELWIDTH] = new String("Bevel Width");

		list[BORDERWIDTH] = new String("Border Width");

		list[BORDERCOLOR] = new String("Border Color");

		list[CAPTION] = new String("Caption");

		return list;

	}

	public String getPropertyString(int index) throws 

		XFPropertyIndexOutOfBoundsException { 

		switch (index) {

			case GRID: return XGridPropertyType.viewString(getProperty(index));

			case BACKGROUNDCOLOR: 

			case FOREGROUNDCOLOR: return XColorPropertyType.viewString(getProperty(index));

			case FONT: return XFontPropertyType.viewString(getProperty(index));

			case ENABLED:

			case VISIBLE:

			case PARENTCOLOR: 

			case PARENTFONT: 

			case DESIGNSIZE: return XBooleanPropertyType.viewString(getProperty(index));

			case BEVELINNER:

			case BEVELOUTER:

			case BEVELWIDTH:

			case BORDERWIDTH: return XIntegerPropertyType.viewString(getProperty(index));

			case BORDERCOLOR: return XColorPropertyType.viewString(getProperty(index));

			case CAPTION:	return XStringPropertyType.viewString(getProperty(index));

			default: throw new XFPropertyIndexOutOfBoundsException();

		}

	}

	public int getPropertyViewerType(int index) throws 

		XFPropertyIndexOutOfBoundsException {

		switch (index) {

			case GRID:

			case BACKGROUNDCOLOR: 

			case FOREGROUNDCOLOR:

			case FONT: return XFDesignConstants.PVT_SPECIAL;

			case ENABLED:

			case VISIBLE:

			case PARENTCOLOR: 

			case PARENTFONT: 

			case DESIGNSIZE: return XFDesignConstants.PVT_CHECK;

			case BEVELINNER:

			case BEVELOUTER:return XFDesignConstants.PVT_CHOICE_STRICT;

			case BEVELWIDTH:

			case BORDERWIDTH: return XFDesignConstants.PVT_INPUT_INT;

			case BORDERCOLOR: return XFDesignConstants.PVT_SPECIAL;

			case CAPTION: return XFDesignConstants.PVT_INPUT_STRING;

			default: throw new XFPropertyIndexOutOfBoundsException();

		}

	}

	public String[] getPropertyValueNames(int index) throws 

		XFPropertyIndexOutOfBoundsException {

		switch (index) {

			case BEVELINNER: 

			case BEVELOUTER: 

					String[] ret = new String[3];

					ret[0] = "NONE";

					ret[1] = "LOWERED";

					ret[2] = "RAISED";

					return ret;

			default: throw new XFPropertyIndexOutOfBoundsException();

		}

	}

	public Object[] getPropertyValueValues(int index) throws 

		XFPropertyIndexOutOfBoundsException {

		switch (index) {

			case BEVELINNER: 

			case BEVELOUTER: 

					Integer[] ret = new Integer[3];

					ret[0] = new Integer(BV_NONE);

					ret[1] = new Integer(BV_LOWERED);

					ret[2] = new Integer(BV_RAISED);

					return ret;

			default: throw new XFPropertyIndexOutOfBoundsException();

		}

	}

	private boolean setParentColor(boolean aParentColor) {

		if (aParentColor == parentColor) return false;

		parentColor = aParentColor;

		if (parentColor) {

			parentUpdate();

//			updateSubComponents();

		}

		return parentColor;

	}

	private boolean setParentFont(boolean aParentFont) {

		if (aParentFont == parentFont) return false;

		parentFont = aParentFont;

		if (parentFont) {

			parentUpdate();

//			updateSubComponents();

		}

		return parentFont;

	}

	public boolean parentUpdate() {

		boolean b = true;

		if ((parentFont) && (!getParent().getFont().equals(getFont()))) {

			b = true;

			setFont(getParent().getFont());

		}

		if (parentColor) {

			if (!getParent().getForeground().equals(getForeground())) {

				b = true;

				setForeground(getParent().getForeground());

			}

			if (!getParent().getBackground().equals(getBackground())) {

				b = true;

				setBackground(getParent().getBackground());

			}

		}

		if (b) {

			updateSubComponents();

//			hide();	show();

//			repaintComponent();

		}

		regenForm(XFDesignConstants.GEN_SETPROPS);

		return b;

	}

	private void updateSubComponents() {

		Component comps1[] = getComponents();

		for (int i=0; i<comps1.length; i++)

			((XelfiVisualComponent)(comps1[i])).parentUpdate();

		invalidate(); validate(); 

		hide(); show();

	}

	public int setProperty(int index, Object value) throws 	

		XFPropertyIndexOutOfBoundsException,

		XFPropertyBadValueTypeException 

	{ 

		int ret = XFDesignConstants.RSP_OK;

		int regen = XFDesignConstants.GEN_SETPROPS;

		switch (index) { 

			case GRID: if (!(value instanceof GridInfo)) throw new XFPropertyBadValueTypeException();

					grid = (GridInfo) value;

					hide(); show(); // [PENDING - to test]

					break;

			case BACKGROUNDCOLOR: if (!(value instanceof Color)) throw new XFPropertyBadValueTypeException();

					setBackground((Color)value);

					backgroundChanged = true;

					ret = XFDesignConstants.RSP_REPAINT_COMP;

					grid.gridImage = null; // to repaint grid image

					hide();

					show();

					if (parentColor) {

						parentColor = false;

						ret = ret | XFDesignConstants.RSP_OTHER_PROP;

					}

					updateSubComponents();

					break;

			case FOREGROUNDCOLOR: if (!(value instanceof Color)) throw new XFPropertyBadValueTypeException();

					setForeground((Color)value);

					foregroundChanged = true;

					ret = XFDesignConstants.RSP_REPAINT_COMP;

					grid.gridImage = null; // to repaint grid image

					hide();

					show();

					if (parentColor) {

						parentColor = false;

						ret = ret | XFDesignConstants.RSP_OTHER_PROP;

					}

					updateSubComponents();

					break;

			case ENABLED: if (!(value instanceof Boolean)) throw new XFPropertyBadValueTypeException();

					enable(((Boolean)value).booleanValue());

				break;

			case VISIBLE: if (!(value instanceof Boolean)) throw new XFPropertyBadValueTypeException();

					bVisible = ((Boolean)value).booleanValue();

				break;

			case FONT: if (!(value instanceof Font)) throw new XFPropertyBadValueTypeException();

					setFont((Font)value);

					fontChanged = true;

					ret = XFDesignConstants.RSP_REPAINT_COMP;

					if (parentFont) {

						parentFont = false;

						ret = ret | XFDesignConstants.RSP_OTHER_PROP;

					}

					updateSubComponents();

					break;

			case PARENTCOLOR:	if (!(value instanceof Boolean)) throw new XFPropertyBadValueTypeException();

					setParentColor(((Boolean)value).booleanValue());

					if (parentColor)

						ret = XFDesignConstants.RSP_REPAINT_COMP;

					break;

			case PARENTFONT: if (!(value instanceof Boolean)) throw new XFPropertyBadValueTypeException();

					setParentFont(((Boolean)value).booleanValue());

					if (parentFont)

						ret = XFDesignConstants.RSP_REPAINT_COMP;

					break;

			case DESIGNSIZE: if (!(value instanceof Boolean)) throw new XFPropertyBadValueTypeException();

					designSize = (((Boolean)value).booleanValue());

					ret = XFDesignConstants.RSP_REPAINT_COMP;

					repaintComponent();

					break;

			case BEVELINNER:if (!(value instanceof Integer)) throw new XFPropertyBadValueTypeException();

					setBevelInner(((Integer)value).intValue());

					break;

			case BEVELOUTER:if (!(value instanceof Integer)) throw new XFPropertyBadValueTypeException();

					setBevelOuter(((Integer)value).intValue());

					break;

			case BEVELWIDTH:if (!(value instanceof Integer)) throw new XFPropertyBadValueTypeException();

					setBevelWidth(((Integer)value).intValue());

					break;

			case BORDERWIDTH:if (!(value instanceof Integer)) throw new XFPropertyBadValueTypeException();

					setBorderWidth(((Integer)value).intValue());

					break;

			case BORDERCOLOR:if (!(value instanceof Color)) throw new XFPropertyBadValueTypeException();

					setBorderColor((Color)value);

					break;

			case CAPTION:if (!(value instanceof String)) throw new XFPropertyBadValueTypeException();

					setCaption((String)value);

					break;

			default: throw new XFPropertyIndexOutOfBoundsException();

		}

		if (parentForm != null)

			parentForm.regenerateCode(this, regen);

		return ret;

	}

	public void specialPropertyInput(Frame parent, int index) throws 	

		XFPropertyIndexOutOfBoundsException, 

		XFPropertyNoSpecialInputException { 

		if ((index < 0) || (index >= propertyCount)) throw new XFPropertyIndexOutOfBoundsException();

		switch (index) { 

			case GRID: XGridPropertyType.invokeSpecialInput(parent, this, index);

						break;

			case BACKGROUNDCOLOR:

			case FOREGROUNDCOLOR: 

			case BORDERCOLOR: XColorPropertyType.invokeSpecialInput(parent, this, index);

				break;

			case FONT: XFontPropertyType.invokeSpecialInput(parent, this, index);

						break;

			default: throw new XFPropertyNoSpecialInputException();

		}

	}

	public int getEventCount() {

		return eventCount;

	}

	public String[] getEventNames() {

		String list[] = new String[eventCount];

		list[0] = new String("OnGotFocus"); 

		list[1] = new String("OnLostFocus"); 

		list[2] = new String("OnKeyAction"); 

		list[3] = new String("OnKeyActionRelease"); 

		list[4] = new String("OnKeyPress"); 

		list[5] = new String("OnKeyRelease"); 

		list[6] = new String("OnMouseDown"); 

		list[7] = new String("OnMouseUp"); 

		list[8] = new String("OnMouseMove"); 

		list[9] = new String("OnMouseDrag"); 

		list[10] = new String("OnMouseEnter"); 

		list[11] = new String("OnMouseExit"); 

		return list;

	}

	public String getEvent(int index) throws 

		XFPropertyIndexOutOfBoundsException {

		if ((index>=0) && (index<eventCount)) {

			if (events[index] == null)

				return null;

			else

				return new String(events[index]); 

		}

		else throw new XFPropertyIndexOutOfBoundsException();

	}		

	public void setEvent(int index, String value) throws 

		XFPropertyIndexOutOfBoundsException {

		if ((index>=0) && (index<eventCount))

			events[index] = value;

		else throw new XFPropertyIndexOutOfBoundsException();

	}		

	public XelfiDesignLayout getDesignLayout() { return xLayout; }

	public int setDesignLayout(XelfiDesignLayout aXLayout) {

		Component comps[] = getComponents();

		for (int i=0; i<comps.length; i++)

			remove(comps[i]);

		xLayout = aXLayout;

		xLayout.setParent(this);

		setLayout((LayoutManager)xLayout);

		for (int i=0; i<comps.length; i++) {

			// this is here because some layouts can hide some components - we must show them again

			if (!comps[i].isVisible()) comps[i].show();  

			xLayout.layoutAdd(this, (XelfiVisualComponent)comps[i]);

		}

		// is is the panel's parent, who is validated - it is because change of layout can influence 

		// size of this panel

		invalidate(); if (getParent() != null) getParent().validate();

		repaint(); // because of grid

		parentForm.regenerateCode(this, XFDesignConstants.GEN_SETLAYOUT);

		return XFDesignConstants.RSP_OK;

	}

	public Vector getSubComponents() {

		int count = countComponents();

		Vector vect = new Vector(count);

		for (int i=0; i<count; i++) {

			Component comp = getComponent(i); 

			vect.addElement(comp);

			if (comp instanceof XelfiVisualContainer) {

				Vector subVect = ((XelfiVisualContainer)comp).getSubComponents();

				for (int j=0; j<subVect.size(); j++)

					vect.addElement(subVect.elementAt(j));

			}

		}

		return vect;

	}

	public Image getIcon() {

		return icon; 

	}

	private void loadIcon() {

		String sep = new String(System.getProperty("file.separator"));

		StringBuffer s = new StringBuffer(XelfiPath.get() + sep + 

			"design" + sep + "components" + sep + "xawt" + sep + "panel3d.gif");

		icon = Toolkit.getDefaultToolkit().getImage(new String(s));

	}

	public String getClassName() { return "Panel3D"; }

	public void setSelection(int aSel) {

		if (sel == aSel)

			return;

		int old = sel;

		sel = aSel;

		if ((old == XFDesignConstants.SEL_UNSELECT) && (sel != XFDesignConstants.SEL_UNSELECT)) {

			Point l = location();

			Dimension s = size();

			int d = XFDesignOptions.selectionSize;

			reshape(l.x - d, l.y - d, s.width + 2*d, s.height + 2*d);

		}

		else if ((old != XFDesignConstants.SEL_UNSELECT) && (sel == XFDesignConstants.SEL_UNSELECT)) {

			Point l = location();

			Dimension s = size();

			int d = XFDesignOptions.selectionSize;

			reshape(l.x + d, l.y + d, s.width - 2*d, s.height - 2*d);

		}

		repaintComponent();

	}

	public int getSelection() {

		return sel;

	}

	/////////////////////

	// Code generation //

	/////////////////////

	public String[] neededImports() {

		String list[] = new String[1];

		list[0] = "xelfi.awt.Panel3D";

		return list;

	}

	public String generateEventCondition(int index) throws 

	XFPropertyIndexOutOfBoundsException {

		String evt = XFDesignOptions.eventVarName;

		switch (index) { 

			case 0: return evt +".id == Event.GOT_FOCUS && "+evt+".target == "+getName();

			case 1: return evt +".id == Event.LOST_FOCUS && "+evt+".target == "+getName();

			case 2: return evt +".id == Event.KEY_ACTION && "+evt+".target == "+getName();

			case 3: return evt +".id == Event.KEY_ACTION_RELEASE && "+evt+".target == "+getName();

			case 4: return evt +".id == Event.KEY_PRESS && "+evt+".target == "+getName();

			case 5: return evt +".id == Event.KEY_RELEASE && "+evt+".target == "+getName();

			case 6: return evt +".id == Event.MOUSE_DOWN && "+evt+".target == "+getName();

			case 7: return evt +".id == Event.MOUSE_UP && "+evt+".target == "+getName();

			case 8: return evt +".id == Event.MOUSE_MOVE && "+evt+".target == "+getName();

			case 9: return evt +".id == Event.MOUSE_DRAG && "+evt+".target == "+getName();

			case 10: return evt +".id == Event.MOUSE_ENTER && "+evt+".target == "+getName();

			case 11: return evt +".id == Event.MOUSE_EXIT && "+evt+".target == "+getName();

			default: throw new XFPropertyIndexOutOfBoundsException();

		}

	}

	public String generateCode(int what) {

		String gen = "";

		switch (what) {

			case XFDesignConstants.GEN_VARIABLE: 

				gen = getClassName()+" "+ name + ";\n";

				break;

			case XFDesignConstants.GEN_INIT: 

				gen = name + " = new " + getClassName() + "();\n";

				break;

			case XFDesignConstants.GEN_SETLAYOUT:

				gen = xLayout.genLayoutInitCode(name, null); // [PENDING - layout variable name]

				break;

			case XFDesignConstants.GEN_SETPROPS:

				for (int i = 0; i < propertyCount; i++) {

					if (!propertyDefault(i)) {

						switch(i) {

							case BACKGROUNDCOLOR: if (!parentColor)

										gen = gen + name + ".setBackground(" +

											XFDesignUtils.genColor(getBackground()) + ");\n";

									break;

							case FOREGROUNDCOLOR: if (!parentColor)

										gen = gen + name + ".setForeground(" +

											XFDesignUtils.genColor(getForeground()) + ");\n";

									break;

							case ENABLED: gen = gen + name + (isEnabled() ? ".enable();\n" : ".disable();\n");

									break;

							case VISIBLE: gen = gen + name + ((bVisible) ? ".show();\n" : ".hide();\n");

									break;

							case FONT: if (!parentFont) {

										gen = gen + name + ".setFont(" + 

											XFDesignUtils.genFont(getFont())+");\n";

									}

									break;

							case BEVELINNER: gen = gen + name + ".setBevelInner(Panel3D.BV_";

									switch (getBevelInner()) {

										case BV_NONE: gen = gen + "NONE"; break;

										case BV_LOWERED: gen = gen + "LOWERED"; break;

										case BV_RAISED: gen = gen + "RAISED"; break;

									}

									gen = gen + ");\n";

									break;

							case BEVELOUTER: gen = gen + name + ".setBevelOuter(Panel3D.BV_";

									switch (getBevelOuter()) {

										case BV_NONE: gen = gen + "NONE"; break;

										case BV_LOWERED: gen = gen + "LOWERED"; break;

										case BV_RAISED: gen = gen + "RAISED"; break;

									}

									gen = gen + ");\n";

									break;

							case BEVELWIDTH: gen = gen + name + ".setBevelWidth("+

										getBevelWidth() + ");\n";

									break;

							case BORDERWIDTH: gen = gen + name + ".setBorderWidth("+

										getBorderWidth() + ");\n";

									break;

							case BORDERCOLOR: gen = gen + name + ".setBorderColor(" +

											XFDesignUtils.genColor(getBorderColor()) + ");\n";

									break;

							case CAPTION: gen = gen + name + ".setCaption(\"" +

										 getCaption() + "\");\n";

									break;

						}

					}

				}

				break;			

			case XFDesignConstants.GEN_RESHAPE:

				if (((XelfiVisualContainer) getParent()).getDesignLayout().allowsDragging()) 

					if (getParent() instanceof XelfiDesignForm) 

						gen = name + ".reshape(insets.left+"+position.x+", insets.top+"+position.y+","+size.width+","+size.height+");\n";

					else

						gen = name + ".reshape("+position.x+", "+position.y+","+size.width+","+size.height+");\n";

				break;

		}

		return gen;

	}

	/////////////////

	// persistence //

	/////////////////

	public void loadFromStream(DataInput stream) throws IOException { 

		boolean dontRead[] = new boolean[propertyCount];

		Debug.debug(Debug.FORMIO_LOAD, "loading panel3d...(1)");

		name = stream.readUTF();

		int x = stream.readInt();

		int y = stream.readInt();

		setPosition(x,y);

		int w = stream.readInt();

		int h = stream.readInt();

		setDesignSize(w,h);

		Debug.debug(Debug.FORMIO_LOAD, "loaded panel3d: "+name+"["+x+", "+y+", "+w+", "+h+"]");

		for (int i = 0; i < propertyCount; i++) {

			if (!stream.readBoolean()) switch (i) {

				case GRID: grid = XGridPropertyType.loadFromStream(stream); break;

				case BACKGROUNDCOLOR: setBackground(XColorPropertyType.loadFromStream(stream)); break;

				case FOREGROUNDCOLOR: setForeground(XColorPropertyType.loadFromStream(stream)); break;

				case ENABLED: enable(XBooleanPropertyType.loadBFromStream(stream)); break;

				case VISIBLE: bVisible = XBooleanPropertyType.loadBFromStream(stream); break;

				case FONT: setFont(XFontPropertyType.loadFromStream(stream)); break;

				case PARENTCOLOR: setParentColor(XBooleanPropertyType.loadBFromStream(stream)); break;

				case PARENTFONT: setParentFont(XBooleanPropertyType.loadBFromStream(stream)); break;

				case DESIGNSIZE: designSize = XBooleanPropertyType.loadBFromStream(stream); break;

				case BEVELINNER: setBevelInner(XIntegerPropertyType.loadFromStream(stream).intValue()); break;

				case BEVELOUTER: setBevelOuter(XIntegerPropertyType.loadFromStream(stream).intValue()); break;

				case BEVELWIDTH: setBevelWidth(XIntegerPropertyType.loadFromStream(stream).intValue()); break;

				case BORDERWIDTH: setBorderWidth(XIntegerPropertyType.loadFromStream(stream).intValue()); break;

				case BORDERCOLOR: setBorderColor(XColorPropertyType.loadFromStream(stream)); break;

				case CAPTION: setCaption(XStringPropertyType.loadFromStream(stream)); break;

			}

		}

		Debug.debug(Debug.FORMIO_LOAD, "loading panel3d...(2)");

		for (int i = 0; i < eventCount; i++) {

			if (stream.readBoolean()) {

				Debug.debug(Debug.FORMIO_LOAD, "event ["+i+"] loading...");

				parentForm.assignEvent(this, i, stream.readUTF());

			}

		}

		Debug.debug(Debug.FORMIO_LOAD, "loading panel3d...(3)");

		// Panel layout

		String layClass = stream.readUTF();

		Debug.debug(Debug.FORMIO_LOAD, "loading panel3d layout: "+layClass);

		try {

			Class lay = Class.forName(layClass);

			XelfiDesignLayout xdl = (XelfiDesignLayout)lay.newInstance();

			xdl.setParent(this); // necessary for some layouts to know what container they manage

			xLayout = xdl;

			xdl.loadFromStream(stream);  // this may actually change the xLayout property (e.g. GridLayout)

			setLayout((LayoutManager)xLayout);

		} catch (IllegalAccessException e) {

			System.err.println("Illegal Access Exception");

		} catch (InstantiationException e) {

			System.err.println("Instantiation Exception");

		} catch (ClassNotFoundException e) {

			System.err.println("ClassNotFound Exception:"+layClass);

		}

		Debug.debug(Debug.FORMIO_LOAD, "loading panel3d...(4)");

		// Subcomponents

		int compNum = stream.readInt();

		Debug.debug(Debug.FORMIO_LOAD, "loading panel3d components["+compNum+"]");

		for (int i = 0; i<compNum; i++) {

			String compClass = stream.readUTF();

			try {

				Class comp = Class.forName(compClass);

				XelfiVisualComponent xvc = (XelfiVisualComponent)comp.newInstance();

				xvc.setParentForm(parentForm);

				Debug.debug(Debug.FORMIO_LOAD, "loading panel3d subcomponent: "+compClass);

				xvc.loadFromStream(stream);

				xLayout.layoutAdd(this, xvc);

			} catch (IllegalAccessException e) {

				System.err.println("Illegal Access Exception");

			} catch (InstantiationException e) {

				System.err.println("Instantiation Exception");

			} catch (ClassNotFoundException e) {

				System.err.println("ClassNotFound Exception:"+compClass);

			}

		}	

		Debug.debug(Debug.FORMIO_LOAD, "panel loaded succesfully");

	}

	public void saveToStream(DataOutput stream) throws IOException {

		Debug.debug(Debug.FORMIO_SAVE, "saving panel3d...(1)");

		stream.writeUTF(getName());

		Point pos = getPosition();

		stream.writeInt(pos.x);

		stream.writeInt(pos.y);

		Dimension size1 = getSize();

		stream.writeInt(size1.width);

		stream.writeInt(size1.height);

		Debug.debug(Debug.FORMIO_SAVE, "saving panel3d...(2)");

		for (int i = 0; i < propertyCount; i++) {

			boolean b = propertyDefault(i);

			stream.writeBoolean(b);

			if (!b) switch (i) {

				case GRID: XGridPropertyType.saveToStream(getProperty(0),stream); break;

				case BACKGROUNDCOLOR: XColorPropertyType.saveToStream(getBackground(), stream); break;

				case FOREGROUNDCOLOR: XColorPropertyType.saveToStream(getForeground(), stream); break;

				case ENABLED: XBooleanPropertyType.saveToStream(isEnabled(), stream); break;

				case VISIBLE: XBooleanPropertyType.saveToStream(bVisible, stream); break;

				case FONT: XFontPropertyType.saveToStream(getFont(), stream); break;

				case PARENTCOLOR: XBooleanPropertyType.saveToStream(parentColor, stream); break;

				case PARENTFONT: XBooleanPropertyType.saveToStream(parentFont, stream); break;

				case DESIGNSIZE: XBooleanPropertyType.saveToStream(designSize, stream); break;

				case BEVELINNER: XIntegerPropertyType.saveToStream(new Integer(getBevelInner()), stream); break;

				case BEVELOUTER: XIntegerPropertyType.saveToStream(new Integer(getBevelOuter()), stream); break;

				case BEVELWIDTH: XIntegerPropertyType.saveToStream(new Integer(getBevelWidth()), stream); break;

				case BORDERWIDTH: XIntegerPropertyType.saveToStream(new Integer(getBorderWidth()), stream); break;

				case BORDERCOLOR: XColorPropertyType.saveToStream(getBorderColor(), stream); break;

				case CAPTION: XStringPropertyType.saveToStream(new String(getCaption()), stream); break;

			}

		}

		for (int i = 0; i < eventCount; i++) {

			if ((events[i] != null) && (events[i].length() > 0)) {

				stream.writeBoolean(true);

				stream.writeUTF(events[i]);

			}

			else stream.writeBoolean(false);

		}

		// Panel layout

		stream.writeUTF(xLayout.getClass().getName());

		xLayout.saveToStream(stream);

		// Subcomponents

		int compNum = countComponents();

		stream.writeInt(compNum);

		Component comps[] = getComponents();

		for (int i = 0; i<compNum; i++) {

			stream.writeUTF(comps[i].getClass().getName());

			((XelfiDesignComponent)comps[i]).saveToStream(stream);

		}

		Debug.debug(Debug.FORMIO_SAVE, "panel3d saved succesfully");

	}

/////////////

// special //

/////////////

	public void paint(Graphics g) {

		if (XFDesignOptions.designMode == XFDesignConstants.DM_REAL) {

			super.paint(g);

			return;

		}

		Dimension d = size();

		int i = XFDesignOptions.selectionSize;

		if (sel != XFDesignConstants.SEL_UNSELECT) {

			g.setColor(XFDesignOptions.selectionColor);

			g.drawRect(i - 2, i - 2, d.width - 2*i + 3, d.height - 2*i + 3);

			if (sel == XFDesignConstants.SEL_SELECT) {