package xelfi.design.inspector;

import java.awt.*;

import java.util.Vector;

import xelfi.awt.TabControl;

import xelfi.design.components.*;

import xelfi.design.components.property.*;

import xelfi.design.forms.XelfiDesignForm;

import xelfi.design.forms.XFInstalledLayouts;

import xelfi.design.util.XFDesignConstants;

import xelfi.util.Debug;

/**

 * XFCommonProperties holds a list of currently selected components,

 * list of their common properties and 

 * properties and events.

 *

 * @author Dafe

 * version 1.22, 24 Nov 1996 - Name, X, Y....props included

 * version 1.23, 13 Dec 1996 - small bug in non-visual comps repaired

 * version 1.24, 22 Dec 1996 - large changes - 

 * methods like getProperties,setProperties added

 * version 1.30, 17 Jan 1997 - bugs in layouts repaired, 

 * event calling added

 *

 * @version 1.30, 17 Jan 1997

	Last change:  DF   17 Feb 97    8:22 pm

 */

class XFCommonProperties {

	// indexes for properties every component has 

	private static final int			NAME_INDEX = -5;

	private static final int			X_INDEX = -4;

	private static final int			Y_INDEX = -3;

	private static final int			WIDTH_INDEX = -2;

  private static final int			HEIGHT_INDEX = -1;

  private static final int			LAYOUT_INDEX = -6;

	// names of well-known properties

	private static final String		NameName = "Name";

	private static final String		XName = "X";

	private static final String		YName = "Y";

	private static final String		WidthName = "Width";

	private static final String		HeightName = "Height";

  private static final String		LayoutName = "Layout";

  // event names comparison constants

	private static final int			NEW_NAME = 1;

	private static final int			DELETED_NAME = 2;

	private static final int			CHANGED_NAME = 3;

	private static final int			SAME_NAME = 4;

	// start of event names

	private static final String 	eventStart = "On";

	private static final String 	defEventNameStart = "on";

	private Vector						allComponents;

	private Vector						selectedComponents;

	private Vector						propertiesIndexes = null, eventsIndexes = null, 

														layoutIndexes = null;

	private int								page;

	XFCommonProperties (Vector allComponents, Vector selectedComponents,

											int page, TabControl pageTab) {

	this.allComponents = allComponents;

	this.selectedComponents = selectedComponents;

  this.page = page;

  boolean layoutAvail = isLayoutPageAvailable();

  int pageCount = pageTab.getTabCount();

  if ((this.page==XFDesignConstants.CI_PG_LAYOUT)&&(!layoutAvail)) {

    this.page = XFDesignConstants.CI_PG_PROPERTIES;

  }

  // add or remove layout page

  if ((layoutAvail) && (pageCount<3))

    pageTab.addTab("Layout");

  if ((!layoutAvail) && (pageCount>=3))

    pageTab.removeTabAt(2);

	buildIndexes();

	}

	Vector getAllComponents () { 

		return allComponents;

	}

	Vector getSelectedComponents () {

		return selectedComponents;

	}

	int getPage () {

		return page;

	}

	boolean setPage (int page) {

		if (page==XFDesignConstants.CI_PG_LAYOUT)

			// check if layout page is available

			if (!isLayoutPageAvailable()) return false;

		this.page = page;

		buildIndexes();

		return true;

	}

	Vector getIndexes (int index) {

		switch (page) {

			case XFDesignConstants.CI_PG_PROPERTIES:

				return (Vector)(propertiesIndexes.elementAt(index));

			case XFDesignConstants.CI_PG_EVENTS:

				return (Vector)(eventsIndexes.elementAt(index));

			case XFDesignConstants.CI_PG_LAYOUT:

				return (Vector)(layoutIndexes.elementAt(index));

		}

		return null;

	}

	Vector getIndexes () {

		switch (page) {

			case XFDesignConstants.CI_PG_PROPERTIES:

				return propertiesIndexes;

			case XFDesignConstants.CI_PG_EVENTS:

				return eventsIndexes;

			case XFDesignConstants.CI_PG_LAYOUT:

				return layoutIndexes;

		}

		return null;

	}

	/** 

	 * Returns property with index "propIndex" in specified component

	 * and in specified page. 

	 * Throws an exception if index is out of bounds

	*/

	Object getProperty (int compIndex, int propIndex) 

			throws XFPropertyIndexOutOfBoundsException,

							XFNameNotFoundException {

		// get the component

    XelfiDesignComponent comp =

        (XelfiDesignComponent)selectedComponents.elementAt(compIndex);

		int realIndex = ((Integer)getIndexes(propIndex).

												elementAt(compIndex)).intValue();

		switch (page) {

			case XFDesignConstants.CI_PG_PROPERTIES:

				if (realIndex<0) {

					// well-known props...i can't ask component about property value 

					// through getProperty method...I have to use special methods

					switch (realIndex) {

						case X_INDEX:

							return new Integer(((XelfiVisualComponent)comp).

																	getPosition().x);

						case Y_INDEX:

							return new Integer(((XelfiVisualComponent)comp).

																	getPosition().y);

						case WIDTH_INDEX:

							return new Integer(((XelfiVisualComponent)comp).

																	getSize().width);

						case HEIGHT_INDEX:

							return new Integer(((XelfiVisualComponent)comp).

																	getSize().height);

						case NAME_INDEX:

							return comp.getName();

            case LAYOUT_INDEX:

              return ((XelfiVisualContainer)comp).getDesignLayout();

					}

				} else {

					// ask component about property

					return comp.getProperty(realIndex);

				}

			case XFDesignConstants.CI_PG_EVENTS:

				return comp.getEvent(realIndex);

			case XFDesignConstants.CI_PG_LAYOUT:

				XelfiDesignLayout xdl = ((XelfiVisualContainer)((Component)comp).

																	getParent()).getDesignLayout();

				return xdl.getProperty((XelfiVisualComponent)comp, realIndex);

		}

		// wrong page number - return null

		return null;

	}

	/**

	 * Returns value of specified property in selected components

	 * Returns null if values are not the same in all selected components

	*/

	Object getPropertiesValue (int propIndex, int viewerType) {

    // return if no comps selected

    if ( selectedComponents.size()==0 ) return null;

		// get property value object from first selected component

		Object firstValue = null;

		try {

			firstValue = getProperty(0, propIndex);

		} catch (XFPropertyIndexOutOfBoundsException e) {

			System.err.println(e.getMessage());

			e.printStackTrace(System.err);

		} catch (XFNameNotFoundException e) {

			System.err.println(e.getMessage());

			e.printStackTrace(System.err);

		}

		//check if all values are the same

		boolean valuesIdentic = true;

		Object propertyValue = null;

		for (int i=1; i<selectedComponents.size(); i++) {

			try {

				propertyValue = getProperty(i, propIndex);

			} catch (XFPropertyIndexOutOfBoundsException e) {

				System.err.println(e.getMessage());

				e.printStackTrace(System.err);

			} catch (XFNameNotFoundException e) {

				System.err.println(e.getMessage());

				e.printStackTrace(System.err);

			}

			if (compareProperties(firstValue, propertyValue,viewerType)!=true) {

				valuesIdentic = false;

				break;

			}

		}

		return valuesIdentic==true ? firstValue : null;

	}

	/**

	 * Compares two properties. Their type is set from viewerType constant.

	 * Returns true if values are the same, false otherwise.

	*/

	private boolean compareProperties (Object first, Object second,

																			int viewerType) {

		if ((first==null)||(second==null))

			return false;

		switch (viewerType) {

			case XFDesignConstants.PVT_CHECK:

				return ((Boolean)first).booleanValue()==

								((Boolean)second).booleanValue();

			case XFDesignConstants.PVT_INPUT_INT:

				return ((Integer)first).intValue()==

								((Integer)second).intValue();

			case XFDesignConstants.PVT_INPUT_FLOAT:

				return ((Double)first).floatValue()==

								((Double)second).floatValue();

			case XFDesignConstants.PVT_INPUT_STRING:

				return ((String)first).compareTo((String)second)==0;

			case XFDesignConstants.PVT_INPUT_CHAR:

				return ((Character)first).charValue()==

                ((Character)second).charValue();

			// [PENDING] - other types not implem. yet

		}

		return false;

	}

	/**

	 * Sets the property with index "propIndex" in specified component

	 * and in specified page.

	 * Throws an exception if index is out of bounds or bad property has

	 * bad type.

	*/

	int setProperty (int compIndex, int propIndex, Object value)

			throws XFPropertyIndexOutOfBoundsException,

							XFPropertyBadValueTypeException,

							XFNameNotFoundException {

		// check property, if value is the same or different

		int viewerType = getPropertyViewerType(propIndex);

		if (compareProperties(value, getProperty(compIndex, propIndex),

													viewerType)) {

			// values are the same, no need to set it again

			return 0;

		}

		// get the component

		XelfiDesignComponent comp =

					(XelfiDesignComponent)selectedComponents.elementAt(compIndex);

		int realIndex = ((Integer)getIndexes(propIndex).

												elementAt(compIndex)).intValue();

		int result = 0;

		switch (page) {

			case XFDesignConstants.CI_PG_PROPERTIES:

				if (realIndex<0) {

					// well-known props...i can't set property value

					// through setproperty...I have to use special methods

					if (comp instanceof XelfiVisualComponent) {

					}

					switch (realIndex) {

						case X_INDEX:

							((XelfiVisualComponent)comp).setPosition(

															((Integer)value).intValue(),

															((XelfiVisualComponent)comp).getPosition().y);

							break;

						case Y_INDEX:

							((XelfiVisualComponent)comp).setPosition(

															((XelfiVisualComponent)comp).getPosition().x,

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

							break;

						case WIDTH_INDEX:

							((XelfiVisualComponent)comp).setDesignSize(

														((Integer)value).intValue(),

														((XelfiVisualComponent)comp).getSize().height);

							break;

						case HEIGHT_INDEX:

							((XelfiVisualComponent)comp).setDesignSize(

														((XelfiVisualComponent)comp).getSize().width,

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

							break;

            case NAME_INDEX:

              // transfers the work of setting the name to parent form

              // parent form will decide, whether this name is allowed or not

              if (comp instanceof XelfiDesignForm) {

                comp.setDesignName((String)value);

              } else {

                XelfiDesignForm parentForm = comp.getParentForm();

                if (parentForm==null) {

                  Debug.debug(Debug.INSPECTOR, "Error: Parent Form is null...");

                  break;

                }

                if (!parentForm.setComponentName(comp, (String)value))

                  Debug.debug(Debug.INSPECTOR, "Error: Property name duplication occured...");

              }

							break;

            case LAYOUT_INDEX:

              ((XelfiVisualContainer)comp).setDesignLayout(

                         buildLayoutFromIndex(((Integer)value).intValue()));

              break;

					}

				} else {

//					int viewerType = comp.getPropertyViewerType(realIndex);

					if ((viewerType==XFDesignConstants.PVT_CHOICE_STRICT) ||

							(viewerType==XFDesignConstants.PVT_CHOICE_FREE)) {

						Object[] valueValues = comp.getPropertyValueValues(realIndex);

						String[] valueNames = comp.getPropertyValueNames(realIndex);

						switch (viewerType) {

							case XFDesignConstants.PVT_CHOICE_STRICT:

								// strict choice = we 've got selected index in parameter

								result = comp.setProperty(realIndex,

																	valueValues[((Integer)value).intValue()]);

								break;

							case XFDesignConstants.PVT_CHOICE_FREE:

								// free choice - value can be integer (index)

                // or direct value (string)

                if ( value instanceof Integer ) {

  								result = comp.setProperty(realIndex,

	      													 valueValues[((Integer)value).intValue()]);

                } else {

                  // [PENDING] - we can save only strings now...

  								result = comp.setProperty(realIndex, value);

                }

								break;

						}

					} else {

						// ok, finally some normal property :-) ... so set the value

						result = comp.setProperty(realIndex, value);

					}

				}

				break;

			case XFDesignConstants.CI_PG_EVENTS:

        // retrieve old value of event prop

        String oldEventName = (String)getProperty(compIndex, propIndex);

        String newEventName = (String)value;

        XelfiDesignForm parentForm = null;

				if (comp instanceof XelfiDesignForm) 

				  parentForm = (XelfiDesignForm)comp;

				else

					parentForm = comp.getParentForm();

				if (parentForm==null) {

					System.err.println("Error: Parent form is null...");

					break;

				}

        switch ( compareEvents(oldEventName, newEventName) )

        {

          case NEW_NAME:

            Debug.debug(Debug.INSPECTOR, "calling assignEvent");

            parentForm.assignEvent(comp, realIndex, newEventName);

            parentForm.focusEvent(newEventName);

            break;

          case CHANGED_NAME:

	          Debug.debug(Debug.INSPECTOR, "calling renameEvent");

 	          parentForm.renameEvent(oldEventName, newEventName);

            break;

          case DELETED_NAME:

            Debug.debug(Debug.INSPECTOR, "calling releaseEvent");

	          parentForm.releaseEvent(comp, realIndex);

            break;

          case SAME_NAME:

            break;

        }

				break;

			case XFDesignConstants.CI_PG_LAYOUT:

				// [PENDING] - maybe not finished yet

				XelfiDesignLayout xdl = ((XelfiVisualContainer)((Component)comp).

																	getParent()).getDesignLayout();

				xdl.setProperty((XelfiVisualComponent)comp, realIndex, value);

				break;

    }

    // refresh component if needed

    refreshComponent(comp, result);

		return result;

	}

	/**

	 * Performs an action of setting new property value of given index 

   * into selected components

	*/

	int setProperties (int propIndex, Object newValue) {

		// iterate through the set of selected components and set new value

		// at specified indexes

		int result = 0;

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

			try {

				result |= setProperty(i, propIndex, newValue);

			} catch (XFPropertyIndexOutOfBoundsException e) {

				// prints an error if property index is out of bounds

				System.err.println(e.getMessage());

				e.printStackTrace(System.err);

			} catch (XFPropertyBadValueTypeException e) {

				// prints an error if bad type of property wanted to be set

				System.err.println(e.getMessage());

				e.printStackTrace(System.err);

			} catch (XFNameNotFoundException e) {

				// prints an error if bad name in layout is given

				System.err.println(e.getMessage());

				e.printStackTrace(System.err);

			}

		}

    return result;

  }

	/**

	 * Gets the property in string form with index "propIndex"

	 * in specified component and in specified page.

	 * Throws an exception if index is out of bounds.

	*/

	String getPropertyString (int compIndex, int propIndex)

			throws XFPropertyIndexOutOfBoundsException,

							XFNameNotFoundException {

		// get the component

    XelfiDesignComponent comp =

                  (XelfiDesignComponent)selectedComponents.elementAt(compIndex);

		// get the index

		int realIndex = ((Integer)getIndexes(propIndex).

												elementAt(compIndex)).intValue();

		String result = null;

		switch (page) {

			case XFDesignConstants.CI_PG_PROPERTIES:

				if (realIndex<0) {

					// well-known props...i can't ask for property string

					// I have to return it by myself

					switch (realIndex) {

						case X_INDEX:

							result = String.valueOf(((XelfiVisualComponent)comp).

																			getPosition().x);

							break;

						case Y_INDEX:

							result = String.valueOf(((XelfiVisualComponent)comp).

																	getPosition().y);

							break;

						case WIDTH_INDEX:

							result = String.valueOf(((XelfiVisualComponent)comp).

																	getSize().width);

							break;

						case HEIGHT_INDEX:

							result = String.valueOf(((XelfiVisualComponent)comp).

																	getSize().height);

							break;

						case NAME_INDEX:

							result = comp.getName();

							break;

            case LAYOUT_INDEX:

              result = ((XelfiVisualContainer)comp).getDesignLayout().

                       getClassName();

              break;

					}

				} else {

					int viewerType = comp.getPropertyViewerType(realIndex);

					if ((viewerType==XFDesignConstants.PVT_CHOICE_FREE) ||

							(viewerType==XFDesignConstants.PVT_CHOICE_STRICT)) {

						// choice = we can't use getPropertyString

						String[] valueNames = comp.getPropertyValueNames(realIndex);

						Object[] valueValues = comp.getPropertyValueValues(realIndex);

						Object value = comp.getProperty(realIndex);

						// find the name of the value

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

							if (valueValues[i].equals(value)) {

								result = valueNames[i];

								break;

							}

						}

					} else {

						result = comp.getPropertyString(realIndex);

					}

				}

				break;

			case XFDesignConstants.CI_PG_EVENTS:

				result = comp.getEvent(realIndex); 

				// modify a string if there's none event handling method

				if ((result==null) || (result.compareTo("")==0))

					result = "[none]";

				break;

			case XFDesignConstants.CI_PG_LAYOUT:

				// [PENDING] - unresolved yet

				XelfiDesignLayout xdl = ((XelfiVisualContainer)((Component)comp).

																	getParent()).getDesignLayout();

				result = xdl.getPropertyString((XelfiVisualComponent)comp, realIndex);

				break;

		}

		return result==null ? "" : result;	

	}

	/**

	 * Returns string representation of property value 

   * in selected components if values are the same.<br>

	 * Returns null otherwise or when no comps are selected.

	*/

	String getPropertiesString (int propIndex) {

    if ( selectedComponents.size()==0 ) return null;

		// get property value string from first selected component

		String firstString = null;

		try {

			firstString = getPropertyString(0, propIndex);

		} catch (XFPropertyIndexOutOfBoundsException e) {

			System.err.println(e.getMessage());

			e.printStackTrace(System.err);

		} catch (XFNameNotFoundException e) {

			System.err.println(e.getMessage());

			e.printStackTrace(System.err);

		}

		//check if all values are the same

		boolean propertiesIdentic = true;

		String propertyString = null;

		for (int i=1; i<selectedComponents.size(); i++) {

			try {

				propertyString = getPropertyString(i, propIndex);

			} catch (XFPropertyIndexOutOfBoundsException e) {

				System.err.println(e.getMessage());

				e.printStackTrace(System.err);

			} catch (XFNameNotFoundException e) {

				System.err.println(e.getMessage());

				e.printStackTrace(System.err);

			}

			if (propertyString.compareTo(firstString)!=0) {

				propertiesIdentic = false;

				break;

			}

		}

		return propertiesIdentic==true ? firstString : null;

	}

	/**

	 * Returns property viewer type constant. 

	*/

	int getPropertyViewerType (int propIndex)

			throws XFPropertyIndexOutOfBoundsException,

							XFNameNotFoundException {

		// get the component - we can find out viewer type from first comp

    XelfiDesignComponent comp =

                  (XelfiDesignComponent)selectedComponents.elementAt(0);

		// get the property index in first comp

		int realIndex = ((Integer)getIndexes(propIndex).

												elementAt(0)).intValue();

		// retrieve viewer type

		int result = -1;

		switch (page) {

			case XFDesignConstants.CI_PG_PROPERTIES:

				if (realIndex<0) {

					// well-known props...i can't ask for property viewer type,

					// I have to set it directly

					switch (realIndex) {

						case X_INDEX:

						case Y_INDEX:

						case WIDTH_INDEX:

						case HEIGHT_INDEX:

							result = XFDesignConstants.PVT_INPUT_INT;

							break;

						case NAME_INDEX:

							result = XFDesignConstants.PVT_INPUT_STRING;

							break;

            case LAYOUT_INDEX:

              result = XFDesignConstants.PVT_CHOICE_STRICT;

              break;

					}

				} else {

					result = comp.getPropertyViewerType(realIndex);				

				}

				break;

			case XFDesignConstants.CI_PG_EVENTS:

				result = XFDesignConstants.PVT_INPUT_STRING;

				break;

			case XFDesignConstants.CI_PG_LAYOUT:

        XelfiDesignLayout xdl = ((XelfiVisualContainer)((Component)comp).

                                 getParent()).getDesignLayout();

				result = xdl.getPropertyViewerType(realIndex);

				break;

		}

		return result;

	}

	boolean isLayoutPageAvailable () {

		// check if all selected components hava the same parent

		Object temp = selectedComponents.elementAt(0);

		if (!(temp instanceof Component)) return false;

		Component parent = ((Component)temp).getParent();

		for (int i=1; i<selectedComponents.size(); i++) {

			temp = selectedComponents.elementAt(i);

			if (!(temp instanceof Component)) return false;

			if (!((Component)temp).getParent().equals(parent)) return false;

		}				

		// check if parent is XelfiVisualContainer

		if (!(parent instanceof XelfiVisualContainer)) return false;

		return true;

	}

	/**

	 * Returns the name (string) of the well known property 

	 * which belongs to index.<br>

	 * Returns null if index is bad.

	*/

	String getWellKnownPropertyName (int index) {

		switch (index) {

			case X_INDEX:

				return XName;

			case Y_INDEX:

				return YName;

			case WIDTH_INDEX:

				return WidthName;

			case HEIGHT_INDEX:

				return HeightName;

			case NAME_INDEX:

				return NameName;

      case LAYOUT_INDEX:

        return LayoutName;

		}

		return null;

	}

	/**

	 * Returns an array of constants' names for specified property,

	 * exception if an error occurs

	*/

	String[] getPropertyValueNames (int propIndex)

			throws XFPropertyIndexOutOfBoundsException {

		// get the component - we can find out value names from first comp

        XelfiDesignComponent comp =

            (XelfiDesignComponent)selectedComponents.elementAt(0);

		// get the property index in first comp

		int realIndex = ((Integer)getIndexes(propIndex).

												elementAt(0)).intValue();

		// get value names and return

		switch (page) {

      case XFDesignConstants.CI_PG_PROPERTIES:

        if (realIndex<0) {

          switch (realIndex) {

            case LAYOUT_INDEX:

              // return names of installed layouts

              return XFInstalledLayouts.getAllLayoutNames();

          }

        }

				return comp.getPropertyValueNames(realIndex);

			case XFDesignConstants.CI_PG_LAYOUT:

				// [PENDING] - maybe not finished yet

				XelfiDesignLayout xdl = ((XelfiVisualContainer)((Component)comp).

																	getParent()).getDesignLayout();

				return xdl.getPropertyValueNames(realIndex);

		}

		return null;

	}

	/**

	 * Runs special property editing dialog. 

	*/	

	void specialPropertyInput (Frame parent, int propIndex) 

			throws XFPropertyIndexOutOfBoundsException,

							XFPropertyNoSpecialInputException,

							XFNameNotFoundException {

		// get the component - we can find out dialog from first comp

		XelfiDesignComponent comp = 

        (XelfiDesignComponent)selectedComponents.elementAt(0);

		// get the property index in first comp

		int realIndex = ((Integer)getIndexes(propIndex).

												elementAt(0)).intValue();

//    Debug.debug(Debug.INSPECTOR, "I'm in special input...");

		// try to run dialog

		switch (page) {

			case XFDesignConstants.CI_PG_PROPERTIES:

				comp.specialPropertyInput(parent, realIndex);

				break;

			case XFDesignConstants.CI_PG_LAYOUT:

				// [PENDING] - maybe not good

				XelfiDesignLayout xdl = ((XelfiVisualContainer)((Component)comp).

																	getParent()).getDesignLayout();

				xdl.specialPropertyInput(parent, (XelfiVisualComponent)comp, realIndex);

				break;

		}

	}

	/**

	 * Returns default event name for specified property.

	 * Returns null if property is not an event prop.

	*/

	String getDefaultEventName (int propIndex) {

		if (getPage()!=XFDesignConstants.CI_PG_EVENTS) return null;

		// get the first component - we take into count name of the first

		// selected component only for now....(change is possible in future)

		XelfiDesignComponent comp =

        (XelfiDesignComponent)selectedComponents.elementAt(0);

		// get the property index in first comp

		int realIndex = ((Integer)getIndexes(propIndex).

												elementAt(0)).intValue();

		// get the name of the component

		String compName = comp.getName();

		// get property name string

		String propName = (comp.getEventNames())[realIndex];

		// merge names and create default event name

		return createDefaultEventName(compName, propName);

	}

	/**

	 * Merges given comp and prop names and creates default event name

	*/

	private String createDefaultEventName(String compName, String propName) {

/*		String restOfEventName = propName.startsWith(eventStart)

	 						? propName.substring(eventStart.length(), propName.length()) 

							: propName; */

		return new String(compName+propName);

	}

	/**

	 * Builds indexes for specified page if they are not created yet

	*/	

	private void buildIndexes () {

		switch (page) {

			case XFDesignConstants.CI_PG_PROPERTIES:

				if (propertiesIndexes==null)

					propertiesIndexes = buildPropertiesIndexes();

				break;

			case XFDesignConstants.CI_PG_EVENTS:

				if (eventsIndexes==null)

					eventsIndexes = buildEventsIndexes();

				break;

			case XFDesignConstants.CI_PG_LAYOUT:

				if (layoutIndexes==null)

					layoutIndexes = buildLayoutIndexes();

				break;

		}

	}			

	/**

	 * Constructs a vector of indexes for properties in selected 

	 * components. Indexes vector says us at which index which 

	 * property can be found in selected components

	 * (yep, that's the point, the same property can be at different 

	 * indexes in different selected components - that's why indexes

	 * vector exists).

	*/

	private Vector buildPropertiesIndexes () {			

		if (selectedComponents==null) return null;

		Vector indexes = new Vector(10, 10);

		Vector propertyIndexes = null;

    XelfiDesignComponent first =

        (XelfiDesignComponent)(selectedComponents.elementAt(0));

		int selCount = selectedComponents.size();

		// adds Name property

		if (selCount==1) {

			propertyIndexes = new Vector();

			propertyIndexes.addElement((Object)(new Integer(NAME_INDEX)));

			indexes.addElement((Object)propertyIndexes);

		}

		if (allSelectedAreVisual()) {

      // selected comps are visual, so add props for position

      // and these are X, Y, Width, Height

      propertyIndexes = new Vector();

			fillVector(propertyIndexes, X_INDEX, selCount);

      indexes.addElement((Object)propertyIndexes);

      propertyIndexes = new Vector();

			fillVector(propertyIndexes, Y_INDEX, selCount);

      indexes.addElement((Object)propertyIndexes);

      propertyIndexes = new Vector();

			fillVector(propertyIndexes, WIDTH_INDEX, selCount);

      indexes.addElement((Object)propertyIndexes);

      propertyIndexes = new Vector();

			fillVector(propertyIndexes, HEIGHT_INDEX, selCount);

      indexes.addElement((Object)propertyIndexes);

    }

    // add layout property, if comp is a container and

		// only and only one component is selected

    if ((selCount==1)&&(first instanceof XelfiVisualContainer)) {

      propertyIndexes = new Vector();

      propertyIndexes.addElement((Object)(new Integer(LAYOUT_INDEX)));

      indexes.addElement((Object)propertyIndexes);

    }

		// iterates through selected components and finds common set

		// saves indexes of found common properties into indexes structure

		String[] firstPropertyNames = first.getPropertyNames();

		for (int i=0; i<first.getPropertyCount(); i++) {

			boolean isCommon = true;

			propertyIndexes = new Vector();

			propertyIndexes.addElement((Object)(new Integer(i)));

			for (int y=1; y<selectedComponents.size(); y++) {

				int propertyIndex = propertyExist(first, i, firstPropertyNames[i], 

									(XelfiDesignComponent)(selectedComponents.elementAt(y)));

				if (propertyIndex>=0) {

					propertyIndexes.addElement((Object)(new Integer(propertyIndex)));

				} else {

					isCommon = false;

					break;

				}

			}

			if (isCommon==true) indexes.addElement((Object)propertyIndexes);

		}

		return indexes;																		

	}

	/**

	 * Checks if all of selected components are visual component.

	*/

	private boolean allSelectedAreVisual () {

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

			if (!(selectedComponents.elementAt(i) 

			  	instanceof XelfiVisualComponent))

				return false;

		}

		return true;

	}

	/**

	 * Fills vector with integer objects created from given index.

	*/

	void fillVector (Vector vector, int index, int count) {

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

			vector.addElement((Object)(new Integer(index)));

		}

	}

	/**

	 * Searches second component for property which is the same as 

	 * property of first component at index "index".

	 * Returns index of found property or -1 on error. 

	*/

	private int propertyExist (XelfiDesignComponent first, int index, 

															String firstName,

															XelfiDesignComponent second) {

		// searches for the property in "second" component 

		// which is equal to property of "first" component at index "index"

		String[] secondNames = second.getPropertyNames();

		for (int i=0; i<second.getPropertyCount(); i++) {

			try {

				// compares names and viewer types of properties

				if ((firstName.compareTo(secondNames[i])==0) &&

						(first.getPropertyViewerType(index)==

							second.getPropertyViewerType(i)))

					return i;

			} catch (XFPropertyIndexOutOfBoundsException e) {};

		}

		// nothing found - return non-existing index

		return -1;

	}

	/**

	 * Builds indexes structure for events.

	*/

	private Vector buildEventsIndexes () {			

		if (selectedComponents==null) return null;

		Vector indexes = new Vector(10, 10);

		// iterates through selected components and finds common set of events

		// saves indexes of found common events into indexes structure

    XelfiDesignComponent first =

        (XelfiDesignComponent)(selectedComponents.elementAt(0));

		String[] firstEventNames = first.getEventNames();

		for (int i=0; i<first.getEventCount(); i++) {

			boolean isCommon = true;

			Vector eventIndexes = new Vector();

			eventIndexes.addElement((Object)(new Integer(i)));

			for (int y=1; y<selectedComponents.size(); y++) {

				int eventIndex = eventExist(first, i, firstEventNames[i], 

									(XelfiDesignComponent)(selectedComponents.elementAt(y)));

				if (eventIndex>=0) {

					eventIndexes.addElement((Object)(new Integer(eventIndex)));

				} else {

					isCommon = false;

					break;

				}

			}

			if (isCommon==true) indexes.addElement((Object)eventIndexes);

		}

		return indexes;																		

	}

	/**

	 * Searches second component for an event property.

	 * Returns index of event property.

	*/

	private int eventExist (XelfiDesignComponent first, int index, 

															String firstName,

															XelfiDesignComponent second) {

		// searches for the event property in "second" component 

		// which is equal to event property of "first" component at index "index"

		String[] secondNames = second.getEventNames();

		for (int i=0; i<second.getEventCount(); i++) {

			// compares names of event properties

			if (firstName.compareTo(secondNames[i])==0)

				return i;

		}

		// nothing found - return non-existing index

		return -1;

	}

	private Vector buildLayoutIndexes () {			

		if (selectedComponents==null) return null;

		Vector indexes = new Vector(10, 10);

		Component parent = 

								((Component)selectedComponents.elementAt(0)).getParent();

		XelfiDesignLayout xdl = ((XelfiVisualContainer)parent).getDesignLayout();

		String[] firstPropertyNames = xdl.getPropertyNames();

		for (int i=0; i<xdl.getPropertyCount(); i++) {

			Vector layoutIndexes = new Vector();

			layoutIndexes.addElement((Object)(new Integer(i)));						

			indexes.addElement((Object)layoutIndexes);

			// debug

			// Debug.debug(Debug.INSPECTOR, firstPropertyNames[i]);

		}

		return indexes;

	}

  /**

   * Compares names of the events.

  */

  private int compareEvents (String oldName, String newName) {

    if ( oldName==null || (oldName.compareTo("")==0) ) {

      if ( newName!=null && (newName.compareTo("")!=0) )

        return NEW_NAME;

    } else {

      if ( newName==null || (newName.compareTo("")==0) )

        return DELETED_NAME;

      else {

        if ( oldName.compareTo(newName)!=0 )

         return CHANGED_NAME;

      }

    }

    return SAME_NAME;

  }

  /**

   * Finds and creates layout from given index.

   * Index means index into array of installed layout names.

  */

  private XelfiDesignLayout buildLayoutFromIndex (int index) {

    // get layout names

    String[] layoutNames = XFInstalledLayouts.getAllLayoutNames();

    // create specified layout

    return XFInstalledLayouts.createLayout(layoutNames[index]);

  }

  /**

   * Refreshes the component according to the given

   * value of refresh type

  */

  private void refreshComponent (XelfiDesignComponent xdc, int refreshType) {

    if (!(xdc instanceof Component)) return;

    Component comp = (Component)xdc;

    switch (refreshType) {

      case XFDesignConstants.RSP_REPAINT_COMP:

        comp.repaint();

        break;

      case XFDesignConstants.RSP_SHOW_HIDE:

        comp.hide();

        comp.show();

        break;

      case XFDesignConstants.RSP_VALIDATE:

        comp.invalidate();

        comp.validate();

        break;

      case XFDesignConstants.RSP_VALIDATE_PARENT:

        comp.invalidate();

        comp.getParent().validate();

        break;

    }

  }

}