import java.util.ArrayList;

import org.eclipse.swt.widgets.Composite;

/*******************************************************************************

 * Copyright (c) 2000, 2007 IBM Corporation and others.

 * All rights reserved. This program and the accompanying materials

 * are made available under the terms of the Eclipse Public License v1.0

 * which accompanies this distribution, and is available at

 * http://www.eclipse.org/legal/epl-v10.html

 * 

 * Contributors:

 *     IBM Corporation - initial API and implementation

 *******************************************************************************/

package org.eclipse.tptp.test.auto.gui.internal.commands;

import java.util.ArrayList;

import java.util.Hashtable;

import java.util.Vector;

import org.eclipse.core.runtime.CoreException;

import org.eclipse.core.runtime.IPath;

import org.eclipse.core.runtime.IProgressMonitor;

import org.eclipse.core.runtime.IStatus;

import org.eclipse.core.runtime.Path;

import org.eclipse.core.runtime.Status;

import org.eclipse.core.runtime.SubProgressMonitor;

import org.eclipse.jface.dialogs.MessageDialog;

import org.eclipse.jface.window.Window;

import org.eclipse.osgi.util.NLS;

import org.eclipse.swt.SWT;

import org.eclipse.swt.SWTException;

import org.eclipse.swt.custom.CCombo;

import org.eclipse.swt.custom.CTabFolder;

import org.eclipse.swt.custom.StyledText;

import org.eclipse.swt.graphics.Point;

import org.eclipse.swt.widgets.Button;

import org.eclipse.swt.widgets.Combo;

import org.eclipse.swt.widgets.Composite;

import org.eclipse.swt.widgets.Control;

import org.eclipse.swt.widgets.Display;

import org.eclipse.swt.widgets.Event;

import org.eclipse.swt.widgets.List;

import org.eclipse.swt.widgets.Listener;

import org.eclipse.swt.widgets.MenuItem;

import org.eclipse.swt.widgets.Shell;

import org.eclipse.swt.widgets.TabFolder;

import org.eclipse.swt.widgets.Table;

import org.eclipse.swt.widgets.Text;

import org.eclipse.swt.widgets.ToolItem;

import org.eclipse.swt.widgets.Tree;

import org.eclipse.swt.widgets.TreeItem;

import org.eclipse.swt.widgets.Widget;

import org.eclipse.tptp.test.auto.gui.internal.AutoGUIMessages;

import org.eclipse.tptp.test.auto.gui.internal.GlobalConstants;

import org.eclipse.tptp.test.auto.gui.internal.GuiPlugin;

import org.eclipse.tptp.test.auto.gui.internal.core.IObjectMine;

import org.eclipse.tptp.test.auto.gui.internal.core.IPlayable;

import org.eclipse.tptp.test.auto.gui.internal.core.IUIObject;

import org.eclipse.tptp.test.auto.gui.internal.core.IWritable;

import org.eclipse.tptp.test.auto.gui.internal.core.VerificationMetaData;

import org.eclipse.tptp.test.auto.gui.internal.core.WidgetIdentifier;

import org.eclipse.tptp.test.auto.gui.internal.macro.AbstractMacroInstruction;

import org.eclipse.tptp.test.auto.gui.internal.macro.Macro;

import org.eclipse.tptp.test.auto.gui.internal.macro.MacroConstants;

import org.eclipse.tptp.test.auto.gui.internal.macro.MacroManager;

import org.eclipse.tptp.test.auto.gui.internal.macro.MacroObjectLocator;

import org.eclipse.tptp.test.auto.gui.internal.macro.MacroUtil;

import org.eclipse.tptp.test.auto.gui.internal.macro.UIObject;

import org.eclipse.tptp.test.auto.gui.internal.macro.ObjectMine.IDCollisionException;

import org.eclipse.tptp.test.auto.gui.internal.macro.ObjectMine.UIObjectNotFound;

import org.w3c.dom.Node;

import org.w3c.dom.NodeList;

/**

 * Keeps track of the macro commands while they are being captured.

 */

public class MacroCommandShell extends AbstractMacroInstruction

{

	/* The commands of this macro shell */

	private ArrayList commands;

	/* The expected return code */

	private int expectedReturnCode;

	/* The last event received */

	private transient Event lastEvent;

	/* The display object */

	private transient Display display;

	/* The shell that this macro command shell represents */

	private transient Shell shell;

	/* The reference id of the macro shell object */

	private String referenceId;

	/* The title of the shell that this macro command shell represents */

	private String shellTitle;

	private transient Window window;

	/* Indicates user interaction -- Set when a key up event is received */

	private transient boolean isKeyPressed;

	/* Indicates user interaction -- Set when a mouse up event is received */

	private transient boolean isMousePressed;

	/* Stores an event that is only acknowledged followed by user interaction. */

	private transient Event toBeAckEvent;

	/* Set when the stored event in toBeAckEvent is acknowledged */

	private transient boolean ackEvent;

	/* Set when there is a listener registered with this MacroCommandShell */

	private transient boolean isListenerRegistered;

	/* Stores the time for which a command was last created in */

	private long lastCommandCreationTime;

	/* A queue of nested shell waiting to be activated (this is used during playback) */ 

	private static Vector nestedShellQueue;

	/* Last index of the nested shell queue */ 

	private static int lastNestedShellInx;

	/* Stores the last command line executed */

	private static int lastCommandLineExecuted;

	/* Mutual lock used to block when a command is being executed.  This lock is used to forcefully wake up

	 * the thread that this object is running in if the command has caused a stall */

	private Boolean mutualLock;

	/* A mutual lock shared across multiple instances of this class -- It's general purpose is to lock shared static resources */

	private static Boolean mutualGlobalLock;

	/* The parent of this macro command shell.  This is null if this macro shell command is the root */

	private MacroCommandShell parent;

	/* The index of the command being executed -- this will correspond to the last command index if isComplete = true */

	private int currentCommandInx;

	/* Indicates if all the commands of this shell has been completed */

	private boolean isComplete;

	/* Indicates that the process needs to be interrupted -- due to an error */

	private static boolean interruptProcess;

	/* Set to true when process has been terminated */

	private static boolean processTerminated;

	/* The exception causing the interruption */

	private static Throwable interruptedException;

	/* A central container for all macro command operation being played */

	private static Vector macroCommandsBeingPlayed;

	/* A central container for all instances of this class */

	private static Vector macroCommandShellContainer;

	/* A central repository for all macro command shells */

	static

	{

		nestedShellQueue = new Vector();

		macroCommandsBeingPlayed = new Vector();

		macroCommandShellContainer = new Vector();

		mutualGlobalLock = new Boolean(true);

	}

	public MacroCommandShell(MacroCommandShell parent)

	{

		this(parent, null, null);

	}

	public MacroCommandShell(MacroCommandShell parent, Shell shell, WidgetIdentifier wid)

	{

		setWidgetId(wid);

		commands = new ArrayList();

		this.shell = shell;

		this.shellTitle = shell == null || shell.isDisposed() ? null : shell.getText();

		hookWindow(false);

		expectedReturnCode = -1;

		isListenerRegistered = false;

		mutualLock = new Boolean(true);

		this.parent = parent;

		isComplete = false;

		macroCommandShellContainer.add (this);		

	}

	private void hookWindow(boolean playback)

	{

		if (shell != null)

		{

			if (!playback)

				doHookWindow();

			else

				display.syncExec(new Runnable()

				{

					public void run()

					{

						doHookWindow();

					}

				});

		}

	}

	private void doHookWindow()

	{

		Object data = shell.getData();

		if (data != null && data instanceof Window)

			this.window = (Window) data;

	}

	/**

	 * @see org.eclipse.tptp.test.auto.gui.internal.macro.AbstractMacroInstruction#load(org.w3c.dom.Node, java.util.Hashtable)

	 */

	public void load(Node node, Hashtable lineTable) throws CoreException

	{

		super.load(node, lineTable);

		/* If the corresponding shell of this command is referenced then attempt to find

		 * the corresponding object in the object mine. */

		setCorrespondingObject(MacroObjectLocator.lookupReferenceId(null, node, lineTable));		

		boolean useObjectMine = getCorrespondingObject() != null;

		setWidgetId(new WidgetIdentifier(

				null,

				new Path(useObjectMine ? getCorrespondingObject().getObjectId() : MacroUtil.getAttribute(node, MacroConstants.ID_ATTRIBUTE)),

				useObjectMine ? getCorrespondingObject().getResolverId() : MacroUtil.getAttribute(node, MacroConstants.RESOLVER_ATTRIBUTE)));		

		String codeId = MacroUtil.getAttribute(node, MacroConstants.RETURN_CODE_ATTRIBUTE);

		if (codeId != null)

		{

			try

			{

				expectedReturnCode = new Integer(codeId).intValue();

			} catch (NumberFormatException e)

			{

			}

		}

		NodeList children = node.getChildNodes();

		for (int i = 0; i < children.getLength(); i++)

		{

			Node child = children.item(i);

			if (child.getNodeType() == Node.ELEMENT_NODE)

			{

				String name = child.getNodeName();

				if (name.equals(MacroConstants.COMMAND_ELEMENT))

					processCommand(child, lineTable);

				else if (name.equals(MacroConstants.SHELL_ELEMENT))

					processShell(child, lineTable);

			}

		}

	}

	/**

	 * Used to process the node that is passed in as argument, the lineTable hashtable indicates

	 * the range of line numbers that the node corresponds to in the macro script

	 *  

	 * @param node The node to be processed

	 * @param lineTable The line number range that the node corresponds to in the script.

	 */

	private void processCommand(Node node, Hashtable lineTable) throws CoreException

	{

		IUIObject commandObject = MacroObjectLocator.lookupReferenceId(getCorrespondingObject(), node, lineTable);

		boolean isObjectFound = commandObject != null;

		String cid = isObjectFound ? commandObject.getContextId() : MacroUtil.getAttribute(node, MacroConstants.CONTEXT_ID_ATTRIBUTE);

		String wid = isObjectFound ? commandObject.getObjectId() : MacroUtil.getAttribute(node, MacroConstants.WIDGET_ID_ATTRIBUTE);		

		String rid = isObjectFound ? commandObject.getResolverId() : MacroUtil.getAttribute(node, MacroConstants.RESOLVER_ATTRIBUTE);

		String type = MacroUtil.getAttribute(node, MacroConstants.TYPE_ATTRIBUTE);

		if (type == null)

			return;

		AbstractMacroCommand command = null;

		WidgetIdentifier wi = (wid != null && cid != null) ? new WidgetIdentifier(new Path(cid), new Path(wid), rid) : null;

		if (type.equals(ModifyCommand.TYPE))

			command = new ModifyCommand(this, wi);

		else if (type.equals(BooleanSelectionCommand.TYPE))

			command = new BooleanSelectionCommand(this, wi);

		else if (type.equals(StructuredSelectionCommand.ITEM_SELECT) || type.equals(StructuredSelectionCommand.DEFAULT_SELECT))

			command = new StructuredSelectionCommand(this, wi, type);

		else if (type.equals(ExpansionCommand.TYPE))

			command = new ExpansionCommand(this, wi);

		else if (type.equals(CheckCommand.TYPE))

			command = new CheckCommand(this, wi);

		else if (type.equals(FocusCommand.TYPE))

			command = new FocusCommand(this, wi);

		else if (type.equals(ChoiceSelectionCommand.TYPE))

			command = new ChoiceSelectionCommand(this, wi);

		else if (type.equals(WaitCommand.TYPE))

			command = new WaitCommand(this);

		/* The verification command */

		else if (type.equals(VerificationCommand.TYPE))

			command = new VerificationCommand(this, new VerificationMetaData());

		/* The close workbench part command */

		else if (type.equals(CloseWorkbenchPartCommand.TYPE))

			command = new CloseWorkbenchPartCommand(this, wi);

		/* Mouse events */

		else if (type.equals(MouseEventCommand.TYPE0) || type.equals(MouseEventCommand.TYPE1) || type.equals(MouseEventCommand.TYPE2))

			command = new MouseEventCommand (this);

		/* Key events */

		else if (type.equals(KeyEventCommand.TYPE0) || type.equals(KeyEventCommand.TYPE1) || type.equals(KeyEventCommand.TYPE2))

			command = new KeyEventCommand (this);

		if (command != null)

		{

			command.setCorrespondingObject(commandObject);		

			command.load(node, lineTable);			

			commands.add(command);

		}

	}

	private void processShell(Node node, Hashtable lineTable) throws CoreException

	{

		MacroCommandShell shell = new MacroCommandShell(this);

		shell.load(node, lineTable);

		commands.add(shell);

	}

	public void addCommandShell(MacroCommandShell cshell)

	{

		commands.add(cshell);

	}

	public void write(int indent, StringBuffer sb)

	{

		/* If this shell command doesn't have any commands, then exit */

		if (commands == null || commands.size() <= 0)

			return;

		/* <shell */

		MacroUtil.addElement(sb, indent, MacroConstants.SHELL_ELEMENT, false, false);

		boolean objectMineInUse = MacroManager.getInstance().isObjectMineOn() && getWidgetId().getReferenceId() != null;

		MacroUtil.addAttribute(sb, 

				new String[] {	MacroConstants.DESCRIPTIVE_ATTRIBUTE,

								MacroConstants.RESOLVER_ATTRIBUTE,

								MacroConstants.ID_ATTRIBUTE,

								MacroConstants.REFERENCE_ID_ATTRIBUTE,

								MacroConstants.RETURN_CODE_ATTRIBUTE},

				new String[] {	getDescriptiveField(),

								objectMineInUse ? null : getWidgetId().getResolverId(),

								objectMineInUse ? null : getWidgetId().getObjectId().toString(),

								objectMineInUse ? getWidgetId().getReferenceId() : null,

								String.valueOf(expectedReturnCode)}, false, true

		);

		int cindent = indent + 1;

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

		{

			IWritable writable = (IWritable) commands.get(i);

			writable.writeStart(cindent, sb);

			writable.write(cindent, sb);

			writable.writeFinish(cindent, sb);

		}

		MacroUtil.addElement(sb, indent, MacroConstants.SHELL_ELEMENT, true, true);

	}

	public String getDescriptiveField()

	{

		return shellTitle == null ? null : MacroUtil.normalizeDescriptiveField(MacroUtil.boundSize(shellTitle, AbstractMacroCommand.DESCRIPTIVE_FIELD_BOUND));

	}

	public void addEvent(Event event)

	{

		if (event.widget instanceof Control)

		{

			if (((Control) event.widget).isVisible() == false)

				return;

		}

		AbstractMacroCommand command = null;

		if (event.detail == MacroManager.POSITION_BASED_EVENT)

			command = createPositionBasedCommand(event);

		else

			command = createCommand(event);

		if (command != null)

		{			

			AbstractMacroCommand lastCommand = getLastCommand();

			/* Take out the last command if it is a focus command and the command just passed in implicitly does a focus */ 

			if (lastCommand != null && 

					(lastCommand.getWidgetId() != null && lastCommand.getWidgetId().equals(command.getWidgetId()) && lastCommand.getType().equals(FocusCommand.TYPE) && isFocusCommand(command.getType())))

			{

				// focus followed by select or modify - focus implied

				commands.remove(lastCommand);

			}

			/* Modify the last event accordinggly */

			if (ackEvent)				

			{

				ackEvent = false;

				lastEvent = toBeAckEvent;

				toBeAckEvent = null;

			}

			else

			{

				lastEvent = event;

			}

			/* Add the artificial wait time if required */

			if (MacroManager.getInstance().isArtificialWaitOn() && lastCommandCreationTime > 0)

			{

				long currentTime = System.currentTimeMillis();

				long difference = currentTime - lastCommandCreationTime;

				command.setTimeDifference(difference);

			}

			lastCommandCreationTime = System.currentTimeMillis();

			/* Ali M.: The following block of code provides a workaround for a limitation that

			 * exists for CloseWorkbenchPartCommand.  We are only able to capture this event

			 * after the entire part has been disposed.  Things would be ideal if this event

			 * could be captured right after the user clicks on the close button of the part */			

			if (command instanceof CloseWorkbenchPartCommand)

			{

				int commandSize = commands.size();

				if (commandSize > 0)

				{

					/* If the last command corresponds to the message dialog that prompts the

					 * user to save an editor, then store it after the close command */

					Object lastCommandStored = commands.get(commandSize - 1);

					if (lastCommandStored instanceof MacroCommandShell &&													/* If the last stored command is a shell */ 

						((CloseWorkbenchPartCommand)command).getWidgetId().getContextId().equals(MacroConstants.EDITOR_VALUE) &&				/* If the part is an editor */

						((MacroCommandShell)lastCommandStored).getWidgetId().getObjectId().equals(MessageDialog.class.getName()))				/* If the shell is a MessageDialog */

					{						

						commands.add(commandSize - 1 , command);

						return;						

					}

				}

			}

			/* Added for defect 164197 in order to add an item-expansion to the parent whenever the 

			 * child is selected in a case where the parent has been pre-expanded.

			 * Liz D.

			 */

			if (command instanceof StructuredSelectionCommand && event.widget instanceof Tree){

				StructuredSelectionCommand s = (StructuredSelectionCommand)command;

				TreeItem[] items = (TreeItem [])s.getItemsForEvent(event);

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

				{

					TreeItem selectedItem = (TreeItem) items[i];

					while(selectedItem.getParentItem()!=null)

					{

						TreeItem parent = selectedItem.getParentItem();

						if (parent.getExpanded()== true)

						{//necessary so that we only apply this in the case where the parent is already expanded

							Event expansionEvent = new Event();

							expansionEvent.widget = parent;

							expansionEvent.item = parent;

							ExpansionCommand parentExpand = new ExpansionCommand(this, command.getWidgetId());

							parentExpand.processEvent(expansionEvent, true);

							commands.add(parentExpand);

						}

						selectedItem = parent;

					}// end while			

				}		

			}

			commands.add(command);}

	}

	/**

	 * Adds a wait command for as long as the last command is not already a wait (i.e.

	 * duplicate addition of wait commands are avoided through this method)

	 */

	public void addPause()

	{

		WaitCommand command = new WaitCommand(this);

		Object lastCommand = null;

		int commandSize = commands.size();

		boolean isLastCommandWait = false;

		if (commandSize <= 0)

			return;

		lastCommand = commands.get (commandSize - 1);

		int lastCmdInx = 2;

		/* Avoid MacroCommandShells that have no commands (since these will not be included 

		 * as part of the macro) */

		while (lastCommand instanceof MacroCommandShell && ((MacroCommandShell)lastCommand).getCommands().size() <= 0) 

		{

			if (commandSize - lastCmdInx >= 0)

				lastCommand = commands.get (commandSize - lastCmdInx);

			else

			{

				lastCommand = null;

				break;

			}

			lastCmdInx++;

		}

		AbstractMacroCommand lastMacroCommand = null;

		if (lastCommand instanceof AbstractMacroCommand)

			lastMacroCommand = (AbstractMacroCommand)lastCommand;

		isLastCommandWait = lastMacroCommand != null && lastMacroCommand.getType() == WaitCommand.TYPE;

		if (commands.size() > 0 && !isLastCommandWait)

		{

			commands.add(command);				

		}

	}

	public void addVerificationCommand (VerificationCommand command)

	{

		commands.add(command);

	}

	public void extractExpectedReturnCode()

	{

		if (window != null)

			expectedReturnCode = window.getReturnCode();

	}

	public boolean matchesReturnCode()

	{

		if (window != null)

		{

			return window.getReturnCode() == expectedReturnCode;

		}

		return true;

	}

	private boolean isFocusCommand(String type)

	{

		return type.equals(BooleanSelectionCommand.TYPE) || type.equals(StructuredSelectionCommand.ITEM_SELECT) || type.equals(StructuredSelectionCommand.DEFAULT_SELECT) || type.equals(ExpansionCommand.TYPE) || type.equals(CheckCommand.TYPE) || type.equals(ModifyCommand.TYPE);

	}

	/**

	 * Handles position-based events 

	 */

	protected AbstractMacroCommand createPositionBasedCommand (Event event)

	{

		AbstractMacroCommand command = null;

		switch (event.type)

		{

			case SWT.MouseUp:

			case SWT.MouseDown:

			case SWT.MouseDoubleClick:

				command = new MouseEventCommand (this);			

				break;

			case SWT.KeyUp:

			case SWT.KeyDown:

				command = new KeyEventCommand (this);

				break;

		}

		if (command != null)

			command.processEvent (event);

		return command;

	}

	/**

	 *  Handles object-based events

	 */

	protected AbstractMacroCommand createCommand(Event event)

	{	

		/* A quick way to get out if we're only getting key up or mouse events that have been detected before */

		if ((isKeyPressed && event.type == SWT.KeyUp) || (isMousePressed && event.type == SWT.MouseUp))

			return null;

		AbstractMacroCommand lastCommand = getLastCommand();

		if (lastEvent != null && lastEvent.widget != null && lastEvent.widget.equals(event.widget))

		{

			if (lastEvent.type == event.type || (lastEvent.type == SWT.Selection && event.type == SWT.DefaultSelection))

			{

				if (lastCommand != null && lastCommand.mergeEvent(event))

					return null;

			}

		}

		AbstractMacroCommand command = null;

		/* Check to see if we are a drop-down menu selection */

		if (lastCommand != null && lastCommand.getType() == BooleanSelectionCommand.TYPE && 

				((BooleanSelectionCommand)lastCommand).getDetail() == SWT.DROP_DOWN)

		{

			((BooleanSelectionCommand)lastCommand).setItemSelected (event);

			return null;

		}

		WidgetIdentifier wi = MacroUtil.getWidgetIdentifier(event.widget);		

		if (wi == null)

			wi = MacroUtil.getCustomEventIdentifier(event);				

		if (wi == null)

			return null;

		switch (event.type)

		{

			case SWT.Modify:				

				if (!isEditable(event.widget))

					return null;

				/* This block of code is used to avoid displaying the browse native dialog when the user clicks

				 * a browse button - it doesn't cover all cases */

				if (lastEvent != null && lastEvent.type == SWT.Selection && lastEvent.widget instanceof Button)

				{

					String text = ((Button)lastEvent.widget).getText();

					if (text != null)

					{

						text = text.replaceAll("\\&", "");

						text = text.toLowerCase();

						if (text.indexOf(AutoGUIMessages.AUTO_GUI_CONTROL_STATUS_BROWSE) != -1)

						{

							ArrayList commands = this.getCommands();

							int size = 0;

							if (commands != null && (size = commands.size()) > 0)

							{

								commands.remove(size - 1);					

								command = new ModifyCommand(this, MacroUtil.getWidgetIdentifier(event.widget));

								break;

							}

						}

					}				

				}

				/* Only acknowledge modifies that are followed by a key up event */

				toBeAckEvent = event;								

				break;

			case SWT.Selection:

			case SWT.DefaultSelection:

				command = createSelectionCommand(wi, event);				

				break;

			case SWT.FocusIn:

				/**

				 * Ali M.: While recording, the SWT display listener has the tendency to report

				 * focus events on controls that are actually not visible to the user.  When the

				 * macro is played back, the control cannot be located.  To avoid this problem

				 * we only acknowledge focus events that are followed by a mouse up or key up event (i.e.

				 * The user explicitly focuses on the control).

				 */

				toBeAckEvent = event;

				break;

			case SWT.Expand:

			case SWT.Collapse:

				command = new ExpansionCommand(this, wi);

				break;

			case SWT.KeyUp:

				isKeyPressed = true;	

				if (toBeAckEvent != null && toBeAckEvent.type == SWT.Modify)

				{

					command = new ModifyCommand(this, MacroUtil.getWidgetIdentifier(toBeAckEvent.widget));

					ackEvent = true;

					break;

				}

			case SWT.MouseUp:

				isMousePressed = true;	

				if (toBeAckEvent != null && toBeAckEvent.type == SWT.FocusIn)

				{

					command = new FocusCommand(this, MacroUtil.getWidgetIdentifier(toBeAckEvent.widget));

					ackEvent = true;

				}

				break;

			case Macro.WORKBENCH_PART_CLOSED:

				/* 110810 -- Create the close workbench command only if there is only one frame

				 * in our shell stack */

				if (MacroManager.getInstance().getCurrentMacro().getShellStackSize() == 1)

					command = new CloseWorkbenchPartCommand (this, wi); 

				break;

		}

		if (event.type != SWT.KeyUp)

			isKeyPressed = false;

		else if (event.type != SWT.MouseUp)

			isMousePressed = false;

		if (command != null)

		{

			/* Lookup the widget of this command.  If it already exists in our object mine, then

			 * have it referenced by setting the reference id of the command. */

			IObjectMine objectMine = MacroManager.getInstance().getObjectMine();

			IUIObject uiObject = null;

			WidgetIdentifier commandWidgetIdentifier = command.getWidgetId();

			boolean needsDescriptiveField = false;

			try

			{

				IUIObject activeObject = objectMine.getActiveObject();

				uiObject = objectMine.lookupUIObject(activeObject, commandWidgetIdentifier.getContextId() == null ? null : commandWidgetIdentifier.getContextId().toString(), commandWidgetIdentifier.getObjectId().toString());

				/* The object is not registered with the object mine - register it */

				if (uiObject == null)

				{

					needsDescriptiveField = true;

					uiObject = UIObject.createInstance(objectMine, command, activeObject);

					objectMine.registerObject(uiObject);

				}

				commandWidgetIdentifier.setReferenceId(uiObject.getReferenceId());				

			} 

			/* We can't afford to show an error message in case of an unexpected error during 

			 * registeration.  We'll ignore the error and not make use of the object mine. */

			catch (UIObjectNotFound e)

			{

				/* Should not happen */

			} catch (IDCollisionException e)

			{

				/* Should not happen */

			} catch (CoreException e)

			{

				/* Should not happen */

			}

			command.processEvent(event);

			if (needsDescriptiveField && uiObject != null)

			{

				uiObject.setDescriptive(command.getObjectClassName(event.widget) + (command.getDescriptiveField() == null ? MacroConstants.EMPTY_STRING : ": " + command.getDescriptiveField()));

			}

		}

		/* Ensure that redundant commands are not created */

		if (lastCommand != null && command != null && command.isRepeatRedundant() && command.equals(lastCommand))

		{

			return null;

		}

		return command;

	}

	private boolean isEditable(Widget widget)

	{

		if (widget instanceof Control)

		{

			Control control = (Control) widget;

			if (!control.isEnabled())

				return false;

			if (control instanceof Text)

				return ((Text) control).getEditable();

			if (control instanceof Combo || control instanceof CCombo)

				return ((control.getStyle() & SWT.READ_ONLY) == 0);

			if (control instanceof StyledText)

				return ((StyledText) control).getEditable();

		}

		return true;

	}

	private AbstractMacroCommand createSelectionCommand(WidgetIdentifier wid, Event event)

	{				

		if (event.widget instanceof MenuItem || event.widget instanceof ToolItem || (event.widget instanceof Button

				/* A CCombo will cause a button selection followed by a combo selection.  

				 * We need to ignore the button selection */

				&& !(event.widget instanceof Control && ((Control)event.widget).getParent() instanceof CCombo)))

		{						

			if (event.x != 0 || event.y != 0 || event.detail != 0)

				return new BooleanSelectionCommand(this, wid, new Point (event.x, event.y), event.detail);

			return new BooleanSelectionCommand(this, wid);			

		}

		if (event.widget instanceof Tree || event.widget instanceof Table || event.widget instanceof List)

		{

			if (event.detail == SWT.CHECK)

				return new CheckCommand(this, wid);

			String type = event.type == SWT.DefaultSelection ? StructuredSelectionCommand.DEFAULT_SELECT : StructuredSelectionCommand.ITEM_SELECT;

			return new StructuredSelectionCommand(this, wid, type);

		}

		if (event.widget instanceof TabFolder || event.widget instanceof CTabFolder)

			return new ChoiceSelectionCommand(this, wid);

		if (event.widget instanceof Combo || event.widget instanceof CCombo)

			return new ChoiceSelectionCommand(this, wid);

		return null;

	}

	private AbstractMacroCommand getLastCommand()

	{

		if (commands.size() > 0)

		{

			Object item = commands.get(commands.size() - 1);

			if (item instanceof AbstractMacroCommand)

				return (AbstractMacroCommand) item;

		}

		return null;

	}

	public boolean isDisposed()

	{

		return this.shell != null && this.shell.isDisposed();

	}

	public void close()

	{

		if (this.shell != null && !this.shell.isDisposed())

			this.shell.close();

	}

	public boolean tracks(Shell shell)

	{

		if (this.shell != null && this.shell.equals(shell))

			return true;

		return false;

	}

	public boolean playback(final Display display, Composite parent, final IProgressMonitor monitor) throws CoreException

	{		

		if (parent instanceof Shell)

		{

			this.shell = (Shell) parent;

			this.display = display;

			hookWindow(true);

		}

		NestedShell nestedShell = null;

		int commandSize = commands.size();

		monitor.beginTask("", commandSize);

		final int commandTimeOut;

		int potentialTimeoutValue = MacroManager.getInstance().getCommandTimeoutThreshold();

		if (MacroManager.getInstance().getCommandTimeoutThreshold() > 0)

			commandTimeOut = potentialTimeoutValue;

		else

			commandTimeOut = GlobalConstants.DEFAULT_COMMAND_TIME_OUT_PERIOD;

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

		{

			currentCommandInx = i;

			checkForInterruptions();							

			Object c = commands.get(i);

			final IPlayable playable = (IPlayable) c;

			/* If this is the last command of this macro command shell, then take out its entry in the shell queue */	

			if (isLastCommand(i))

			{

				if (getNestedShellQueue() != null && getNestedShellQueue().size() > 0)

				{

					if (lastNestedShellInx > 0)

						lastNestedShellInx--;

					removeNestedShell(0);

				}

			}

			/* If this command is a nested shell, then we need to wait until it completes before proceeding to the next command. */

			if (c instanceof MacroCommandShell)

			{

				MacroCommandShell nestedCommandShell = (MacroCommandShell)c;

				//System.out.println("NESTED SHELL WAIT: " + nestedCommandShell.getId());

				Object lastNestedCommand = null;

				Object currentNestedCommand = null;

				synchronized (nestedCommandShell)

				{

					/* Give each command in the nested shell a maximum of commandTimeOut to execute */

					while (!nestedCommandShell.isComplete() && (currentNestedCommand == null || lastNestedCommand != currentNestedCommand) && !interruptProcess)

					{

						try 

						{

							nestedCommandShell.wait(commandTimeOut);

							lastNestedCommand = currentNestedCommand;

							currentNestedCommand = nestedCommandShell.getCommandBeingExecuted();

						} catch (InterruptedException e) 

						{

							/* Handled by next set of code */

						}

					}

					/* Indicate an error if the nested shell never completed */

					if (!nestedCommandShell.isComplete())

					{							

						synchronized (mutualGlobalLock)

						{

							interruptProcess = true;

							if (interruptedException == null)

								interruptedException = new CoreException (new Status(IStatus.ERROR, GuiPlugin.getID(), 0, 

										NLS.bind(AutoGUIMessages.AUTO_GUI_ERROR_MACRO_NEST_TOUT, nestedCommandShell.getWidgetId().getObjectId().toString()), null));

						}

						continue;	/* Interrupt the normal flow */

					}

					//System.out.println("NESTED SHELL FINISH: " + nestedCommandShell.getId());

				}

			}

			if (i < commandSize - 1)

			{

				/* Ali M.: We need to iterate through all the shell commands and register listeners

				 * before it's too late.  It's not sufficient to just register a listener with the 

				 * next command */

				int counter = 1;

				IPlayable next = (IPlayable) commands.get(i + counter);

				while (next instanceof MacroCommandShell)

				{					

					/* This command will open a new shell.  Add a listener before it is too late */

					MacroCommandShell nestedCommand = (MacroCommandShell) next;

					if (!nestedCommand.isListenerRegistered())

					{

						nestedShell = new NestedShell(display, nestedCommand, new SubProgressMonitor(monitor, 1));

						final NestedShell fnestedShell = nestedShell;

						/* If this is a child of the previous shell, then it takes precedence.  If it's a sibling, then it

						 * should go to the end of the queue. */

						nestedCommand.setListenerRegistered(true);

						if (nestedShellQueue.size() > 0 && ((NestedShell)nestedShellQueue.get(0)).isParent(nestedCommand))

						{

							addNestedShell(0, fnestedShell);

							lastNestedShellInx = 0;

						}

						else

						{

							if (nestedShellQueue.size() > 0)

								addNestedShell(++lastNestedShellInx, fnestedShell);

							else

								addNestedShell(fnestedShell);							

						}

						display.syncExec(new Runnable()

								{

									public void run()

									{

										//System.out.println("ADDED");

										display.addFilter(SWT.Activate, fnestedShell);

									}

								});						

					}

					counter++;

					next = (i + counter <= commandSize - 1 ? (IPlayable) commands.get(i + counter) : null);					

				}

			}

			if (playable instanceof AbstractMacroCommand)

			{			

				final boolean last = i == commandSize - 1;	

				class WakeUpOperaion implements Runnable

				{

					private AbstractMacroCommand command;

					private boolean invalidate;

					public WakeUpOperaion (AbstractMacroCommand command)

					{

						this.command = command;

						invalidate = false;

					}

					public void run() 

					{

						if (!invalidate && MacroCommandShell.lastCommandLineExecuted == command.getStartLine())

						{

							/* Ali M.: A command just timed-out.  We need to indicate the error 

							 * and wakeup the thread */

							synchronized (mutualGlobalLock)

							{

								interruptProcess = true;								

								if (interruptedException == null)

									interruptedException = new CoreException (new Status(IStatus.ERROR, GuiPlugin.getID(), 0, 

										NLS.bind(AutoGUIMessages.AUTO_GUI_ERROR_MACRO_TIME_OUT, command.toString()), null));

							}

							synchronized (mutualLock)

							{

								mutualLock.notify();

							}

						}

					}

					public void invalidate()

					{

						this.invalidate = true;

					}

				}					

				WakeUpOperaion wakeupOpt = null;

				if (i < commandSize - 1)

				{				

					wakeupOpt = new WakeUpOperaion ((AbstractMacroCommand)playable);

					final Runnable wakeupOperation = wakeupOpt;					

					display.asyncExec(

						new Runnable()

						{

							public void run() 

							{

								display.timerExec(commandTimeOut, wakeupOperation);

							};

						}	

					);

				}

				class RunCommandOperation implements Runnable

				{

					private boolean isComplete;

					public void run()

					{ 

						try 

						{						

							if (!macroCommandsBeingPlayed.contains(this))

								macroCommandsBeingPlayed.add(this);

							lastCommandLineExecuted = ((AbstractMacroCommand)playable).getStartLine();

							playInGUIThread(display, playable, last, monitor);	

							macroCommandsBeingPlayed.remove(this);

							isComplete = true;

							synchronized (mutualLock) 

							{

								mutualLock.notify();

							}

						}

						catch (Throwable e) 

						{					

							macroCommandsBeingPlayed.remove(this);

							synchronized (mutualGlobalLock)

							{

								interruptProcess = true;

								if (interruptedException == null)

									interruptedException = e;

							}

							isComplete = true;

							synchronized (mutualLock)

							{

								mutualLock.notify();

							}

						} 

					} 

					public boolean isComplete()

					{

						return isComplete;

					}

				}

				RunCommandOperation runCommandOpt = new RunCommandOperation();

				/* Run the command */

				synchronized (mutualLock)

				{					

					new Thread(runCommandOpt).start();

					long start = System.currentTimeMillis();

					long wakeUpTime = start;

					long timeToSleep = commandTimeOut;

					try 

					{

						while (!runCommandOpt.isComplete() && timeToSleep > 0 && !interruptProcess)

						{

							//System.out.println("WAITING on command: " + playable);

							mutualLock.wait(timeToSleep);

							wakeUpTime = System.currentTimeMillis();

							timeToSleep = timeToSleep - (wakeUpTime - start);

						}

					} catch (InterruptedException e) 

					{

						/* Doesn't need to be handled */

					}

					/* Indicate an error if command didn't complete */

					if (!runCommandOpt.isComplete())

					{	

						synchronized (mutualGlobalLock)

						{

							interruptProcess = true;

							if (interruptedException == null)

								interruptedException = new CoreException (new Status(IStatus.ERROR, GuiPlugin.getID(), 0, 

										NLS.bind(AutoGUIMessages.AUTO_GUI_ERROR_MACRO_TIME_OUT, playable.toString()), null));							

						}

					}	

					/* Otherwise invalidate the wake up operation that was suppose to wake this

					command up */

					else if (wakeupOpt != null)

						wakeupOpt.invalidate();

					//System.out.println("FINISHED WAITING on command: " + playable);

				}

				monitor.worked(1);

			} 			

		}

		checkForInterruptions();

		shell = null;

		/* We made it out alive -- mark this as complete and wake any parents that are waiting upon our completion */

		isComplete = true;

		synchronized(this)

		{

			this.notify();

		}

		macroCommandShellContainer.remove(this);

		return true;

	}

	private boolean isComplete() 

	{	

		return isComplete;

	}

	private Object getCommandBeingExecuted() 

	{

		if (commands == null || currentCommandInx >= commands.size())

			return null;

		return commands.get(currentCommandInx);

	}

	private void checkForInterruptions() throws CoreException

	{

		if (interruptProcess)

		{	

			/* Wake up all threads in case they are asleep */

			if (!processTerminated)

			{

				processTerminated = true;

				interruptOperation();				

				MacroCommandShell.macroStopped();

				MacroUtil.closeSecondaryShells(display);			

			}

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

			{

				synchronized (mutualLock)

				{

					mutualLock.notify();

				}

				synchronized (macroCommandShellContainer.get(i))

				{

					macroCommandShellContainer.get(i).notify();

				}

			}

			/* Try to close all nested shells */

			synchronized (mutualGlobalLock)

			{

				if (interruptedException instanceof CoreException)

					throw (CoreException)interruptedException;

				throw new CoreException (new Status(IStatus.ERROR, GuiPlugin.getID(), 0, interruptedException.getLocalizedMessage(), interruptedException));

			}

		}

	}

	/**

	 * A helper method that walks through all macro command shells and 

	 * interrupts their normal flow.

	 */

	private void interruptOperation() 

	{

		MacroCommandShell currentMacroShell = this;

		while (currentMacroShell != null)

		{

			Boolean lock = currentMacroShell.mutualLock;

			synchronized(lock)

			{

				lock.notify();

			}

			currentMacroShell = currentMacroShell.getParent();

		}

	}

	private boolean isLastCommand(int index) 

	{

		for (int i = index + 1; i < commands.size(); i++)

		{

			if (commands.get(i) instanceof AbstractMacroCommand)

				return false;

		}

		return true;

	}

	private void playInGUIThread(final Display display, final IPlayable playable, boolean last, final IProgressMonitor monitor) throws CoreException

	{

		final CoreException[] ex = new CoreException[1];

		Runnable runnable = new Runnable()

		{

			public void run()

			{

				try

				{						

					boolean status = playable.playback(display, MacroCommandShell.this.shell, monitor);

					/* Something went wrong playing this item */

					if (!status)

						ex[0] = createPlaybackException(playable, null);

					else

						MacroUtil.processDisplayEvents(display);

				} 

				catch (ClassCastException e)

				{

					ex[0] = createPlaybackException(playable, e);

				} 

				catch (CoreException e)

				{

					ex[0] = e;

				}

				catch (SWTException e)

				{

					/* Don't handle */

				}

				catch (Throwable error)

				{

					ex[0] = createPlaybackException(playable, error);

				}

			}

		};

		if (playable instanceof WaitCommand)

		{

			playable.playback(display, this.shell, monitor);

		} 

		else

		{

			display.syncExec(runnable);			

		}

		try

		{

			Thread.sleep(100);

		} catch (InterruptedException e)

		{

		}

		if (ex[0] != null)

			throw ex[0];

	}

	private CoreException createPlaybackException(IPlayable playable, Throwable th)

	{

		IStatus status = new Status(IStatus.ERROR, "org.eclipse.pde.ui.tests", IStatus.OK, NLS.bind(AutoGUIMessages.AUTO_GUI_ERROR_MACRO_COMMAND, playable.toString()), th);

		return new CoreException(status);

	}

	public ArrayList getCommands()

	{

		return commands;

	}

	public boolean isListenerRegistered() {

		return isListenerRegistered;

	}

	public void setListenerRegistered(boolean isListenerRegistered) {

		this.isListenerRegistered = isListenerRegistered;

	}

	public static Vector getNestedShellQueue() 

	{

		return nestedShellQueue;

	}

	public static void addNestedShell(int inx, NestedShell nestedShell)

	{

		synchronized (nestedShellQueue)

		{

			if (inx >= 0)

				nestedShellQueue.add(inx, nestedShell);

			else

				nestedShellQueue.add(nestedShell);

		}

	}

	private static void addNestedShell(NestedShell fnestedShell) 

	{

		addNestedShell (-1, fnestedShell);		

	}

	public static void removeNestedShell(int inx)

	{

		synchronized (nestedShellQueue)

		{

			nestedShellQueue.remove(inx);

		}

	}

	public static void initializeForNewPlay()

	{

		nestedShellQueue.clear();

		lastNestedShellInx = 0;

		interruptProcess = false;

		processTerminated = false;

		interruptedException = null;

		MouseEventCommand.init();

		macroCommandsBeingPlayed.clear();

		macroCommandShellContainer.clear();

	}

	public Shell getShell() {

		return shell;

	}

	public void writeStart(int indent, StringBuffer sb)

	{

		/* Doesn't need to be implemented */		

	}

	public void writeFinish(int indent, StringBuffer sb)

	{

		/* Doesn't need to be implemented */	

	}

	public MacroCommandShell getParent() {

		return parent;

	}

	public void setParent(MacroCommandShell parent) {

		this.parent = parent;

	}

	public static void macroStopped() 

	{

		/* Walk through nested shell listeners and remove them if any exists */

		final Display display = GuiPlugin.getDefault().getWorkbench().getDisplay();

		display.syncExec(new Runnable(){

			public void run() {

				for (int i = 0, nestedShellListenerSize = nestedShellQueue.size(); i < nestedShellListenerSize; i++)

				{

					display.removeFilter(SWT.Activate, (NestedShell)nestedShellQueue.get(i));	

				}				

			}

		});					

	}

	public static Vector getMacroCommandsBeingPlayed() {

		return macroCommandsBeingPlayed;

	}

	public String getReferenceId()

	{

		return referenceId;

	}

	public void setReferenceId(String referenceId)

	{

		this.referenceId = referenceId;

	}

	private static class NestedShell implements Listener, Runnable

	{

		private MacroCommandShell cshell;

		private Display display;

		private Shell nshell;

		private boolean released;

		private CoreException exception;

		private IProgressMonitor monitor;

		private boolean served;		

		public NestedShell(Display display, MacroCommandShell cshell, IProgressMonitor monitor)

		{

			this.display = display;

			this.cshell = cshell;

			this.monitor = monitor;

		}

		public void handleEvent(Event e)

		{

			try

			{

				if (e.widget instanceof Shell)

				{

					// shell activated

					Shell shell = (Shell) e.widget;

					IPath path = new Path(MacroUtil.getShellId(shell, null).toString());

					String sid = path.toString();

					/* Debug */

					//System.out.println();

					//System.out.println(sid + " : " + cshell.getId());

					//if (MacroCommandShell.getNestedShellQueue() != null && MacroCommandShell.getNestedShellQueue().size() > 0)

						//System.out.println("Is Served: " + ((NestedShell)MacroCommandShell.getNestedShellQueue().get(0)).isServed());

					//System.out.println(this + " : " + MacroCommandShell.getNestedShellQueue().get(0));

					//System.out.println();  

					if (sid.equals(cshell.getWidgetId().getObjectId().toString()) && 

									(MacroCommandShell.getNestedShellQueue() == null || 

									MacroCommandShell.getNestedShellQueue().size() <= 0 || 

									(!((NestedShell)MacroCommandShell.getNestedShellQueue().get(0)).isServed() && this.equals(MacroCommandShell.getNestedShellQueue().get(0)))))

					{

						//System.out.println("REMOVED FILTER: " + cshell.getId());

						shell.getDisplay().removeFilter(SWT.Activate, this);

						released = true;

						this.nshell = shell;

						/* We need to start this in a separate thread.  MacroCommandShells should not be played in UI threads (otherwise wait commands

						 * will not work properly) */					

						this.setServed(true);

						new Thread(this).start();					

					}

				}

			}

			catch (Throwable t)

			{

				//System.out.println("REMOVED filter");

				/* Something unexpected has happened -- Remove this listener */

				e.display.removeFilter(SWT.Activate, this);

			}

		}

		public void setServed(boolean served) 

		{

			this.served = served;			

		}

		public boolean isServed()

		{

			return served;

		}

		public boolean getResult()

		{

			return cshell.matchesReturnCode();

		}