/*******************************************************************************
 * Copyright (c) 2005 The Regents of the University of California. 
 * This material was produced under U.S. Government contract W-7405-ENG-36 
 * for Los Alamos National Laboratory, which is operated by the University 
 * of California for the U.S. Department of Energy. The U.S. Government has 
 * rights to use, reproduce, and distribute this software. NEITHER THE 
 * GOVERNMENT NOR THE UNIVERSITY MAKES ANY WARRANTY, EXPRESS OR IMPLIED, OR 
 * ASSUMES ANY LIABILITY FOR THE USE OF THIS SOFTWARE. If software is modified 
 * to produce derivative works, such modified software should be clearly marked, 
 * so as not to confuse it with the version available from LANL.
 * 
 * Additionally, 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
 * 
 * LA-CC 04-115
 *******************************************************************************/
package org.eclipse.ptp.debug.ui.views;

import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Status;
import org.eclipse.core.runtime.jobs.Job;
import org.eclipse.debug.core.DebugException;
import org.eclipse.debug.core.model.IDebugElement;
import org.eclipse.debug.core.model.IDebugTarget;
import org.eclipse.debug.core.model.IStackFrame;
import org.eclipse.debug.core.model.IThread;
import org.eclipse.debug.internal.ui.viewers.model.InternalTreeModelViewer;
import org.eclipse.debug.ui.AbstractDebugView;
import org.eclipse.debug.ui.IDebugUIConstants;
import org.eclipse.jface.action.GroupMarker;
import org.eclipse.jface.action.IMenuManager;
import org.eclipse.jface.action.IToolBarManager;
import org.eclipse.jface.action.Separator;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.ISelectionChangedListener;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jface.viewers.SelectionChangedEvent;
import org.eclipse.jface.viewers.StructuredSelection;
import org.eclipse.jface.viewers.TreeViewer;
import org.eclipse.jface.viewers.Viewer;
import org.eclipse.ptp.core.elements.IPJob;
import org.eclipse.ptp.core.elements.IPProcess;
import org.eclipse.ptp.core.elements.attributes.ProcessAttributes;
import org.eclipse.ptp.core.util.BitList;
import org.eclipse.ptp.debug.core.IPSession;
import org.eclipse.ptp.debug.core.model.IPDebugElement;
import org.eclipse.ptp.debug.core.model.IPDebugTarget;
import org.eclipse.ptp.debug.internal.ui.UIDebugManager;
import org.eclipse.ptp.debug.internal.ui.actions.RegisterAction;
import org.eclipse.ptp.debug.internal.ui.actions.ResumeAction;
import org.eclipse.ptp.debug.internal.ui.actions.StepIntoAction;
import org.eclipse.ptp.debug.internal.ui.actions.StepOverAction;
import org.eclipse.ptp.debug.internal.ui.actions.StepReturnAction;
import org.eclipse.ptp.debug.internal.ui.actions.SuspendAction;
import org.eclipse.ptp.debug.internal.ui.actions.TerminateAction;
import org.eclipse.ptp.debug.internal.ui.actions.UnregisterAction;
import org.eclipse.ptp.debug.internal.ui.views.AbstractPDebugViewEventHandler;
import org.eclipse.ptp.debug.ui.IPTPDebugUIConstants;
import org.eclipse.ptp.debug.ui.PTPDebugUIPlugin;
import org.eclipse.ptp.ui.IManager;
import org.eclipse.ptp.ui.actions.ParallelAction;
import org.eclipse.ptp.ui.model.IElement;
import org.eclipse.ptp.ui.model.IElementHandler;
import org.eclipse.ptp.ui.model.IElementSet;
import org.eclipse.ptp.ui.views.IIconCanvasActionListener;
import org.eclipse.ptp.ui.views.ParallelJobsView;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.ui.IActionBars;
import org.eclipse.ui.IViewPart;
import org.eclipse.ui.IWorkbenchPage;
import org.eclipse.ui.PartInitException;
import org.eclipse.ui.progress.WorkbenchJob;

/**
 * @author clement chu
 * 
 */
public class ParallelDebugView extends ParallelJobsView {
	// actions
	protected ParallelAction resumeAction = null;
	protected ParallelAction suspendAction = null;
	protected ParallelAction terminateAction = null;
	protected ParallelAction stepIntoAction = null;
	protected ParallelAction stepOverAction = null;
	protected ParallelAction stepReturnAction = null;
	protected ParallelAction registerAction = null;
	protected ParallelAction unregisterAction = null;
	protected AbstractPDebugViewEventHandler fEventHandler = null;
	protected Viewer launchViewer = null;
	
	protected ISelectionChangedListener debugViewSelectChangedListener = new ISelectionChangedListener() {
		public void selectionChanged(SelectionChangedEvent event) {
			ISelection selection = event.getSelection();
			if (!selection.isEmpty()) {
				if (selection instanceof IStructuredSelection) {
					Object element = ((IStructuredSelection)selection).getFirstElement();
					if (element instanceof IPDebugElement) {
						if (canvas != null && !canvas.isDisposed()) {
							if (getCurrentSet() != null) {
								int index = getCurrentSet().findIndexByName(String.valueOf(((IPDebugElement)element).getID()));
								if (index > -1) {
									canvas.unselectAllElements();
									canvas.selectElement(index);
									canvas.setCurrentSelection(false);
									refresh(false);
								}
							}
						}
					}
				}
			}
		}
	};
	/*
	private MouseAdapter debugViewMouseAdapter = new MouseAdapter() {
		public void mouseUp(MouseEvent event) {
			Object test = event.getSource();
			if (test instanceof Tree) {
				TreeItem[] items = ((Tree)test).getSelection();
				Object[] targets = new Object[items.length];
				for (int i=0; i<items.length; i++) {
					targets[i] = items[i].getData();
				}
				selectElements(targets);
			}
		}
	};
	*/
	public ParallelDebugView(IManager manager) {
		super(manager);
	}
	public ParallelDebugView() {
		this(PTPDebugUIPlugin.getUIDebugManager());
	}

	/* (non-Javadoc)
	 * @see org.eclipse.ui.IWorkbenchPart#dispose()
	 */
	public void dispose() {
		Viewer viewer = getDebugViewer();
		if (viewer != null)
			viewer.removeSelectionChangedListener(debugViewSelectChangedListener);
		if (getEventHandler() != null)
			getEventHandler().dispose();
		super.dispose();
	}
	
	/**
	 * @return
	 */
	protected Viewer getDebugViewer() {
		if (launchViewer == null) {
			IWorkbenchPage page = getViewSite().getPage();
			if (page == null)
				return null;
			IViewPart part = page.findView(IDebugUIConstants.ID_DEBUG_VIEW);
			if (part == null) {
				if (page == null)
					return null;
				try {
					part = page.showView(IDebugUIConstants.ID_DEBUG_VIEW);
				} catch (PartInitException e) {
					return null;
				}
			}
			if (part != null && part instanceof AbstractDebugView) {
				launchViewer = ((AbstractDebugView)part).getViewer();
				if (launchViewer != null)
					launchViewer.addSelectionChangedListener(debugViewSelectChangedListener);
			}			
		}
		return launchViewer;
	}
	
	/*
	 * FIXME does not work if create a new set.  Currently we can task id to identify icon, but viewer is using order 
	private void selectElements(final Object[] objects) {
        SafeRunnable.run(new SafeRunnable() {
            public void run() {
				if (!canvas.isDisposed()) {
					canvas.unselectAllElements();
					for (int i=0; i<objects.length; i++) {
						Object obj = objects[i];
						int id = ((UIDebugManager) manager).getSelectedRegisteredTasks(obj);
						if (id > -1) {
							if (!canvas.isSelected(id))
								canvas.selectElement(id);
						}
					}
					canvas.redraw();
					canvas.setCurrentSelection(false);
				}
			}
		});
	}
	*/
		
	/**
	 * Sets the event handler for this view
	 * 
	 * @param eventHandler event handler
	 */
	protected void setEventHandler(AbstractPDebugViewEventHandler eventHandler) {
		this.fEventHandler = eventHandler;
	}
	
	/**
	 * Returns the event handler for this view
	 * 
	 * @return The event handler for this view
	 */
	protected AbstractPDebugViewEventHandler getEventHandler() {
		return this.fEventHandler;
	}	
		
	/* (non-Javadoc)
	 * @see org.eclipse.ptp.ui.views.ParallelJobView#createView(org.eclipse.swt.widgets.Composite)
	 */
	public void createView(Composite parent) {
		super.createView(parent);
		setEventHandler(new ParallelDebugViewEventHandler(this));
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.ptp.ui.views.AbstractParallelSetView#fillContextMenu(org.eclipse.jface.action.IMenuManager)
	 */
	protected void fillContextMenu(IMenuManager manager) {
		super.fillContextMenu(manager);
		manager.add(new Separator(IPTPDebugUIConstants.THREAD_GROUP));
		manager.add(new Separator(IPTPDebugUIConstants.STEP_GROUP));
		manager.add(new GroupMarker(IPTPDebugUIConstants.STEP_INTO_GROUP));
		manager.add(new GroupMarker(IPTPDebugUIConstants.STEP_OVER_GROUP));
		manager.add(new GroupMarker(IPTPDebugUIConstants.STEP_RETURN_GROUP));
		manager.add(new GroupMarker(IPTPDebugUIConstants.EMPTY_STEP_GROUP));
		manager.add(new Separator(IPTPDebugUIConstants.REG_GROUP));

		manager.appendToGroup(IPTPDebugUIConstants.THREAD_GROUP, resumeAction);
		manager.appendToGroup(IPTPDebugUIConstants.THREAD_GROUP, suspendAction);
		manager.appendToGroup(IPTPDebugUIConstants.THREAD_GROUP, terminateAction);
		manager.appendToGroup(IPTPDebugUIConstants.STEP_INTO_GROUP, stepIntoAction);
		manager.appendToGroup(IPTPDebugUIConstants.STEP_OVER_GROUP, stepOverAction);
		manager.appendToGroup(IPTPDebugUIConstants.EMPTY_STEP_GROUP, stepReturnAction);
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.ptp.ui.views.AbstractParallelSetView#createToolBarActionGroup(org.eclipse.jface.action.IToolBarManager)
	 */
	protected void createToolBarActionGroup(IToolBarManager toolBarMgr) {
		toolBarMgr.add(new Separator(IPTPDebugUIConstants.THREAD_GROUP));
		toolBarMgr.add(new Separator(IPTPDebugUIConstants.STEP_GROUP));
		toolBarMgr.add(new GroupMarker(IPTPDebugUIConstants.STEP_INTO_GROUP));
		toolBarMgr.add(new GroupMarker(IPTPDebugUIConstants.STEP_OVER_GROUP));
		toolBarMgr.add(new GroupMarker(IPTPDebugUIConstants.STEP_RETURN_GROUP));
		toolBarMgr.add(new GroupMarker(IPTPDebugUIConstants.EMPTY_STEP_GROUP));
		toolBarMgr.add(new Separator(IPTPDebugUIConstants.REG_GROUP));
		super.createToolBarActionGroup(toolBarMgr);
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.ptp.ui.views.AbstractParallelSetView#createToolBarActions(org.eclipse.jface.action.IToolBarManager)
	 */
	protected void createToolBarActions(IToolBarManager toolBarMgr) {
		resumeAction = new ResumeAction(this);
		suspendAction = new SuspendAction(this);
		terminateAction = new TerminateAction(this);
		stepIntoAction = new StepIntoAction(this);
		stepOverAction = new StepOverAction(this);
		stepReturnAction = new StepReturnAction(this);
		registerAction = new RegisterAction(this);
		unregisterAction = new UnregisterAction(this);
				
		toolBarMgr.appendToGroup(IPTPDebugUIConstants.THREAD_GROUP, resumeAction);
		toolBarMgr.appendToGroup(IPTPDebugUIConstants.THREAD_GROUP, suspendAction);
		toolBarMgr.appendToGroup(IPTPDebugUIConstants.THREAD_GROUP, terminateAction);
		toolBarMgr.appendToGroup(IPTPDebugUIConstants.STEP_INTO_GROUP, stepIntoAction);
		toolBarMgr.appendToGroup(IPTPDebugUIConstants.STEP_OVER_GROUP, stepOverAction);
		toolBarMgr.appendToGroup(IPTPDebugUIConstants.STEP_RETURN_GROUP, stepReturnAction);
		toolBarMgr.appendToGroup(IPTPDebugUIConstants.REG_GROUP, registerAction);
		toolBarMgr.appendToGroup(IPTPDebugUIConstants.REG_GROUP, unregisterAction);
		
		super.buildInToolBarActions(toolBarMgr);
		//createOrientationActions();
	}
	
	/** Create orientation actions
	 * 
	 */
	protected void createOrientationActions() {
		IActionBars actionBars = getViewSite().getActionBars();
		IMenuManager viewMenu = actionBars.getMenuManager();
		viewMenu.add(new Separator());
	}
	
	/*******************************************************************************************************************************************************************************************************************************************************************************************************
	 * IIconCanvasActionListener
	 ******************************************************************************************************************************************************************************************************************************************************************************************************/
	/* (non-Javadoc)
	 * @see org.eclipse.ptp.ui.views.IIconCanvasActionListener#handleAction(int, int)
	 */
	public void handleAction(int type, int index) {
		IElement element = canvas.getElement(index);
		if (type == IIconCanvasActionListener.DOUBLE_CLICK_ACTION) {
			doubleClick(element);
		}
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.ptp.ui.views.AbstractParallelElementView#doubleClick(org.eclipse.ptp.ui.model.IElement)
	 */
	public void doubleClick(IElement element) {
		try {
			registerElement(element);
		} catch (CoreException e) {
			PTPDebugUIPlugin.errorDialog(getViewSite().getShell(), "Error", e.getStatus());
		}
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.ptp.ui.views.AbstractParallelElementView#getToolTipText(java.lang.Object)
	 */
	public String[] getToolTipText(Object obj) {
		if (obj == null)
			return new String[] {"", ""};
		String[] header = super.getToolTipText(obj);
		String variableText = ((UIDebugManager) manager).getValueText(new Integer(((IPProcess)obj).getProcessIndex()).intValue(), this);
		if (variableText != null && variableText.length() > 0) {
			return new String[] { header[0], variableText };
		}
		return header;
	}
	
	/** Register element
	 * @param element
	 * @throws CoreException
	 */
	public void registerElement(IElement element) throws CoreException {
		if (element.isRegistered())
			((UIDebugManager) manager).unregisterElements(new IElement[] { element });
		else
			((UIDebugManager) manager).registerElements(new IElement[] { element });
	}
	
	/** Register selected elements
	 * @throws CoreException
	 */
	public void registerSelectedElements() throws CoreException {
		if (cur_element_set != null) {
			((UIDebugManager) manager).registerElements(canvas.getSelectedElements());
		}
	}
	
	/** Unregister selected elements
	 * @throws CoreException
	 */
	public void unregisterSelectedElements() throws CoreException {
		if (cur_element_set != null) {
			((UIDebugManager) manager).unregisterElements(canvas.getSelectedElements());
		}
	}
	// Update button
	/* (non-Javadoc)
	 * @see org.eclipse.ptp.ui.views.AbstractParallelSetView#updateAction()
	 */
	public void updateAction() {
		super.updateAction();
		IPJob job = ((UIDebugManager) manager).findJobById(getCurrentID());
		boolean isDebugMode = ((UIDebugManager) manager).isDebugMode(job);
		boolean isRunning = ((UIDebugManager) manager).isRunning(job);
		registerAction.setEnabled(isRunning && isDebugMode);
		unregisterAction.setEnabled(isRunning && isDebugMode);
		suspendAction.setEnabled(isRunning && isDebugMode);
		terminateAction.setEnabled(isRunning);
		if (isRunning && isDebugMode) {
			IElementHandler elementHandler = getCurrentElementHandler();
			if (elementHandler != null) {
				updateDebugButtons(job);
			}
		} else {
			resumeAction.setEnabled(false);
			stepIntoAction.setEnabled(false);
			stepOverAction.setEnabled(false);
			stepReturnAction.setEnabled(false);
			suspendAction.setEnabled(false);
		}
	}
	/**
	 * Update debug button
	 */
	public void updateDebugButtons(IPJob job) {
		IPSession session = ((UIDebugManager) manager).getDebugSession(job);
		if (session == null)
			return;
		IElementSet set = getCurrentSet();
		if (set == null)
			return;

		BitList terminatedTasks = session.getPDISession().getTaskManager().getTerminatedTasks();
		BitList suspendedTasks = session.getPDISession().getTaskManager().getSuspendedTasks();
		BitList stepReturnTasks = session.getPDISession().getTaskManager().getCanStepReturnTasks();
		if (terminatedTasks == null || suspendedTasks == null || stepReturnTasks == null)
			return;

		int setSize = set.size();
		int totalTerminatedSize = 0;
		int totalSuspendedSize = 0;
		int totalStepReturnSize = 0;
		if (set.isRootSet()) {
			totalTerminatedSize = terminatedTasks.cardinality();
			totalSuspendedSize = suspendedTasks.isEmpty() ? 0 : suspendedTasks.cardinality();
			totalStepReturnSize = stepReturnTasks.isEmpty() ? 0 : stepReturnTasks.cardinality();
		}
		else {
			try {
				BitList setTasks = ((UIDebugManager) manager).getTasks(set.getID());
				if (setTasks == null)
					return;
				setSize = setTasks.cardinality();
				BitList setTerminatedTasks = session.getPDISession().getTaskManager().getTerminatedTasks(setTasks.copy());
				totalTerminatedSize = setTerminatedTasks.cardinality();
				// size equals: the set contains all terminated processes
				if (setSize != totalTerminatedSize) {
					BitList setSuspendedTasks = session.getPDISession().getTaskManager().getSuspendedTasks(setTasks.copy());
					totalSuspendedSize = setSuspendedTasks.cardinality();
					BitList setCanStepReturnTasks = session.getPDISession().getTaskManager().getCanStepReturnTasks(setTasks.copy());
					totalStepReturnSize = setCanStepReturnTasks.cardinality();
				}
			} catch (CoreException e) {
				PTPDebugUIPlugin.log(e);
			}
		}
//System.err.println("Set size: " + setSize + ", T: " + totalTerminatedSize + ", S: "+ totalSuspendedSize + ", Return: " + totalStepReturnSize);
		boolean enabledTerminatedButton = (setSize != totalTerminatedSize);
		terminateAction.setEnabled(enabledTerminatedButton);
		if (enabledTerminatedButton) {// not all processes terminated
			resumeAction.setEnabled(totalSuspendedSize > 0);
			boolean enableStepButtons = (setSize == totalSuspendedSize + totalTerminatedSize);
			stepIntoAction.setEnabled(enableStepButtons);
			stepOverAction.setEnabled(enableStepButtons);
			suspendAction.setEnabled(!enableStepButtons);
			stepReturnAction.setEnabled(enableStepButtons && totalStepReturnSize > 0);
		} else {// all process terminated
			resumeAction.setEnabled(false);
			stepIntoAction.setEnabled(false);
			stepOverAction.setEnabled(false);
			stepReturnAction.setEnabled(false);
			suspendAction.setEnabled(false);
		}
	}
    /* (non-Javadoc)
     * @see org.eclipse.ptp.ui.views.AbstractParallelElementView#selectionChanged(org.eclipse.jface.viewers.SelectionChangedEvent)
     */
    public void selectionChanged(SelectionChangedEvent event) {
    	super.selectionChanged(event);
    	ISelection selection = event.getSelection();
    	if (!selection.isEmpty() && selection instanceof IStructuredSelection) {
    		IStructuredSelection structSelection = (IStructuredSelection)selection;
    		if (structSelection.size() == 1 && structSelection.getFirstElement() instanceof IElement) {
	    		IElement element = (IElement)structSelection.getFirstElement();
	    		if (element.isRegistered()) {
					try {
		    			focusOnDebugTarget(getJobManager().getJob(), Integer.parseInt(element.getName()));
					} catch (NumberFormatException e) {
						// The element name had better be the process number
					}
	    		}
    		}
    	}
    }
    
    /*
	public void drawSpecial(Object obj, GC gc, int x_loc, int y_loc, int width, int height) {
		super.drawSpecial(obj, gc, x_loc, y_loc, width, height);
		if (cur_element_set != null && obj instanceof DebugElement) {
			DebugElement element =  (DebugElement)obj;
			switch(element.getType()) {
			case DebugElement.VALUE_DIFF:
				gc.setForeground(getDisplay().getSystemColor(SWT.COLOR_BLUE));
				gc.drawLine(x_loc, y_loc, x_loc+width, y_loc+height);
				gc.drawLine(x_loc, y_loc+height, x_loc+width, y_loc);
				break;
			}
		}
	}
	*/
	
	/******************************************************
	 * focus on debug target on debug view 
	 ******************************************************/
	private IDebugElement getDebugElement(IPJob job, int task_id) {
		IPSession session = ((UIDebugManager)manager).getDebugSession(job);
		if (session != null) {
			return session.getLaunch().getDebugTarget(task_id);
			/*
			IPDebugTarget debugTarget = session.getLaunch().getDebugTarget(task_id);
			if (debugTarget != null) {
				try {
					IThread[] threads = debugTarget.getThreads();
					for (int i=0; i<threads.length; i++) {
						IStackFrame frame = threads[i].getTopStackFrame();
						if (frame != null)
							return frame;
					}
					if (threads.length > 0) {
						return threads[0];
					}
				}
				catch (DebugException e) {
					return debugTarget;
				}
				return debugTarget;
			}
			*/
		}
		return null;
	}
	public void focusOnDebugTarget(final IPJob job, final int task_id) {
		WorkbenchJob wjob = new WorkbenchJob("Focusing on debug element...") {
			public IStatus runInUIThread(IProgressMonitor monitor) {
				Viewer viewer = getDebugViewer();
				if (viewer != null) {
					ISelection selection = viewer.getSelection();
					//ISelection selection = getViewSite().getPage().getSelection(IDebugUIConstants.ID_DEBUG_VIEW);
					if (selection instanceof IStructuredSelection) {
						Object element = ((IStructuredSelection)selection).getFirstElement();
						if (element instanceof IPDebugElement) {
							if (((IPDebugElement)element).getID() != task_id) {
								//FIXME: only work if all elements are collapse
								//((TreeViewer)viewer).collapseAll();

								IDebugElement focusElement = getDebugElement(job, task_id); 
								if (focusElement == null) {
									//do nothing if cannot find debug target
									return Status.CANCEL_STATUS;
								}
								selectOnViewer(viewer, (IPDebugElement)focusElement);
								// set focus element to selected element
								element = focusElement;
							}
						}
						else {
							IDebugElement focusElement = getDebugElement(job, task_id); 
							if (focusElement == null) {
								//do nothing if cannot find debug target
								return Status.CANCEL_STATUS;
							}
							selectOnViewer(viewer, (IDebugElement)focusElement);
							// set focus element to selected element
							element = focusElement;
						}
						
						if (element instanceof IStackFrame) {
							//do nothing if selected element is stack frame
							return Status.CANCEL_STATUS;
						}
						if (element instanceof IThread) {
							//expand thread this thread
							expandOnViewer(viewer, (IThread)element);
							return Status.OK_STATUS;
						}
						if (element instanceof IDebugTarget) {
							//expand debug target this thread
							expandOnViewer(viewer, (IDebugTarget)element);
							return Status.OK_STATUS;
						}
						//if (!((TreeViewer)viewer).getExpandedState(element)) {
							//((TreeViewer)viewer).setExpandedState(element, true);
						//}
					}
					//viewer.setSelection(new StructuredSelection(focusElement), true);
					//viewer.setSelection(new StructuredSelection(focusElement.getDebugTarget()), true);
					//((TreeViewer)viewer).expandAll();
				}
				return Status.CANCEL_STATUS;
			}
        };
        //set job priority very low to make sure it is executed at last
        wjob.setPriority(Job.DECORATE);
        wjob.schedule(500);
	}
	private void expandOnViewer(final Viewer viewer, final IDebugElement element) {
		WorkbenchJob wjob = new WorkbenchJob("Expanding on viewer...") {
			public IStatus runInUIThread(IProgressMonitor monitor) {
				((TreeViewer)viewer).setExpandedState(element, true);
				try {
					if (element instanceof IThread) {
						selectOnViewer(viewer, ((IThread)element).getTopStackFrame());
						return Status.OK_STATUS;
					}
					if (element instanceof IDebugTarget) {
						IThread[] threads = ((IPDebugTarget)element).getThreads();
						if (threads.length > 0) {
							expandOnViewer(viewer, threads[0]);
							return Status.OK_STATUS;
						}
						return Status.CANCEL_STATUS;
					}
				}
				catch (DebugException e) {
					return Status.CANCEL_STATUS;
				}
				return Status.OK_STATUS;
			}
        };
        //set job priority very low to make sure it is executed at last
        wjob.setPriority(Job.DECORATE);
        wjob.schedule();
	}
	private void selectOnViewer(final Viewer viewer, final IDebugElement element) {
		if (element != null) {
			WorkbenchJob wjob = new WorkbenchJob("Selecting debug element...") {
				public IStatus runInUIThread(IProgressMonitor monitor) {
					/* FIXME 
					 * In Debug View, there is a Selection Policy.  If current selected element is stack frame and its status is suspended, then it cannot allow to change selection to others.
					 * Now I used internal class to avoid policy checking
					 */
					if (viewer instanceof InternalTreeModelViewer) {
						((InternalTreeModelViewer) viewer).setSelection(new StructuredSelection(element), true, true);
					} 
					else {
						viewer.setSelection(new StructuredSelection(element), true);
					}
					return Status.OK_STATUS;
				}
	        };
	        //set job priority very low to make sure it is executed at last
	        wjob.setPriority(Job.DECORATE);
	        wjob.schedule();
		}
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.ptp.ui.views.ParallelJobsView#changeJobRefresh(org.eclipse.ptp.core.elements.IPJob, boolean)
	 */
	public void changeJobRefresh(IPJob job, boolean force) {
		if (job != null && job.isTerminated()) {
			IPSession session = ((UIDebugManager) manager).getDebugSession(job);
			if (session != null) {
				BitList tasks = session.getTasks();
				if (!session.getPDISession().getTaskManager().isAllTerminated(tasks)) {
					session.forceStoppedDebugger(ProcessAttributes.State.ERROR);
				}
			}
		}
		super.changeJobRefresh(job, force);
	}
}