/**

* Xelfi

*/

package xelfi.design.forms;

import java.awt.*;

import java.io.*;

import java.util.Vector;

import java.util.Enumeration;

import java.util.Hashtable;

import xelfi.top.*;

import xelfi.editor.*;

import xelfi.xedit.*;

import xelfi.design.forms.layouts.*;

import xelfi.design.components.*;

import xelfi.design.components.property.*;

import xelfi.design.util.*;

import xelfi.design.inspector.XelfiComponentInspector;

import xelfi.design.components.palette.XelfiComponentPalette;

import xelfi.design.components.xawt.XMenuBar;

import xelfi.util.Debug;

/**

* XelfiFormDialog is a Dialog which serves as a design Form for Dialog Forms.

* It implements interfaces: <br>

* - XelfiVisualContainer so as it is a container component

* - XelfiDesignForm so as it is a Form

* - ActionController so as it generates and controls blocks of text in text editor

*

* @version 	1.41, 06 Apr 1997

* @author 		Ian Formanek, Petr Hamernik

*/

public class XFFormDialog extends TopDialog implements 

	XelfiVisualContainer, 

	XelfiDesignForm, 

	ActionController

{

	// Component data (form is a component)

	private static int propertyCount = 13;

	private static int eventCount = 12;

	// property constants

	private static final int GRID = 0; 

	private static final int BACKGROUNDCOLOR = 1; 

	private static final int FOREGROUNDCOLOR = 2; 

	private static final int FONT = 3; 

	private static final int TITLE = 4; 

	private static final int MODAL = 5; 

	private static final int RESIZABLE = 6; 

	private static final int SHOWFORM = 7; 

	private static final int MOVEFORM = 8; 

	private static final int RESIZEFORM = 9; 

	private static final int CLASSPUBLIC = 10; 

	private static final int IMPLEMENTS = 11; 

	private static final int IMPORTS = 12; 

	private static Object propDef[];

	private static boolean propDefSet = false;

	private static void propertiesSetDefault() {

		propDefSet = true;

		propDef = new Object[propertyCount];

		propDef[GRID] = null;

		propDef[BACKGROUNDCOLOR] = null;

		propDef[FOREGROUNDCOLOR] = null;

		propDef[FONT] = null;

		propDef[TITLE] = new String("");

		propDef[MODAL] = new Boolean(true);

		propDef[RESIZABLE] = new Boolean(true);

		propDef[SHOWFORM] = new Boolean(true);

		propDef[MOVEFORM] = new Boolean(true);

		propDef[RESIZEFORM] = new Boolean(true);

		propDef[CLASSPUBLIC] = new Boolean(true);

		propDef[IMPLEMENTS] = null;

		propDef[IMPORTS] = null;

	}

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

	private Dimension size;

	private Point position;

	private String formName;

	private XelfiDesignForm parentForm = null;

	private XelfiDesignLayout xLayout;

	private boolean backgroundChanged = false;

	private boolean foregroundChanged = false;

	private boolean fontChanged = false;

	private boolean pIsModal = true;

	private boolean pIsResizable = true; 

	private boolean pShowForm = false;

	private boolean pMoveForm = true;

	private boolean pResizeForm = true;

	private String pImports[] = new String[0];

	private XFFormInheritance inheritance;

	// other

	XelfiComponentInspector inspector;	

	XelfiComponentPalette palette;

	XFNameManager nameManager;

	String packageName;

	private Vector selectedComps;

	private Vector nonVisualComps;

	private Vector containers;

	// for dragging

	private final static int DM_NONE = 0;

	private final static int DM_DRAG = 1;

	private final static int DM_ADD = 2;

	private int dragMode = DM_NONE;

	private XelfiVisualComponent dragComp = null;	// the component that we are dragging/adding

	int drx, dry;

	Point dragP = null;

	Point addPos = null;

	boolean lMouseDown = false;

	XelfiVisualContainer xvcParent = null;

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

	// for code generation

	XFImportsManager impsManager;

	Source formSource;

	Document formDocument;

	Block sourceBeginB, packageB, importsB;

	Block classBeginB, classEndB;

	Block variablesB;

	Block constructorBeginB, constructorEndB;

	Block componentsB;

	Block formLayoutB, formSetpropsB, formResizeB;

	Block handleBeginB, handleEndB;

	Block userMethodsUB, importsUB, constructorUB, handleBodyUB;

	BlockContainer userBlocks;

	DesignBackgroundCallback backCallback;

	// events managenent

	EventPool evPool;

	// templateName	

	String templateName = "Dialog";

	/**

	* Creates new form dialog.

	* @param parent		Frame parent of the design-time dialog form

	* @param aFormName 	name of the form = name of generated class

	* @param aFormSource	Source where the form code will be generated

	*/

	public XFFormDialog(Frame parent, String aFormName, Source aFormSource) {

		this(parent, aFormName, null, aFormSource);

	}

	/**

	* Creates new form frame.

	* @param parent		Frame parent of the design-time dialog form

	* @param aFormName 	name of the form = name of generated class

	* @param aPackageName	Name of the package in which the generated class shoul be

	* @param aFormSource	Source where the form code will be generated

	*/

	public XFFormDialog(Frame parent, String aFormName, String aPackageName, Source aFormSource) {

		super(parent, false);

		if (!propDefSet) propertiesSetDefault();

		formSource = aFormSource;

		// Component init

		position = new Point(0,0); size = null;

		// Other init

		formName = aFormName;

		inheritance = XFFormInheritance.Dialog(pIsModal);

		inspector = TopLevel.getInspector();	

		palette = TopLevel.getPalette();

		nameManager = new XFNameManager();

		impsManager = new XFImportsManager();

		impsManager.assignImport("java.awt.*");

		impsManager.assignImports(neededImports());

		if (!XFDesignOptions.defaultFormBackground.isDefault())

			setBackground(XFDesignOptions.defaultFormBackground.getColor());

		setTitle("");

		xLayout = new XAbsoluteLayout();

		xLayout.setParent(this);

		setLayout((LayoutManager)xLayout);

		impsManager.assignImports(xLayout.neededImports());

		resize(XFDesignOptions.formDefWidth, XFDesignOptions.formDefHeight);

		userBlocks = new BlockContainer();

		backCallback = new DesignBackgroundCallback(userBlocks);

		createFormSource(); // creates new source where the code will be generated

		setPackage(aPackageName);

		selectedComps = new Vector(1,1);

		nonVisualComps = new Vector(1,1);

		containers = new Vector(1,1);

		containers.addElement(this);

		select(this); // initial selection = form

	}

	protected void finalize() throws Throwable {

		formDocument.removeActionController(this);

		super.finalize();

	}

	public boolean handleEvent(Event evt) {

		if (evt.id == Event.WINDOW_DESTROY) {

			hide();

			return true;

		}

		else

		if (evt.id == Event.KEY_PRESS && evt.key == 127) { // Del pressed

			deleteSelection();

		}

		return super.handleEvent(evt);

	}

	public boolean gotFocus(Event evt, Object o) {

		if (inspector.getInspectable()!= this)

			inspector.inspectableChanged(this);

		return super.gotFocus(evt,o);

	}

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

// component dragging //

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

// selection management methods

	// add given component to selected components if it is not already there

	// otherwise remove

	private void toggleSelect(XelfiDesignComponent comp) { 

		if (selectedComps.removeElement(comp)) {  // O.K it was there

			comp.setSelection(XFDesignConstants.SEL_UNSELECT);

			if (selectedComps.size() == 1)

				((XelfiDesignComponent)selectedComps.elementAt(0)).setSelection(XFDesignConstants.SEL_SELECT);

			else if (selectedComps.isEmpty()) select(this); // if last component is deselected, select form

		}

		else {	// component was not selected -->> we add it now

			if (selectedComps.contains(this)) selectedComps.removeElement(this);  // form cannot be in multiple selection

			select(comp);

		}		

	}

	// remove all from selected components

	private void deselectAll() { 

		int count = selectedComps.size();

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

			((XelfiDesignComponent)selectedComps.elementAt(i)).setSelection(XFDesignConstants.SEL_UNSELECT);

		selectedComps.removeAllElements();

	}

	// add given component to selected components

	private void select(XelfiDesignComponent comp) { 

		int oldSize = selectedComps.size();

		selectedComps.addElement(comp);

		int newSize = selectedComps.size();

		if (newSize == 1)

			comp.setSelection(XFDesignConstants.SEL_SELECT);

		else

			if (oldSize == 1)

				for (int i=0; i<newSize; i++)

					((XelfiDesignComponent)selectedComps.elementAt(i)).setSelection(XFDesignConstants.SEL_MUL_SELECT);

			else

				comp.setSelection(XFDesignConstants.SEL_MUL_SELECT);

	}

	// returns whether this component is selected

	private boolean isSelected(XelfiDesignComponent comp) { 

		return selectedComps.contains(comp);

	}

	// returns whether selected components can be dragged

	// (i.e. they are on same depth and their parent's layout allows dragging)

	private boolean isSelectionDragable() { 

		// [PENDING - now dragable only when only one component is selected]

		if (selectedComps.size() != 1) return false;

		if (XFDesignOptions.lockComponents) return false; 

		Object comp = selectedComps.elementAt(0);

		if (comp instanceof XelfiDesignForm) return false;

		if (comp instanceof XelfiVisualComponent) {

			Container parentCont = ((Component)comp).getParent();

			if (parentCont == null) return false; // null parent

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

		}

		return false; // non-visual component is selected

	}

	public void deleteSelection() {

		if (isSelected(this)) return;

		int count = selectedComps.size();

		XelfiDesignComponent comps[] = new XelfiDesignComponent[count];

		selectedComps.copyInto(comps);

		deselectAll();

		select(this);

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

			XelfiDesignComponent xdc = comps[i];

			// 1. release events

			for (int j=0; j<xdc.getEventCount(); j++)

				if (xdc.getEvent(j) != null) releaseEvent(xdc, j);

			// 2. release imports

			impsManager.releaseImports(xdc.neededImports());

			// 3. release names

			nameManager.releaseName(xdc);

			// 4. according to component type remove from list or parent

			if (xdc instanceof XelfiVisualComponent) {

				Container compParent = ((Component)xdc).getParent();

				((XelfiVisualContainer)compParent).getDesignLayout().removeComponent((XelfiVisualComponent)xdc);

				compParent.remove((Component)xdc);

				validate();

			}

			else

				nonVisualComps.removeElement(xdc);

		}

		inspector.selectionChanged(); // update CI

		regenerateComponents();

	}

// mouse event handlers

	public boolean mouseDown(Event evt, int x, int y) {

		if (XFDesignOptions.designMode==XFDesignConstants.DM_REAL) return false;

		if (XFDesignUtils.leftMouse(evt)) {

			lMouseDown = true;

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

				if (palette.getMode() == XFDesignConstants.XM_SELECTIONMODE) {// lmouse/design/selection

					if (evt.shiftDown()) { // lmouse/design/selection/shift

						if (evt.target == this) return true; // form cannot be in multiple selection

						toggleSelect((XelfiVisualComponent)evt.target);

						inspector.selectionChanged(); // update CI

						return true;

					}

					else { // lmouse/design/selection/not shift

						if (!isSelected((XelfiVisualComponent)evt.target)) {

							deselectAll(); // remove all from selected components

							select((XelfiVisualComponent)evt.target); // add current to selected components

							inspector.selectionChanged(); // update CI

							if (isSelectionDragable()) {

								dragMode = DM_DRAG;

								drx = x; dry = y;

								dragComp = (XelfiVisualComponent)selectedComps.elementAt(0);

								dragP = ((Component)dragComp).location();

							}

							return true;

						}

						else {

							if (evt.target != this) { // form cannot be in multiple selection

								if (isSelectionDragable()) {

									dragMode = DM_DRAG;

									drx = x; dry = y;

									dragComp = (XelfiVisualComponent)selectedComps.elementAt(0);

									dragP = ((Component)dragComp).location();

								}

							}

							return true;

						}

					}

				}

				else { // lmouse/design/add mode

					// find nearest (in depth) container to which we are adding this component

					Component tempC = (Component)evt.target;

					while (!(tempC instanceof XelfiVisualContainer)) tempC = tempC.getParent();

					xvcParent = (XelfiVisualContainer) tempC;

					dragP = new Point(x,y);

					Point parentPos = null;

					// what if this is nested more in depth

					if (xvcParent != this) {

						parentPos = ((Container)xvcParent).location();

						Container tmpParent = ((Container)xvcParent).getParent();

						while (tmpParent != this) {

							Point tmpPos = tmpParent.location();

							tmpParent = tmpParent.getParent();

							parentPos.x += tmpPos.x;

							parentPos.y += tmpPos.y;

						}

						Insets insets = insets();

						parentPos.x -= insets.left;

						parentPos.y -= insets.top;

						// in parentPos now I have the difference between mouse click position

						// and position I want to get (relative position of xvc within its parent)

					}

					else parentPos = new Point(0,0);

					Class xx;

					XelfiVisualComponent xvc = null;

					XelfiDesignComponent xdc = null;

					try {

						xx = Class.forName(palette.getAddComponent());

						xdc = (XelfiDesignComponent) xx.newInstance();

						xdc.setParentForm(this);

						if (xdc instanceof XMenuBar) {										// MENU COMPONENT

							Debug.debug(Debug.FORM, "Cannot add menu component to Dialog!");

							palette.setSelectionMode();							

							// [PENDING - invoke message box with this message]

						} else if (xdc instanceof XelfiVisualComponent) {		// VISUAL COMPONENT

							xvc = (XelfiVisualComponent) xdc;

							if (evt.target != this) {

								Insets insets = insets();

								addPos = new Point(x-parentPos.x-insets.left,y-parentPos.y-insets.top);

							}

							else

								addPos = new Point(x-parentPos.x,y-parentPos.y);

						} else {  																	// NON-VISUAL COMPONENT

							xdc.setDesignName(nameManager.getNewName(xdc));

							nonVisualComps.addElement(xdc);

							deselectAll();

							select(xdc);

							inspector.selectionChanged();

							impsManager.assignImports(xdc.neededImports());

							regenerateComponents(); 

//							[PENDING show up non-visual components manager]

						}

					} catch (IllegalAccessException e) {

						Debug.debugException(e);

					} catch (InstantiationException e) {

						Debug.debugException(e);

					} catch (ClassNotFoundException e) {

						Debug.debugException(e);

					}

					// [PENDING - in case of exception do something]

					if (xvc != null) {

						dragComp = xvc;

						dragMode = DM_ADD;

					}

					if (!evt.shiftDown()) palette.setSelectionMode(); // this resets the mode to "selection"

				}

			}

		}

		return false;

	}

	public boolean mouseDrag(Event evt, int x, int y) {

		if (XFDesignOptions.designMode==XFDesignConstants.DM_REAL) return false;

		if (lMouseDown) {

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

				if (dragMode == DM_DRAG) {

					if (dragP != null) {

						Point cpos=dragComp.getPosition();

						int roundedX = ((x-drx+cpos.x) / grid.gridX()) * grid.gridX();

						int roundedY = ((y-dry+cpos.y) / grid.gridY()) * grid.gridY();

						int newX = roundedX -cpos.x +dragP.x;

						int newY = roundedY -cpos.y +dragP.y;

						Point oldP = ((Component)dragComp).location();

						if ((newX != oldP.x) || (newY != oldP.y))

							((Component)dragComp).move(newX, newY);

						}

				}

				return true;

			}

		}	

		return false;

	}	

	public boolean mouseUp(Event evt, int x, int y) {

		if (XFDesignOptions.designMode==XFDesignConstants.DM_REAL) return false;

		if (lMouseDown) {

			lMouseDown = false;

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

				if (dragMode == DM_DRAG) {

					dragMode = DM_NONE;

					Point cpos=dragComp.getPosition();

					int roundedX = ((x-drx+cpos.x) / grid.gridX()) * grid.gridX();

					int roundedY = ((y-dry+cpos.y) / grid.gridY()) * grid.gridY();

					dragComp.setPosition(roundedX,roundedY);

					dragP = null;

					inspector.propertiesChanged();

				}

				else if ((dragMode == DM_ADD) && (dragComp != null)) {

					dragMode = DM_NONE;

					formDocument.redrawLock();

					dragComp.setDesignName(nameManager.getNewName(dragComp));

					addPos.x = (addPos.x / grid.gridX()) * grid.gridX();

					addPos.y = (addPos.y / grid.gridY()) * grid.gridY();

					dragComp.setPosition(addPos.x, addPos.y);

					if (dragComp instanceof XelfiVisualContainer)

						containers.addElement(dragComp);

					int newW = x - dragP.x; if (newW < 0) newW = 0;

					int newH = y - dragP.y; if (newH < 0) newH = 0;

					if ((newW>XFDesignOptions.minDragSize) || 

					    (newH>XFDesignOptions.minDragSize))

						dragComp.setDesignSize(newW, newH);

					xvcParent.getDesignLayout().layoutAdd((Container)xvcParent, dragComp);

					deselectAll();

					validate();

					select(dragComp);

					inspector.selectionChanged();

					impsManager.assignImports(dragComp.neededImports());

					regenerateComponents();

					formDocument.redrawUnlock();

				}

			}

		}

		return false;

	}

	public void paint(Graphics g) {

		Dimension aSize=size();

		if (XFDesignOptions.designMode == XFDesignConstants.DM_DESIGN)

			XFDesignUtils.paintGrid(this, g, grid, 0, 0, aSize.width, aSize.height);

		// when form's size property changes

		if ((size == null) || (aSize.width != size.width) || (aSize.height != size.height)) {

			// [PENDING - not when minimized ]

			size = aSize;

			if (pResizeForm)

				regenerateCode(this, XFDesignConstants.FGEN_FORM_RESIZE);

			if (isSelected(this))

				inspector.propertiesChanged();

		}

	}

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

	// XelfiVisualContainer implementation //

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

	public void setParentForm(XelfiDesignForm form) { }

	public XelfiDesignForm getParentForm() { return this; }

	public String getName() { return formName; }

	public int setDesignName(String aName) { formName = aName; return XFDesignConstants.RSP_OK; }

	public Point getPosition() { return position; }

	public int setPosition(int x, int y) { 

		position.x = x; position.y = y;

		if (pMoveForm)

			regenerateCode(this, XFDesignConstants.FGEN_FORM_RESIZE);

		return XFDesignConstants.RSP_OK;

	}

	public Dimension getSize() {

		if (size == null)

			size = new Dimension(XFDesignOptions.formDefWidth, XFDesignOptions.formDefHeight);

		return size;

	}

	public Dimension getDesignSize() {

		return preferredSize();

	}

	public int setDesignSize(int w, int h) {

		if (size == null)

			size = new Dimension(w,h);

		else {

			size.width = w;

			size.height = h;

		}

		resize(w,h);

		if (pResizeForm)

			regenerateCode(this, XFDesignConstants.FGEN_FORM_RESIZE);

		return XFDesignConstants.RSP_OK;

	}

	private boolean propertyDefault(int i) throws XFPropertyIndexOutOfBoundsException {

		switch (i) {

			case GRID: return false;

			case BACKGROUNDCOLOR: return !backgroundChanged;

			case FOREGROUNDCOLOR: return !foregroundChanged;

			case FONT: return !fontChanged;

			case TITLE: return ((String)propDef[i]).equals(getTitle());

			case MODAL: return ((Boolean) propDef[i]).booleanValue() == pIsModal;

			case RESIZABLE: return ((Boolean) propDef[i]).booleanValue() == pIsResizable;

			case SHOWFORM: return ((Boolean) propDef[i]).booleanValue() == pShowForm;

			case MOVEFORM: return ((Boolean) propDef[i]).booleanValue() == pMoveForm;

			case RESIZEFORM: return ((Boolean) propDef[i]).booleanValue() == pResizeForm;

			case CLASSPUBLIC: return ((Boolean) propDef[i]).booleanValue() == inheritance.isPublic;

			case IMPLEMENTS: return false;

			case IMPORTS: return false;

			default: throw new XFPropertyIndexOutOfBoundsException();

		}

	}

	public boolean parentUpdate() { return true; }

	public int getPropertyCount() { return propertyCount; }

	public String[] getPropertyNames() {

		String list[] = new String[propertyCount];

		list[GRID] = "Grid";

		list[BACKGROUNDCOLOR] = "Background Color";

		list[FOREGROUNDCOLOR] = "Foreground Color";

		list[FONT] = "Font";

		list[TITLE] = "Title";

		list[MODAL] = "Modal";

		list[RESIZABLE] = "Resizable";

		list[SHOWFORM] = "ShowForm";

		list[MOVEFORM] = "MoveForm";		// whether to set position from x,y properties

		list[RESIZEFORM] = "ResizeForm";

		list[CLASSPUBLIC] = "ClassPublic";

		list[IMPLEMENTS] = "Implements";

		list[IMPORTS] = "Imports";

		return list;

	}

	public Object getProperty(int index) throws XFPropertyIndexOutOfBoundsException {

		switch (index) {

			case GRID: return grid;

			case BACKGROUNDCOLOR: return getBackground();

			case FOREGROUNDCOLOR: return getForeground();

			case FONT: return getFont();

			case TITLE: return getTitle();

			case MODAL: return new Boolean(pIsModal);

			case RESIZABLE: return new Boolean(pIsResizable);

			case SHOWFORM: return new Boolean(pShowForm);

			case MOVEFORM: return new Boolean(pMoveForm);

			case RESIZEFORM: return new Boolean(pResizeForm);

			case CLASSPUBLIC: return new Boolean(inheritance.isPublic);

			case IMPLEMENTS: return inheritance.pImplements;

			case IMPORTS: return pImports;

			default: throw new XFPropertyIndexOutOfBoundsException();

		}

	}

	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 TITLE: return getTitle();

			case MODAL:

			case RESIZABLE:

			case SHOWFORM:

			case MOVEFORM:

			case RESIZEFORM:

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

			case IMPLEMENTS:

			case IMPORTS: return XStringArrayPropertyType.viewString(getProperty(index));

			default: throw new XFPropertyIndexOutOfBoundsException();

		}

	}

	public int getPropertyViewerType(int index) throws

	XFPropertyIndexOutOfBoundsException {

		switch (index) {

			case TITLE: return XFDesignConstants.PVT_INPUT_STRING;

			case MODAL:

			case RESIZABLE:

			case SHOWFORM:

			case MOVEFORM:

			case RESIZEFORM:

			case CLASSPUBLIC: return XFDesignConstants.PVT_CHECK; 

			case GRID:

			case BACKGROUNDCOLOR:

			case FOREGROUNDCOLOR:

			case FONT:

			case IMPLEMENTS:

			case IMPORTS: return XFDesignConstants.PVT_SPECIAL; 

			default: throw new XFPropertyIndexOutOfBoundsException();

		}

	}

	public String[] getPropertyValueNames(int index) throws

	XFPropertyIndexOutOfBoundsException {

		switch (index) {

			default: throw new XFPropertyIndexOutOfBoundsException();

		}

	}

	public Object[] getPropertyValueValues(int index) throws

	XFPropertyIndexOutOfBoundsException {

		switch (index) {

			default: throw new XFPropertyIndexOutOfBoundsException();

		}

	}

	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

	{

		boolean bval;

		int ival;

		int ret = XFDesignConstants.RSP_OK;

		int regen = 0;

		Block regenB = null;

		switch (index) {

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

					grid = (GridInfo) value;

					grid.invalidate();

					repaint();

					break;

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

					setBackground((Color)value);

					backgroundChanged = true;

					ret = ret | XFDesignConstants.RSP_REPAINT_COMP;

					updateSubComponents();

					regen = XFDesignConstants.FGEN_FORM_SETPROPS;

					regenB = formSetpropsB;

					break;

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

					setForeground((Color)value);

					foregroundChanged = true;

					ret = ret | XFDesignConstants.RSP_REPAINT_COMP;

					updateSubComponents();

					regen = XFDesignConstants.FGEN_FORM_SETPROPS;

					regenB = formSetpropsB;

					break;

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

					setFont((Font)value);

					fontChanged = true;

					ret = ret | XFDesignConstants.RSP_REPAINT_COMP;

					updateSubComponents();

					regen = XFDesignConstants.FGEN_FORM_SETPROPS;

					regenB = formSetpropsB;

					break;

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

					setTitle((String)value);

					regen = XFDesignConstants.FGEN_FORM_SETPROPS;

					regenB = formSetpropsB;

					break;

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

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

					if (pIsModal != bval) {

						pIsModal = bval;

						inheritance.setDialogModal(pIsModal);

						regen = XFDesignConstants.FGEN_CONSTRUCTOR_BEGIN;

						regenB = constructorBeginB;

					}

					break;					

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

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

					if (pIsResizable != bval) {

						pIsResizable = bval;

						regen = XFDesignConstants.FGEN_FORM_SETPROPS;

						regenB = formSetpropsB;

					}

					break;					

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

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

					if (pShowForm != bval) {

						pShowForm = bval;

						regen = XFDesignConstants.FGEN_FORM_RESIZE;

						regenB = formResizeB;

					}

					break;					

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

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

					if (pMoveForm != bval) {

						pMoveForm = bval;

						regen = XFDesignConstants.FGEN_FORM_RESIZE;

						regenB = formResizeB;

					}

					break;					

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

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

					if (pResizeForm != bval) {

						pResizeForm = bval;

						regen = XFDesignConstants.FGEN_FORM_RESIZE;

						regenB = formResizeB;

					}

					break;					

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

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

					if (inheritance.isPublic != bval) {

						inheritance.isPublic = bval;

						regen = XFDesignConstants.FGEN_CLASS_BEGIN;

						regenB = classBeginB;

					}

					break;					

			case IMPLEMENTS: if (!(value instanceof String[])) throw new XFPropertyBadValueTypeException();

					inheritance.pImplements = XStringArrayPropertyType.removeEmptyStrings((String[])value);

					regen = XFDesignConstants.FGEN_CLASS_BEGIN;

					regenB = classBeginB;

					break;

			case IMPORTS: if (!(value instanceof String[])) throw new XFPropertyBadValueTypeException();

					impsManager.releaseImports(pImports);

					pImports = (String[])value;

					impsManager.assignImports(pImports);

					regen = XFDesignConstants.FGEN_IMPORTS;

					regenB = importsB;

					break;

			default: throw new XFPropertyIndexOutOfBoundsException();

		}

		if (regenB != null)

			try {

				regenB.set(generateCode(regen), new GuardedStamp());

			} catch (NotAllowedException e) {

				throw new InternalError("Block generation error");

			}

		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: XColorPropertyType.invokeSpecialInput(parent, this, index);

						break;

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

						break;

			case IMPLEMENTS: 

			case IMPORTS: XStringArrayPropertyType.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 String generateEventCondition(int index) throws 

	XFPropertyIndexOutOfBoundsException {

		String evt = XFDesignOptions.eventVarName;

		switch (index) { 

			case 0: return evt +".id == Event.GOT_FOCUS && "+evt+".target == this";

			case 1: return evt +".id == Event.LOST_FOCUS && "+evt+".target == this";

			case 2: return evt +".id == Event.KEY_ACTION && "+evt+".target == this";

			case 3: return evt +".id == Event.KEY_ACTION_RELEASE && "+evt+".target == this";

			case 4: return evt +".id == Event.KEY_PRESS && "+evt+".target == this";

			case 5: return evt +".id == Event.KEY_RELEASE && "+evt+".target == this";

			case 6: return evt +".id == Event.MOUSE_DOWN && "+evt+".target == this";

			case 7: return evt +".id == Event.MOUSE_UP && "+evt+".target == this";

			case 8: return evt +".id == Event.MOUSE_MOVE && "+evt+".target == this";

			case 9: return evt +".id == Event.MOUSE_DRAG && "+evt+".target == this";

			case 10: return evt +".id == Event.MOUSE_ENTER && "+evt+".target == this";

			case 11: return evt +".id == Event.MOUSE_EXIT && "+evt+".target == this";

			default: throw new XFPropertyIndexOutOfBoundsException();

		}

	}

	public Image getIcon() { return null; }

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

	public XelfiDesignLayout getDesignLayout() { return xLayout; }

	public int setDesignLayout(XelfiDesignLayout aXLayout) { 

		boolean oldAllows = xLayout.allowsDragging();

		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]);

		}

		if (XFDesignOptions.showGrid && oldAllows != xLayout.allowsDragging()) {  // if grid needs to be rapainted

			hide(); show();

		}

		else 

			validate();

		formDocument.redrawLock();

		regenerateCode(this, XFDesignConstants.FGEN_FORM_LAYOUT | XFDesignConstants.FGEN_FORM_RESIZE);

		regenerateComponents();

		formDocument.redrawUnlock();

		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 void setSelection(int aSelection) {

	}

	public int getSelection() {

		return XFDesignConstants.SEL_UNSELECT;

	}

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

	// XelfiDesignForm implementation //

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

	public Source getSource() {

		return formSource;

	}

	public String getPackage() {

		return packageName;

	}

	public void setPackage(String aPackageName) {

		packageName = aPackageName;

		try {

			if (packageName == null || "".equalsIgnoreCase(packageName))

				packageB.set("", new GuardedStamp());

			else

				packageB.set("package "+packageName+";\n\n", new GuardedStamp());

		} catch (NotAllowedException e) {

			throw new InternalError("Block generation error");

		}

	}

	public Vector getSelectedComponents() {

		return selectedComps;

	}

	public void setSelectedComponents(Vector comps) {

		deselectAll();

		if (comps == null) {

			select(this);

			return;

		}

		int count = comps.size();

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

			select((XelfiDesignComponent)comps.elementAt(i));

	}

	public Vector getAllComponents() {

		Vector comps = getSubComponents();

		comps.insertElementAt(this,0);

		// also add all the non-visual components

		for (int i=0; i<nonVisualComps.size(); i++)