Attachment #58754 for bug #167609

Some Eclipse Foundation services are deprecated, or will be soon. Please ensure you've read this important communication.




      <view
            category="org.eclipse.hyades.trace.internal.ui.trace"
            class="org.eclipse.tptp.trace.jvmti.internal.client.views.ThreadStatesViewer"
            id="org.eclipse.tptp.trace.jvmti.internal.client.views.ThreadStatesViewer"
            name="Thread States"/>
      <view
            class="org.eclipse.tptp.trace.jvmti.internal.client.views.CallStackViewer"
            id="org.eclipse.tptp.trace.jvmti.internal.client.views.CallStackView"
            name="Call Stack">
      </view>

         <view
               id="org.eclipse.tptp.trace.jvmti.internal.client.views.ThreadStatesViewer"
               relationship="stack"
               relative="org.eclipse.hyades.trace.views.adapter.internal.ExecutionStatisticViewer2"
               visible="false">
         </view>
         <view
               id="org.eclipse.tptp.trace.jvmti.internal.client.views.CallStackViewer"
               relationship="bottom"
               relative="org.eclipse.tptp.trace.jvmti.internal.client.views.ThreadStatesViewer"
               visible="false">
         </view>

         </action>
         <action
               class="org.eclipse.tptp.trace.jvmti.internal.client.views.OpenThreadStatesViewAction"
               id="org.eclipse.tptp.trace.jvmti.internal.client.views.OpenThreadStatesViewAction"
               label="Thread States"
               style="push"
               toolbarPath="trace/group.statistic"/>
         <action
               class="org.eclipse.tptp.trace.jvmti.internal.client.views.OpenCallStackViewAction"
               id="org.eclipse.tptp.trace.jvmti.internal.client.views.OpenCallStackViewAction"
               label="Call Stack"
               style="push"
               toolbarPath="trace/group.statistic">




/*****************************************************************************
 * Copyright (c) 1997-2006, Intel Corporation.
 * 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:
 *    Intel Corporation - Initial API and implementation
 *    Ruslan A. Scherbakov, Intel - Initial API and implementation
 *
 * $Id$ 
 *****************************************************************************/

package org.eclipse.tptp.trace.jvmti.internal.client.views;

import java.util.ArrayList;

import org.eclipse.emf.common.util.EList;
import org.eclipse.hyades.models.trace.TRCMethod;
import org.eclipse.hyades.models.trace.TRCMethodInvocation;
import org.eclipse.hyades.models.trace.TRCThread;
import org.eclipse.hyades.models.trace.TRCThreadDeadEvent;
import org.eclipse.hyades.models.trace.TRCThreadDeadLockEvent;
import org.eclipse.hyades.models.trace.TRCThreadEvent;
import org.eclipse.hyades.models.trace.TRCThreadRunningEvent;
import org.eclipse.hyades.models.trace.TRCThreadSleepingEvent;
import org.eclipse.hyades.models.trace.TRCThreadWaitingForLockEvent;
import org.eclipse.hyades.models.trace.TRCThreadWaitingForObjectEvent;
import org.eclipse.hyades.trace.ui.IViewSelectionChangedListener;
import org.eclipse.hyades.trace.ui.UIPlugin;
import org.eclipse.hyades.trace.ui.ViewSelectionChangedEvent;
import org.eclipse.hyades.trace.views.util.internal.OpenSource;
import org.eclipse.jface.viewers.DoubleClickEvent;
import org.eclipse.jface.viewers.IDoubleClickListener;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jface.viewers.ITreeContentProvider;
import org.eclipse.jface.viewers.LabelProvider;
import org.eclipse.jface.viewers.TreeSelection;
import org.eclipse.jface.viewers.TreeViewer;
import org.eclipse.jface.viewers.Viewer;
import org.eclipse.swt.SWT;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.ui.ISharedImages;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.part.ViewPart;

public class CallStackViewer extends ViewPart implements
		IViewSelectionChangedListener {

	private TreeViewer _calStackCtrl;
	private Object _selection;

	public CallStackViewer() {
	}

	public void createPartControl(Composite parent) {
		_calStackCtrl = new TreeViewer(parent, SWT.H_SCROLL | SWT.V_SCROLL
				| SWT.FULL_SELECTION | SWT.SINGLE);
		_calStackCtrl.setContentProvider(new CallStackContentProvider());
		_calStackCtrl.setLabelProvider(new CallStackLabelProvider());
		_calStackCtrl.setInput(this);
		_calStackCtrl.addDoubleClickListener(new IDoubleClickListener() {
			public void doubleClick(DoubleClickEvent event) {
				OpenSource.openSource(getFirstSelectedElement());
			}
		});
		UIPlugin.getDefault().addViewSelectionChangedListener(this);
		UIPlugin.getDefault().getViewSelectionChangedEvent();
	}

	public void setFocus() {
		if (null != _calStackCtrl)
			_calStackCtrl.getControl().setFocus();
	}

	public void dispose() {
		UIPlugin.getDefault().removeViewSelectionChangedListener(this);
		super.dispose();
	}

	public Object getFirstSelectedElement() {
		Object obj = null;
		if (null != _calStackCtrl)
			obj = ((TreeSelection) _calStackCtrl.getSelection())
					.getFirstElement();
		return obj;
	}

	/** update view content */
	void update(Object selection) {
		if (null == _calStackCtrl)
			return;
		_selection = selection;
		_calStackCtrl.refresh();
	}

	public void handleObjectChanged(Object sel) {
		update(sel);
	}

	/**
	 * Compose String name for TRCMethodInvocation
	 * 
	 * @param method
	 * @return
	 */
	static String methodName(TRCMethodInvocation method) {
		TRCMethod m = method.getMethod();
		String name = "";
		name += m.getDefiningClass().getName();
		name += ".";
		name += m.getName();
		name += m.getSignature();
		name += " [" + m.getCalls() + "]";
		return name;
	}

	/**
	 * Compose String name for TRCThread
	 * 
	 * @param thread
	 * @return
	 */
	static String threadName(TRCThread thread) {
		String name = thread.getName();
		name += " [" + thread.getGroupName() + "]";
		return name;
	}

	static String getEventName(TRCThreadEvent event) {
		if (event instanceof TRCThreadRunningEvent) {
			return "RUNNING";
		} else if (event instanceof TRCThreadSleepingEvent) {
			return "SLEEPING";
		} else if (event instanceof TRCThreadDeadLockEvent) {
			return "DEADLOCK";
		} else if (event instanceof TRCThreadWaitingForLockEvent) {
			return "BLOCKED";
		} else if (event instanceof TRCThreadWaitingForObjectEvent) {
			return "WAITING";
		} else if (event instanceof TRCThreadDeadEvent) {
			return "STOPPED";
		}
		return "UNKNOWN";
	}

	/**
	 * Compose String name for TRCThreadEvent
	 * 
	 * @param event
	 * @return
	 */
	static String eventName(TRCThreadEvent event) {
		String name = event.getThread().getName();
		name += " [" + event.getThread().getGroupName() + "] State: " + getEventName(event);
		if (event instanceof TRCThreadWaitingForObjectEvent) {
			name += " Timeout=" + ((TRCThreadWaitingForObjectEvent)event).getTimeout();
		} else if (event instanceof TRCThreadWaitingForLockEvent) {
			TRCThread thread = ((TRCThreadWaitingForLockEvent)event).getLockingThread();
			if (null != thread)
				name += " by Thread=" + thread.getName();
		}
		return name;
	}

	/**
	 * Compose String name from object
	 * 
	 * @param obj
	 * @return
	 */
	public String getItemText(Object obj) {
		if (obj instanceof TRCMethodInvocation) {
			return methodName((TRCMethodInvocation) obj);
		}
		if (obj instanceof TRCThread) {
			return threadName((TRCThread) obj);
		}
		if (obj instanceof TRCThreadEvent) {
			return eventName((TRCThreadEvent) obj);
		}
		return obj.toString();
	}

	/**
	 * Icon image for object.
	 * 
	 * @param obj
	 * @return
	 */
	public Image getItemImage(Object obj) {
		Image img = null;
		String imageKey = ISharedImages.IMG_OBJ_ELEMENT;
		if (obj instanceof TRCMethodInvocation) {
			imageKey = ISharedImages.IMG_OBJ_FILE;
		}
		if (null == img) {
			img = PlatformUI.getWorkbench().getSharedImages()
					.getImage(imageKey);
		}
		return img;
	}

	static final Object[] empty = new Object[0];

	class CallStackContentProvider implements ITreeContentProvider {

		public void inputChanged(Viewer v, Object oldInput, Object newInput) {
		}

		public void dispose() {
		}

		public Object[] getElements(Object parent) {
			Object[] ret = empty;
			if (null != _selection)
				ret = new Object[] { _selection };
			return ret;
		}

		public Object[] getChildren(Object parentElement) {
			Object[] ret = empty;
			if (parentElement instanceof TRCThread) {
				TRCThread thread = (TRCThread) parentElement;
				TRCMethodInvocation mi;
				ArrayList arrlist = new ArrayList();
				EList list = thread.getInitialInvocations();
				while (list != null && !list.isEmpty()) {
					mi = (TRCMethodInvocation) list.get(list.size() - 1);
					arrlist.add(mi);
					list = mi.getInvokes();
				}
				ret = arrlist.toArray();
			} else if (parentElement instanceof TRCThreadEvent) {
				// TODO: CS from event
				ret = new String[] { "Placeholder for EVENT's call stack...", };
			}
			return ret;
		}

		public Object getParent(Object element) {
			return null;
		}

		public boolean hasChildren(Object element) {
			boolean ret = false;
			if (element instanceof TRCThread) {
				ret = true;
			} else if (element instanceof TRCThreadEvent) {
				ret = true;
			}
			return ret;
		}
	}

	class CallStackLabelProvider extends LabelProvider {
		public String getText(Object obj) {
			return getItemText(obj);
		}

		public Image getImage(Object obj) {
			return getItemImage(obj);
		}
	}

	public void handleViewSelectionChangedEvent(ViewSelectionChangedEvent event) {
		Object source = event.getSource();
		if (source instanceof ThreadStatisticView) {
			ThreadStatisticView view = (ThreadStatisticView) source;
			TRCThread thread = view.getSelectedThread();
			update(thread);
		} else if (source instanceof ThreadStatesPage) {
			ThreadStatesPage page = (ThreadStatesPage) source;
			IStructuredSelection sel = (IStructuredSelection) page.getSelection();
			update(sel.getFirstElement());
		}
	}
}




/*****************************************************************************
 * Copyright (c) 1997-2006, Intel Corporation.
 * 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:
 *    Intel Corporation - Initial API and implementation
 *    Ruslan A. Scherbakov, Intel - Initial API and implementation
 *
 * $Id$ 
 *****************************************************************************/

package org.eclipse.tptp.trace.jvmti.internal.client.views;

import org.eclipse.core.resources.IResourceStatus;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.Status;
import org.eclipse.hyades.trace.ui.UIPlugin;
import org.eclipse.hyades.trace.views.actions.internal.OpenTraceViewAction;
import org.eclipse.hyades.trace.views.internal.TraceUIMessages;
import org.eclipse.jface.action.IAction;
import org.eclipse.jface.dialogs.ErrorDialog;
import org.eclipse.jface.resource.ImageDescriptor;
import org.eclipse.ui.IWorkbenchWindow;

public class OpenCallStackViewAction extends OpenTraceViewAction {

	static final String VIEW_ID = "org.eclipse.tptp.trace.jvmti.internal.client.views.CallStackView";

	public OpenCallStackViewAction() {
		super("");
	}

	public OpenCallStackViewAction(String label) {
		super(label);
	}

	public OpenCallStackViewAction(String label, ImageDescriptor image) {
		super(label, image);
	}

	public boolean isVisibleForType(Object mofObject) {
		return true;
	}

	static public void openCallStackView(boolean showError) {
		IWorkbenchWindow window = UIPlugin.getDefault().getWorkbench()
				.getActiveWorkbenchWindow();
		try {
			UIPlugin.getActivePage().showView(VIEW_ID);
		} catch (Exception e) {
			if (showError) {
				String msg = TraceUIMessages._3;
				Status err = new Status(Status.WARNING,
						ResourcesPlugin.PI_RESOURCES,
						IResourceStatus.INTERNAL_ERROR, e.toString(), null);
				ErrorDialog.openError(window.getShell(), msg, "", err);
			}
			e.printStackTrace();
		}
	}

	public void run() {
		openCallStackView(true);
	}

	public void run(IAction action) {
		run();
	}

	public String getViewID() {
		return VIEW_ID;
	}
}




/*****************************************************************************
 * Copyright (c) 1997-2006, Intel Corporation.
 * 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:
 *    Intel Corporation - Initial API and implementation
 *    Ruslan A. Scherbakov, Intel - Initial API and implementation
 *
 * $Id$ 
 *****************************************************************************/

package org.eclipse.tptp.trace.jvmti.internal.client.views;

import org.eclipse.core.resources.IResourceStatus;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.Status;
import org.eclipse.hyades.trace.ui.TraceViewer;
import org.eclipse.hyades.trace.ui.UIPlugin;
import org.eclipse.hyades.trace.views.actions.internal.OpenTraceViewAction;
import org.eclipse.hyades.trace.views.internal.TraceUIMessages;
import org.eclipse.jface.action.IAction;
import org.eclipse.jface.dialogs.ErrorDialog;
import org.eclipse.jface.resource.ImageDescriptor;
import org.eclipse.ui.IViewPart;
import org.eclipse.ui.IWorkbenchPage;
import org.eclipse.ui.IWorkbenchWindow;

public class OpenThreadStatesViewAction extends OpenTraceViewAction {

	private final String VIEW_ID = "org.eclipse.tptp.trace.jvmti.internal.client.views.ThreadStatesViewer";

	public OpenThreadStatesViewAction() {
		super("");
	}

	public OpenThreadStatesViewAction(String label) {
		super(label);
	}

	public OpenThreadStatesViewAction(String label, ImageDescriptor image) {
		super(label, image);
	}

	public boolean isVisibleForType(Object mofObject) {
		return true;
	}
	
	public void run() {
		IWorkbenchWindow window = UIPlugin.getDefault().getWorkbench()
				.getActiveWorkbenchWindow();
		try {
			IWorkbenchPage persp = UIPlugin.getActivePage();
			IViewPart view = persp.showView(VIEW_ID);
			if (view != null && view instanceof TraceViewer) {
				((TraceViewer) view).addViewPage(getMofObject(), true);
			}
		} catch (Exception e) {
			String msg = TraceUIMessages._3;
			Status err = new Status(Status.WARNING,
					ResourcesPlugin.PI_RESOURCES,
					IResourceStatus.INTERNAL_ERROR, e.toString(), null);
			ErrorDialog.openError(window.getShell(), msg, "", err);
			e.printStackTrace();
		}

	}

	public void run(IAction action) {
		run();
	}

	public String getViewID() {
		return VIEW_ID;
	}
}

Line 27 Link Here

(-)CVS (-2 / +1 lines)
27	private final String VIEW_ID="org.eclipse.tptp.trace.jvmti.internal.client.views.ThreadStatisticViewer";	27	static final String VIEW_ID="org.eclipse.tptp.trace.jvmti.internal.client.views.ThreadStatisticViewer";
28	--




/*****************************************************************************
 * Copyright (c) 1997-2006, Intel Corporation.
 * 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:
 *    Intel Corporation - Initial API and implementation
 *    Ruslan A. Scherbakov, Intel - Initial API and implementation
 *
 * $Id$ 
 *****************************************************************************/

package org.eclipse.tptp.trace.jvmti.internal.client.views;

import org.eclipse.emf.common.util.EList;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.hyades.models.trace.TRCThread;
import org.eclipse.hyades.models.trace.TRCThreadEvent;
import org.eclipse.hyades.trace.ui.TraceViewer;
import org.eclipse.hyades.trace.ui.TraceViewerPage;
import org.eclipse.hyades.trace.ui.UIPlugin;
import org.eclipse.hyades.trace.ui.ViewSelectionChangedEvent;
import org.eclipse.hyades.trace.ui.internal.util.PerftraceUtil;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.swt.SWT;
import org.eclipse.swt.events.ControlAdapter;
import org.eclipse.swt.events.ControlEvent;
import org.eclipse.swt.events.PaintEvent;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.events.SelectionListener;
import org.eclipse.swt.graphics.Rectangle;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.tptp.trace.jvmti.internal.client.widgets.ITimeDataProvider;
import org.eclipse.tptp.trace.jvmti.internal.client.widgets.LegendCtrl;
import org.eclipse.tptp.trace.jvmti.internal.client.widgets.ThreadStatesCtrl;
import org.eclipse.tptp.trace.jvmti.internal.client.widgets.TimeScaleCtrl;
import org.eclipse.tptp.trace.jvmti.internal.client.widgets.TraceColorScheme;

public class ThreadStatesPage extends TraceViewerPage implements
		ITimeDataProvider, SelectionListener {

	/* vars */
	double _minTimeInterval = .000001;
	double _selectedTime = -1;
	double _beginTime = 0;
	double _endTime = 0;
	double _time0 = 0;
	double _time1 = 0;
	double _time0_ = 0;
	double _time1_ = 0;
	double _time1bak = 0;
	double _timeStep = 0.01;
	boolean _timeRangeFixed = false;
	private int _nameWidth = 96;
	private int _legendHeight = 22;
	private int _timeScaleHeight = 22;
	private Composite _viewContainer;
	private ThreadStatesCtrl _stateCtrl;
	private LegendCtrl _legendCtrl;
	private TimeScaleCtrl _timeScaleCtrl;
	static TraceColorScheme _colors = new TraceColorScheme();

	/** ctor */
	public ThreadStatesPage(EObject mofObject, TraceViewer viewer) {
		super(mofObject, viewer);
	}

	/** Refresher */
	public void refreshPage() {
		if (null != _stateCtrl) {
			refreshData();
			_stateCtrl.redraw();
			_timeScaleCtrl.redraw();
		}
	}

	public void selectionChanged() {
	}

	public void update(boolean newPage) {
		refreshPage();
	}

	public void createControl(Composite parent) {
		_viewContainer = new Composite(parent, SWT.NULL);
		_legendCtrl = new LegendCtrl(_viewContainer, _colors);
		_timeScaleCtrl = new TimeScaleCtrl(_viewContainer, _colors);
		_timeScaleCtrl.setTimeProvider(this);
		_stateCtrl = new ThreadStatesCtrl(_viewContainer, _colors);
		_stateCtrl.setTimeProvider(this);
		_stateCtrl.addSelectionListener(this);
		_viewContainer.addControlListener(new ControlAdapter() {
			public void controlResized(ControlEvent event) {
				Rectangle r = _viewContainer.getClientArea();
				_legendCtrl.setBounds(r.x, r.y, r.width, _legendHeight);
				_timeScaleCtrl.setBounds(r.x, r.y + _legendHeight, r.width,
						_timeScaleHeight);
				_stateCtrl.setBounds(r.x, r.y + _legendHeight
						+ _timeScaleHeight, r.width, r.height - _legendHeight
						- _timeScaleHeight);
			}
		});
	}

	public void dispose() {
		_stateCtrl.dispose();
		_legendCtrl.dispose();
		_viewContainer.dispose();
		_colors.dispose();
		super.dispose();
	}

	/** Tries to set most convinient time range for display. */
	void setTimeRange(Object threads[]) {
		_endTime = 0;
		_beginTime = -1;
		TRCThreadEvent event;
		for (int i = 0; i < threads.length; i++) {
			TRCThread thread = (TRCThread) threads[i];
			double lastEventTime = thread.getStopTime();
			if (lastEventTime > thread.getStartTime()) {
				if (lastEventTime > _endTime)
					_endTime = lastEventTime;
			}
			EList list = thread.getThreadEvents();
			int len = list.size();
			if (len > 0) {
				event = (TRCThreadEvent) list.get(list.size() - 1);
				lastEventTime = event.getTime();
				if (lastEventTime > _endTime)
					_endTime = lastEventTime;
				event = (TRCThreadEvent) list.get(0);
				if (_beginTime < 0 || _beginTime > event.getTime())
					_beginTime = event.getTime();
			}
		}
		_endTime += 0.1;
		if (_beginTime < 0)
			_beginTime = 0;
	}

	void setTimeBounds() {
		_time0_ = _beginTime - (_endTime - _beginTime) * 0.05;
		if (_time0_ < 0)
			_time0_ = 0;
		_time1_ = _time0_ + (_endTime - _time0_) * 1.05;
		_time0_ = Math.floor(_time0_);
		_time1_ = Math.ceil(_time1_);
		if (!_timeRangeFixed) {
			_time0 = _time0_;
			_time1 = _time1_;
		}
	}

	void refreshData() {
		Object threads[] = PerftraceUtil.getAllThreads(getMOFObject(), false);
		if (null == threads)
			threads = new TRCThread[0];
		setTimeRange(threads);
		setTimeBounds();
		if (_selectedTime < 0 || _selectedTime > _endTime)
			_selectedTime = _endTime;
		_stateCtrl.refreshData(threads);
	}

	public Control getControl() {
		return _viewContainer;
	}

	public void setFocus() {
		if (null != _stateCtrl)
			_stateCtrl.setFocus();
	}

	public TRCThread getSelectedThread() {
		return _stateCtrl.getSelectedThread();
	}

	public ISelection getSelection() {
		return _stateCtrl.getSelection();
	}

	public double getTime0() {
		return _time0;
	}

	public double getTime1() {
		return _time1;
	}

	public double getMinTimeInterval() {
		return _minTimeInterval;
	}

	public int getNameSpace() {
		return _nameWidth;
	}

	public int getTimeSpace() {
		int w = _stateCtrl.getClientArea().width;
		return w - _nameWidth;
	}

	public double getSelectedTime() {
		return _selectedTime;
	}

	public double getBeginTime() {
		return _beginTime;
	}

	public double getEndTime() {
		return _endTime;
	}

	public double getMaxTime() {
		return _time1_;
	}

	public double getMinTime() {
		return _time0_;
	}

	public void setStartFinishTime(double time0, double time1) {
		_time0 = time0;
		if (_time0 < 0)
			_time0 = 0;
		_time1 = time1;
		if (_time1 - _time0 < _minTimeInterval)
			_time1 = _time0 + _minTimeInterval;
		if (_time1 > _time1_)
			_time1 = _time1_;
		_timeRangeFixed = true;
		_stateCtrl.adjustScrolls();
		_stateCtrl.redraw();
		_timeScaleCtrl.redraw();
	}

	public void resetStartFinishTime() {
		_timeRangeFixed = false;
		_time0 = _time0_;
		_time1 = _time1_;
		_stateCtrl.adjustScrolls();
		_stateCtrl.redraw();
		_timeScaleCtrl.redraw();
	}

	public void paintControl(PaintEvent e) {
	}

	public void setSelectedTime(double time, boolean ensureVisible) {
		_selectedTime = time;
		if (_selectedTime > _endTime)
			_selectedTime = _endTime;
		if (_selectedTime < _beginTime)
			_selectedTime = _beginTime;
		if (ensureVisible) {
			double timeSpace = (_time1 - _time0) * .1;
			double timeMid = (_time1 - _time0) * .5;
			if (_selectedTime < _time0 + timeSpace) {
				double dt = _time0 - _selectedTime + timeMid;
				_time0 -= dt;
				_time1 -= dt;
			} else if (_selectedTime > _time1 - timeSpace) {
				double dt = _selectedTime - _time1 + timeMid;
				_time0 += dt;
				_time1 += dt;
			}
			if (_time0 < 0) {
				_time1 -= _time0;
				_time0 = 0;
			} else if (_time1 > _time1_) {
				_time0 += _time1 - _time1_;
				_time1 = _time1_;
			}
		}
		_stateCtrl.adjustScrolls();
		_stateCtrl.redraw();
		_timeScaleCtrl.redraw();
	}

	public void updateModelSelection() {
		ISelection selection = getSelection();
		Object sel = null;
		if (selection != null && !selection.isEmpty()) {
			sel = ((IStructuredSelection) selection).getFirstElement();
			notifyViewSelectionChanged(this, sel);
		}
	}

	public void notifyViewSelectionChanged(Object source, Object selection) {
		UIPlugin.getDefault().getSelectionModel(getMOFObject()).add(selection);
		ViewSelectionChangedEvent event = UIPlugin.getDefault()
				.getViewSelectionChangedEvent();
		event.setSource(source);
		UIPlugin.getDefault().notifyViewSelectionChangedListener(event);
	}

	public void widgetDefaultSelected(SelectionEvent e) {
		OpenCallStackViewAction.openCallStackView(false);
		updateModelSelection();
	}

	public void widgetSelected(SelectionEvent e) {
		updateModelSelection();
	}

	public void selectNextEvent() {
		_stateCtrl.selectNextEvent();
	}

	public void selectPrevEvent() {
		_stateCtrl.selectPrevEvent();
	}
}




/*****************************************************************************
 * Copyright (c) 1997-2006, Intel Corporation.
 * 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:
 *    Intel Corporation - Initial API and implementation
 *    Ruslan A. Scherbakov, Intel - Initial API and implementation
 *
 * $Id$ 
 *****************************************************************************/

package org.eclipse.tptp.trace.jvmti.internal.client.views;

import org.eclipse.emf.ecore.EObject;
import org.eclipse.hyades.trace.ui.TraceViewer;
import org.eclipse.hyades.trace.ui.TraceViewerPage;
import org.eclipse.jface.action.Action;
import org.eclipse.jface.action.IMenuManager;
import org.eclipse.jface.action.IToolBarManager;
import org.eclipse.ui.IActionBars;
import org.eclipse.ui.ISharedImages;
import org.eclipse.ui.PlatformUI;

public class ThreadStatesViewer extends TraceViewer {

	public ThreadStatesViewer() {
	}

	public TraceViewerPage createPage(EObject mofObject) {
		return new ThreadStatesPage(mofObject, this);
	}

	public String getViewTitle() {
		return UIMessages.THREAD_STATES_TITLE;
	}

	public void setFocus() {
		if (getCurrentPage() != null)
			getCurrentPage().setFocus();
	}

	public void makeActions() {
		super.makeActions();
		createActions();
		IActionBars bars = getViewSite().getActionBars();
		fillLocalPullDown(bars.getMenuManager());
		fillLocalToolBar(bars.getToolBarManager());
		bars.updateActionBars();
	}

	Action _selectNextEvent;
	Action _selectPrevEvent;

	private void createActions() {
		_selectNextEvent = new Action() {
			public void run() {
				if (getCurrentPage() instanceof ThreadStatesPage)
					((ThreadStatesPage) getCurrentPage()).selectNextEvent();
			}
		};
		_selectNextEvent.setText("Next");
		_selectNextEvent.setToolTipText("Select Next Event");
		_selectNextEvent.setImageDescriptor(PlatformUI.getWorkbench()
				.getSharedImages().getImageDescriptor(
						ISharedImages.IMG_TOOL_FORWARD));
		_selectPrevEvent = new Action() {
			public void run() {
				if (getCurrentPage() instanceof ThreadStatesPage)
					((ThreadStatesPage) getCurrentPage()).selectPrevEvent();
			}
		};
		_selectPrevEvent.setText("Prev");
		_selectPrevEvent.setToolTipText("Select Previous Event");
		_selectPrevEvent.setImageDescriptor(PlatformUI.getWorkbench()
				.getSharedImages().getImageDescriptor(
						ISharedImages.IMG_TOOL_BACK));
	}

	private void fillLocalPullDown(IMenuManager manager) {
		manager.add(_selectPrevEvent);
		manager.add(_selectNextEvent);
	}

	private void fillLocalToolBar(IToolBarManager manager) {
		manager.add(_selectPrevEvent);
		manager.add(_selectNextEvent);
	}
}




import org.eclipse.tptp.trace.jvmti.internal.client.widgets.Utils;

	static final int COL_CLASS_NAME = 0;
	static final int COL_THREAD_NAME = 1;
	static final int COL_STATE = 2;
	static final int COL_RUN_TIME = 3;
	static final int COL_WAIT_TIME = 4;
	static final int COL_BLOCK_TIME = 5;
	static final int COL_BLOCK_COUNT = 6;
	static final int COL_DEADLOCK_TIME = 7;
	static final int COL_DEADLOCK_COUNT = 8;



	public ThreadStatisticView(Composite parent, TraceViewerPage page) {
--


--


	protected String getContextHelpId() {
		return TraceUIPlugin.getPluginId() + ".stvw0001";
	}

	public void createColumnsLabelProviders() {
	public void createColumnsLabelProviders()
	{
--

				new ThreadClassNameColumnLabel(),
				new ThreadNameColumnLabel(),
				//new ThreadStartTimeColumnLabel(),
				//new ThreadStopTimeColumnLabel(),
				new ThreadStateColumnLabel(),
				new ThreadRunningTimeColumnLabel(),
				//new ThreadSleepingTimeColumnLabel(),
				new ThreadWaitingTimeColumnLabel(),
				new ThreadBlockedTimeColumnLabel(),
				new ThreadBlockCountColumnLabel(),
				new ThreadDeadlockedTimeColumnLabel(),
				new ThreadDeadlockCountColumnLabel() };
		};
--


--


		/**
		 * Returns the current selection for this provider.
		 * 
		 * @return the current selection
		 */
		public ISelection getSelection() {
			ISelection sel = super.getSelection();
			if (sel != null && !sel.isEmpty()) {
				Object obj = ((IStructuredSelection) sel).getFirstElement();
				if (obj instanceof ThreadDetails)
					return new StructuredSelection(((ThreadDetails) obj).getThread());
			}
			return sel;
		}

	}

	public class ThreadStatisticContentProvider implements ITreeContentProvider {

		public Object[] getChildren(Object element) {
	{
		
		public Object[] getChildren(Object element)
		{
--


--

		}
--


--

			Object[] threads = PerftraceUtil.getAllThreads(
					_page.getMOFObject(), false);

			for (int i = 0; i < threads.length; i++) {
				elements[i] = new ThreadDetails((TRCThread) threads[i]);
--


	public class ThreadStatisticLabelProvider extends LabelProvider implements
			ITableLabelProvider {
--


--

			StatisticTableColumnInfo info =
				StatisticTableColumnInfo.getStatisticTableColumnInfo(_viewer.getTree().getColumn(col));
			int pos = info.getColumnData().getInitalPos();

			if (pos >= 0 && pos < _columns.length) {
				return getElementColumnText(obj, _columns[pos], info.isDeltaColumn());
			} else {
				return "";
			}


--

			StatisticTableColumnInfo info = 
				StatisticTableColumnInfo.getStatisticTableColumnInfo(_viewer.getTree().getColumn(col));
			int pos = info.getColumnData().getInitalPos();

			if (pos == COL_STATE) { // thread state
			}

			if (info.isDeltaColumn())
--

			if (pos >= 0 && pos < _columns.length) {
				return getElementColumnImage(obj, _columns[pos], info.isDeltaColumn());
			} else {
				return null;
			}
--


--

			if (_pos >= 0 && _pos < _columns.length) {
--

			} else {
				return 0;
			}
--

	public class ThreadStatisticFilter extends StatisticFilter {

--


--


--

			String compareText = (element instanceof TRCThread) ? PerftraceUtil.getThreadName((TRCThread) element) : "";
					PerftraceUtil.getThreadName((TRCThread)element) : "";
--


	public String getDefaultColumnsTemplate() {
		return IContextAttributes.THREAD_CLASS_NAME + ":" + COL_CLASS_NAME + ":" + String.valueOf(ColumnData.NONDELETABLE | ColumnData.IS_VISIBLE | ColumnData.NONMOVABLE) + ":left:150,"
				+ IContextAttributes.THREAD_NAME + ":" + COL_THREAD_NAME + ":" + String.valueOf(ColumnData.NONDELETABLE | ColumnData.IS_VISIBLE | ColumnData.NONMOVABLE) + ":left:120,"
				//+ IContextAttributes.THREAD_START_TIME + ":2:" + String.valueOf(ColumnData.IS_VISIBLE) + ":right:80,"
				//+ IContextAttributes.THREAD_STOP_TIME + ":3:" + String.valueOf(ColumnData.IS_VISIBLE) + ":right:80,"
				+ IContextAttributes.THREAD_STATE + ":" + COL_STATE + ":" + String.valueOf(ColumnData.IS_VISIBLE) + ":right:80,"
				+ IContextAttributes.THREAD_RUNNING_TIME + ":" + COL_RUN_TIME + ":" + String.valueOf(ColumnData.IS_VISIBLE) + ":right:120," 
				//+ IContextAttributes.THREAD_SLEEPING_TIME + ":6:" + String.valueOf(ColumnData.IS_VISIBLE) + ":right:120,"
				+ IContextAttributes.THREAD_WAITING_TIME + ":" + COL_WAIT_TIME + ":" + String.valueOf(ColumnData.IS_VISIBLE) + ":right:120,"
				+ IContextAttributes.THREAD_BLOCKED_TIME + ":" + COL_BLOCK_TIME+ ":" + String.valueOf(ColumnData.IS_VISIBLE) + ":right:120,"
				+ IContextAttributes.THREAD_BLOCK_COUNT + ":" + COL_BLOCK_COUNT + ":" + String.valueOf(ColumnData.IS_VISIBLE) + ":right:80,"
				+ IContextAttributes.THREAD_DEADLOCKED_TIME + ":" + COL_DEADLOCK_TIME + ":" + String.valueOf(ColumnData.IS_VISIBLE) + ":right:80,"
				+ IContextAttributes.THREAD_DEADLOCK_COUNT + ":" + COL_DEADLOCK_COUNT + ":" + String.valueOf(ColumnData.IS_VISIBLE) + ":right:80"
				+ String.valueOf(ColumnData.IS_VISIBLE) + ":right:120,"
//			+  IContextAttributes.THREAD_SLEEPING_TIME	+ ":6:" 
//				+ String.valueOf(ColumnData.IS_VISIBLE) + ":right:120,"
			+  IContextAttributes.THREAD_WAITING_TIME	+ ":6:" 
				+ String.valueOf(ColumnData.IS_VISIBLE) + ":right:120,"
			+  IContextAttributes.THREAD_BLOCKED_TIME	+ ":7:" 
				+ String.valueOf(ColumnData.IS_VISIBLE) + ":right:120,"
			+  IContextAttributes.THREAD_BLOCK_COUNT	+ ":8:" 
				+ String.valueOf(ColumnData.IS_VISIBLE) + ":right:80,"
			+  IContextAttributes.THREAD_DEADLOCKED_TIME+ ":9:" 
				+ String.valueOf(ColumnData.IS_VISIBLE) + ":right:80,"
				+  IContextAttributes.THREAD_DEADLOCK_COUNT	+ ":10:" 
				+ String.valueOf(ColumnData.IS_VISIBLE) + ":right:80"
--

	}

	public boolean isEmptyUpdate() {
		// Object[] threads = PerftraceUtil.getAllThreads(_page.getMOFObject(), false);
		// for (int i = 0; i < threads.length; i++) {
		// TRCThread thread = (TRCThread)threads[i];
		// for (Iterator it = thread.getThreadEvents().iterator(); it.hasNext();
		// ) {
		// Object event = it.next();
		// if (event instanceof TRCThreadWaitingForLockEvent
		// || event instanceof TRCThreadWaitingForObjectEvent
		// || event instanceof TRCThreadSleepingEvent
		// || event instanceof TRCThreadDeadLockEvent) {
		return false;
		// }
		// }
		// }
		// return true;
	}

	public IContentProvider getContentProvider() {
	{
--


	public LabelProvider getTableLabelProvider() {
	{
--


	protected StatisticSorter getViewerSorterInstance() {
	{
--


	protected StatisticFilter getFilterInstance() {
	{
--

	}

	public String getColumnsPreferencesKey() {
		return PREFERENCE_KEY_PREFIX + "ThreadStats2";
	}

	protected String getViewTypeStr() {
	protected String getViewTypeStr()
	{
--

	}

--

	}

--

	}

	public void update() {
		if (_page instanceof ThreadStatisticPage) {
	{
		if(_page instanceof ThreadStatisticPage)
		{
--


--

		if (_page instanceof ThreadStatisticPage) {
		{
--


--

								region.add(event.x, event.y, width, event.height);
--

				}

--

				if (event.index == COL_STATE) { // thread state
--

				} else if (event.index == COL_BLOCK_COUNT // block count
--

				} else if (event.index == COL_DEADLOCK_COUNT // deadlock count
--


--

					Color fore = Utils.mixColors(display, sysBack, sysFore, 1, 4);
					Color back = Utils.mixColors(display, sysBack, sysFore, 1, 1);

					gc.setAdvanced(true);
					if (gc.getAdvanced()) {
						gc.setAlpha(180);
					}

	 				gc.setAdvanced(true);
	 				if (gc.getAdvanced()) {
	 					gc.setAlpha(180);
	 				}
	


--


			private Color mixColors(Display display, Color c1, Color c2, int w1, int w2) {
				return new Color(display,
						(w1 * c1.getRed() + w2 * c2.getRed()) / (w1 + w2), 
						(w1 * c1.getGreen() + w2 * c2.getGreen()) / (w1 + w2), 
						(w1 * c1.getBlue() + w2 * c2.getBlue()) / (w1 + w2));
			}

		ITraceSelection model = UIPlugin.getDefault().getSelectionModel(_page.getMOFObject());
			UIPlugin.getDefault().getSelectionModel(_page.getMOFObject());
--

				

					updateStatusContext(ContextManager.getContextLanguage(ContextUpdaterHelper.getContext((EObject) sel)));
--

		Object sel = null;
		if (selection != null && !selection.isEmpty()) {
			sel = ((IStructuredSelection) selection).getFirstElement();
			if (sel instanceof ThreadDetails)
				sel = ((ThreadDetails) sel).getThread();
			notifyViewSelectionChanged(this, sel);
		}
	}

	public TRCThread getSelectedThread() {
		TRCThread thread = null;
		ISelection selection = getTreeViewer().getSelection();
		if (selection != null && !selection.isEmpty()) {
			Object sel = ((IStructuredSelection) selection).getFirstElement();
			if (sel instanceof TRCThread)
				thread = (TRCThread) sel;
			if (sel instanceof ThreadDetails)
				thread = ((ThreadDetails) sel).getThread();

		return thread;

		Object source = event.getSource();
		if (source != this) {
--

		} else {
			ITraceSelection model = UIPlugin.getDefault().getSelectionModel(_page.getMOFObject());
		{
			ITraceSelection model =
				UIPlugin.getDefault().getSelectionModel(_page.getMOFObject());
--

					updateStatusContext(ContextManager.getContextLanguage(ContextUpdaterHelper.getContext((EObject) sel)));
--



		menu.add(getChooseColumnsAction(getColumnDataList(),
			getChooseColumnsAction(
				getColumnDataList(),
--

		menu.add(getSortByColumnAction());
			getSortByColumnAction());
					
--


--


--

			obj = ((ThreadDetails) obj).getThread();
--


--

			if (item != null && !item.isDisposed()) {
--

					data = ((ThreadDetails) data).getThread();
--


		if (_page.getTraceViewer() instanceof MultiLevelStatisticViewer) {
		{
--

			_contextInfo.setViewer((IContextViewer) _page.getTraceViewer());
--

			_contextInfo.addContextInfoContainerListener(new IContextInfoContainerListener() {
						public void visibilityChanged(boolean isVisible) {
					{
						public void visibilityChanged(boolean isVisible)
						{
--


--


	protected void updateStatusContext(IContextLanguage language) {
	{
--


--

		ArrayList list = ColumnData.createColumnData(getColumnsPreferencesKey()
				, getDefaultColumnsTemplate());
--

		

	}

	public void dispose() {
		super.dispose();
	}

	public void widgetDefaultSelected(SelectionEvent arg0) {
		OpenCallStackViewAction.openCallStackView(false);

Line 28 Link Here

(-)CVS (-56 / +40 lines)
28	public class ThreadStatisticViewer extends TraceViewer implements IContextViewer {	28	public class ThreadStatisticViewer extends TraceViewer implements
29	--	29	IContextViewer {
Line 30 Link Here
30	protected Action _chooseColumns;	31	protected Action _chooseColumns;
31	--
Line 32 Link Here
		33	protected Action _openCallStackView;
Line 33 Link Here
33		35
34	--
Line 36 Link Here
36		38
37	--
Line 52 Link Here
52	return UIMessages.TITLE;	54	return UIMessages.THREAD_STATISTIC_TITLE;
53	--
Line 54 Link Here
54		56
55	--
Line 60 Link Here
60		62
61	--
Line 71 Link Here
71		73
72	--
Line 88 Link Here
88		90
89	--
Line 90 Link Here
90		92
91	--
Line 92 Link Here
92	((TraceViewerPage)getCurrentPage()).refreshPage();	94	((TraceViewerPage) getCurrentPage()).refreshPage();
93	--
Line 96 Link Here
96	ContextUpdaterHelper.setCurrentFocusContextLanguage(getSelectedContext());	98	ContextUpdaterHelper
97	--	99	.setCurrentFocusContextLanguage(getSelectedContext());
Lines 100-106 Link Here
100	public Object[] getViewerControls()	103	public Object[] getViewerControls() {
101	{	104	if (getCurrentPage() instanceof ThreadStatisticPage) {
102	if (getCurrentPage() instanceof ThreadStatisticPage) {	105	return new Object[] { ((ThreadStatisticPage) getCurrentPage())
103	return new Object[] { ((ThreadStatisticPage)getCurrentPage()).getView().getTree() };	106	.getView().getTree() };
104	}	107	}
105	return null;	108	return null;
106	}	109	}
107	--
Lines 120-122 Link Here
120	if (agent	123	if (agent.getType()
121	.getType()	124	.equals(CommonUIConstants.PROFILE_AGENT_TYPE)) {
122	.equals(CommonUIConstants.PROFILE_AGENT_TYPE)) {
123	--
Line 133 Link Here
133		135
134	--
Line 140 Link Here
140	ThreadStatisticPage page = (ThreadStatisticPage)getCurrentPage();	142	ThreadStatisticPage page = (ThreadStatisticPage) getCurrentPage();
141	--
Line 145 Link Here
145	view.getChooseColumnsAction(view.getColumnDataList(), view.getColumnsPreferencesKey()).run();	147	view.getChooseColumnsAction(view.getColumnDataList(),
146	--	148	view.getColumnsPreferencesKey()).run();
Line 149 Link Here
149	TracePluginImages.setImageDescriptors(_chooseColumns, TracePluginImages.T_LCL, TracePluginImages.IMG_CHOOSECOLUMNS);	152	TracePluginImages.setImageDescriptors(_chooseColumns,
150	--	153	TracePluginImages.T_LCL, TracePluginImages.IMG_CHOOSECOLUMNS);
Line 157 Link Here
157	ThreadStatisticPage page = (ThreadStatisticPage)getCurrentPage();	161	ThreadStatisticPage page = (ThreadStatisticPage) getCurrentPage();
158	--
Line 165 Link Here
165		169
166	--
Line 167 Link Here
167	TracePluginImages.setImageDescriptors(_sortByColumn, TracePluginImages.T_LCL, TracePluginImages.IMG_SORTCOLUMNS);	171	TracePluginImages.setImageDescriptors(_sortByColumn,
168	--	172	TracePluginImages.T_LCL, TracePluginImages.IMG_SORTCOLUMNS);
Line 171 Link Here
171		176
172	--	177	_openCallStackView = new OpenCallStackViewAction();
		178
Line 175 Link Here
175		182	menum.add(_openCallStackView);
176	--	183
Line 179 Link Here
179		187
180	--

Line 20 Link Here

(-)CVS (-11 / +7 lines)
20	public static String TITLE;	20	public static String THREAD_STATISTIC_TITLE;
21	--	21	public static String THREAD_STATES_TITLE;
		22	public static String LEGEND_LABEL;
		23	public static String CURRENT_TIME;
		24	public static String SELECTED_TIME;
		25	public static String TIME_SCALE;
Line 23 Link Here
23
Line 25 Link Here
25
Line 27 Link Here
27
Line 29 Link Here
29
Line 31 Link Here
31
Line 33 Link Here
33		33	public static String _267;
34	--
Line 38 Link Here
38
Line 44 Link Here
44

Line 16 Link Here

(-)CVS (-2 / +7 lines)
16	TITLE = Thread Statistics	16	THREAD_STATISTIC_TITLE = Thread Statistics
17	--	17	THREAD_STATES_TITLE = Thread States
		18	LEGEND_LABEL = Legend
		19	CURRENT_TIME = Current Time
		20	SELECTED_TIME = Selected Time
		21	TIME_SCALE = Time Scale
Line 23 Link Here
		28	_267 = Unknown




/*****************************************************************************
 * Copyright (c) 1997-2006, Intel Corporation.
 * 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:
 *    Intel Corporation - Initial API and implementation
 *    Ruslan A. Scherbakov, Intel - Initial API and implementation
 *
 * $Id$ 
 *****************************************************************************/

package org.eclipse.tptp.trace.jvmti.internal.client.widgets;

public interface ITimeDataProvider {

	double getSelectedTime();

	double getBeginTime();

	double getEndTime();

	double getMinTime();

	double getMaxTime();

	double getTime0();

	double getTime1();

	double getMinTimeInterval();

	void setStartFinishTime(double time0, double time1);

	void setSelectedTime(double time, boolean ensureVisible);

	void resetStartFinishTime();

	int getNameSpace();

	int getTimeSpace();
}




/*****************************************************************************
 * Copyright (c) 1997-2006, Intel Corporation.
 * 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:
 *    Intel Corporation - Initial API and implementation
 *    Ruslan A. Scherbakov, Intel - Initial API and implementation
 *
 * $Id$ 
 *****************************************************************************/

package org.eclipse.tptp.trace.jvmti.internal.client.widgets;

import org.eclipse.swt.graphics.GC;
import org.eclipse.swt.graphics.Point;
import org.eclipse.swt.graphics.Rectangle;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.tptp.trace.jvmti.internal.client.views.UIMessages;

public class LegendCtrl extends TraceCtrl {

	static private String _names[];

	public LegendCtrl(Composite parent, TraceColorScheme colors) {
		super(parent, colors);
	}
	
	static private String [] getNames() {
		if (null == _names) {
			String names[] = {
					UIMessages._267, // "Unknown",
					UIMessages._261, // "Running",
					UIMessages._262, // "Sleeping",
					UIMessages._263, // "Waiting",
					UIMessages._264, // "Blocked",
					UIMessages._265, // "Deadlock",
					UIMessages._266, // "Stopped",
			};
			_names = names;
		}
		return _names;
	}

	void paint(Rectangle rect, GC gc) {
		gc.setBackground(_colors.getColor(TraceColorScheme.LEGEND_BACKGROUND));
		gc.fillRectangle(rect);
		// draw legend rect
		Utils.init(_rect1, rect);
		//gc.setForeground(_colors.getColor(TraceColorScheme.LEGEND_FOREGROUND));
		//gc.drawRectangle(_rect1.x, _rect1.y, _rect1.width - 1, _rect1.height - 1);
		// draw legend elements
		int idx = 0;
		String names[] = getNames();
		_rect1.x += 4;
		_rect1.y += 2;
		while (idx < names.length && _rect1.x < rect.x + rect.width) {
			Point size = gc.stringExtent(names[idx]);
			_rect1.width = 16;
			_rect1.height = size.y;
			Utils.drawState(_colors, idx, _rect1, gc, false, true, false);
			_rect1.x += _rect1.width + 2;
			_rect1.width = size.x;
			gc.setForeground(_colors.getColor(TraceColorScheme.LEGEND_FOREGROUND));
			Utils.drawText(gc, names[idx], _rect1, true);
			_rect1.x += _rect1.width + 8;
			idx++;
		}
	}
}




/*****************************************************************************
 * Copyright (c) 1997-2006, Intel Corporation.
 * 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:
 *    Intel Corporation - Initial API and implementation
 *    Ruslan A. Scherbakov, Intel - Initial API and implementation
 *
 * $Id$ 
 *****************************************************************************/

package org.eclipse.tptp.trace.jvmti.internal.client.widgets;

import java.util.ArrayList;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.List;
import java.util.Set;

import org.eclipse.emf.common.util.EList;
import org.eclipse.hyades.models.trace.TRCThread;
import org.eclipse.hyades.models.trace.TRCThreadEvent;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.swt.SWT;
import org.eclipse.swt.events.ControlEvent;
import org.eclipse.swt.events.ControlListener;
import org.eclipse.swt.events.FocusEvent;
import org.eclipse.swt.events.FocusListener;
import org.eclipse.swt.events.KeyEvent;
import org.eclipse.swt.events.KeyListener;
import org.eclipse.swt.events.MouseEvent;
import org.eclipse.swt.events.MouseListener;
import org.eclipse.swt.events.MouseMoveListener;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.events.SelectionListener;
import org.eclipse.swt.graphics.GC;
import org.eclipse.swt.graphics.Point;
import org.eclipse.swt.graphics.Rectangle;
import org.eclipse.swt.widgets.Composite;

public class ThreadStatesCtrl extends TraceCtrl implements FocusListener,
		KeyListener, MouseMoveListener, MouseListener, ControlListener,
		SelectionListener {

	private ITimeDataProvider _timeProvider;
	boolean _isInFocus = false;
	private int _topItem = 0;
	private int _itemHeight = 18;
	private int _dragState = 0;
	private int _hitIdx = 0;
	private int _dragX0 = 0;
	private int _dragX = 0;
	private double _timeStep = 0.01;
	private double _time0bak;
	private double _time1bak;
	private ItemData _data = new ItemData();
	private ArrayList _selectionListeners;

	public ThreadStatesCtrl(Composite parent, TraceColorScheme colors) {
		super(parent, colors, SWT.NO_BACKGROUND | SWT.H_SCROLL | SWT.V_SCROLL);
		addFocusListener(this);
		addMouseListener(this);
		addMouseMoveListener(this);
		addKeyListener(this);
		addControlListener(this);
		getVerticalBar().addSelectionListener(this);
		getHorizontalBar().addSelectionListener(this);
	}

	public void setTimeProvider(ITimeDataProvider timeProvider) {
		_timeProvider = timeProvider;
		adjustScrolls();
		redraw();
	}

	public void addSelectionListener(SelectionListener listener) {
		if (listener == null)
			SWT.error(SWT.ERROR_NULL_ARGUMENT);
		if (null == _selectionListeners)
			_selectionListeners = new ArrayList();
		_selectionListeners.add(listener);
	}

	public void removeSelectionListener(SelectionListener listener) {
		if (null != _selectionListeners)
			_selectionListeners.remove(listener);
	}

	public void fireSelectionChanged() {
		if (null != _selectionListeners) {
			Iterator it = _selectionListeners.iterator();
			while (it.hasNext()) {
				SelectionListener listener = (SelectionListener) it.next();
				listener.widgetSelected(null);
			}
		}
	}

	public void fireDefaultSelection() {
		if (null != _selectionListeners) {
			Iterator it = _selectionListeners.iterator();
			while (it.hasNext()) {
				SelectionListener listener = (SelectionListener) it.next();
				listener.widgetDefaultSelected(null);
			}
		}
	}

	public void refreshData(Object threads[]) {
		_data.refreshData(threads);
		adjustScrolls();
		redraw();
	}

	public void adjustScrolls() {
		if (null == _timeProvider) {
			getVerticalBar().setValues(0, 1, 1, 1, 1, 1);
			getHorizontalBar().setValues(0, 1, 1, 1, 1, 1);
			return;
		}
		int page = countPerPage();
		if (_topItem + page > _data._items.length)
			_topItem = _data._items.length - page;
		if (_topItem < 0)
			_topItem = 0;
		getVerticalBar().setValues(_topItem, 0, _data._items.length, page, 1,
				page);
		double time0 = _timeProvider.getTime0();
		double time1 = _timeProvider.getTime1();
		double timeMin = _timeProvider.getMinTime();
		double timeMax = _timeProvider.getMaxTime();
		int timePage = (int) ((time1 - time0) / _timeStep);
		int timePos = (int) (time0 / _timeStep);
		getHorizontalBar().setValues(timePos, (int) (timeMin / _timeStep),
				(int) (timeMax / _timeStep), timePage, 1, timePage);
	}

	boolean ensureVisibleItem(int idx, boolean redraw) {
		boolean changed = false;
		if (idx < 0 || idx >= _data._items.length)
			return changed;
		if (idx < _topItem) {
			_topItem = idx;
			getVerticalBar().setSelection(_topItem);
			if (redraw)
				redraw();
			changed = true;
		} else {
			int page = countPerPage();
			if (idx >= _topItem + page) {
				_topItem = idx - page + 1;
				getVerticalBar().setSelection(_topItem);
				if (redraw)
					redraw();
				changed = true;
			}
		}
		return changed;
	}

	static TRCThreadEvent getFirstEvent(TRCThread thread) {
		EList list = thread.getThreadEvents();
		TRCThreadEvent event = null;
		if (!list.isEmpty())
			event = (TRCThreadEvent) list.get(0);
		return event;
	}

	static TRCThreadEvent findEvent(TRCThread thread, double time, int n) {
		EList list = thread.getThreadEvents();
		Iterator it = list.iterator();
		TRCThreadEvent event = null;
		TRCThreadEvent prevEvent = null;
		TRCThreadEvent nextEvent = null;
		if (it.hasNext()) {
			event = (TRCThreadEvent) it.next();
			double currTime = event.getTime();
			if (time < currTime) {
				if (1 != n)
					event = null;
				return event;
			}
			while (it.hasNext()) {
				nextEvent = (TRCThreadEvent) it.next();
				double nextTime = nextEvent.getTime();
				if (currTime <= time && time < nextTime) {
					if (1 == n)
						event = nextEvent;
					else if (-1 == n)
						event = prevEvent;
					return event;
				}
				prevEvent = event;
				event = nextEvent;
			}
		}
		if (1 == n)
			event = null;
		else if (-1 == n)
			event = prevEvent;
		return event;
	}

	static class Selection implements IStructuredSelection {

		List list = new ArrayList();

		public Object getFirstElement() {
			if (!list.isEmpty())
				return list.get(0);
			return null;
		}

		public Iterator iterator() {
			return list.iterator();
		}

		public int size() {
			return list.size();
		}

		public Object[] toArray() {
			return list.toArray();
		}

		public List toList() {
			return list;
		}

		public boolean isEmpty() {
			return list.isEmpty();
		}
	}

	public ISelection getSelection() {
		Selection sel = new Selection();
		TRCThread thread = getSelectedThread();
		if (null != thread && null != _timeProvider) {
			double selectedTime = _timeProvider.getSelectedTime();
			TRCThreadEvent event = findEvent(thread, selectedTime, 0);
			if (null != event)
				sel.list.add(event);
		}
		return sel;
	}

	public void selectEvent(int n) {
		if (null == _timeProvider)
			return;
		TRCThread thread = getSelectedThread();
		if (thread == _timeProvider)
			return;
		double selectedTime = _timeProvider.getSelectedTime();
		double endTime = _timeProvider.getEndTime();
		TRCThreadEvent nextEvent;
		if (-1 == n && selectedTime >= endTime)
			nextEvent = findEvent(thread, selectedTime, 0);
		else
			nextEvent = findEvent(thread, selectedTime, n);
		if (null != nextEvent) {
			_timeProvider.setSelectedTime(nextEvent.getTime(), true);
			fireSelectionChanged();
		}
		else if (1 == n) {
			_timeProvider.setSelectedTime(endTime, true);
			fireSelectionChanged();
		}
	}

	public void selectNextEvent() {
		selectEvent(1);
	}

	public void selectPrevEvent() {
		selectEvent(-1);
	}

	public TRCThread getSelectedThread() {
		TRCThread thread = null;
		int idx = getSelectedIndex();
		if (idx >= 0 && _data._items[idx] instanceof ThreadItem)
			thread = ((ThreadItem) _data._items[idx])._thread;
		return thread;
	}

	public int getSelectedIndex() {
		int idx = -1;
		for (int i = 0; i < _data._items.length; i++) {
			Item item = (Item) _data._items[i];
			if (item._selected) {
				idx = i;
				break;
			}
		}
		return idx;
	}

	boolean toggle(int idx) {
		boolean toggled = false;
		if (idx >= 0 && idx < _data._items.length) {
			Item item = (Item) _data._items[idx];
			if (item._hasChildren) {
				item._expanded = !item._expanded;
				_data.updateItems();
				adjustScrolls();
				redraw();
				toggled = true;
			}
		}
		return toggled;
	}

	int hitTest(int x, int y) {
		if (x < 0)
			return -1;
		if (y < 0)
			return -1;
		int hit = -1;
		int idx = y / _itemHeight;
		idx += _topItem;
		if (idx < _data._items.length)
			hit = idx;
		return hit;
	}

	double hitTimeTest(int x, int y) {
		if (null == _timeProvider)
			return -1;
		double hitTime = -1;
		Point size = getCtrlSize();
		double time0 = _timeProvider.getTime0();
		double time1 = _timeProvider.getTime1();
		int left = _timeProvider.getNameSpace();
		x -= left;
		if (x >= 0 && size.x >= left) {
			hitTime = time0 + (time1 - time0) * x / (size.x - left);
		}
		return hitTime;
	}

	void selectItem(int idx, boolean addSelection) {
		if (addSelection) {
			if (idx >= 0 && idx < _data._items.length) {
				Item item = (Item) _data._items[idx];
				item._selected = true;
			}
		} else {
			for (int i = 0; i < _data._items.length; i++) {
				Item item = (Item) _data._items[i];
				item._selected = i == idx;
			}
		}
		boolean changed = ensureVisibleItem(idx, true);
		if (!changed)
			redraw();
	}

	public int countPerPage() {
		int height = getCtrlSize().y;
		int count = 0;
		if (height > 0)
			count = height / _itemHeight;
		return count;
	}

	public int getTopIndex() {
		int idx = -1;
		if (_data._items.length > 0)
			idx = 0;
		return idx;
	}

	public int getBottomIndex() {
		int idx = _data._items.length - 1;
		return idx;
	}

	Point getCtrlSize() {
		Point size = getSize();
		size.x -= getVerticalBar().getSize().x;
		size.y -= getHorizontalBar().getSize().y;
		return size;
	}

	void getNameRect(Rectangle rect, Point size, int idx, int nameWidth) {
		idx -= _topItem;
		rect.x = 0;
		rect.y = idx * _itemHeight;
		rect.width = nameWidth;
		rect.height = _itemHeight;
	}

	void getStatesRect(Rectangle rect, Point size, int idx, int nameWidth) {
		idx -= _topItem;
		rect.x = nameWidth;
		rect.y = idx * _itemHeight;
		rect.width = size.x - rect.x;
		rect.height = _itemHeight;
	}

	void paint(Rectangle rect, GC gc) {
		Point size = getCtrlSize();
		if (size.x < 2 || size.y < 2 || null == _timeProvider)
			return;
		double time0 = _timeProvider.getTime0();
		double time1 = _timeProvider.getTime1();
		double endTime = _timeProvider.getEndTime();
		double selectedTime = _timeProvider.getSelectedTime();
		int left = _timeProvider.getNameSpace();
		// draw thread states
		Object[] items = _data._items;
		for (int i = _topItem; i < items.length; i++) {
			Item item = (Item) items[i];
			getNameRect(_rect0, size, i, left);
			if (_rect0.y >= size.y)
				break;
			if (item instanceof GroupItem) {
				getStatesRect(_rect1, size, i, left);
				_rect0.width += _rect1.width;
				drawName(item, _rect0, gc);
			} else {
				drawName(item, _rect0, gc);
				getStatesRect(_rect0, size, i, left);
				drawItemData(item, _rect0, time0, time1, endTime, selectedTime,
						gc);
			}
		}
		// fill free canvas area
		_rect0.x = 0;
		_rect0.y += _rect0.height;
		_rect0.width = size.x;
		_rect0.height = size.y - _rect0.y;
		if (_rect0.y < size.y) {
			gc.setBackground(_colors.getColor(TraceColorScheme.BACKGROUND));
			gc.fillRectangle(_rect0);
		}
	}

	void drawName(Item item, Rectangle rect, GC gc) {
		if (item instanceof GroupItem) {
			gc.setBackground(_colors
					.getBkColorGroup(item._selected, _isInFocus));
			gc.fillRectangle(rect);
			if (item._selected && _isInFocus) {
				gc.setForeground(_colors.getBkColor(item._selected, _isInFocus,
						false));
				gc.drawRectangle(rect.x, rect.y, rect.width - 2,
						rect.height - 2);
			}
			gc.setForeground(_colors.getBkColor(false, false, false));
			gc.drawLine(rect.x, rect.y + rect.height - 1, rect.width - 1,
					rect.y + rect.height - 1);
			gc.setForeground(_colors
					.getFgColorGroup(item._selected, _isInFocus));
		} else {
			gc.setBackground(_colors.getBkColor(item._selected, _isInFocus,
					true));
			gc.setForeground(_colors.getFgColor(item._selected, _isInFocus));
			gc.fillRectangle(rect);
		}
		Utils.init(_rect1, rect);
		_rect1.x += 4;
		_rect1.width -= 4;
		int textWidth = 0;
		// draw text
		if (_rect1.width > 0)
			textWidth = Utils.drawText(gc, item._name, _rect1, true) + 8;
		// draw middle line
		Utils.init(_rect1, rect);
		_rect1.x += textWidth;
		_rect1.width -= textWidth;
		gc.setForeground(_colors.getColor(TraceColorScheme.LIGHT_LINE));
		if (_rect1.width > 0 && item instanceof ThreadItem) {
			int midy = _rect1.y + _rect1.height / 2;
			gc.drawLine(_rect1.x, midy, _rect1.x + _rect1.width, midy);
		}
		// gc.drawLine(_rect1.x + _rect1.width - 1, _rect1.y, _rect1.x +
		// _rect1.width - 1, _rect1.y + _rect1.height);
	}

	void drawItemData(Item item, Rectangle rect, double time0, double time1,
			double endTime, double selectedTime, GC gc) {
		if (rect.isEmpty())
			return;
		if (time1 <= time0) {
			gc.setBackground(_colors.getBkColor(false, false, false));
			gc.fillRectangle(rect);
			return;
		}

		Utils.init(_rect1, rect);
		boolean selected = item._selected;
		double K = (double) rect.width / (time1 - time0);

		if (item instanceof GroupItem) {
			gc.setBackground(_colors.getBkColorGroup(selected, _isInFocus));
			gc.fillRectangle(rect);
		} else if (item instanceof ThreadItem) {
			TRCThread thread = ((ThreadItem) item)._thread;
			int x0 = rect.x;
			EList list = thread.getThreadEvents();
			Iterator it = list.iterator();
			TRCThreadEvent lastEvent = null;
			if (it.hasNext()) {
				TRCThreadEvent currEvent = (TRCThreadEvent) it.next();
				TRCThreadEvent nextEvent = null;
				double currEventTime = currEvent.getTime();
				double nextEventTime = currEventTime;
				x0 = rect.x + (int) ((currEventTime - time0) * K);
				int xEnd = rect.x + (int) ((time1 - time0) * K);
				int x1 = -1;

				// reduce rect
				_rect1.y += 3;
				_rect1.height -= 6;

				// fill space before first event
				if (x0 > rect.x) {
					_rect1.width = (x0 <= xEnd ? x0 : xEnd) - _rect1.x;
					gc.setBackground(_colors.getBkColor(selected, _isInFocus,
							false));
					gc.fillRectangle(_rect1);
					// draw middle line
					gc.setForeground(_colors
							.getColor(TraceColorScheme.MID_LINE));
					int midy = _rect1.y + _rect1.height / 2;
					gc.drawLine(_rect1.x, midy, _rect1.x + _rect1.width, midy);
				}

				// draw event states
				while (x0 <= xEnd && null != currEvent) {
					boolean stopped = false;//currEvent instanceof TRCThreadDeadEvent;
					if (it.hasNext()) {
						nextEvent = (TRCThreadEvent) it.next();
						nextEventTime = nextEvent.getTime();
					} else if (stopped) {
						nextEvent = null;
						nextEventTime = time1;
					} else {
						nextEvent = null;
						nextEventTime = endTime;
					}
					x1 = rect.x + (int) ((nextEventTime - time0) * K);
					if (x1 >= rect.x) {
						_rect1.x = x0 >= rect.x ? x0 : rect.x;
						_rect1.width = (x1 <= xEnd ? x1 : xEnd) - _rect1.x;
						boolean timeSelected = currEventTime <= selectedTime && selectedTime < nextEventTime;
						Utils.drawState(_colors, currEvent, _rect1, gc, selected, false, timeSelected);
					}
					lastEvent = currEvent;
					currEvent = nextEvent;
					currEventTime = nextEventTime;
					x0 = x1;
				}
			}

			// fill space after last event
			int xEnd = rect.x + rect.width;
			if (x0 < xEnd) {
				_rect1.x = x0 >= rect.x ? x0 : rect.x;
				_rect1.width = xEnd - _rect1.x;
				gc.setBackground(_colors.getBkColor(selected, _isInFocus, false));
				gc.fillRectangle(_rect1);
				// draw middle line
				gc.setForeground(_colors.getColor(Utils.getEventColor(lastEvent)));
				int midy = _rect1.y + _rect1.height / 2;
				int lw = gc.getLineWidth();
				gc.setLineWidth(2);
				gc.drawLine(_rect1.x, midy, _rect1.x + _rect1.width, midy);
				gc.setLineWidth(lw);
			}

			// draw focus ares
			Utils.init(_rect1, rect);
			gc.setForeground(_colors.getBkColor(false, false, false));
			int y = _rect1.y;
			gc.drawLine(_rect1.x, y, _rect1.x + _rect1.width, y);
			y++;
			gc.drawLine(_rect1.x, y, _rect1.x + _rect1.width, y);
			y++;
			gc.drawLine(_rect1.x, y, _rect1.x + _rect1.width, y);
			y = _rect1.y + _rect1.height - 1;
			gc.drawLine(_rect1.x, y, _rect1.x + _rect1.width, y);
			y--;
			gc.drawLine(_rect1.x, y, _rect1.x + _rect1.width, y);
			y--;
			gc.drawLine(_rect1.x, y, _rect1.x + _rect1.width, y);
			// gc.setForeground(_colors.getBkColor(selected, _isInFocus,
			// false));
		}

		// draw selected time
		int x = rect.x + (int) ((selectedTime - time0) * K);
		if (x >= rect.x && x < rect.x + rect.width) {
			gc.setForeground(_colors.getColor(TraceColorScheme.SELECTED_TIME));
			gc.drawLine(x, rect.y, x, rect.y + rect.height);
		}
	}

	public void keyPressed(KeyEvent e) {
		int idx = -1;
		if (SWT.HOME == e.keyCode) {
			idx = getTopIndex();
		} else if (SWT.END == e.keyCode) {
			idx = getBottomIndex();
		} else if (SWT.ARROW_DOWN == e.keyCode) {
			idx = getSelectedIndex();
			if (idx < 0)
				idx = 0;
			else if (idx < _data._items.length - 1)
				idx++;
		} else if (SWT.ARROW_UP == e.keyCode) {
			idx = getSelectedIndex();
			if (idx < 0)
				idx = 0;
			else if (idx > 0)
				idx--;
		} else if (SWT.ARROW_LEFT == e.keyCode) {
			selectPrevEvent();
		} else if (SWT.ARROW_RIGHT == e.keyCode) {
			selectNextEvent();
		} else if (SWT.PAGE_DOWN == e.keyCode) {
			int page = countPerPage();
			idx = getSelectedIndex();
			if (idx < 0)
				idx = 0;
			idx += page;
			if (idx >= _data._items.length)
				idx = _data._items.length - 1;
		} else if (SWT.PAGE_UP == e.keyCode) {
			int page = countPerPage();
			idx = getSelectedIndex();
			if (idx < 0)
				idx = 0;
			idx -= page;
			if (idx < 0)
				idx = 0;
		} else if (SWT.CR == e.keyCode) {
			idx = getSelectedIndex();
			if (idx >= 0) {
				if (_data._items[idx] instanceof ThreadItem)
					fireDefaultSelection();
				else if (_data._items[idx] instanceof GroupItem)
					toggle(idx);
			}
			idx = -1;
		}
		if (idx >= 0) {
			selectItem(idx, false);
			fireSelectionChanged();
		}
	}

	public void keyReleased(KeyEvent e) {
	}

	public void focusGained(FocusEvent e) {
		_isInFocus = true;
		redraw();
	}

	public void focusLost(FocusEvent e) {
		_isInFocus = false;
		if (1 == _dragState) {
			setCapture(false);
			_dragState = 0;
		}
		redraw();
	}

	public void mouseMove(MouseEvent e) {
		Point size = getCtrlSize();
		if (1 == _dragState && null != _timeProvider) {
			int leftSpace = _timeProvider.getNameSpace();
			int x = e.x - leftSpace;
			if (x > 0 && size.x > leftSpace && _dragX != x) {
				_dragX = x;
				double K = (double) (size.x - leftSpace)
						/ (_time1bak - _time0bak);
				double timeDelta = (_dragX - _dragX0) / K;
				double time1 = _time1bak - timeDelta;
				double maxTime = _timeProvider.getMaxTime();
				if (time1 > maxTime)
					time1 = maxTime;
				double time0 = time1 - (_time1bak - _time0bak);
				if (time0 < 0)
					time0 = 0;
				_timeProvider.setStartFinishTime(time0, time1);
			}
		}
	}

	public void mouseDoubleClick(MouseEvent e) {
		if (1 == e.button) {
			int idx = hitTest(e.x, e.y);
			if (idx >= 0) {
				selectItem(idx, false);
				if (_data._items[idx] instanceof ThreadItem) {
					fireDefaultSelection();
				}
			}
		}
	}

	public void mouseDown(MouseEvent e) {
		if (null == _timeProvider)
			return;
		if (1 == e.button) {
			int idx = hitTest(e.x, e.y);
			if (idx >= 0) {
				if (_data._items[idx] instanceof ThreadItem) {
					double hitTime = hitTimeTest(e.x, e.y);
					if (hitTime >= 0) {
						_timeProvider.setSelectedTime(hitTime, false);
						setCapture(true);
						_dragState = 1;
						_dragX = _dragX0 = e.x - _timeProvider.getNameSpace();
						_time0bak = _timeProvider.getTime0();
						_time1bak = _timeProvider.getTime1();
					}
				} else if (_data._items[idx] instanceof GroupItem) {
					_hitIdx = idx;
					_dragState = 2;
				}
				selectItem(idx, false);
				fireSelectionChanged();
			}
		}
	}

	public void mouseUp(MouseEvent e) {
		if (0 != _dragState) {
			setCapture(false);
			if (2 == _dragState) {
				if (hitTest(e.x, e.y) == _hitIdx)
					toggle(_hitIdx);
			}
			_dragState = 0;
		}
	}

	public void controlMoved(ControlEvent e) {
	}

	public void controlResized(ControlEvent e) {
		adjustScrolls();
	}

	public void widgetDefaultSelected(SelectionEvent e) {
	}

	public void widgetSelected(SelectionEvent e) {
		if (e.widget == getVerticalBar()) {
			_topItem = getVerticalBar().getSelection();
			if (_topItem < 0)
				_topItem = 0;
			redraw();
		} else if (e.widget == getHorizontalBar() && null != _timeProvider) {
			int startTime = getHorizontalBar().getSelection();
			double time0 = _timeProvider.getTime0();
			double time1 = _timeProvider.getTime1();
			double range = time1 - time0;
			// _timeRangeFixed = true;
			time0 = _timeStep * startTime;
			time1 = time0 + range;
			_timeProvider.setStartFinishTime(time0, time1);
		}
	}
}

class Item {
	public boolean _expanded;
	public boolean _selected;
	public boolean _hasChildren;
	public String _name;

	Item(String name) {
		_name = name;
	}

	public String toString() {
		return _name;
	}
}

class ThreadItem extends Item {
	public TRCThread _thread;

	ThreadItem(TRCThread thread) {
		super(thread.getName());
		_thread = thread;
	}
}

class GroupItem extends Item {
	public ArrayList _threads;

	GroupItem(String name) {
		super(name);
		_threads = new ArrayList();
		_hasChildren = true;
	}

	void add(Object thread) {
		_threads.add(thread);
	}
}

class ItemData {
	public Object[] _items = new Object[0];
	private Object _threads[] = new Object[0];
	private Hashtable _groupTable = new Hashtable();
	private boolean _flatList;

	void clearGroups() {
		Set keys = _groupTable.keySet();
		Iterator it = keys.iterator();
		while (it.hasNext()) {
			String key = (String) it.next();
			GroupItem group = (GroupItem) _groupTable.get(key);
			group._threads.clear();
		}
	}

	void deleteEmptyGroups() {
		Set keys = _groupTable.keySet();
		Iterator it = keys.iterator();
		while (it.hasNext()) {
			String key = (String) it.next();
			GroupItem group = (GroupItem) _groupTable.get(key);
			if (group._threads.size() == 0)
				_groupTable.remove(key);
		}
	}

	public void updateItems() {
		ArrayList itemList = new ArrayList();
		Set keys = _groupTable.keySet();
		Iterator it = keys.iterator();
		while (it.hasNext()) {
			String key = (String) it.next();
			GroupItem group = (GroupItem) _groupTable.get(key);
			if (!_flatList)
				itemList.add(group);
			if (_flatList || group._expanded) {
				Iterator it2 = group._threads.iterator();
				while (it2.hasNext())
					itemList.add(new ThreadItem((TRCThread) it2.next()));
			}
		}
		_items = itemList.toArray();
	}

	public void refreshData(Object threads[]) {
		clearGroups();
		_threads = threads;
		String undef = "<undefined>";
		ArrayList groupList = new ArrayList();
		for (int i = 0; i < _threads.length; i++) {
			TRCThread thread = (TRCThread) _threads[i];
			String groupName = thread.getGroupName();
			if (null == groupName)
				groupName = undef;
			GroupItem group = (GroupItem) _groupTable.get(groupName);
			if (null == group) {
				group = new GroupItem(groupName);
				group._expanded = !groupName.equalsIgnoreCase("system")
						&& !groupName.equalsIgnoreCase(undef);
				_groupTable.put(groupName, group);
				groupList.add(group);
			}
			group.add(thread);
		}
		deleteEmptyGroups();
		updateItems();
	}
}




/*****************************************************************************
 * Copyright (c) 1997-2006, Intel Corporation.
 * 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:
 *    Intel Corporation - Initial API and implementation
 *    Ruslan A. Scherbakov, Intel - Initial API and implementation
 *
 * $Id$ 
 *****************************************************************************/

package org.eclipse.tptp.trace.jvmti.internal.client.widgets;

import org.eclipse.swt.events.MouseEvent;
import org.eclipse.swt.events.MouseListener;
import org.eclipse.swt.events.MouseMoveListener;
import org.eclipse.swt.graphics.GC;
import org.eclipse.swt.graphics.Point;
import org.eclipse.swt.graphics.Rectangle;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.tptp.trace.jvmti.internal.client.views.UIMessages;

public class TimeScaleCtrl extends TraceCtrl implements MouseListener, MouseMoveListener {

	public TimeScaleCtrl(Composite parent, TraceColorScheme colors) {
		super(parent, colors);
		addMouseListener(this);
		addMouseMoveListener(this);
	}

	private ITimeDataProvider _timeProvider;
	private int _dragState = 0;
	private int _dragX0 = 0;
	private int _dragX = 0;
	private double _time0bak;
	private double _time1bak;
	private boolean _isInUpdate;

	public void setTimeProvider(ITimeDataProvider timeProvider) {
		_timeProvider = timeProvider;
	}

	private double _timeDeltaD;
	private long _timeDelta;
	private void calcTimeDelta(int width, double K) {
		long D[] = { 1, 2, 5, };
		long pow = 1;
		double powD = 0.000000001;
		long td = pow;
		double tdD = powD;
		double dx = tdD * K;
		int i = 0;
		while (dx < width) {
			td = D[i] * pow;
			tdD = D[i] * powD;
			dx = tdD * K;
			i++;
			if (i == 3) {
				i = 0;
				pow *= 10;
				powD *= 10;
			}
		}
		_timeDeltaD = tdD;
		_timeDelta = td;
	}

	static private TimeDraw _tds[] = new TimeDraw[] {
		new TimeDrawSec(),
		new TimeDrawMillisec(),
		new TimeDrawMicrosec(),
		new TimeDrawNanosec(),
	};
	
	static TimeDraw getTimeDraw(long timeDelta) {
		TimeDraw timeDraw;
		if (timeDelta >= 1000000000)
			timeDraw = _tds[0];
		else if (timeDelta >= 1000000)
			timeDraw = _tds[1];
		else if (timeDelta >= 1000) 
			timeDraw = _tds[2];
		else
			timeDraw = _tds[3];
		return timeDraw;
	}

	void paint(Rectangle rect, GC gc) {

		if (_isInUpdate || null == _timeProvider)
			return;

		if (null == _timeProvider) {
			gc.fillRectangle(rect);
			return;
		}

		gc.setBackground(_colors.getColor(TraceColorScheme.TOOL_BACKGROUND));
		gc.setForeground(_colors.getColor(TraceColorScheme.TOOL_FOREGROUND));
		double time0 = _timeProvider.getTime0();
		double time1 = _timeProvider.getTime1();
		double selectedTime = _timeProvider.getSelectedTime();
		int leftSpace = _timeProvider.getNameSpace();
		int timeSpace = _timeProvider.getTimeSpace();

		if (time1 <= time0) {
			gc.fillRectangle(rect);
			return;
		}
		double timeRange = time1 - time0;
		int numDigits = 8; // 11:222
		if (timeRange < .00001)
			numDigits = 16; // 11:222:333:444__
		else if (timeRange < .01)
			numDigits = 12; // 11:222:333__

		Utils.init(_rect1, rect);
		int labelWidth = gc.getCharWidth('0') * numDigits;
		double K = 1;
		if (rect.width - leftSpace > 0) {
			K = (double) timeSpace / (time1 - time0);
			calcTimeDelta(labelWidth, K);
		}
		TimeDraw timeDraw = getTimeDraw(_timeDelta);

		// draw top left area
		_rect1.width = leftSpace;
		gc.fillRectangle(_rect1);
		_rect1.x += 4;
		_rect1.width -= 4;
		if (_rect1.width > 0) {
			if (rect.width - leftSpace > 0)
				Utils.drawText(gc, "Time: " + timeDraw.hint(), _rect1, true);
			else
				Utils.drawText(gc, UIMessages.TIME_SCALE, _rect1, true);
		}
		_rect1.x -= 4;
		_rect1.width += 4;

		// prepare and draw right rect of the timescale
		_rect1.x += leftSpace;
		_rect1.width = rect.width - leftSpace;

		// draw bottom border and erase all other area
		gc.drawLine(rect.x, rect.y + rect.height - 1, rect.x + rect.width - 1,
				rect.y + rect.height - 1);
		_rect1.height--;
		gc.fillRectangle(_rect1);

		if (_rect1.isEmpty())
			return;

		// draw selected time
		int x = _rect1.x + (int) ((selectedTime - time0) * K);
		if (x >= _rect1.x && x < _rect1.x + _rect1.width) {
			gc.setForeground(_colors.getColor(TraceColorScheme.SELECTED_TIME));
			gc.drawLine(x, _rect1.y + _rect1.height - 6, x, _rect1.y + _rect1.height);
			gc.setForeground(_colors.getColor(TraceColorScheme.TOOL_FOREGROUND));
		}

		// draw time scale ticks
		_rect1.y = rect.y;
		_rect1.height = rect.height - 4;
		_rect1.width = labelWidth;
		double time = Math.floor(time0 / _timeDeltaD) * _timeDeltaD;
		long t = (long)(time * 1000000000);
		int y = _rect1.y + _rect1.height;
		while (true) {
			x = rect.x + leftSpace + (int) ((time - time0) * K);
			if (x >= rect.x + leftSpace + rect.width - _rect1.width) {
				break;
			}
			if (x >= rect.x + leftSpace) {
				gc.drawLine(x, y, x, y + 4);
				_rect1.x = x;
				if (x + _rect1.width <= rect.x + rect.width)
					timeDraw.draw(gc, t, _rect1);
			}
			time += _timeDeltaD;
			t += _timeDelta;
		}
	}

	public void mouseDown(MouseEvent e) {
		if (1 == e.button && null != _timeProvider) {
			setCapture(true);
			_dragState = 1;
			_dragX = _dragX0 = e.x - _timeProvider.getNameSpace();
			_time0bak = _timeProvider.getTime0();
			_time1bak = _timeProvider.getTime1();
		}
	}

	public void mouseUp(MouseEvent e) {
		if (1 == _dragState) {
			setCapture(false);
			_dragState = 0;
		}
	}

	public void mouseMove(MouseEvent e) {
		Point size = getSize();
		if (1 == _dragState && null != _timeProvider) {
			int leftSpace = _timeProvider.getNameSpace();
			int x = e.x - leftSpace;
			if (x > 0 && size.x > leftSpace && _dragX != x) {
				_dragX = x;
				double time1 = _time0bak + (_time1bak - _time0bak) * _dragX0 / _dragX;
				_timeProvider.setStartFinishTime(_time0bak, time1);
			}
		}
	}

	public void mouseDoubleClick(MouseEvent e) {
		if (null != _timeProvider) {
			_timeProvider.resetStartFinishTime();
		}
	}
}

abstract class TimeDraw {
	static String S = ":";
	static String S0 = ":0";
	static String S00 = ":00";

	static String pad(long n) {
		String s = S;
		if (n < 10)
			s = S00;
		else if (n < 100)
			s = S0;
		return s + n;
	}

	public abstract void draw(GC gc, long time, Rectangle rect);
	public abstract String hint();
}

class TimeDrawSec extends TimeDraw {
	static String _hint = "sec";

	public void draw(GC gc, long time, Rectangle rect) {
		time /= 1000000000;
		Utils.drawText(gc, time + "", rect, true);
	}

	public String hint() {
		return _hint;
	}
}

class TimeDrawMillisec extends TimeDraw {
	static String _hint = "s:ms";

	public void draw(GC gc, long time, Rectangle rect) {
		time /= 1000000;
		long ms = time % 1000;
		time /= 1000;
		Utils.drawText(gc, time + pad(ms), rect, true);
	}

	public String hint() {
		return _hint;
	}
}

class TimeDrawMicrosec extends TimeDraw {
	static String _hint = "s:ms:mcs";

	public void draw(GC gc, long time, Rectangle rect) {
		time /= 1000;
		long mcs = time % 1000;
		time /= 1000;
		long ms = time % 1000;
		time /= 1000;
		Utils.drawText(gc, time + pad(ms) + pad(mcs), rect, true);
	}

	public String hint() {
		return _hint;
	}
}

class TimeDrawNanosec extends TimeDraw {
	static String _hint = "s:ms:mcs:ns";

	public void draw(GC gc, long time, Rectangle rect) {
		long ns = time % 1000;
		time /= 1000;
		long mcs = time % 1000;
		time /= 1000;
		long ms = time % 1000;
		time /= 1000;
		Utils.drawText(gc, time + pad(ms) + pad(mcs) + pad(ns), rect, true);
	}

	public String hint() {
		return _hint;
	}
}




/*****************************************************************************
 * Copyright (c) 1997-2006, Intel Corporation.
 * 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:
 *    Intel Corporation - Initial API and implementation
 *    Ruslan A. Scherbakov, Intel - Initial API and implementation
 *
 * $Id$ 
 *****************************************************************************/

package org.eclipse.tptp.trace.jvmti.internal.client.widgets;

import org.eclipse.swt.SWT;
import org.eclipse.swt.graphics.Color;

public class TraceColorScheme {

	// state elements color indices
	static public final int UNKNOWN = 0;
	static public final int RUNNING = 1;
	static public final int SLEEPING = 2;
	static public final int WAITING = 3;
	static public final int BLOCKED = 4;
	static public final int DEADLOCK = 5;
	static public final int STOPPED = 6;

	static public final int STATES0 = 0;
	static public final int STATES1 = 7;

	// selected state elements color indices
	static public final int UNKNOWN_SEL = 7;
	static public final int RUNNING_SEL = 8;
	static public final int SLEEPING_SEL = 9;
	static public final int WAITING_SEL = 10;
	static public final int BLOCKED_SEL = 11;
	static public final int DEADLOCK_SEL = 12;
	static public final int STOPPED_SEL = 13;

	static public final int STATES_SEL0 = 7;
	static public final int STATES_SEL1 = 13;

	// colors indices for viewer controls
	static public final int BACKGROUND = 14;
	static public final int FOREGROUND = 15;
	static public final int BACKGROUND_SEL = 16;
	static public final int FOREGROUND_SEL = 17;
	static public final int BACKGROUND_SEL_NOFOCUS = 18;
	static public final int FOREGROUND_SEL_NOFOCUS = 19;
	static public final int TOOL_BACKGROUND = 20;
	static public final int TOOL_FOREGROUND = 21;

	// misc colors
	static public final int FIX_COLOR = 22;
	static public final int WHITE = 23;
	static public final int GRAY = 24;
	static public final int BLACK = 25;
	static public final int DARK_GRAY = 26;

	// selected state elements border color indices
	static public final int UNKNOWN_BORDER = 27;
	static public final int RUNNING_BORDER = 28;
	static public final int SLEEPING_BORDER = 29;
	static public final int WAITING_BORDER = 30;
	static public final int BLOCKED_BORDER = 31;
	static public final int DEADLOCK_BORDER = 32;
	static public final int STOPPED_BORDER = 33;

	static public final int STATES_BORDER0 = 27;
	static public final int STATES_BORDER1 = 33;

	static public final int MID_LINE = 34;
	static public final int RED = 35;
	static public final int GREEN = 36;
	static public final int BLUE = 37;
	static public final int YELLOW = 38;
	static public final int CYAN = 39;
	static public final int MAGENTA = 40;

	static public final int SELECTED_TIME = 41;
	static public final int LEGEND_BACKGROUND = 42;
	static public final int LEGEND_FOREGROUND = 43;

	// group items' colors
	static public final int GR_BACKGROUND = 44;
	static public final int GR_FOREGROUND = 45;
	static public final int GR_BACKGROUND_SEL = 46;
	static public final int GR_FOREGROUND_SEL = 47;
	static public final int GR_BACKGROUND_SEL_NOFOCUS = 48;
	static public final int GR_FOREGROUND_SEL_NOFOCUS = 49;
	
	static public final int LIGHT_LINE = 50;
	static public final int BACKGROUND_NAME = 51;

	static interface IColorProvider {
		public Color get();
	}

	static class SysCol implements IColorProvider {
		int syscol;

		SysCol(int syscol) {
			this.syscol = syscol;
		}

		public Color get() {
			return Utils.getSysColor(syscol);
		}
	}

	static class RGB implements IColorProvider {
		int r;
		int g;
		int b;

		RGB(int r, int g, int b) {
			this.r = r;
			this.g = g;
			this.b = b;
		}

		public Color get() {
			return new Color(null, r, g, b);
		}
	}

	static class Mix implements IColorProvider {
		IColorProvider cp1;
		IColorProvider cp2;
		int w1;
		int w2;

		Mix(IColorProvider cp1, IColorProvider cp2, int w1, int w2) {
			this.cp1 = cp1;
			this.cp2 = cp2;
			this.w1 = w1;
			this.w2 = w2;
		}

		Mix(IColorProvider cp1, IColorProvider cp2) {
			this.cp1 = cp1;
			this.cp2 = cp2;
			this.w1 = 1;
			this.w2 = 1;
		}

		public Color get() {
			Color col1 = cp1.get();
			Color col2 = cp2.get();
			Color col = Utils.mixColors(col1, col2, w1, w2);
			return col;
		}
	}

	static private final IColorProvider _providersMap[] = {
			//
			new RGB(100, 100, 100), // UNKNOWN
			new RGB(174, 200, 124), // RUNNING
			new Mix(new SysCol(SWT.COLOR_BLUE), new SysCol(SWT.COLOR_GRAY), 1, 3), // SLEEPING
			new RGB(210, 150, 60), // WAITING
			new RGB(242, 225, 168), // BLOCKED
			new Mix(new SysCol(SWT.COLOR_RED), new SysCol(SWT.COLOR_GRAY), 1, 3), // DEADLOCK
			new RGB(200, 200, 200), // STOPPED

			new SysCol(SWT.COLOR_WHITE), // UNKNOWN_SEL
			new SysCol(SWT.COLOR_GREEN), // RUNNING_SEL
			new SysCol(SWT.COLOR_BLUE), // SLEEPING_SEL
			new SysCol(SWT.COLOR_CYAN), // WAITING_SEL
			new SysCol(SWT.COLOR_YELLOW), // BLOCKED_SEL
			new SysCol(SWT.COLOR_RED), // DEADLOCK_SEL
			new SysCol(SWT.COLOR_DARK_GRAY), // STOPPED_SEL

			new SysCol(SWT.COLOR_LIST_BACKGROUND), // BACKGROUND
			new SysCol(SWT.COLOR_LIST_FOREGROUND), // FOREGROUND
			new SysCol(SWT.COLOR_LIST_SELECTION), // BACKGROUND_SEL
			new SysCol(SWT.COLOR_LIST_SELECTION_TEXT), // FOREGROUND_SEL
			new SysCol(SWT.COLOR_WIDGET_BACKGROUND), // BACKGROUND_SEL_NOFOCUS
			new SysCol(SWT.COLOR_WIDGET_FOREGROUND), // FOREGROUND_SEL_NOFOCUS
			new SysCol(SWT.COLOR_WIDGET_BACKGROUND), // TOOL_BACKGROUND
			new SysCol(SWT.COLOR_WIDGET_DARK_SHADOW), // TOOL_FOREGROUND

			new SysCol(SWT.COLOR_GRAY), // FIX_COLOR
			new SysCol(SWT.COLOR_WHITE), // WHITE
			new SysCol(SWT.COLOR_GRAY), // GRAY
			new SysCol(SWT.COLOR_BLACK), // BLACK
			new SysCol(SWT.COLOR_DARK_GRAY), // DARK_GRAY

			new SysCol(SWT.COLOR_DARK_GRAY), // UNKNOWN_BORDER
			new RGB(75, 115, 120), // RUNNING_BORDER
			new SysCol(SWT.COLOR_DARK_BLUE), // SLEEPING_BORDER
			new RGB(242, 225, 168), // WAITING_BORDER
			new RGB(210, 150, 60), // BLOCKED_BORDER
			new SysCol(SWT.COLOR_DARK_RED), // DEADLOCK_BORDER
			new SysCol(SWT.COLOR_BLACK), // STOPPED_BORDER

			new SysCol(SWT.COLOR_GRAY), // MID_LINE
			new SysCol(SWT.COLOR_RED), // RED
			new SysCol(SWT.COLOR_GREEN), // GREEN
			new SysCol(SWT.COLOR_BLUE), // BLUE
			new SysCol(SWT.COLOR_YELLOW), // YELLOW
			new SysCol(SWT.COLOR_CYAN), // CYAN
			new SysCol(SWT.COLOR_MAGENTA), // MAGENTA

			new SysCol(SWT.COLOR_BLUE), // SELECTED_TIME
			new SysCol(SWT.COLOR_WIDGET_BACKGROUND), // LEGEND_BACKGROUND
			new SysCol(SWT.COLOR_WIDGET_DARK_SHADOW), // LEGEND_FOREGROUND

			new Mix(new RGB(150, 200, 240), new SysCol(SWT.COLOR_LIST_BACKGROUND)),// GR_BACKGROUND
			new RGB(0, 0, 50), // GR_FOREGROUND
			new Mix(new RGB(200, 200, 100), new SysCol(SWT.COLOR_LIST_SELECTION)),  // GR_BACKGROUND_SEL
			new Mix(new RGB(150, 200, 240), new SysCol(SWT.COLOR_LIST_SELECTION_TEXT)), // GR_FOREGROUND_SEL
			new Mix(new RGB(222, 222, 155), new SysCol(SWT.COLOR_WIDGET_BACKGROUND)), // GR_BACKGROUND_SEL_NOFOCUS
			new RGB(0, 0, 50), // GR_FOREGROUND_SEL_NOFOCUS

			new Mix(new SysCol(SWT.COLOR_GRAY), new SysCol(SWT.COLOR_LIST_BACKGROUND), 1, 3), // LIGHT_LINE
			new Mix(new SysCol(SWT.COLOR_GRAY), new SysCol(SWT.COLOR_LIST_BACKGROUND), 1, 6), // BACKGROUND_NAME
	};

	private Color _colors[];

	public TraceColorScheme() {
		_colors = new Color[_providersMap.length];
	}

	public void dispose() {
		for (int i = 0; i < _colors.length; i++) {
			Utils.dispose(_colors[i]);
			_colors[i] = null;
		}
	}

	public Color getColor(int idx) {
		if (null == _colors[idx]) {
			if (idx >= STATES_SEL0 && idx <= STATES_SEL1) {
				Color col1 = getColor(idx - STATES_SEL0);
				Color col2 = getColor(BACKGROUND_SEL);
				_colors[idx] = Utils.mixColors(col1, col2, 3, 1);
			} else {
				_colors[idx] = _providersMap[idx].get();
			}
		}
		return _colors[idx];
	}

	public Color getBkColor(boolean selected, boolean focused, boolean name) {
		if (selected && focused)
			return getColor(BACKGROUND_SEL);
		if (selected)
			return getColor(BACKGROUND_SEL_NOFOCUS);
		if (name)
			return getColor(BACKGROUND_NAME);
		return getColor(BACKGROUND);
	}

	public Color getFgColor(boolean selected, boolean focused) {
		if (selected && focused)
			return getColor(FOREGROUND_SEL);
		if (selected)
			return getColor(FOREGROUND_SEL_NOFOCUS);
		return getColor(FOREGROUND);
	}

	public Color getBkColorGroup(boolean selected, boolean focused) {
		if (selected && focused)
			return getColor(GR_BACKGROUND_SEL);
		if (selected)
			return getColor(GR_BACKGROUND_SEL_NOFOCUS);
		return getColor(GR_BACKGROUND);
	}

	public Color getFgColorGroup(boolean selected, boolean focused) {
		if (selected && focused)
			return getColor(GR_FOREGROUND_SEL);
		if (selected)
			return getColor(GR_FOREGROUND_SEL_NOFOCUS);
		return getColor(GR_FOREGROUND);
	}
}




/*****************************************************************************
 * Copyright (c) 1997-2006, Intel Corporation.
 * 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:
 *    Intel Corporation - Initial API and implementation
 *    Ruslan A. Scherbakov, Intel - Initial API and implementation
 *
 * $Id$ 
 *****************************************************************************/

package org.eclipse.tptp.trace.jvmti.internal.client.widgets;

import org.eclipse.swt.SWT;
import org.eclipse.swt.events.PaintEvent;
import org.eclipse.swt.events.PaintListener;
import org.eclipse.swt.graphics.Color;
import org.eclipse.swt.graphics.GC;
import org.eclipse.swt.graphics.Point;
import org.eclipse.swt.graphics.Rectangle;
import org.eclipse.swt.widgets.Canvas;
import org.eclipse.swt.widgets.Composite;

public abstract class TraceCtrl extends Canvas implements PaintListener {

	protected TraceColorScheme _colors;
	protected Rectangle _rect0 = new Rectangle(0, 0, 0, 0);
	protected Rectangle _rect1 = new Rectangle(0, 0, 0, 0);

	public TraceCtrl(Composite parent, TraceColorScheme colors) {
		this(parent, colors, SWT.NO_BACKGROUND | SWT.NO_FOCUS);
	}

	public TraceCtrl(Composite parent, TraceColorScheme colors, int style) {
		super(parent, style);
		_colors = colors;
		addPaintListener(this);
	}

	public void dispose() {
		super.dispose();
	}

	public void paintControl(PaintEvent e) {
		if (e.widget != this)
			return;
		Point size = getSize();
		if (size.x > 0 && size.y > 0) {
			Color colBackup = e.gc.getBackground();
			Utils.init(_rect0, 0, 0, size.x, size.y);
			paint(_rect0, e.gc);
			e.gc.setBackground(colBackup);
		}
	}

	void paint(Rectangle rect, GC gc) {
		gc.setBackground(_colors.getColor(TraceColorScheme.BACKGROUND));
		gc.fillRectangle(rect);
	}
}




/*****************************************************************************
 * Copyright (c) 1997-2006, Intel Corporation.
 * 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:
 *    Intel Corporation - Initial API and implementation
 *    Ruslan A. Scherbakov, Intel - Initial API and implementation
 *
 * $Id$ 
 *****************************************************************************/

package org.eclipse.tptp.trace.jvmti.internal.client.widgets;

import org.eclipse.hyades.models.trace.TRCThreadDeadEvent;
import org.eclipse.hyades.models.trace.TRCThreadDeadLockEvent;
import org.eclipse.hyades.models.trace.TRCThreadEvent;
import org.eclipse.hyades.models.trace.TRCThreadRunningEvent;
import org.eclipse.hyades.models.trace.TRCThreadSleepingEvent;
import org.eclipse.hyades.models.trace.TRCThreadWaitingForLockEvent;
import org.eclipse.hyades.models.trace.TRCThreadWaitingForObjectEvent;
import org.eclipse.swt.SWT;
import org.eclipse.swt.graphics.Color;
import org.eclipse.swt.graphics.Device;
import org.eclipse.swt.graphics.GC;
import org.eclipse.swt.graphics.Point;
import org.eclipse.swt.graphics.Rectangle;
import org.eclipse.swt.widgets.Display;

public class Utils {

	static public void init(Rectangle rect) {
		rect.x = 0;
		rect.y = 0;
		rect.width = 0;
		rect.height = 0;
	}

	static public void init(Rectangle rect, int x, int y, int width, int height) {
		rect.x = x;
		rect.y = y;
		rect.width = width;
		rect.height = height;
	}

	static public void init(Rectangle rect, Rectangle source) {
		rect.x = source.x;
		rect.y = source.y;
		rect.width = source.width;
		rect.height = source.height;
	}

	static public void deflate(Rectangle rect, int x, int y) {
		rect.x += x;
		rect.y += y;
		rect.width -= x + x;
		rect.height -= y + y;
	}

	static public void inflate(Rectangle rect, int x, int y) {
		rect.x -= x;
		rect.y -= y;
		rect.width += x + x;
		rect.height += y + y;
	}

	static void dispose(Color col) {
		if (null != col)
			col.dispose();
	}

	static public Color mixColors(Device display, Color c1, Color c2, int w1,
			int w2) {
		return new Color(display, (w1 * c1.getRed() + w2 * c2.getRed())
				/ (w1 + w2), (w1 * c1.getGreen() + w2 * c2.getGreen())
				/ (w1 + w2), (w1 * c1.getBlue() + w2 * c2.getBlue())
				/ (w1 + w2));
	}

	static public Color getSysColor(int id) {
		return Display.getCurrent().getSystemColor(id);
	}

	static public Color mixColors(Color col1, Color col2, int w1, int w2) {
		return mixColors(Display.getCurrent(), col1, col2, w1, w2);
	}

	static public void drawState(TraceColorScheme colors, TRCThreadEvent event,
			Rectangle rect, GC gc, boolean selected, boolean rectBound, boolean timeSelected) {
		int colorIdx = getEventColor(event);
		drawState(colors, colorIdx, rect, gc, selected, rectBound, timeSelected);
	}

	static public void drawState(TraceColorScheme colors, int colorIdx,
			Rectangle rect, GC gc, boolean selected, boolean rectBound, boolean timeSelected) {
		if (rect.isEmpty())
			return;
		// FILL RECT
		int colorIdx1 = colorIdx;
		timeSelected = timeSelected && selected;
		if (selected)
			colorIdx1 = colorIdx + TraceColorScheme.STATES_SEL0 - TraceColorScheme.STATES0;
		gc.setBackground(colors.getColor(colorIdx1));
		gc.fillRectangle(rect);
		colorIdx1 = colorIdx + TraceColorScheme.STATES_BORDER0 - TraceColorScheme.STATES0;
		gc.setForeground(colors.getColor(colorIdx1));
		// DRAW BOUNDS
		if (!timeSelected) {
			if (rectBound && rect.width >= 3) {
				gc.drawRectangle(rect.x, rect.y, rect.width - 1, rect.height - 1);
			} else {
				gc.drawLine(rect.x, rect.y, rect.x + rect.width - 1, rect.y);
				gc.drawLine(rect.x, rect.y + rect.height - 1, rect.x + rect.width - 1, rect.y + rect.height - 1);
			}
		}
		// DRAW MID LINE
		int mindy = rect.y + rect.height / 2;
		if (TraceColorScheme.BLOCKED == colorIdx || TraceColorScheme.WAITING == colorIdx) {
			int s = gc.getLineStyle();
			int w = gc.getLineWidth();
			gc.setLineStyle(SWT.LINE_DOT);
			gc.setLineWidth(2);
			gc.drawLine(rect.x, mindy, rect.x + rect.width, mindy);
			gc.setLineStyle(s);
			gc.setLineWidth(w);
		} else if (TraceColorScheme.DEADLOCK == colorIdx || TraceColorScheme.STOPPED == colorIdx) {
			int w = gc.getLineWidth();
			gc.setLineWidth(2);
			gc.drawLine(rect.x, mindy, rect.x + rect.width, mindy);
			gc.setLineWidth(w);
		}
		// DRAW SELECTED BOUNDS
		if (timeSelected) {
			if (rect.width >= 3) {
				gc.setForeground(colors.getColor(TraceColorScheme.SELECTED_TIME));
				gc.drawRectangle(rect.x, rect.y, rect.width - 1, rect.height - 1);
				//gc.drawRectangle(rect.x + 1, rect.y + 1, rect.width - 3, rect.height - 3);
			} else {
				gc.drawLine(rect.x, rect.y, rect.x + rect.width - 1, rect.y);
				gc.drawLine(rect.x, rect.y + rect.height - 1, rect.x + rect.width - 1, rect.y + rect.height - 1);				
			}
		}
	}

	static public int getEventColor(TRCThreadEvent event) {
		if (event instanceof TRCThreadRunningEvent)
			return TraceColorScheme.RUNNING;
		else if (event instanceof TRCThreadSleepingEvent)
			return TraceColorScheme.SLEEPING;
		else if (event instanceof TRCThreadDeadLockEvent)
			return TraceColorScheme.DEADLOCK;
		else if (event instanceof TRCThreadWaitingForLockEvent)
			return TraceColorScheme.BLOCKED;
		else if (event instanceof TRCThreadWaitingForObjectEvent)
			return TraceColorScheme.WAITING;
		else if (event instanceof TRCThreadDeadEvent)
			return TraceColorScheme.STOPPED;
		return TraceColorScheme.UNKNOWN;
	}

	static public int drawText(GC gc, String text, Rectangle rect, boolean transp) {
		Point size = gc.stringExtent(text);
		gc.drawText(text, rect.x, rect.y, transp);
		return size.x;
	}
}

Return to bug 167609

Line 104 Link Here

(-)CVS (+35 lines)
	104	<view
	105	category="org.eclipse.hyades.trace.internal.ui.trace"
	106	class="org.eclipse.tptp.trace.jvmti.internal.client.views.ThreadStatesViewer"
	107	id="org.eclipse.tptp.trace.jvmti.internal.client.views.ThreadStatesViewer"
	108	name="Thread States"/>
	109	<view
	110	class="org.eclipse.tptp.trace.jvmti.internal.client.views.CallStackViewer"
	111	id="org.eclipse.tptp.trace.jvmti.internal.client.views.CallStackView"
	112	name="Call Stack">
	113	</view>
Line 116 Link Here
	126	<view
	127	id="org.eclipse.tptp.trace.jvmti.internal.client.views.ThreadStatesViewer"
	128	relationship="stack"
	129	relative="org.eclipse.hyades.trace.views.adapter.internal.ExecutionStatisticViewer2"
	130	visible="false">
	131	</view>
	132	<view
	133	id="org.eclipse.tptp.trace.jvmti.internal.client.views.CallStackViewer"
	134	relationship="bottom"
	135	relative="org.eclipse.tptp.trace.jvmti.internal.client.views.ThreadStatesViewer"
	136	visible="false">
	137	</view>
Line 132 Link Here
	154	</action>
	155	<action
	156	class="org.eclipse.tptp.trace.jvmti.internal.client.views.OpenThreadStatesViewAction"
	157	id="org.eclipse.tptp.trace.jvmti.internal.client.views.OpenThreadStatesViewAction"
	158	label="Thread States"
	159	style="push"
	160	toolbarPath="trace/group.statistic"/>
	161	<action
	162	class="org.eclipse.tptp.trace.jvmti.internal.client.views.OpenCallStackViewAction"
	163	id="org.eclipse.tptp.trace.jvmti.internal.client.views.OpenCallStackViewAction"
	164	label="Call Stack"
	165	style="push"
	166	toolbarPath="trace/group.statistic">

Line 1 Link Here

(-)CVS (+280 lines)
		1	/*****************************************************************************
		2	* Copyright (c) 1997-2006, Intel Corporation.
		3	* All rights reserved. This program and the accompanying materials
		4	* are made available under the terms of the Eclipse Public License v1.0
		5	* which accompanies this distribution, and is available at
		6	* http://www.eclipse.org/legal/epl-v10.html
		7	*
		8	* Contributors:
		9	* Intel Corporation - Initial API and implementation
		10	* Ruslan A. Scherbakov, Intel - Initial API and implementation
		11	*
		12	* $Id$
		13	*****************************************************************************/
		14
		15	package org.eclipse.tptp.trace.jvmti.internal.client.views;
		16
		17	import java.util.ArrayList;
		18
		19	import org.eclipse.emf.common.util.EList;
		20	import org.eclipse.hyades.models.trace.TRCMethod;
		21	import org.eclipse.hyades.models.trace.TRCMethodInvocation;
		22	import org.eclipse.hyades.models.trace.TRCThread;
		23	import org.eclipse.hyades.models.trace.TRCThreadDeadEvent;
		24	import org.eclipse.hyades.models.trace.TRCThreadDeadLockEvent;
		25	import org.eclipse.hyades.models.trace.TRCThreadEvent;
		26	import org.eclipse.hyades.models.trace.TRCThreadRunningEvent;
		27	import org.eclipse.hyades.models.trace.TRCThreadSleepingEvent;
		28	import org.eclipse.hyades.models.trace.TRCThreadWaitingForLockEvent;
		29	import org.eclipse.hyades.models.trace.TRCThreadWaitingForObjectEvent;
		30	import org.eclipse.hyades.trace.ui.IViewSelectionChangedListener;
		31	import org.eclipse.hyades.trace.ui.UIPlugin;
		32	import org.eclipse.hyades.trace.ui.ViewSelectionChangedEvent;
		33	import org.eclipse.hyades.trace.views.util.internal.OpenSource;
		34	import org.eclipse.jface.viewers.DoubleClickEvent;
		35	import org.eclipse.jface.viewers.IDoubleClickListener;
		36	import org.eclipse.jface.viewers.IStructuredSelection;
		37	import org.eclipse.jface.viewers.ITreeContentProvider;
		38	import org.eclipse.jface.viewers.LabelProvider;
		39	import org.eclipse.jface.viewers.TreeSelection;
		40	import org.eclipse.jface.viewers.TreeViewer;
		41	import org.eclipse.jface.viewers.Viewer;
		42	import org.eclipse.swt.SWT;
		43	import org.eclipse.swt.graphics.Image;
		44	import org.eclipse.swt.widgets.Composite;
		45	import org.eclipse.ui.ISharedImages;
		46	import org.eclipse.ui.PlatformUI;
		47	import org.eclipse.ui.part.ViewPart;
		48
		49	public class CallStackViewer extends ViewPart implements
		50	IViewSelectionChangedListener {
		51
		52	private TreeViewer _calStackCtrl;
		53	private Object _selection;
		54
		55	public CallStackViewer() {
		56	}
		57
		58	public void createPartControl(Composite parent) {
		59	_calStackCtrl = new TreeViewer(parent, SWT.H_SCROLL \| SWT.V_SCROLL
		60	\| SWT.FULL_SELECTION \| SWT.SINGLE);
		61	_calStackCtrl.setContentProvider(new CallStackContentProvider());
		62	_calStackCtrl.setLabelProvider(new CallStackLabelProvider());
		63	_calStackCtrl.setInput(this);
		64	_calStackCtrl.addDoubleClickListener(new IDoubleClickListener() {
65	public void doubleClick(DoubleClickEvent event) {
66	OpenSource.openSource(getFirstSelectedElement());
67	}
68	});
69	UIPlugin.getDefault().addViewSelectionChangedListener(this);
70	UIPlugin.getDefault().getViewSelectionChangedEvent();
71	}
72
73	public void setFocus() {
74	if (null != _calStackCtrl)
75	_calStackCtrl.getControl().setFocus();
76	}
77
78	public void dispose() {
79	UIPlugin.getDefault().removeViewSelectionChangedListener(this);
80	super.dispose();
81	}
82
83	public Object getFirstSelectedElement() {
84	Object obj = null;
85	if (null != _calStackCtrl)
86	obj = ((TreeSelection) _calStackCtrl.getSelection())
87	.getFirstElement();
88	return obj;
89	}
90
91	/** update view content */
92	void update(Object selection) {
93	if (null == _calStackCtrl)
94	return;
95	_selection = selection;
96	_calStackCtrl.refresh();
97	}
98
99	public void handleObjectChanged(Object sel) {
100	update(sel);
101	}
102
103	/**
104	* Compose String name for TRCMethodInvocation
105	*
106	* @param method
107	* @return
108	*/
109	static String methodName(TRCMethodInvocation method) {
110	TRCMethod m = method.getMethod();
111	String name = "";
112	name += m.getDefiningClass().getName();
113	name += ".";
114	name += m.getName();
115	name += m.getSignature();
116	name += " [" + m.getCalls() + "]";
117	return name;
118	}
119
120	/**
121	* Compose String name for TRCThread
122	*
123	* @param thread
124	* @return
125	*/
126	static String threadName(TRCThread thread) {
127	String name = thread.getName();
128	name += " [" + thread.getGroupName() + "]";
129	return name;
130	}
131
132	static String getEventName(TRCThreadEvent event) {
133	if (event instanceof TRCThreadRunningEvent) {
134	return "RUNNING";
135	} else if (event instanceof TRCThreadSleepingEvent) {
136	return "SLEEPING";
137	} else if (event instanceof TRCThreadDeadLockEvent) {
138	return "DEADLOCK";
139	} else if (event instanceof TRCThreadWaitingForLockEvent) {
140	return "BLOCKED";
141	} else if (event instanceof TRCThreadWaitingForObjectEvent) {
142	return "WAITING";
143	} else if (event instanceof TRCThreadDeadEvent) {
144	return "STOPPED";
145	}
146	return "UNKNOWN";
147	}
148
149	/**
150	* Compose String name for TRCThreadEvent
151	*
152	* @param event
153	* @return
154	*/
155	static String eventName(TRCThreadEvent event) {
156	String name = event.getThread().getName();
157	name += " [" + event.getThread().getGroupName() + "] State: " + getEventName(event);
158	if (event instanceof TRCThreadWaitingForObjectEvent) {
159	name += " Timeout=" + ((TRCThreadWaitingForObjectEvent)event).getTimeout();
160	} else if (event instanceof TRCThreadWaitingForLockEvent) {
161	TRCThread thread = ((TRCThreadWaitingForLockEvent)event).getLockingThread();
162	if (null != thread)
163	name += " by Thread=" + thread.getName();
164	}
165	return name;
166	}
167
168	/**
169	* Compose String name from object
170	*
171	* @param obj
172	* @return
173	*/
174	public String getItemText(Object obj) {
175	if (obj instanceof TRCMethodInvocation) {
176	return methodName((TRCMethodInvocation) obj);
177	}
178	if (obj instanceof TRCThread) {
179	return threadName((TRCThread) obj);
180	}
181	if (obj instanceof TRCThreadEvent) {
182	return eventName((TRCThreadEvent) obj);
183	}
184	return obj.toString();
185	}
186
187	/**
188	* Icon image for object.
189	*
190	* @param obj
191	* @return
192	*/
193	public Image getItemImage(Object obj) {
194	Image img = null;
195	String imageKey = ISharedImages.IMG_OBJ_ELEMENT;
196	if (obj instanceof TRCMethodInvocation) {
197	imageKey = ISharedImages.IMG_OBJ_FILE;
198	}
199	if (null == img) {
200	img = PlatformUI.getWorkbench().getSharedImages()
201	.getImage(imageKey);
202	}
203	return img;
204	}
205
206	static final Object[] empty = new Object[0];
207
208	class CallStackContentProvider implements ITreeContentProvider {
209
210	public void inputChanged(Viewer v, Object oldInput, Object newInput) {
211	}
212
213	public void dispose() {
214	}
215
216	public Object[] getElements(Object parent) {
217	Object[] ret = empty;
218	if (null != _selection)
219	ret = new Object[] { _selection };
220	return ret;
221	}
222
223	public Object[] getChildren(Object parentElement) {
224	Object[] ret = empty;
225	if (parentElement instanceof TRCThread) {
226	TRCThread thread = (TRCThread) parentElement;
227	TRCMethodInvocation mi;
228	ArrayList arrlist = new ArrayList();
229	EList list = thread.getInitialInvocations();
230	while (list != null && !list.isEmpty()) {
231	mi = (TRCMethodInvocation) list.get(list.size() - 1);
232	arrlist.add(mi);
233	list = mi.getInvokes();
234	}
235	ret = arrlist.toArray();
236	} else if (parentElement instanceof TRCThreadEvent) {
237	// TODO: CS from event
238	ret = new String[] { "Placeholder for EVENT's call stack...", };
239	}
240	return ret;
241	}
242
243	public Object getParent(Object element) {
244	return null;
245	}
246
247	public boolean hasChildren(Object element) {
248	boolean ret = false;
249	if (element instanceof TRCThread) {
250	ret = true;
251	} else if (element instanceof TRCThreadEvent) {
252	ret = true;
253	}
254	return ret;
255	}
256	}
257
258	class CallStackLabelProvider extends LabelProvider {
259	public String getText(Object obj) {
260	return getItemText(obj);
261	}
262
263	public Image getImage(Object obj) {
264	return getItemImage(obj);
265	}
266	}
267
268	public void handleViewSelectionChangedEvent(ViewSelectionChangedEvent event) {
269	Object source = event.getSource();
270	if (source instanceof ThreadStatisticView) {
271	ThreadStatisticView view = (ThreadStatisticView) source;
272	TRCThread thread = view.getSelectedThread();
273	update(thread);
274	} else if (source instanceof ThreadStatesPage) {
275	ThreadStatesPage page = (ThreadStatesPage) source;
276	IStructuredSelection sel = (IStructuredSelection) page.getSelection();
277	update(sel.getFirstElement());
278	}
279	}
280	}

Line 1 Link Here

(-)CVS (+76 lines)
		1	/*****************************************************************************
		2	* Copyright (c) 1997-2006, Intel Corporation.
		3	* All rights reserved. This program and the accompanying materials
		4	* are made available under the terms of the Eclipse Public License v1.0
		5	* which accompanies this distribution, and is available at
		6	* http://www.eclipse.org/legal/epl-v10.html
		7	*
		8	* Contributors:
		9	* Intel Corporation - Initial API and implementation
		10	* Ruslan A. Scherbakov, Intel - Initial API and implementation
		11	*
		12	* $Id$
		13	*****************************************************************************/
		14
		15	package org.eclipse.tptp.trace.jvmti.internal.client.views;
		16
		17	import org.eclipse.core.resources.IResourceStatus;
		18	import org.eclipse.core.resources.ResourcesPlugin;
		19	import org.eclipse.core.runtime.Status;
		20	import org.eclipse.hyades.trace.ui.UIPlugin;
		21	import org.eclipse.hyades.trace.views.actions.internal.OpenTraceViewAction;
		22	import org.eclipse.hyades.trace.views.internal.TraceUIMessages;
		23	import org.eclipse.jface.action.IAction;
		24	import org.eclipse.jface.dialogs.ErrorDialog;
		25	import org.eclipse.jface.resource.ImageDescriptor;
		26	import org.eclipse.ui.IWorkbenchWindow;
		27
		28	public class OpenCallStackViewAction extends OpenTraceViewAction {
		29
		30	static final String VIEW_ID = "org.eclipse.tptp.trace.jvmti.internal.client.views.CallStackView";
		31
		32	public OpenCallStackViewAction() {
		33	super("");
		34	}
		35
		36	public OpenCallStackViewAction(String label) {
		37	super(label);
		38	}
		39
		40	public OpenCallStackViewAction(String label, ImageDescriptor image) {
		41	super(label, image);
		42	}
		43
		44	public boolean isVisibleForType(Object mofObject) {
		45	return true;
		46	}
		47
		48	static public void openCallStackView(boolean showError) {
		49	IWorkbenchWindow window = UIPlugin.getDefault().getWorkbench()
		50	.getActiveWorkbenchWindow();
		51	try {
		52	UIPlugin.getActivePage().showView(VIEW_ID);
		53	} catch (Exception e) {
		54	if (showError) {
		55	String msg = TraceUIMessages._3;
		56	Status err = new Status(Status.WARNING,
		57	ResourcesPlugin.PI_RESOURCES,
		58	IResourceStatus.INTERNAL_ERROR, e.toString(), null);
		59	ErrorDialog.openError(window.getShell(), msg, "", err);
		60	}
		61	e.printStackTrace();
		62	}
		63	}
		64
65	public void run() {
66	openCallStackView(true);
67	}
68
69	public void run(IAction action) {
70	run();
71	}
72
73	public String getViewID() {
74	return VIEW_ID;
75	}
76	}

Line 1 Link Here

(-)CVS (+78 lines)
		1	/*****************************************************************************
		2	* Copyright (c) 1997-2006, Intel Corporation.
		3	* All rights reserved. This program and the accompanying materials
		4	* are made available under the terms of the Eclipse Public License v1.0
		5	* which accompanies this distribution, and is available at
		6	* http://www.eclipse.org/legal/epl-v10.html
		7	*
		8	* Contributors:
		9	* Intel Corporation - Initial API and implementation
		10	* Ruslan A. Scherbakov, Intel - Initial API and implementation
		11	*
		12	* $Id$
		13	*****************************************************************************/
		14
		15	package org.eclipse.tptp.trace.jvmti.internal.client.views;
		16
		17	import org.eclipse.core.resources.IResourceStatus;
		18	import org.eclipse.core.resources.ResourcesPlugin;
		19	import org.eclipse.core.runtime.Status;
		20	import org.eclipse.hyades.trace.ui.TraceViewer;
		21	import org.eclipse.hyades.trace.ui.UIPlugin;
		22	import org.eclipse.hyades.trace.views.actions.internal.OpenTraceViewAction;
		23	import org.eclipse.hyades.trace.views.internal.TraceUIMessages;
		24	import org.eclipse.jface.action.IAction;
		25	import org.eclipse.jface.dialogs.ErrorDialog;
		26	import org.eclipse.jface.resource.ImageDescriptor;
		27	import org.eclipse.ui.IViewPart;
		28	import org.eclipse.ui.IWorkbenchPage;
		29	import org.eclipse.ui.IWorkbenchWindow;
		30
		31	public class OpenThreadStatesViewAction extends OpenTraceViewAction {
		32
		33	private final String VIEW_ID = "org.eclipse.tptp.trace.jvmti.internal.client.views.ThreadStatesViewer";
		34
		35	public OpenThreadStatesViewAction() {
		36	super("");
		37	}
		38
		39	public OpenThreadStatesViewAction(String label) {
		40	super(label);
		41	}
		42
		43	public OpenThreadStatesViewAction(String label, ImageDescriptor image) {
		44	super(label, image);
		45	}
		46
		47	public boolean isVisibleForType(Object mofObject) {
		48	return true;
		49	}
		50
		51	public void run() {
		52	IWorkbenchWindow window = UIPlugin.getDefault().getWorkbench()
		53	.getActiveWorkbenchWindow();
		54	try {
		55	IWorkbenchPage persp = UIPlugin.getActivePage();
		56	IViewPart view = persp.showView(VIEW_ID);
		57	if (view != null && view instanceof TraceViewer) {
		58	((TraceViewer) view).addViewPage(getMofObject(), true);
		59	}
		60	} catch (Exception e) {
		61	String msg = TraceUIMessages._3;
		62	Status err = new Status(Status.WARNING,
		63	ResourcesPlugin.PI_RESOURCES,
		64	IResourceStatus.INTERNAL_ERROR, e.toString(), null);
65	ErrorDialog.openError(window.getShell(), msg, "", err);
66	e.printStackTrace();
67	}
68
69	}
70
71	public void run(IAction action) {
72	run();
73	}
74
75	public String getViewID() {
76	return VIEW_ID;
77	}
78	}

Line 1 Link Here

(-)CVS (+319 lines)
		1	/*****************************************************************************
		2	* Copyright (c) 1997-2006, Intel Corporation.
		3	* All rights reserved. This program and the accompanying materials
		4	* are made available under the terms of the Eclipse Public License v1.0
		5	* which accompanies this distribution, and is available at
		6	* http://www.eclipse.org/legal/epl-v10.html
		7	*
		8	* Contributors:
		9	* Intel Corporation - Initial API and implementation
		10	* Ruslan A. Scherbakov, Intel - Initial API and implementation
		11	*
		12	* $Id$
		13	*****************************************************************************/
		14
		15	package org.eclipse.tptp.trace.jvmti.internal.client.views;
		16
		17	import org.eclipse.emf.common.util.EList;
		18	import org.eclipse.emf.ecore.EObject;
		19	import org.eclipse.hyades.models.trace.TRCThread;
		20	import org.eclipse.hyades.models.trace.TRCThreadEvent;
		21	import org.eclipse.hyades.trace.ui.TraceViewer;
		22	import org.eclipse.hyades.trace.ui.TraceViewerPage;
		23	import org.eclipse.hyades.trace.ui.UIPlugin;
		24	import org.eclipse.hyades.trace.ui.ViewSelectionChangedEvent;
		25	import org.eclipse.hyades.trace.ui.internal.util.PerftraceUtil;
		26	import org.eclipse.jface.viewers.ISelection;
		27	import org.eclipse.jface.viewers.IStructuredSelection;
		28	import org.eclipse.swt.SWT;
		29	import org.eclipse.swt.events.ControlAdapter;
		30	import org.eclipse.swt.events.ControlEvent;
		31	import org.eclipse.swt.events.PaintEvent;
		32	import org.eclipse.swt.events.SelectionEvent;
		33	import org.eclipse.swt.events.SelectionListener;
		34	import org.eclipse.swt.graphics.Rectangle;
		35	import org.eclipse.swt.widgets.Composite;
		36	import org.eclipse.swt.widgets.Control;
		37	import org.eclipse.tptp.trace.jvmti.internal.client.widgets.ITimeDataProvider;
		38	import org.eclipse.tptp.trace.jvmti.internal.client.widgets.LegendCtrl;
		39	import org.eclipse.tptp.trace.jvmti.internal.client.widgets.ThreadStatesCtrl;
		40	import org.eclipse.tptp.trace.jvmti.internal.client.widgets.TimeScaleCtrl;
		41	import org.eclipse.tptp.trace.jvmti.internal.client.widgets.TraceColorScheme;
		42
		43	public class ThreadStatesPage extends TraceViewerPage implements
		44	ITimeDataProvider, SelectionListener {
		45
		46	/* vars */
		47	double _minTimeInterval = .000001;
		48	double _selectedTime = -1;
		49	double _beginTime = 0;
		50	double _endTime = 0;
		51	double _time0 = 0;
		52	double _time1 = 0;
		53	double _time0_ = 0;
		54	double _time1_ = 0;
		55	double _time1bak = 0;
		56	double _timeStep = 0.01;
		57	boolean _timeRangeFixed = false;
		58	private int _nameWidth = 96;
		59	private int _legendHeight = 22;
		60	private int _timeScaleHeight = 22;
		61	private Composite _viewContainer;
		62	private ThreadStatesCtrl _stateCtrl;
		63	private LegendCtrl _legendCtrl;
		64	private TimeScaleCtrl _timeScaleCtrl;
65	static TraceColorScheme _colors = new TraceColorScheme();
66
67	/** ctor */
68	public ThreadStatesPage(EObject mofObject, TraceViewer viewer) {
69	super(mofObject, viewer);
70	}
71
72	/** Refresher */
73	public void refreshPage() {
74	if (null != _stateCtrl) {
75	refreshData();
76	_stateCtrl.redraw();
77	_timeScaleCtrl.redraw();
78	}
79	}
80
81	public void selectionChanged() {
82	}
83
84	public void update(boolean newPage) {
85	refreshPage();
86	}
87
88	public void createControl(Composite parent) {
89	_viewContainer = new Composite(parent, SWT.NULL);
90	_legendCtrl = new LegendCtrl(_viewContainer, _colors);
91	_timeScaleCtrl = new TimeScaleCtrl(_viewContainer, _colors);
92	_timeScaleCtrl.setTimeProvider(this);
93	_stateCtrl = new ThreadStatesCtrl(_viewContainer, _colors);
94	_stateCtrl.setTimeProvider(this);
95	_stateCtrl.addSelectionListener(this);
96	_viewContainer.addControlListener(new ControlAdapter() {
97	public void controlResized(ControlEvent event) {
98	Rectangle r = _viewContainer.getClientArea();
99	_legendCtrl.setBounds(r.x, r.y, r.width, _legendHeight);
100	_timeScaleCtrl.setBounds(r.x, r.y + _legendHeight, r.width,
101	_timeScaleHeight);
102	_stateCtrl.setBounds(r.x, r.y + _legendHeight
103	+ _timeScaleHeight, r.width, r.height - _legendHeight
104	- _timeScaleHeight);
105	}
106	});
107	}
108
109	public void dispose() {
110	_stateCtrl.dispose();
111	_legendCtrl.dispose();
112	_viewContainer.dispose();
113	_colors.dispose();
114	super.dispose();
115	}
116
117	/** Tries to set most convinient time range for display. */
118	void setTimeRange(Object threads[]) {
119	_endTime = 0;
120	_beginTime = -1;
121	TRCThreadEvent event;
122	for (int i = 0; i < threads.length; i++) {
123	TRCThread thread = (TRCThread) threads[i];
124	double lastEventTime = thread.getStopTime();
125	if (lastEventTime > thread.getStartTime()) {
126	if (lastEventTime > _endTime)
127	_endTime = lastEventTime;
128	}
129	EList list = thread.getThreadEvents();
130	int len = list.size();
131	if (len > 0) {
132	event = (TRCThreadEvent) list.get(list.size() - 1);
133	lastEventTime = event.getTime();
134	if (lastEventTime > _endTime)
135	_endTime = lastEventTime;
136	event = (TRCThreadEvent) list.get(0);
137	if (_beginTime < 0 \|\| _beginTime > event.getTime())
138	_beginTime = event.getTime();
139	}
140	}
141	_endTime += 0.1;
142	if (_beginTime < 0)
143	_beginTime = 0;
144	}
145
146	void setTimeBounds() {
147	_time0_ = _beginTime - (_endTime - _beginTime) * 0.05;
148	if (_time0_ < 0)
149	_time0_ = 0;
150	_time1_ = _time0_ + (_endTime - _time0_) * 1.05;
151	_time0_ = Math.floor(_time0_);
152	_time1_ = Math.ceil(_time1_);
153	if (!_timeRangeFixed) {
154	_time0 = _time0_;
155	_time1 = _time1_;
156	}
157	}
158
159	void refreshData() {
160	Object threads[] = PerftraceUtil.getAllThreads(getMOFObject(), false);
161	if (null == threads)
162	threads = new TRCThread[0];
163	setTimeRange(threads);
164	setTimeBounds();
165	if (_selectedTime < 0 \|\| _selectedTime > _endTime)
166	_selectedTime = _endTime;
167	_stateCtrl.refreshData(threads);
168	}
169
170	public Control getControl() {
171	return _viewContainer;
172	}
173
174	public void setFocus() {
175	if (null != _stateCtrl)
176	_stateCtrl.setFocus();
177	}
178
179	public TRCThread getSelectedThread() {
180	return _stateCtrl.getSelectedThread();
181	}
182
183	public ISelection getSelection() {
184	return _stateCtrl.getSelection();
185	}
186
187	public double getTime0() {
188	return _time0;
189	}
190
191	public double getTime1() {
192	return _time1;
193	}
194
195	public double getMinTimeInterval() {
196	return _minTimeInterval;
197	}
198
199	public int getNameSpace() {
200	return _nameWidth;
201	}
202
203	public int getTimeSpace() {
204	int w = _stateCtrl.getClientArea().width;
205	return w - _nameWidth;
206	}
207
208	public double getSelectedTime() {
209	return _selectedTime;
210	}
211
212	public double getBeginTime() {
213	return _beginTime;
214	}
215
216	public double getEndTime() {
217	return _endTime;
218	}
219
220	public double getMaxTime() {
221	return _time1_;
222	}
223
224	public double getMinTime() {
225	return _time0_;
226	}
227
228	public void setStartFinishTime(double time0, double time1) {
229	_time0 = time0;
230	if (_time0 < 0)
231	_time0 = 0;
232	_time1 = time1;
233	if (_time1 - _time0 < _minTimeInterval)
234	_time1 = _time0 + _minTimeInterval;
235	if (_time1 > _time1_)
236	_time1 = _time1_;
237	_timeRangeFixed = true;
238	_stateCtrl.adjustScrolls();
239	_stateCtrl.redraw();
240	_timeScaleCtrl.redraw();
241	}
242
243	public void resetStartFinishTime() {
244	_timeRangeFixed = false;
245	_time0 = _time0_;
246	_time1 = _time1_;
247	_stateCtrl.adjustScrolls();
248	_stateCtrl.redraw();
249	_timeScaleCtrl.redraw();
250	}
251
252	public void paintControl(PaintEvent e) {
253	}
254
255	public void setSelectedTime(double time, boolean ensureVisible) {
256	_selectedTime = time;
257	if (_selectedTime > _endTime)
258	_selectedTime = _endTime;
259	if (_selectedTime < _beginTime)
260	_selectedTime = _beginTime;
261	if (ensureVisible) {
262	double timeSpace = (_time1 - _time0) * .1;
263	double timeMid = (_time1 - _time0) * .5;
264	if (_selectedTime < _time0 + timeSpace) {
265	double dt = _time0 - _selectedTime + timeMid;
266	_time0 -= dt;
267	_time1 -= dt;
268	} else if (_selectedTime > _time1 - timeSpace) {
269	double dt = _selectedTime - _time1 + timeMid;
270	_time0 += dt;
271	_time1 += dt;
272	}
273	if (_time0 < 0) {
274	_time1 -= _time0;
275	_time0 = 0;
276	} else if (_time1 > _time1_) {
277	_time0 += _time1 - _time1_;
278	_time1 = _time1_;
279	}
280	}
281	_stateCtrl.adjustScrolls();
282	_stateCtrl.redraw();
283	_timeScaleCtrl.redraw();
284	}
285
286	public void updateModelSelection() {
287	ISelection selection = getSelection();
288	Object sel = null;
289	if (selection != null && !selection.isEmpty()) {
290	sel = ((IStructuredSelection) selection).getFirstElement();
291	notifyViewSelectionChanged(this, sel);
292	}
293	}
294
295	public void notifyViewSelectionChanged(Object source, Object selection) {
296	UIPlugin.getDefault().getSelectionModel(getMOFObject()).add(selection);
297	ViewSelectionChangedEvent event = UIPlugin.getDefault()
298	.getViewSelectionChangedEvent();
299	event.setSource(source);
300	UIPlugin.getDefault().notifyViewSelectionChangedListener(event);
301	}
302
303	public void widgetDefaultSelected(SelectionEvent e) {
304	OpenCallStackViewAction.openCallStackView(false);
305	updateModelSelection();
306	}
307
308	public void widgetSelected(SelectionEvent e) {
309	updateModelSelection();
310	}
311
312	public void selectNextEvent() {
313	_stateCtrl.selectNextEvent();
314	}
315
316	public void selectPrevEvent() {
317	_stateCtrl.selectPrevEvent();
318	}
319	}

Line 1 Link Here

(-)CVS (+91 lines)
		1	/*****************************************************************************
		2	* Copyright (c) 1997-2006, Intel Corporation.
		3	* All rights reserved. This program and the accompanying materials
		4	* are made available under the terms of the Eclipse Public License v1.0
		5	* which accompanies this distribution, and is available at
		6	* http://www.eclipse.org/legal/epl-v10.html
		7	*
		8	* Contributors:
		9	* Intel Corporation - Initial API and implementation
		10	* Ruslan A. Scherbakov, Intel - Initial API and implementation
		11	*
		12	* $Id$
		13	*****************************************************************************/
		14
		15	package org.eclipse.tptp.trace.jvmti.internal.client.views;
		16
		17	import org.eclipse.emf.ecore.EObject;
		18	import org.eclipse.hyades.trace.ui.TraceViewer;
		19	import org.eclipse.hyades.trace.ui.TraceViewerPage;
		20	import org.eclipse.jface.action.Action;
		21	import org.eclipse.jface.action.IMenuManager;
		22	import org.eclipse.jface.action.IToolBarManager;
		23	import org.eclipse.ui.IActionBars;
		24	import org.eclipse.ui.ISharedImages;
		25	import org.eclipse.ui.PlatformUI;
		26
		27	public class ThreadStatesViewer extends TraceViewer {
		28
		29	public ThreadStatesViewer() {
		30	}
		31
		32	public TraceViewerPage createPage(EObject mofObject) {
		33	return new ThreadStatesPage(mofObject, this);
		34	}
		35
		36	public String getViewTitle() {
		37	return UIMessages.THREAD_STATES_TITLE;
		38	}
		39
		40	public void setFocus() {
		41	if (getCurrentPage() != null)
		42	getCurrentPage().setFocus();
		43	}
		44
		45	public void makeActions() {
		46	super.makeActions();
		47	createActions();
		48	IActionBars bars = getViewSite().getActionBars();
		49	fillLocalPullDown(bars.getMenuManager());
		50	fillLocalToolBar(bars.getToolBarManager());
		51	bars.updateActionBars();
		52	}
		53
		54	Action _selectNextEvent;
		55	Action _selectPrevEvent;
		56
		57	private void createActions() {
		58	_selectNextEvent = new Action() {
		59	public void run() {
		60	if (getCurrentPage() instanceof ThreadStatesPage)
		61	((ThreadStatesPage) getCurrentPage()).selectNextEvent();
		62	}
		63	};
		64	_selectNextEvent.setText("Next");
65	_selectNextEvent.setToolTipText("Select Next Event");
66	_selectNextEvent.setImageDescriptor(PlatformUI.getWorkbench()
67	.getSharedImages().getImageDescriptor(
68	ISharedImages.IMG_TOOL_FORWARD));
69	_selectPrevEvent = new Action() {
70	public void run() {
71	if (getCurrentPage() instanceof ThreadStatesPage)
72	((ThreadStatesPage) getCurrentPage()).selectPrevEvent();
73	}
74	};
75	_selectPrevEvent.setText("Prev");
76	_selectPrevEvent.setToolTipText("Select Previous Event");
77	_selectPrevEvent.setImageDescriptor(PlatformUI.getWorkbench()
78	.getSharedImages().getImageDescriptor(
79	ISharedImages.IMG_TOOL_BACK));
80	}
81
82	private void fillLocalPullDown(IMenuManager manager) {
83	manager.add(_selectPrevEvent);
84	manager.add(_selectNextEvent);
85	}
86
87	private void fillLocalToolBar(IToolBarManager manager) {
88	manager.add(_selectPrevEvent);
89	manager.add(_selectNextEvent);
90	}
91	}

Line 60 Link Here

(-)CVS (-311 / +225 lines)
		60	import org.eclipse.tptp.trace.jvmti.internal.client.widgets.Utils;
Line 66 Link Here
		67	static final int COL_CLASS_NAME = 0;
		68	static final int COL_THREAD_NAME = 1;
		69	static final int COL_STATE = 2;
		70	static final int COL_RUN_TIME = 3;
		71	static final int COL_WAIT_TIME = 4;
		72	static final int COL_BLOCK_TIME = 5;
		73	static final int COL_BLOCK_COUNT = 6;
		74	static final int COL_DEADLOCK_TIME = 7;
		75	static final int COL_DEADLOCK_COUNT = 8;
		76
Lines 71-72 Link Here
71		82
72	public ThreadStatisticView(Composite parent, TraceViewerPage page){	83	public ThreadStatisticView(Composite parent, TraceViewerPage page) {
73	--
Line 74 Link Here
74		85
75	--
Lines 77-84 Link Here
77		88
78	protected String getContextHelpId()	89	protected String getContextHelpId() {
79	{	90	return TraceUIPlugin.getPluginId() + ".stvw0001";
80	return TraceUIPlugin.getPluginId()+".stvw0001";	91	}
81	}	92
82		93	public void createColumnsLabelProviders() {
83	public void createColumnsLabelProviders()
84	{
85	--
Lines 86-98 Link Here
86	new ThreadClassNameColumnLabel(),	95	new ThreadClassNameColumnLabel(),
87	new ThreadNameColumnLabel(),	96	new ThreadNameColumnLabel(),
88	new ThreadStartTimeColumnLabel(),	97	//new ThreadStartTimeColumnLabel(),
89	new ThreadStopTimeColumnLabel(),	98	//new ThreadStopTimeColumnLabel(),
90	new ThreadStateColumnLabel(),	99	new ThreadStateColumnLabel(),
91	new ThreadRunningTimeColumnLabel(),	100	new ThreadRunningTimeColumnLabel(),
92	// new ThreadSleepingTimeColumnLabel(),	101	//new ThreadSleepingTimeColumnLabel(),
93	new ThreadWaitingTimeColumnLabel(),	102	new ThreadWaitingTimeColumnLabel(),
94	new ThreadBlockedTimeColumnLabel(),	103	new ThreadBlockedTimeColumnLabel(),
95	new ThreadBlockCountColumnLabel(),	104	new ThreadBlockCountColumnLabel(),
96	new ThreadDeadlockedTimeColumnLabel(),	105	new ThreadDeadlockedTimeColumnLabel(),
97	new ThreadDeadlockCountColumnLabel()	106	new ThreadDeadlockCountColumnLabel() };
98	};
99	--
Line 100 Link Here
100		108
101	--
Lines 114-138 Link Here
114		122
115	/**	123	/**
116	* Returns the current selection for this provider.	124	* Returns the current selection for this provider.
117	*	125	*
118	* @return the current selection	126	* @return the current selection
119	*/	127	*/
120	public ISelection getSelection()	128	public ISelection getSelection() {
121	{	129	ISelection sel = super.getSelection();
122	ISelection sel = super.getSelection();	130	if (sel != null && !sel.isEmpty()) {
123	if(sel != null && !sel.isEmpty())	131	Object obj = ((IStructuredSelection) sel).getFirstElement();
124	{	132	if (obj instanceof ThreadDetails)
125	Object obj = ((IStructuredSelection)sel).getFirstElement();	133	return new StructuredSelection(((ThreadDetails) obj).getThread());
126	if(obj instanceof ThreadDetails)	134	}
127	return new StructuredSelection(((ThreadDetails)obj).getThread());	135	return sel;
128	}	136	}
129	return sel;	137
130	}	138	}
131		139
132	}	140	public class ThreadStatisticContentProvider implements ITreeContentProvider {
133		141
134	public class ThreadStatisticContentProvider implements ITreeContentProvider	142	public Object[] getChildren(Object element) {
135	{
136
137	public Object[] getChildren(Object element)
138	{
139	--
Line 141 Link Here
141		145
142	--
Line 144 Link Here
144	}	148	}
145	--
Line 149 Link Here
149		153
150	--
Line 154 Link Here
154	Object[] threads = PerftraceUtil.getAllThreads(_page.getMOFObject(), false);	158	Object[] threads = PerftraceUtil.getAllThreads(
155	--	159	_page.getMOFObject(), false);
Lines 156-157 Link Here
156	for (int i=0; i < threads.length; i++) {	161	for (int i = 0; i < threads.length; i++) {
157	elements[i] = new ThreadDetails((TRCThread)threads[i]);	162	elements[i] = new ThreadDetails((TRCThread) threads[i]);
158	--
Lines 168-170 Link Here
168		173
169	public class ThreadStatisticLabelProvider extends LabelProvider	174	public class ThreadStatisticLabelProvider extends LabelProvider implements
170	implements ITableLabelProvider {	175	ITableLabelProvider {
171	--
Line 172 Link Here
172		177
173	--
Lines 178-185 Link Here
178	StatisticTableColumnInfo info = StatisticTableColumnInfo.getStatisticTableColumnInfo(_viewer.getTree().getColumn(col));	183	StatisticTableColumnInfo info =
179	int pos = info.getColumnData().getInitalPos();	184	StatisticTableColumnInfo.getStatisticTableColumnInfo(_viewer.getTree().getColumn(col));
180		185	int pos = info.getColumnData().getInitalPos();
181	if (pos >= 0 && pos < _columns.length) {	186
182	return getElementColumnText(obj, _columns[pos], info.isDeltaColumn());	187	if (pos >= 0 && pos < _columns.length) {
183	} else {	188	return getElementColumnText(obj, _columns[pos], info.isDeltaColumn());
184	return "";	189	} else {
185	}	190	return "";
186	--	191	}
Line 187 Link Here
187		193
188	--
Lines 189-196 Link Here
189	StatisticTableColumnInfo info = StatisticTableColumnInfo.getStatisticTableColumnInfo(_viewer.getTree().getColumn(col));	195	StatisticTableColumnInfo info =
190	int pos = info.getColumnData().getInitalPos();	196	StatisticTableColumnInfo.getStatisticTableColumnInfo(_viewer.getTree().getColumn(col));
191		197	int pos = info.getColumnData().getInitalPos();
192	if (pos == 4) { // thread state	198
193		199	if (pos == COL_STATE) { // thread state
194	}	200	}
195		201
196	if(info.isDeltaColumn())	202	if (info.isDeltaColumn())
197	--
Lines 199-203 Link Here
199	if (pos >= 0 && pos < _columns.length) {	205	if (pos >= 0 && pos < _columns.length) {
200	return getElementColumnImage(obj, _columns[pos], info.isDeltaColumn());	206	return getElementColumnImage(obj, _columns[pos], info.isDeltaColumn());
201	} else {	207	} else {
202	return null;	208	return null;
203	}	209	}
204	--
Line 208 Link Here
208		214
209	--
Line 210 Link Here
210	if (_pos >= 0 && _pos < _columns.length) {	216	if (_pos >= 0 && _pos < _columns.length) {
211	--
Lines 212-214 Link Here
212	} else {	218	} else {
213	return 0;	219	return 0;
214	}	220	}
215	--
Lines 218-219 Link Here
218	public class ThreadStatisticFilter extends StatisticFilter{	224	public class ThreadStatisticFilter extends StatisticFilter {
219		225
220	--
Line 223 Link Here
223		229
224	--
Line 225 Link Here
225		231
226	--
Lines 227-228 Link Here
227	String compareText = (element instanceof TRCThread) ?	233	String compareText = (element instanceof TRCThread) ? PerftraceUtil.getThreadName((TRCThread) element) : "";
228	PerftraceUtil.getThreadName((TRCThread)element) : "";
229	--
Lines 262-288 Link Here
262		267
263	public String getDefaultColumnsTemplate()	268	public String getDefaultColumnsTemplate() {
264	{	269	return IContextAttributes.THREAD_CLASS_NAME + ":" + COL_CLASS_NAME + ":" + String.valueOf(ColumnData.NONDELETABLE \| ColumnData.IS_VISIBLE \| ColumnData.NONMOVABLE) + ":left:150,"
265	return IContextAttributes.THREAD_CLASS_NAME + ":0:"	270	+ IContextAttributes.THREAD_NAME + ":" + COL_THREAD_NAME + ":" + String.valueOf(ColumnData.NONDELETABLE \| ColumnData.IS_VISIBLE \| ColumnData.NONMOVABLE) + ":left:120,"
266	+ String.valueOf(ColumnData.NONDELETABLE \| ColumnData.IS_VISIBLE \| ColumnData.NONMOVABLE) + ":left:150,"	271	//+ IContextAttributes.THREAD_START_TIME + ":2:" + String.valueOf(ColumnData.IS_VISIBLE) + ":right:80,"
267	+ IContextAttributes.THREAD_NAME + ":1:"	272	//+ IContextAttributes.THREAD_STOP_TIME + ":3:" + String.valueOf(ColumnData.IS_VISIBLE) + ":right:80,"
268	+ String.valueOf(ColumnData.NONDELETABLE \| ColumnData.IS_VISIBLE \| ColumnData.NONMOVABLE) + ":left:120,"	273	+ IContextAttributes.THREAD_STATE + ":" + COL_STATE + ":" + String.valueOf(ColumnData.IS_VISIBLE) + ":right:80,"
269	+ IContextAttributes.THREAD_START_TIME + ":2:"	274	+ IContextAttributes.THREAD_RUNNING_TIME + ":" + COL_RUN_TIME + ":" + String.valueOf(ColumnData.IS_VISIBLE) + ":right:120,"
270	+ String.valueOf(ColumnData.IS_VISIBLE) + ":right:80,"	275	//+ IContextAttributes.THREAD_SLEEPING_TIME + ":6:" + String.valueOf(ColumnData.IS_VISIBLE) + ":right:120,"
271	+ IContextAttributes.THREAD_STOP_TIME + ":3:"	276	+ IContextAttributes.THREAD_WAITING_TIME + ":" + COL_WAIT_TIME + ":" + String.valueOf(ColumnData.IS_VISIBLE) + ":right:120,"
272	+ String.valueOf(ColumnData.IS_VISIBLE) + ":right:80,"	277	+ IContextAttributes.THREAD_BLOCKED_TIME + ":" + COL_BLOCK_TIME+ ":" + String.valueOf(ColumnData.IS_VISIBLE) + ":right:120,"
273	+ IContextAttributes.THREAD_STATE + ":4:"	278	+ IContextAttributes.THREAD_BLOCK_COUNT + ":" + COL_BLOCK_COUNT + ":" + String.valueOf(ColumnData.IS_VISIBLE) + ":right:80,"
274	+ String.valueOf(ColumnData.IS_VISIBLE) + ":right:80,"	279	+ IContextAttributes.THREAD_DEADLOCKED_TIME + ":" + COL_DEADLOCK_TIME + ":" + String.valueOf(ColumnData.IS_VISIBLE) + ":right:80,"
275	+ IContextAttributes.THREAD_RUNNING_TIME + ":5:"	280	+ IContextAttributes.THREAD_DEADLOCK_COUNT + ":" + COL_DEADLOCK_COUNT + ":" + String.valueOf(ColumnData.IS_VISIBLE) + ":right:80"
276	+ String.valueOf(ColumnData.IS_VISIBLE) + ":right:120,"
277	// + IContextAttributes.THREAD_SLEEPING_TIME + ":6:"
278	// + String.valueOf(ColumnData.IS_VISIBLE) + ":right:120,"
279	+ IContextAttributes.THREAD_WAITING_TIME + ":6:"
280	+ String.valueOf(ColumnData.IS_VISIBLE) + ":right:120,"
281	+ IContextAttributes.THREAD_BLOCKED_TIME + ":7:"
282	+ String.valueOf(ColumnData.IS_VISIBLE) + ":right:120,"
283	+ IContextAttributes.THREAD_BLOCK_COUNT + ":8:"
284	+ String.valueOf(ColumnData.IS_VISIBLE) + ":right:80,"
285	+ IContextAttributes.THREAD_DEADLOCKED_TIME+ ":9:"
286	+ String.valueOf(ColumnData.IS_VISIBLE) + ":right:80,"
287	+ IContextAttributes.THREAD_DEADLOCK_COUNT + ":10:"
288	+ String.valueOf(ColumnData.IS_VISIBLE) + ":right:80"
289	--
Lines 290-311 Link Here
290	}	282	}
291		283
292	public boolean isEmptyUpdate()	284	public boolean isEmptyUpdate() {
293	{	285	// Object[] threads = PerftraceUtil.getAllThreads(_page.getMOFObject(), false);
294	// Object[] threads = PerftraceUtil.getAllThreads(_page.getMOFObject(), false);	286	// for (int i = 0; i < threads.length; i++) {
295	// for (int i = 0; i < threads.length; i++) {	287	// TRCThread thread = (TRCThread)threads[i];
296	// TRCThread thread = (TRCThread)threads[i];	288	// for (Iterator it = thread.getThreadEvents().iterator(); it.hasNext();
297	// for (Iterator it = thread.getThreadEvents().iterator(); it.hasNext(); ) {	289	// ) {
298	// Object event = it.next();	290	// Object event = it.next();
299	// if (event instanceof TRCThreadWaitingForLockEvent	291	// if (event instanceof TRCThreadWaitingForLockEvent
300	// \|\| event instanceof TRCThreadWaitingForObjectEvent	292	// \|\| event instanceof TRCThreadWaitingForObjectEvent
301	// \|\| event instanceof TRCThreadSleepingEvent	293	// \|\| event instanceof TRCThreadSleepingEvent
302	// \|\| event instanceof TRCThreadDeadLockEvent) {	294	// \|\| event instanceof TRCThreadDeadLockEvent) {
303	return false;	295	return false;
304	// }	296	// }
305	// }	297	// }
306	// }	298	// }
307	// return true;	299	// return true;
308	}	300	}
309		301
310	public IContentProvider getContentProvider()	302	public IContentProvider getContentProvider() {
311	{
312	--
Lines 314-316 Link Here
314		305
315	public LabelProvider getTableLabelProvider()	306	public LabelProvider getTableLabelProvider() {
316	{
317	--
Lines 319-321 Link Here
319		309
320	protected StatisticSorter getViewerSorterInstance()	310	protected StatisticSorter getViewerSorterInstance() {
321	{
322	--
Lines 324-326 Link Here
324		313
325	protected StatisticFilter getFilterInstance()	314	protected StatisticFilter getFilterInstance() {
326	{
327	--
Lines 328-336 Link Here
328	}	316	}
329		317
330	public String getColumnsPreferencesKey()	318	public String getColumnsPreferencesKey() {
331	{	319	return PREFERENCE_KEY_PREFIX + "ThreadStats2";
332	return PREFERENCE_KEY_PREFIX + "ThreadStats1";	320	}
333	}	321
334		322	protected String getViewTypeStr() {
335	protected String getViewTypeStr()
336	{
337	--
Lines 338-339 Link Here
338	}	324	}
339		325
340	--
Lines 341-342 Link Here
341	}	327	}
342		328
343	--
Lines 344-350 Link Here
344	}	330	}
345		331
346		332	public void update() {
347	public void update()	333	if (_page instanceof ThreadStatisticPage) {
348	{
349	if(_page instanceof ThreadStatisticPage)
350	{
351	--
Line 358 Link Here
358		341
359	--
Lines 361-362 Link Here
361	if(_page instanceof ThreadStatisticPage)	344	if (_page instanceof ThreadStatisticPage) {
362	{
363	--
Line 366 Link Here
366		348
367	--
Line 388 Link Here
388	region.add(event.x, event.y, width, event.height);	370	region.add(event.x, event.y, width, event.height);
389	--
Lines 401-402 Link Here
401	}	383	}
402		384
403	--
Line 405 Link Here
405	if (event.index == 4) { // thread state	387	if (event.index == COL_STATE) { // thread state
406	--
Line 407 Link Here
407	} else if (event.index == 8 // block count	389	} else if (event.index == COL_BLOCK_COUNT // block count
408	--
Line 410 Link Here
410	} else if (event.index == 10 // deadlock count	392	} else if (event.index == COL_DEADLOCK_COUNT // deadlock count
411	--
Line 419 Link Here
419		401
420	--
Lines 424-425 Link Here
424	Color fore = mixColors(display, sysBack, sysFore, 1, 4);	406	Color fore = Utils.mixColors(display, sysBack, sysFore, 1, 4);
425	Color back = mixColors(display, sysBack, sysFore, 1, 1);	407	Color back = Utils.mixColors(display, sysBack, sysFore, 1, 1);
426	--	408
		409	gc.setAdvanced(true);
		410	if (gc.getAdvanced()) {
		411	gc.setAlpha(180);
		412	}
Lines 427-431 Link Here
427	gc.setAdvanced(true);
428	if (gc.getAdvanced()) {
429	gc.setAlpha(180);
430	}
431
Line 435 Link Here
435		417
436	--
Lines 442-448 Link Here
442
443	private Color mixColors(Display display, Color c1, Color c2, int w1, int w2) {
444	return new Color(display,
445	(w1 * c1.getRed() + w2 * c2.getRed()) / (w1 + w2),
446	(w1 * c1.getGreen() + w2 * c2.getGreen()) / (w1 + w2),
447	(w1 * c1.getBlue() + w2 * c2.getBlue()) / (w1 + w2));
448	}
Lines 463-464 Link Here
463	ITraceSelection model =	438	ITraceSelection model = UIPlugin.getDefault().getSelectionModel(_page.getMOFObject());
464	UIPlugin.getDefault().getSelectionModel(_page.getMOFObject());
465	--
Line 469 Link Here
469
Line 471 Link Here
471	updateStatusContext(ContextManager.getContextLanguage(ContextUpdaterHelper.getContext((EObject)sel)));	444	updateStatusContext(ContextManager.getContextLanguage(ContextUpdaterHelper.getContext((EObject) sel)));
472	--
Lines 478-484 Link Here
478	if(selection != null && !selection.isEmpty())	451	Object sel = null;
479	{	452	if (selection != null && !selection.isEmpty()) {
480	Object sel = ((IStructuredSelection)selection).getFirstElement();	453	sel = ((IStructuredSelection) selection).getFirstElement();
481	if(sel instanceof ThreadDetails)	454	if (sel instanceof ThreadDetails)
482	notifyViewSelectionChanged(this, ((ThreadDetails)sel).getThread());	455	sel = ((ThreadDetails) sel).getThread();
483	else	456	notifyViewSelectionChanged(this, sel);
484	notifyViewSelectionChanged(this,sel);	457	}
485	--	458	}
		459
		460	public TRCThread getSelectedThread() {
		461	TRCThread thread = null;
		462	ISelection selection = getTreeViewer().getSelection();
		463	if (selection != null && !selection.isEmpty()) {
		464	Object sel = ((IStructuredSelection) selection).getFirstElement();
		465	if (sel instanceof TRCThread)
		466	thread = (TRCThread) sel;
		467	if (sel instanceof ThreadDetails)
		468	thread = ((ThreadDetails) sel).getThread();
Line 486 Link Here
		470	return thread;
Lines 489-490 Link Here
489	Object source = event.getSource();	474	Object source = event.getSource();
490	if(source!=this){	475	if (source != this) {
491	--
Lines 492-496 Link Here
492	}	477	} else {
493	else	478	ITraceSelection model = UIPlugin.getDefault().getSelectionModel(_page.getMOFObject());
494	{
495	ITraceSelection model =
496	UIPlugin.getDefault().getSelectionModel(_page.getMOFObject());
497	--
Line 500 Link Here
500	updateStatusContext(ContextManager.getContextLanguage(ContextUpdaterHelper.getContext((EObject)sel)));	482	updateStatusContext(ContextManager.getContextLanguage(ContextUpdaterHelper.getContext((EObject) sel)));
501	--
Line 506 Link Here
506
Lines 510-512 Link Here
510	menu.add(	491	menu.add(getChooseColumnsAction(getColumnDataList(),
511	getChooseColumnsAction(
512	getColumnDataList(),
513	--
Lines 514-516 Link Here
514	menu.add(	493	menu.add(getSortByColumnAction());
515	getSortByColumnAction());
516
517	--
Line 518 Link Here
518		495
519	--
Line 531 Link Here
531		508
532	--
Line 541 Link Here
541	obj = ((ThreadDetails)obj).getThread();	518	obj = ((ThreadDetails) obj).getThread();
542	--
Line 545 Link Here
545		522
546	--
Line 550 Link Here
550	if (item!=null && !item.isDisposed()) {	527	if (item != null && !item.isDisposed()) {
551	--
Line 553 Link Here
553	data = ((ThreadDetails)data).getThread();	530	data = ((ThreadDetails) data).getThread();
554	--
Lines 565-567 Link Here
565		542
566	if (_page.getTraceViewer() instanceof MultiLevelStatisticViewer)	543	if (_page.getTraceViewer() instanceof MultiLevelStatisticViewer) {
567	{
568	--
Line 569 Link Here
569	_contextInfo.setViewer((IContextViewer)_page.getTraceViewer());	545	_contextInfo.setViewer((IContextViewer) _page.getTraceViewer());
570	--
Lines 571-575 Link Here
571	_contextInfo.addContextInfoContainerListener(	547	_contextInfo.addContextInfoContainerListener(new IContextInfoContainerListener() {
572	new IContextInfoContainerListener()	548	public void visibilityChanged(boolean isVisible) {
573	{
574	public void visibilityChanged(boolean isVisible)
575	{
576	--
Line 580 Link Here
580		553
581	--
Lines 583-585 Link Here
583		556
584	protected void updateStatusContext(IContextLanguage language)	557	protected void updateStatusContext(IContextLanguage language) {
585	{
586	--
Line 589 Link Here
589		561
590	--
Lines 601-602 Link Here
601		573	ArrayList list = ColumnData.createColumnData(getColumnsPreferencesKey()
602	ArrayList list = ColumnData.createColumnData(getColumnsPreferencesKey(), getDefaultColumnsTemplate());	574	, getDefaultColumnsTemplate());
603	--
Line 606 Link Here
606
Line 608 Link Here
		579	}
		580
		581	public void dispose() {
		582	super.dispose();
		583	}
		584
		585	public void widgetDefaultSelected(SelectionEvent arg0) {
		586	OpenCallStackViewAction.openCallStackView(false);

Line 1 Link Here

(-)CVS (+44 lines)
	1	/*****************************************************************************
	2	* Copyright (c) 1997-2006, Intel Corporation.
	3	* All rights reserved. This program and the accompanying materials
	4	* are made available under the terms of the Eclipse Public License v1.0
	5	* which accompanies this distribution, and is available at
	6	* http://www.eclipse.org/legal/epl-v10.html
	7	*
	8	* Contributors:
	9	* Intel Corporation - Initial API and implementation
	10	* Ruslan A. Scherbakov, Intel - Initial API and implementation
	11	*
	12	* $Id$
	13	*****************************************************************************/
	14
	15	package org.eclipse.tptp.trace.jvmti.internal.client.widgets;
	16
	17	public interface ITimeDataProvider {
	18
	19	double getSelectedTime();
	20
	21	double getBeginTime();
	22
	23	double getEndTime();
	24
	25	double getMinTime();
	26
	27	double getMaxTime();
	28
	29	double getTime0();
	30
	31	double getTime1();
	32
	33	double getMinTimeInterval();
	34
	35	void setStartFinishTime(double time0, double time1);
	36
	37	void setSelectedTime(double time, boolean ensureVisible);
	38
	39	void resetStartFinishTime();
	40
	41	int getNameSpace();
	42
	43	int getTimeSpace();
	44	}

Line 1 Link Here

(-)CVS (+72 lines)
		1	/*****************************************************************************
		2	* Copyright (c) 1997-2006, Intel Corporation.
		3	* All rights reserved. This program and the accompanying materials
		4	* are made available under the terms of the Eclipse Public License v1.0
		5	* which accompanies this distribution, and is available at
		6	* http://www.eclipse.org/legal/epl-v10.html
		7	*
		8	* Contributors:
		9	* Intel Corporation - Initial API and implementation
		10	* Ruslan A. Scherbakov, Intel - Initial API and implementation
		11	*
		12	* $Id$
		13	*****************************************************************************/
		14
		15	package org.eclipse.tptp.trace.jvmti.internal.client.widgets;
		16
		17	import org.eclipse.swt.graphics.GC;
		18	import org.eclipse.swt.graphics.Point;
		19	import org.eclipse.swt.graphics.Rectangle;
		20	import org.eclipse.swt.widgets.Composite;
		21	import org.eclipse.tptp.trace.jvmti.internal.client.views.UIMessages;
		22
		23	public class LegendCtrl extends TraceCtrl {
		24
		25	static private String _names[];
		26
		27	public LegendCtrl(Composite parent, TraceColorScheme colors) {
		28	super(parent, colors);
		29	}
		30
		31	static private String [] getNames() {
		32	if (null == _names) {
		33	String names[] = {
		34	UIMessages._267, // "Unknown",
		35	UIMessages._261, // "Running",
		36	UIMessages._262, // "Sleeping",
		37	UIMessages._263, // "Waiting",
		38	UIMessages._264, // "Blocked",
		39	UIMessages._265, // "Deadlock",
		40	UIMessages._266, // "Stopped",
		41	};
		42	_names = names;
		43	}
		44	return _names;
		45	}
		46
		47	void paint(Rectangle rect, GC gc) {
		48	gc.setBackground(_colors.getColor(TraceColorScheme.LEGEND_BACKGROUND));
		49	gc.fillRectangle(rect);
		50	// draw legend rect
		51	Utils.init(_rect1, rect);
		52	//gc.setForeground(_colors.getColor(TraceColorScheme.LEGEND_FOREGROUND));
		53	//gc.drawRectangle(_rect1.x, _rect1.y, _rect1.width - 1, _rect1.height - 1);
		54	// draw legend elements
		55	int idx = 0;
		56	String names[] = getNames();
		57	_rect1.x += 4;
		58	_rect1.y += 2;
		59	while (idx < names.length && _rect1.x < rect.x + rect.width) {
		60	Point size = gc.stringExtent(names[idx]);
		61	_rect1.width = 16;
		62	_rect1.height = size.y;
		63	Utils.drawState(_colors, idx, _rect1, gc, false, true, false);
		64	_rect1.x += _rect1.width + 2;
65	_rect1.width = size.x;
66	gc.setForeground(_colors.getColor(TraceColorScheme.LEGEND_FOREGROUND));
67	Utils.drawText(gc, names[idx], _rect1, true);
68	_rect1.x += _rect1.width + 8;
69	idx++;
70	}
71	}
72	}

Line 1 Link Here

(-)CVS (+303 lines)
		1	/*****************************************************************************
		2	* Copyright (c) 1997-2006, Intel Corporation.
		3	* All rights reserved. This program and the accompanying materials
		4	* are made available under the terms of the Eclipse Public License v1.0
		5	* which accompanies this distribution, and is available at
		6	* http://www.eclipse.org/legal/epl-v10.html
		7	*
		8	* Contributors:
		9	* Intel Corporation - Initial API and implementation
		10	* Ruslan A. Scherbakov, Intel - Initial API and implementation
		11	*
		12	* $Id$
		13	*****************************************************************************/
		14
		15	package org.eclipse.tptp.trace.jvmti.internal.client.widgets;
		16
		17	import org.eclipse.swt.events.MouseEvent;
		18	import org.eclipse.swt.events.MouseListener;
		19	import org.eclipse.swt.events.MouseMoveListener;
		20	import org.eclipse.swt.graphics.GC;
		21	import org.eclipse.swt.graphics.Point;
		22	import org.eclipse.swt.graphics.Rectangle;
		23	import org.eclipse.swt.widgets.Composite;
		24	import org.eclipse.tptp.trace.jvmti.internal.client.views.UIMessages;
		25
		26	public class TimeScaleCtrl extends TraceCtrl implements MouseListener, MouseMoveListener {
		27
		28	public TimeScaleCtrl(Composite parent, TraceColorScheme colors) {
		29	super(parent, colors);
		30	addMouseListener(this);
		31	addMouseMoveListener(this);
		32	}
		33
		34	private ITimeDataProvider _timeProvider;
		35	private int _dragState = 0;
		36	private int _dragX0 = 0;
		37	private int _dragX = 0;
		38	private double _time0bak;
		39	private double _time1bak;
		40	private boolean _isInUpdate;
		41
		42	public void setTimeProvider(ITimeDataProvider timeProvider) {
		43	_timeProvider = timeProvider;
		44	}
		45
		46	private double _timeDeltaD;
		47	private long _timeDelta;
		48	private void calcTimeDelta(int width, double K) {
		49	long D[] = { 1, 2, 5, };
		50	long pow = 1;
		51	double powD = 0.000000001;
		52	long td = pow;
		53	double tdD = powD;
		54	double dx = tdD * K;
		55	int i = 0;
		56	while (dx < width) {
		57	td = D[i] * pow;
		58	tdD = D[i] * powD;
		59	dx = tdD * K;
		60	i++;
		61	if (i == 3) {
		62	i = 0;
		63	pow *= 10;
		64	powD *= 10;
65	}
66	}
67	_timeDeltaD = tdD;
68	_timeDelta = td;
69	}
70
71	static private TimeDraw _tds[] = new TimeDraw[] {
72	new TimeDrawSec(),
73	new TimeDrawMillisec(),
74	new TimeDrawMicrosec(),
75	new TimeDrawNanosec(),
76	};
77
78	static TimeDraw getTimeDraw(long timeDelta) {
79	TimeDraw timeDraw;
80	if (timeDelta >= 1000000000)
81	timeDraw = _tds[0];
82	else if (timeDelta >= 1000000)
83	timeDraw = _tds[1];
84	else if (timeDelta >= 1000)
85	timeDraw = _tds[2];
86	else
87	timeDraw = _tds[3];
88	return timeDraw;
89	}
90
91	void paint(Rectangle rect, GC gc) {
92
93	if (_isInUpdate \|\| null == _timeProvider)
94	return;
95
96	if (null == _timeProvider) {
97	gc.fillRectangle(rect);
98	return;
99	}
100
101	gc.setBackground(_colors.getColor(TraceColorScheme.TOOL_BACKGROUND));
102	gc.setForeground(_colors.getColor(TraceColorScheme.TOOL_FOREGROUND));
103	double time0 = _timeProvider.getTime0();
104	double time1 = _timeProvider.getTime1();
105	double selectedTime = _timeProvider.getSelectedTime();
106	int leftSpace = _timeProvider.getNameSpace();
107	int timeSpace = _timeProvider.getTimeSpace();
108
109	if (time1 <= time0) {
110	gc.fillRectangle(rect);
111	return;
112	}
113	double timeRange = time1 - time0;
114	int numDigits = 8; // 11:222
115	if (timeRange < .00001)
116	numDigits = 16; // 11:222:333:444__
117	else if (timeRange < .01)
118	numDigits = 12; // 11:222:333__
119
120	Utils.init(_rect1, rect);
121	int labelWidth = gc.getCharWidth('0') * numDigits;
122	double K = 1;
123	if (rect.width - leftSpace > 0) {
124	K = (double) timeSpace / (time1 - time0);
125	calcTimeDelta(labelWidth, K);
126	}
127	TimeDraw timeDraw = getTimeDraw(_timeDelta);
128
129	// draw top left area
130	_rect1.width = leftSpace;
131	gc.fillRectangle(_rect1);
132	_rect1.x += 4;
133	_rect1.width -= 4;
134	if (_rect1.width > 0) {
135	if (rect.width - leftSpace > 0)
136	Utils.drawText(gc, "Time: " + timeDraw.hint(), _rect1, true);
137	else
138	Utils.drawText(gc, UIMessages.TIME_SCALE, _rect1, true);
139	}
140	_rect1.x -= 4;
141	_rect1.width += 4;
142
143	// prepare and draw right rect of the timescale
144	_rect1.x += leftSpace;
145	_rect1.width = rect.width - leftSpace;
146
147	// draw bottom border and erase all other area
148	gc.drawLine(rect.x, rect.y + rect.height - 1, rect.x + rect.width - 1,
149	rect.y + rect.height - 1);
150	_rect1.height--;
151	gc.fillRectangle(_rect1);
152
153	if (_rect1.isEmpty())
154	return;
155
156	// draw selected time
157	int x = _rect1.x + (int) ((selectedTime - time0) * K);
158	if (x >= _rect1.x && x < _rect1.x + _rect1.width) {
159	gc.setForeground(_colors.getColor(TraceColorScheme.SELECTED_TIME));
160	gc.drawLine(x, _rect1.y + _rect1.height - 6, x, _rect1.y + _rect1.height);
161	gc.setForeground(_colors.getColor(TraceColorScheme.TOOL_FOREGROUND));
162	}
163
164	// draw time scale ticks
165	_rect1.y = rect.y;
166	_rect1.height = rect.height - 4;
167	_rect1.width = labelWidth;
168	double time = Math.floor(time0 / _timeDeltaD) * _timeDeltaD;
169	long t = (long)(time * 1000000000);
170	int y = _rect1.y + _rect1.height;
171	while (true) {
172	x = rect.x + leftSpace + (int) ((time - time0) * K);
173	if (x >= rect.x + leftSpace + rect.width - _rect1.width) {
174	break;
175	}
176	if (x >= rect.x + leftSpace) {
177	gc.drawLine(x, y, x, y + 4);
178	_rect1.x = x;
179	if (x + _rect1.width <= rect.x + rect.width)
180	timeDraw.draw(gc, t, _rect1);
181	}
182	time += _timeDeltaD;
183	t += _timeDelta;
184	}
185	}
186
187	public void mouseDown(MouseEvent e) {
188	if (1 == e.button && null != _timeProvider) {
189	setCapture(true);
190	_dragState = 1;
191	_dragX = _dragX0 = e.x - _timeProvider.getNameSpace();
192	_time0bak = _timeProvider.getTime0();
193	_time1bak = _timeProvider.getTime1();
194	}
195	}
196
197	public void mouseUp(MouseEvent e) {
198	if (1 == _dragState) {
199	setCapture(false);
200	_dragState = 0;
201	}
202	}
203
204	public void mouseMove(MouseEvent e) {
205	Point size = getSize();
206	if (1 == _dragState && null != _timeProvider) {
207	int leftSpace = _timeProvider.getNameSpace();
208	int x = e.x - leftSpace;
209	if (x > 0 && size.x > leftSpace && _dragX != x) {
210	_dragX = x;
211	double time1 = _time0bak + (_time1bak - _time0bak) * _dragX0 / _dragX;
212	_timeProvider.setStartFinishTime(_time0bak, time1);
213	}
214	}
215	}
216
217	public void mouseDoubleClick(MouseEvent e) {
218	if (null != _timeProvider) {
219	_timeProvider.resetStartFinishTime();
220	}
221	}
222	}
223
224	abstract class TimeDraw {
225	static String S = ":";
226	static String S0 = ":0";
227	static String S00 = ":00";
228
229	static String pad(long n) {
230	String s = S;
231	if (n < 10)
232	s = S00;
233	else if (n < 100)
234	s = S0;
235	return s + n;
236	}
237
238	public abstract void draw(GC gc, long time, Rectangle rect);
239	public abstract String hint();
240	}
241
242	class TimeDrawSec extends TimeDraw {
243	static String _hint = "sec";
244
245	public void draw(GC gc, long time, Rectangle rect) {
246	time /= 1000000000;
247	Utils.drawText(gc, time + "", rect, true);
248	}
249
250	public String hint() {
251	return _hint;
252	}
253	}
254
255	class TimeDrawMillisec extends TimeDraw {
256	static String _hint = "s:ms";
257
258	public void draw(GC gc, long time, Rectangle rect) {
259	time /= 1000000;
260	long ms = time % 1000;
261	time /= 1000;
262	Utils.drawText(gc, time + pad(ms), rect, true);
263	}
264
265	public String hint() {
266	return _hint;
267	}
268	}
269
270	class TimeDrawMicrosec extends TimeDraw {
271	static String _hint = "s:ms:mcs";
272
273	public void draw(GC gc, long time, Rectangle rect) {
274	time /= 1000;
275	long mcs = time % 1000;
276	time /= 1000;
277	long ms = time % 1000;
278	time /= 1000;
279	Utils.drawText(gc, time + pad(ms) + pad(mcs), rect, true);
280	}
281
282	public String hint() {
283	return _hint;
284	}
285	}
286
287	class TimeDrawNanosec extends TimeDraw {
288	static String _hint = "s:ms:mcs:ns";
289
290	public void draw(GC gc, long time, Rectangle rect) {
291	long ns = time % 1000;
292	time /= 1000;
293	long mcs = time % 1000;
294	time /= 1000;
295	long ms = time % 1000;
296	time /= 1000;
297	Utils.drawText(gc, time + pad(ms) + pad(mcs) + pad(ns), rect, true);
298	}
299
300	public String hint() {
301	return _hint;
302	}
303	}

Line 1 Link Here

(-)CVS (+281 lines)
		1	/*****************************************************************************
		2	* Copyright (c) 1997-2006, Intel Corporation.
		3	* All rights reserved. This program and the accompanying materials
		4	* are made available under the terms of the Eclipse Public License v1.0
		5	* which accompanies this distribution, and is available at
		6	* http://www.eclipse.org/legal/epl-v10.html
		7	*
		8	* Contributors:
		9	* Intel Corporation - Initial API and implementation
		10	* Ruslan A. Scherbakov, Intel - Initial API and implementation
		11	*
		12	* $Id$
		13	*****************************************************************************/
		14
		15	package org.eclipse.tptp.trace.jvmti.internal.client.widgets;
		16
		17	import org.eclipse.swt.SWT;
		18	import org.eclipse.swt.graphics.Color;
		19
		20	public class TraceColorScheme {
		21
		22	// state elements color indices
		23	static public final int UNKNOWN = 0;
		24	static public final int RUNNING = 1;
		25	static public final int SLEEPING = 2;
		26	static public final int WAITING = 3;
		27	static public final int BLOCKED = 4;
		28	static public final int DEADLOCK = 5;
		29	static public final int STOPPED = 6;
		30
		31	static public final int STATES0 = 0;
		32	static public final int STATES1 = 7;
		33
		34	// selected state elements color indices
		35	static public final int UNKNOWN_SEL = 7;
		36	static public final int RUNNING_SEL = 8;
		37	static public final int SLEEPING_SEL = 9;
		38	static public final int WAITING_SEL = 10;
		39	static public final int BLOCKED_SEL = 11;
		40	static public final int DEADLOCK_SEL = 12;
		41	static public final int STOPPED_SEL = 13;
		42
		43	static public final int STATES_SEL0 = 7;
		44	static public final int STATES_SEL1 = 13;
		45
		46	// colors indices for viewer controls
		47	static public final int BACKGROUND = 14;
		48	static public final int FOREGROUND = 15;
		49	static public final int BACKGROUND_SEL = 16;
		50	static public final int FOREGROUND_SEL = 17;
		51	static public final int BACKGROUND_SEL_NOFOCUS = 18;
		52	static public final int FOREGROUND_SEL_NOFOCUS = 19;
		53	static public final int TOOL_BACKGROUND = 20;
		54	static public final int TOOL_FOREGROUND = 21;
		55
		56	// misc colors
		57	static public final int FIX_COLOR = 22;
		58	static public final int WHITE = 23;
		59	static public final int GRAY = 24;
		60	static public final int BLACK = 25;
		61	static public final int DARK_GRAY = 26;
		62
		63	// selected state elements border color indices
		64	static public final int UNKNOWN_BORDER = 27;
65	static public final int RUNNING_BORDER = 28;
66	static public final int SLEEPING_BORDER = 29;
67	static public final int WAITING_BORDER = 30;
68	static public final int BLOCKED_BORDER = 31;
69	static public final int DEADLOCK_BORDER = 32;
70	static public final int STOPPED_BORDER = 33;
71
72	static public final int STATES_BORDER0 = 27;
73	static public final int STATES_BORDER1 = 33;
74
75	static public final int MID_LINE = 34;
76	static public final int RED = 35;
77	static public final int GREEN = 36;
78	static public final int BLUE = 37;
79	static public final int YELLOW = 38;
80	static public final int CYAN = 39;
81	static public final int MAGENTA = 40;
82
83	static public final int SELECTED_TIME = 41;
84	static public final int LEGEND_BACKGROUND = 42;
85	static public final int LEGEND_FOREGROUND = 43;
86
87	// group items' colors
88	static public final int GR_BACKGROUND = 44;
89	static public final int GR_FOREGROUND = 45;
90	static public final int GR_BACKGROUND_SEL = 46;
91	static public final int GR_FOREGROUND_SEL = 47;
92	static public final int GR_BACKGROUND_SEL_NOFOCUS = 48;
93	static public final int GR_FOREGROUND_SEL_NOFOCUS = 49;
94
95	static public final int LIGHT_LINE = 50;
96	static public final int BACKGROUND_NAME = 51;
97
98	static interface IColorProvider {
99	public Color get();
100	}
101
102	static class SysCol implements IColorProvider {
103	int syscol;
104
105	SysCol(int syscol) {
106	this.syscol = syscol;
107	}
108
109	public Color get() {
110	return Utils.getSysColor(syscol);
111	}
112	}
113
114	static class RGB implements IColorProvider {
115	int r;
116	int g;
117	int b;
118
119	RGB(int r, int g, int b) {
120	this.r = r;
121	this.g = g;
122	this.b = b;
123	}
124
125	public Color get() {
126	return new Color(null, r, g, b);
127	}
128	}
129
130	static class Mix implements IColorProvider {
131	IColorProvider cp1;
132	IColorProvider cp2;
133	int w1;
134	int w2;
135
136	Mix(IColorProvider cp1, IColorProvider cp2, int w1, int w2) {
137	this.cp1 = cp1;
138	this.cp2 = cp2;
139	this.w1 = w1;
140	this.w2 = w2;
141	}
142
143	Mix(IColorProvider cp1, IColorProvider cp2) {
144	this.cp1 = cp1;
145	this.cp2 = cp2;
146	this.w1 = 1;
147	this.w2 = 1;
148	}
149
150	public Color get() {
151	Color col1 = cp1.get();
152	Color col2 = cp2.get();
153	Color col = Utils.mixColors(col1, col2, w1, w2);
154	return col;
155	}
156	}
157
158	static private final IColorProvider _providersMap[] = {
159	//
160	new RGB(100, 100, 100), // UNKNOWN
161	new RGB(174, 200, 124), // RUNNING
162	new Mix(new SysCol(SWT.COLOR_BLUE), new SysCol(SWT.COLOR_GRAY), 1, 3), // SLEEPING
163	new RGB(210, 150, 60), // WAITING
164	new RGB(242, 225, 168), // BLOCKED
165	new Mix(new SysCol(SWT.COLOR_RED), new SysCol(SWT.COLOR_GRAY), 1, 3), // DEADLOCK
166	new RGB(200, 200, 200), // STOPPED
167
168	new SysCol(SWT.COLOR_WHITE), // UNKNOWN_SEL
169	new SysCol(SWT.COLOR_GREEN), // RUNNING_SEL
170	new SysCol(SWT.COLOR_BLUE), // SLEEPING_SEL
171	new SysCol(SWT.COLOR_CYAN), // WAITING_SEL
172	new SysCol(SWT.COLOR_YELLOW), // BLOCKED_SEL
173	new SysCol(SWT.COLOR_RED), // DEADLOCK_SEL
174	new SysCol(SWT.COLOR_DARK_GRAY), // STOPPED_SEL
175
176	new SysCol(SWT.COLOR_LIST_BACKGROUND), // BACKGROUND
177	new SysCol(SWT.COLOR_LIST_FOREGROUND), // FOREGROUND
178	new SysCol(SWT.COLOR_LIST_SELECTION), // BACKGROUND_SEL
179	new SysCol(SWT.COLOR_LIST_SELECTION_TEXT), // FOREGROUND_SEL
180	new SysCol(SWT.COLOR_WIDGET_BACKGROUND), // BACKGROUND_SEL_NOFOCUS
181	new SysCol(SWT.COLOR_WIDGET_FOREGROUND), // FOREGROUND_SEL_NOFOCUS
182	new SysCol(SWT.COLOR_WIDGET_BACKGROUND), // TOOL_BACKGROUND
183	new SysCol(SWT.COLOR_WIDGET_DARK_SHADOW), // TOOL_FOREGROUND
184
185	new SysCol(SWT.COLOR_GRAY), // FIX_COLOR
186	new SysCol(SWT.COLOR_WHITE), // WHITE
187	new SysCol(SWT.COLOR_GRAY), // GRAY
188	new SysCol(SWT.COLOR_BLACK), // BLACK
189	new SysCol(SWT.COLOR_DARK_GRAY), // DARK_GRAY
190
191	new SysCol(SWT.COLOR_DARK_GRAY), // UNKNOWN_BORDER
192	new RGB(75, 115, 120), // RUNNING_BORDER
193	new SysCol(SWT.COLOR_DARK_BLUE), // SLEEPING_BORDER
194	new RGB(242, 225, 168), // WAITING_BORDER
195	new RGB(210, 150, 60), // BLOCKED_BORDER
196	new SysCol(SWT.COLOR_DARK_RED), // DEADLOCK_BORDER
197	new SysCol(SWT.COLOR_BLACK), // STOPPED_BORDER
198
199	new SysCol(SWT.COLOR_GRAY), // MID_LINE
200	new SysCol(SWT.COLOR_RED), // RED
201	new SysCol(SWT.COLOR_GREEN), // GREEN
202	new SysCol(SWT.COLOR_BLUE), // BLUE
203	new SysCol(SWT.COLOR_YELLOW), // YELLOW
204	new SysCol(SWT.COLOR_CYAN), // CYAN
205	new SysCol(SWT.COLOR_MAGENTA), // MAGENTA
206
207	new SysCol(SWT.COLOR_BLUE), // SELECTED_TIME
208	new SysCol(SWT.COLOR_WIDGET_BACKGROUND), // LEGEND_BACKGROUND
209	new SysCol(SWT.COLOR_WIDGET_DARK_SHADOW), // LEGEND_FOREGROUND
210
211	new Mix(new RGB(150, 200, 240), new SysCol(SWT.COLOR_LIST_BACKGROUND)),// GR_BACKGROUND
212	new RGB(0, 0, 50), // GR_FOREGROUND
213	new Mix(new RGB(200, 200, 100), new SysCol(SWT.COLOR_LIST_SELECTION)), // GR_BACKGROUND_SEL
214	new Mix(new RGB(150, 200, 240), new SysCol(SWT.COLOR_LIST_SELECTION_TEXT)), // GR_FOREGROUND_SEL
215	new Mix(new RGB(222, 222, 155), new SysCol(SWT.COLOR_WIDGET_BACKGROUND)), // GR_BACKGROUND_SEL_NOFOCUS
216	new RGB(0, 0, 50), // GR_FOREGROUND_SEL_NOFOCUS
217
218	new Mix(new SysCol(SWT.COLOR_GRAY), new SysCol(SWT.COLOR_LIST_BACKGROUND), 1, 3), // LIGHT_LINE
219	new Mix(new SysCol(SWT.COLOR_GRAY), new SysCol(SWT.COLOR_LIST_BACKGROUND), 1, 6), // BACKGROUND_NAME
220	};
221
222	private Color _colors[];
223
224	public TraceColorScheme() {
225	_colors = new Color[_providersMap.length];
226	}
227
228	public void dispose() {
229	for (int i = 0; i < _colors.length; i++) {
230	Utils.dispose(_colors[i]);
231	_colors[i] = null;
232	}
233	}
234
235	public Color getColor(int idx) {
236	if (null == _colors[idx]) {
237	if (idx >= STATES_SEL0 && idx <= STATES_SEL1) {
238	Color col1 = getColor(idx - STATES_SEL0);
239	Color col2 = getColor(BACKGROUND_SEL);
240	_colors[idx] = Utils.mixColors(col1, col2, 3, 1);
241	} else {
242	_colors[idx] = _providersMap[idx].get();
243	}
244	}
245	return _colors[idx];
246	}
247
248	public Color getBkColor(boolean selected, boolean focused, boolean name) {
249	if (selected && focused)
250	return getColor(BACKGROUND_SEL);
251	if (selected)
252	return getColor(BACKGROUND_SEL_NOFOCUS);
253	if (name)
254	return getColor(BACKGROUND_NAME);
255	return getColor(BACKGROUND);
256	}
257
258	public Color getFgColor(boolean selected, boolean focused) {
259	if (selected && focused)
260	return getColor(FOREGROUND_SEL);
261	if (selected)
262	return getColor(FOREGROUND_SEL_NOFOCUS);
263	return getColor(FOREGROUND);
264	}
265
266	public Color getBkColorGroup(boolean selected, boolean focused) {
267	if (selected && focused)
268	return getColor(GR_BACKGROUND_SEL);
269	if (selected)
270	return getColor(GR_BACKGROUND_SEL_NOFOCUS);
271	return getColor(GR_BACKGROUND);
272	}
273
274	public Color getFgColorGroup(boolean selected, boolean focused) {
275	if (selected && focused)
276	return getColor(GR_FOREGROUND_SEL);
277	if (selected)
278	return getColor(GR_FOREGROUND_SEL_NOFOCUS);
279	return getColor(GR_FOREGROUND);
280	}
281	}

Line 1 Link Here

(-)CVS (+63 lines)
	1	/*****************************************************************************
	2	* Copyright (c) 1997-2006, Intel Corporation.
	3	* All rights reserved. This program and the accompanying materials
	4	* are made available under the terms of the Eclipse Public License v1.0
	5	* which accompanies this distribution, and is available at
	6	* http://www.eclipse.org/legal/epl-v10.html
	7	*
	8	* Contributors:
	9	* Intel Corporation - Initial API and implementation
	10	* Ruslan A. Scherbakov, Intel - Initial API and implementation
	11	*
	12	* $Id$
	13	*****************************************************************************/
	14
	15	package org.eclipse.tptp.trace.jvmti.internal.client.widgets;
	16
	17	import org.eclipse.swt.SWT;
	18	import org.eclipse.swt.events.PaintEvent;
	19	import org.eclipse.swt.events.PaintListener;
	20	import org.eclipse.swt.graphics.Color;
	21	import org.eclipse.swt.graphics.GC;
	22	import org.eclipse.swt.graphics.Point;
	23	import org.eclipse.swt.graphics.Rectangle;
	24	import org.eclipse.swt.widgets.Canvas;
	25	import org.eclipse.swt.widgets.Composite;
	26
	27	public abstract class TraceCtrl extends Canvas implements PaintListener {
	28
	29	protected TraceColorScheme _colors;
	30	protected Rectangle _rect0 = new Rectangle(0, 0, 0, 0);
	31	protected Rectangle _rect1 = new Rectangle(0, 0, 0, 0);
	32
	33	public TraceCtrl(Composite parent, TraceColorScheme colors) {
	34	this(parent, colors, SWT.NO_BACKGROUND \| SWT.NO_FOCUS);
	35	}
	36
	37	public TraceCtrl(Composite parent, TraceColorScheme colors, int style) {
	38	super(parent, style);
	39	_colors = colors;
	40	addPaintListener(this);
	41	}
	42
	43	public void dispose() {
	44	super.dispose();
	45	}
	46
	47	public void paintControl(PaintEvent e) {
	48	if (e.widget != this)
	49	return;
	50	Point size = getSize();
	51	if (size.x > 0 && size.y > 0) {
	52	Color colBackup = e.gc.getBackground();
	53	Utils.init(_rect0, 0, 0, size.x, size.y);
	54	paint(_rect0, e.gc);
	55	e.gc.setBackground(colBackup);
	56	}
	57	}
	58
	59	void paint(Rectangle rect, GC gc) {
	60	gc.setBackground(_colors.getColor(TraceColorScheme.BACKGROUND));
	61	gc.fillRectangle(rect);
	62	}
	63	}

Line 1 Link Here

(-)CVS (+168 lines)
		1	/*****************************************************************************
		2	* Copyright (c) 1997-2006, Intel Corporation.
		3	* All rights reserved. This program and the accompanying materials
		4	* are made available under the terms of the Eclipse Public License v1.0
		5	* which accompanies this distribution, and is available at
		6	* http://www.eclipse.org/legal/epl-v10.html
		7	*
		8	* Contributors:
		9	* Intel Corporation - Initial API and implementation
		10	* Ruslan A. Scherbakov, Intel - Initial API and implementation
		11	*
		12	* $Id$
		13	*****************************************************************************/
		14
		15	package org.eclipse.tptp.trace.jvmti.internal.client.widgets;
		16
		17	import org.eclipse.hyades.models.trace.TRCThreadDeadEvent;
		18	import org.eclipse.hyades.models.trace.TRCThreadDeadLockEvent;
		19	import org.eclipse.hyades.models.trace.TRCThreadEvent;
		20	import org.eclipse.hyades.models.trace.TRCThreadRunningEvent;
		21	import org.eclipse.hyades.models.trace.TRCThreadSleepingEvent;
		22	import org.eclipse.hyades.models.trace.TRCThreadWaitingForLockEvent;
		23	import org.eclipse.hyades.models.trace.TRCThreadWaitingForObjectEvent;
		24	import org.eclipse.swt.SWT;
		25	import org.eclipse.swt.graphics.Color;
		26	import org.eclipse.swt.graphics.Device;
		27	import org.eclipse.swt.graphics.GC;
		28	import org.eclipse.swt.graphics.Point;
		29	import org.eclipse.swt.graphics.Rectangle;
		30	import org.eclipse.swt.widgets.Display;
		31
		32	public class Utils {
		33
		34	static public void init(Rectangle rect) {
		35	rect.x = 0;
		36	rect.y = 0;
		37	rect.width = 0;
		38	rect.height = 0;
		39	}
		40
		41	static public void init(Rectangle rect, int x, int y, int width, int height) {
		42	rect.x = x;
		43	rect.y = y;
		44	rect.width = width;
		45	rect.height = height;
		46	}
		47
		48	static public void init(Rectangle rect, Rectangle source) {
		49	rect.x = source.x;
		50	rect.y = source.y;
		51	rect.width = source.width;
		52	rect.height = source.height;
		53	}
		54
		55	static public void deflate(Rectangle rect, int x, int y) {
		56	rect.x += x;
		57	rect.y += y;
		58	rect.width -= x + x;
		59	rect.height -= y + y;
		60	}
		61
		62	static public void inflate(Rectangle rect, int x, int y) {
		63	rect.x -= x;
		64	rect.y -= y;
65	rect.width += x + x;
66	rect.height += y + y;
67	}
68
69	static void dispose(Color col) {
70	if (null != col)
71	col.dispose();
72	}
73
74	static public Color mixColors(Device display, Color c1, Color c2, int w1,
75	int w2) {
76	return new Color(display, (w1 * c1.getRed() + w2 * c2.getRed())
77	/ (w1 + w2), (w1 * c1.getGreen() + w2 * c2.getGreen())
78	/ (w1 + w2), (w1 * c1.getBlue() + w2 * c2.getBlue())
79	/ (w1 + w2));
80	}
81
82	static public Color getSysColor(int id) {
83	return Display.getCurrent().getSystemColor(id);
84	}
85
86	static public Color mixColors(Color col1, Color col2, int w1, int w2) {
87	return mixColors(Display.getCurrent(), col1, col2, w1, w2);
88	}
89
90	static public void drawState(TraceColorScheme colors, TRCThreadEvent event,
91	Rectangle rect, GC gc, boolean selected, boolean rectBound, boolean timeSelected) {
92	int colorIdx = getEventColor(event);
93	drawState(colors, colorIdx, rect, gc, selected, rectBound, timeSelected);
94	}
95
96	static public void drawState(TraceColorScheme colors, int colorIdx,
97	Rectangle rect, GC gc, boolean selected, boolean rectBound, boolean timeSelected) {
98	if (rect.isEmpty())
99	return;
100	// FILL RECT
101	int colorIdx1 = colorIdx;
102	timeSelected = timeSelected && selected;
103	if (selected)
104	colorIdx1 = colorIdx + TraceColorScheme.STATES_SEL0 - TraceColorScheme.STATES0;
105	gc.setBackground(colors.getColor(colorIdx1));
106	gc.fillRectangle(rect);
107	colorIdx1 = colorIdx + TraceColorScheme.STATES_BORDER0 - TraceColorScheme.STATES0;
108	gc.setForeground(colors.getColor(colorIdx1));
109	// DRAW BOUNDS
110	if (!timeSelected) {
111	if (rectBound && rect.width >= 3) {
112	gc.drawRectangle(rect.x, rect.y, rect.width - 1, rect.height - 1);
113	} else {
114	gc.drawLine(rect.x, rect.y, rect.x + rect.width - 1, rect.y);
115	gc.drawLine(rect.x, rect.y + rect.height - 1, rect.x + rect.width - 1, rect.y + rect.height - 1);
116	}
117	}
118	// DRAW MID LINE
119	int mindy = rect.y + rect.height / 2;
120	if (TraceColorScheme.BLOCKED == colorIdx \|\| TraceColorScheme.WAITING == colorIdx) {
121	int s = gc.getLineStyle();
122	int w = gc.getLineWidth();
123	gc.setLineStyle(SWT.LINE_DOT);
124	gc.setLineWidth(2);
125	gc.drawLine(rect.x, mindy, rect.x + rect.width, mindy);
126	gc.setLineStyle(s);
127	gc.setLineWidth(w);
128	} else if (TraceColorScheme.DEADLOCK == colorIdx \|\| TraceColorScheme.STOPPED == colorIdx) {
129	int w = gc.getLineWidth();
130	gc.setLineWidth(2);
131	gc.drawLine(rect.x, mindy, rect.x + rect.width, mindy);
132	gc.setLineWidth(w);
133	}
134	// DRAW SELECTED BOUNDS
135	if (timeSelected) {
136	if (rect.width >= 3) {
137	gc.setForeground(colors.getColor(TraceColorScheme.SELECTED_TIME));
138	gc.drawRectangle(rect.x, rect.y, rect.width - 1, rect.height - 1);
139	//gc.drawRectangle(rect.x + 1, rect.y + 1, rect.width - 3, rect.height - 3);
140	} else {
141	gc.drawLine(rect.x, rect.y, rect.x + rect.width - 1, rect.y);
142	gc.drawLine(rect.x, rect.y + rect.height - 1, rect.x + rect.width - 1, rect.y + rect.height - 1);
143	}
144	}
145	}
146
147	static public int getEventColor(TRCThreadEvent event) {
148	if (event instanceof TRCThreadRunningEvent)
149	return TraceColorScheme.RUNNING;
150	else if (event instanceof TRCThreadSleepingEvent)
151	return TraceColorScheme.SLEEPING;
152	else if (event instanceof TRCThreadDeadLockEvent)
153	return TraceColorScheme.DEADLOCK;
154	else if (event instanceof TRCThreadWaitingForLockEvent)
155	return TraceColorScheme.BLOCKED;
156	else if (event instanceof TRCThreadWaitingForObjectEvent)
157	return TraceColorScheme.WAITING;
158	else if (event instanceof TRCThreadDeadEvent)
159	return TraceColorScheme.STOPPED;
160	return TraceColorScheme.UNKNOWN;
161	}
162
163	static public int drawText(GC gc, String text, Rectangle rect, boolean transp) {
164	Point size = gc.stringExtent(text);
165	gc.drawText(text, rect.x, rect.y, transp);
166	return size.x;
167	}
168	}