/*******************************************************************************
* Copyright (c) 2009 the CHISEL group and contributors. 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: Del Myers - initial API and implementation
*******************************************************************************/
package ca.uvic.chisel.javasketch.ui.internal.presentation;
import java.lang.reflect.InvocationTargetException;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import org.eclipse.core.runtime.IAdaptable;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.ListenerList;
import org.eclipse.core.runtime.Status;
import org.eclipse.core.runtime.jobs.ISchedulingRule;
import org.eclipse.core.runtime.jobs.Job;
import org.eclipse.jdt.core.IJavaElement;
import org.eclipse.jdt.core.IMethod;
import org.eclipse.jdt.core.IType;
import org.eclipse.jface.action.Action;
import org.eclipse.jface.action.ContributionItem;
import org.eclipse.jface.action.IAction;
import org.eclipse.jface.action.IMenuListener;
import org.eclipse.jface.action.IMenuManager;
import org.eclipse.jface.action.MenuManager;
import org.eclipse.jface.action.Separator;
import org.eclipse.jface.operation.IRunnableWithProgress;
import org.eclipse.jface.preference.IPreferenceStore;
import org.eclipse.jface.resource.ImageDescriptor;
import org.eclipse.jface.resource.ImageRegistry;
import org.eclipse.jface.util.IPropertyChangeListener;
import org.eclipse.jface.util.PropertyChangeEvent;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.ISelectionChangedListener;
import org.eclipse.jface.viewers.ISelectionProvider;
import org.eclipse.jface.viewers.IStructuredContentProvider;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jface.viewers.SelectionChangedEvent;
import org.eclipse.jface.viewers.StructuredSelection;
import org.eclipse.jface.viewers.Viewer;
import org.eclipse.jface.viewers.ViewerFilter;
import org.eclipse.swt.SWT;
import org.eclipse.swt.events.ModifyEvent;
import org.eclipse.swt.events.ModifyListener;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.events.SelectionListener;
import org.eclipse.swt.graphics.Point;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Menu;
import org.eclipse.swt.widgets.Widget;
import org.eclipse.ui.IMemento;
import org.eclipse.ui.ISelectionListener;
import org.eclipse.ui.IViewSite;
import org.eclipse.ui.IWorkbenchPage;
import org.eclipse.ui.IWorkbenchPart;
import org.eclipse.ui.PartInitException;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.commands.ICommandService;
import org.eclipse.ui.internal.operations.TimeTriggeredProgressMonitorDialog;
import org.eclipse.ui.menus.CommandContributionItem;
import org.eclipse.ui.menus.CommandContributionItemParameter;
import org.eclipse.ui.part.ViewPart;
import org.eclipse.ui.progress.UIJob;
import org.eclipse.ui.views.contentoutline.IContentOutlinePage;
import org.eclipse.ui.views.properties.IPropertySheetPage;
import org.eclipse.ui.views.properties.tabbed.ITabbedPropertySheetPageContributor;
import org.eclipse.ui.views.properties.tabbed.TabbedPropertySheetPage;
import org.eclipse.zest.custom.sequence.widgets.Activation;
import org.eclipse.zest.custom.sequence.widgets.Call;
import org.eclipse.zest.custom.sequence.widgets.Message;
import org.eclipse.zest.custom.sequence.widgets.MessageGroup;
import org.eclipse.zest.custom.sequence.widgets.UMLItem;
import org.eclipse.zest.custom.sequence.widgets.UMLSequenceChart;
import org.eclipse.zest.custom.uml.viewers.BreadCrumbViewer;
import org.eclipse.zest.custom.uml.viewers.IMessageGrouping;
import org.eclipse.zest.custom.uml.viewers.ISequenceContentExtension2;
import org.eclipse.zest.custom.uml.viewers.ISequenceViewerListener;
import org.eclipse.zest.custom.uml.viewers.SequenceViewerEvent;
import org.eclipse.zest.custom.uml.viewers.SequenceViewerGroupEvent;
import org.eclipse.zest.custom.uml.viewers.SequenceViewerRootEvent;
import org.eclipse.zest.custom.uml.viewers.UMLSequenceViewer;
import ca.uvic.chisel.javasketch.IProgramSketch;
import ca.uvic.chisel.javasketch.ISketchEventListener;
import ca.uvic.chisel.javasketch.ISketchInterestListener;
import ca.uvic.chisel.javasketch.SketchEvent;
import ca.uvic.chisel.javasketch.SketchInterestEvent;
import ca.uvic.chisel.javasketch.SketchPlugin;
import ca.uvic.chisel.javasketch.data.model.IActivation;
import ca.uvic.chisel.javasketch.data.model.IActivationEvent;
import ca.uvic.chisel.javasketch.data.model.ICall;
import ca.uvic.chisel.javasketch.data.model.IMessage;
import ca.uvic.chisel.javasketch.data.model.IOriginMessage;
import ca.uvic.chisel.javasketch.data.model.ITargetMessage;
import ca.uvic.chisel.javasketch.data.model.IThread;
import ca.uvic.chisel.javasketch.data.model.ITraceClass;
import ca.uvic.chisel.javasketch.data.model.ITraceClassMethod;
import ca.uvic.chisel.javasketch.data.model.ITraceEvent;
import ca.uvic.chisel.javasketch.data.model.ITraceEventListener;
import ca.uvic.chisel.javasketch.data.model.ITraceMetaEvent;
import ca.uvic.chisel.javasketch.data.model.ITraceModel;
import ca.uvic.chisel.javasketch.data.model.ITraceModelProxy;
import ca.uvic.chisel.javasketch.data.model.imple.internal.ActivationImpl;
import ca.uvic.chisel.javasketch.data.model.imple.internal.ThreadImpl;
import ca.uvic.chisel.javasketch.data.model.imple.internal.TraceImpl;
import ca.uvic.chisel.javasketch.internal.ast.groups.ASTMessageGroupingTree;
import ca.uvic.chisel.javasketch.ui.ISketchImageConstants;
import ca.uvic.chisel.javasketch.ui.internal.preferences.ISketchPluginPreferences;
import ca.uvic.chisel.javasketch.ui.internal.presentation.MarkRangeForSelectionJob.InvocationReference;
import ca.uvic.chisel.javasketch.ui.internal.presentation.commands.CollapseAllHandler;
import ca.uvic.chisel.javasketch.ui.internal.presentation.commands.ExpandAllHandler;
import ca.uvic.chisel.javasketch.ui.internal.presentation.commands.FocusInHandler;
import ca.uvic.chisel.javasketch.ui.internal.presentation.commands.FocusUpHandler;
import ca.uvic.chisel.javasketch.ui.internal.presentation.commands.ScreenshotHandler;
import ca.uvic.chisel.javasketch.ui.internal.presentation.commands.SelectIterationAction;
import ca.uvic.chisel.javasketch.ui.internal.presentation.metadata.PresentationData;
import ca.uvic.chisel.widgets.RangeAnnotation;
import ca.uvic.chisel.widgets.RangeSlider;
import ca.uvic.chisel.widgets.TimeField;
@SuppressWarnings("restriction")
public class JavaThreadSequenceView extends ViewPart implements IJavaSketchPresenter,
ITabbedPropertySheetPageContributor, ISketchInterestListener {
public static final String VIEW_ID = "ca.uvic.chisel.javasketch.threadView";
private static final String LAST_TRACE = "last_trace";
private static final String LAST_THREAD = "last_thread";
private class InternalSelectionProvider implements ISelectionProvider {
ListenerList selectionListeners = new ListenerList();
private ISelection selection = StructuredSelection.EMPTY;
/* (non-Javadoc)
* @see org.eclipse.jface.viewers.ISelectionProvider#addSelectionChangedListener(org.eclipse.jface.viewers.ISelectionChangedListener)
*/
@Override
public void addSelectionChangedListener(
ISelectionChangedListener listener) {
selectionListeners.add(listener);
}
/* (non-Javadoc)
* @see org.eclipse.jface.viewers.ISelectionProvider#getSelection()
*/
@Override
public ISelection getSelection() {
return selection;
}
/* (non-Javadoc)
* @see org.eclipse.jface.viewers.ISelectionProvider#removeSelectionChangedListener(org.eclipse.jface.viewers.ISelectionChangedListener)
*/
@Override
public void removeSelectionChangedListener(
ISelectionChangedListener listener) {
selectionListeners.remove(listener);
}
/* (non-Javadoc)
* @see org.eclipse.jface.viewers.ISelectionProvider#setSelection(org.eclipse.jface.viewers.ISelection)
*/
@Override
public void setSelection(ISelection selection) {
if (selection == null) {
return;
}
if (this.selection != null) {
if (this.selection.equals(selection)) {
return;
}
}
this.selection = selection;
SelectionChangedEvent event = new SelectionChangedEvent(this, selection);
for (Object o : selectionListeners.getListeners()) {
((ISelectionChangedListener)o).selectionChanged(event);
}
//update commands
ICommandService service = (ICommandService) SketchPlugin.getDefault().getWorkbench().getService(ICommandService.class);
if (service != null) {
service.refreshElements(FocusInHandler.COMMAND_ID, null);
}
}
public void dispose() {
selectionListeners.clear();
}
}
/**
* @author Del Myers
*
*/
private final class InternalSelectionChangedListener implements
ISelectionChangedListener {
@Override
public void selectionChanged(SelectionChangedEvent event) {
IJavaElement[] elements = new IJavaElement[0];
if (javaSelection != null) {
elements = javaSelection.toArray(elements);
}
rangeJob.cancel();
rangeJob.schedule(elements);
selectionProvider.setSelection(event.getSelection());
}
}
/**
* @author Del Myers
*
*/
private final class PresentationListener implements ISequenceViewerListener, ISchedulingRule {
private IProgressMonitor progress;
@Override
public void rootChanged(SequenceViewerRootEvent event) {
if (isCancelled()) {
reset();
return;
}
PresentationData pd = PresentationData.connect(getSketch());
if (pd != null) {
try {
pd.setThreadRoot(thread, (IActivation) event
.getSequenceViewer().getRootActivation());
} finally {
pd.disconnect();
}
}
}
@Override
public void groupExpanded(SequenceViewerGroupEvent event) {
if (isCancelled()) {
reset();
return;
}
setGroupExpansion(event, true);
}
private void setGroupExpansion(SequenceViewerGroupEvent event, boolean b) {
if (isCancelled()) {
reset();
return;
}
PresentationData pd = PresentationData.connect(getSketch());
if (pd != null) {
try {
ASTMessageGroupingTree grouping = getGroupIng(event
.getGroup());
if (grouping != null) {
pd.setGroupExpanded((IActivation) event.getGroup()
.getActivationElement(), grouping, b);
}
} finally {
pd.disconnect();
}
}
}
@Override
public void groupCollapsed(SequenceViewerGroupEvent event) {
if (isCancelled()) {
reset();
return;
}
setGroupExpansion(event, false);
}
@Override
public void elementExpanded(SequenceViewerEvent event) {
if (isCancelled()) {
reset();
return;
}
setActivationExpanded(event, true);
internalResetExpansionStates((IActivation) event.getElement());
}
/**
*
*/
private void reset() {
this.progress = null;
}
@Override
public void elementCollapsed(SequenceViewerEvent event) {
if (isCancelled()) {
reset();
return;
}
setActivationExpanded(event, false);
}
/**
* @return
*/
private boolean isCancelled() {
return (progress != null && progress.isCanceled());
}
private void setActivationExpanded(SequenceViewerEvent event, boolean b) {
if (event.getElement() instanceof IActivation) {
PresentationData pd = PresentationData.connect(getSketch());
if (pd != null) {
try {
pd.setActivationExpanded((IActivation) event
.getElement(), b);
} finally {
pd.disconnect();
}
}
}
}
/* (non-Javadoc)
* @see org.eclipse.core.runtime.jobs.ISchedulingRule#contains(org.eclipse.core.runtime.jobs.ISchedulingRule)
*/
@Override
public boolean contains(ISchedulingRule rule) {
if (isConflicting(rule)) {
return true;
}
return false;
}
/* (non-Javadoc)
* @see org.eclipse.core.runtime.jobs.ISchedulingRule#isConflicting(org.eclipse.core.runtime.jobs.ISchedulingRule)
*/
@Override
public boolean isConflicting(ISchedulingRule rule) {
return (rule instanceof PresentationListener);
}
/**
* @param monitor
*/
public void setProgress(IProgressMonitor monitor) {
this.progress = monitor;
}
}
/**
* @author Del Myers
*
*/
private final class ISketchEventListenerImplementation implements
ISketchEventListener {
@Override
public void handleSketchEvent(final SketchEvent fevent) {
getViewSite().getShell().getDisplay().asyncExec(new Runnable() {
public void run() {
try {
IProgramSketch sketch = SketchPlugin.getDefault()
.getSketch(thread);
SketchEvent event = fevent;
if (sketch != null && sketch.equals(event.getSketch())) {
switch (event.getType()) {
case SketchAnalysisStarted:
case SketchAnalysisEnded:
case SketchAnalysisInterrupted:
case SketchRefreshed:
if (thread != null && !thread.isValid()) {
for (IThread test : sketch.getTraceData()
.getThreads()) {
if (test.getID() == thread.getID()
&& test.getName().equals(
thread.getName())) {
setInput(test);
return;
}
}
thread = null;
setInput(thread);
} else {
resetViewers();
}
break;
case SketchDeleted:
setInput(null);
break;
}
}
} catch (Throwable t) {
t.printStackTrace();
}
}
});
}
}
private final class RefreshActivationListener implements
ITraceEventListener {
/*
* (non-Javadoc)
* @see
* ca.uvic.chisel.javasketch.data.model.ITraceEventListener#handleEvents
* (ca.uvic.chisel.javasketch.data.model.ITraceEvent[])
*/
@Override
public void handleEvents(ITraceEvent[] events) {
for (ITraceEvent event : events) {
switch (event.getType()) {
case ActivationEventType:
IActivation[] activations = ((IActivationEvent) event)
.getActivations();
refreshActivationsJob.cancel();
refreshActivationsJob.schedule(activations);
break;
}
}
}
}
private class RefreshActivationsJob extends UIJob {
private IActivation[] activations;
public RefreshActivationsJob() {
super("Refreshing Activations");
activations = new IActivation[0];
}
/*
* (non-Javadoc)
* @see
* org.eclipse.ui.progress.UIJob#runInUIThread(org.eclipse.core.runtime
* .IProgressMonitor)
*/
@Override
public IStatus runInUIThread(IProgressMonitor monitor) {
synchronized (activations) {
for (IActivation activation : activations) {
viewer.refresh(activation);
}
}
return Status.OK_STATUS;
}
public void schedule(IActivation[] activations) {
if (activations == null) {
return;
}
synchronized (this.activations) {
if (activations.length != this.activations.length) {
this.activations = new IActivation[activations.length];
}
System.arraycopy(activations, 0, this.activations, 0,
activations.length);
}
if (this.activations.length > 0) {
schedule();
}
}
}
private class RequestReconnaissanceJob extends Job {
private class FilterAnimator implements Runnable {
private int index = 0;
private boolean up;
private boolean running = false;
FilterAnimator() {
}
/* (non-Javadoc)
* @see java.lang.Runnable#run()
*/
@Override
public void run() {
if (running) {
enableReconnaissanceAction.setImageDescriptor(filterImages[index]);
if (up) {
index++;
if (index >= filterImages.length) {
index = filterImages.length-2;
up = false;
}
} else {
index--;
if (index < 0) {
index = 1;
up = true;
}
}
PlatformUI.getWorkbench().getDisplay().timerExec(150, this);
} else {
if (enableReconnaissanceAction.isChecked()) {
enableReconnaissanceAction.setImageDescriptor(filterImages[3]);
} else {
enableReconnaissanceAction.setImageDescriptor(filterImages[0]);
}
}
}
public void stop() {
running = false;
}
public void start() {
if (!running) {
running = true;
index = 0;
PlatformUI.getWorkbench().getDisplay().asyncExec(this);
}
}
}
private FilterAnimator animator;
/**
* @param name
*/
public RequestReconnaissanceJob() {
super("Filtering Thread");
animator = new FilterAnimator();
}
/* (non-Javadoc)
* @see org.eclipse.core.runtime.jobs.Job#run(org.eclipse.core.runtime.IProgressMonitor)
*/
@Override
protected IStatus run(IProgressMonitor monitor) {
animator.start();
SketchPlugin.getDefault().getDOI().requestFiltering(thread, monitor);
IPreferenceStore store = SketchPlugin.getDefault().getPreferenceStore();
if (monitor.isCanceled()) {
store.setValue(ISketchPluginPreferences.DIAGRAM_RECONNAISSANCE, false);
enableReconnaissanceAction.setChecked(false);
animator.stop();
return Status.CANCEL_STATUS;
} else {
store.setValue(ISketchPluginPreferences.DIAGRAM_RECONNAISSANCE, true);
animator.start();
enableReconnaissanceAction.setChecked(true);
}
animator.stop();
if (store.getBoolean(ISketchPluginPreferences.DIAGRAM_RECON_HIDE)) {
refreshJob.cancel();
refreshJob.schedule();
} else {
getSite().getWorkbenchWindow().getShell().getDisplay().asyncExec(new Runnable(){
@Override
public void run() {
updateForReconnaissanceFiltering();
updateAll();
}
});
}
return Status.OK_STATUS;
}
}
private class RequestReconnaissanceAction extends Action {
/* (non-Javadoc)
* @see org.eclipse.jface.action.Action#run()
*/
/**
*
*/
public RequestReconnaissanceAction() {
super("Filter", IAction.AS_CHECK_BOX);
}
@Override
public void run() {
IPreferenceStore store = SketchPlugin.getDefault().getPreferenceStore();
if (isChecked()) {
requestReconnaissanceJob.cancel();
requestReconnaissanceJob.schedule();
setImageDescriptor(filterImages[3]);
} else {
store.setValue(ISketchPluginPreferences.DIAGRAM_RECONNAISSANCE, false);
setImageDescriptor(filterImages[0]);
requestReconnaissanceJob.cancel();
if (store.getBoolean(ISketchPluginPreferences.DIAGRAM_RECON_HIDE)) {
refreshJob.cancel();
refreshJob.schedule();
} else {
updateForReconnaissanceFiltering();
updateAll();
}
}
}
}
public class ToggleReconFilterAction extends Action {
/**
*
*/
public ToggleReconFilterAction() {
super("Exclude Hidden Method Calls", IAction.AS_CHECK_BOX);
}
public void run() {
IPreferenceStore store = SketchPlugin.getDefault().getPreferenceStore();
store.setValue(ISketchPluginPreferences.DIAGRAM_RECON_HIDE, isChecked());
if (store.getBoolean(ISketchPluginPreferences.DIAGRAM_RECONNAISSANCE)) {
refreshJob.cancel();
refreshJob.schedule();
}
}
}
private class SwapLoopAction extends Action {
private IActivation activation;
private ASTMessageGroupingTree nodeToSwap;
public SwapLoopAction(IActivation a, ASTMessageGroupingTree nodeToSwap) {
this.activation = a;
this.nodeToSwap = nodeToSwap;
}
/*
* (non-Javadoc)
* @see org.eclipse.jface.action.Action#run()
*/
@Override
public void run() {
PresentationData pd = PresentationData.connect(SketchPlugin
.getDefault().getSketch(activation));
if (pd != null) {
try {
pd.swapLoop(activation, nodeToSwap, reconnaissanceEnabled() && hidingUnusedCalls());
} finally {
pd.disconnect();
}
viewer.refresh(activation);
resetExpansionStates(activation);
}
super.run();
}
}
private class InternalPreferenceListener implements IPropertyChangeListener{
/* (non-Javadoc)
* @see org.eclipse.jface.util.IPropertyChangeListener#propertyChange(org.eclipse.jface.util.PropertyChangeEvent)
*/
@Override
public void propertyChange(PropertyChangeEvent event) {
String property = event.getProperty();
if (ISketchPluginPreferences.COMPACT_LOOPS_PREFERENCE.equals(property) ||
ISketchPluginPreferences.DISPLAY_GROUPS_PREFERENCE.equals(property)) {
refreshJob.cancel();
refreshJob.schedule();
}
}
}
UMLSequenceViewer viewer;
private InternalSelectionProvider selectionProvider;
private UIJob refreshJob;
private RangeSlider timeRange;
private ContributionItem collapseAllAction;
private ContributionItem expandAllAction;
private ContributionItem focusInAction;
private ContributionItem focusUpAction;
private RequestReconnaissanceAction enableReconnaissanceAction;
private ThumbnailOutlinePage outlinePage;
private BreadCrumbViewer breadcrumb;
private ISelectionListener javaSelectionListener;
private MarkRangeForSelectionJob rangeJob;
private ISketchEventListener sketchListener;
private IThread thread;
private RefreshActivationsJob refreshActivationsJob;
private RequestReconnaissanceJob requestReconnaissanceJob;
private ITraceEventListener activationChangeListener;
private PresentationListener presentationListener;
private ArrayList<IJavaElement> javaSelection;
private ISelectionChangedListener internalSelectionListener;
private TimeField maxTime;
private TimeField minTime;
private InternalPreferenceListener preferenceListener;
private ImageDescriptor[] filterImages;
private ToggleReconFilterAction toggleReconFilterAction;
public JavaThreadSequenceView() {
refreshJob = new UIJob("Refreshing sequence viewer") {
@Override
public IStatus runInUIThread(IProgressMonitor monitor) {
try {
viewer.refresh();
} catch (Exception e) {
IStatus status = new Status(IStatus.ERROR,
SketchPlugin.PLUGIN_ID,
"Error refreshing sequence viewer", e);
SketchPlugin.getDefault().getLog().log(status);
}
return Status.OK_STATUS;
}
};
requestReconnaissanceJob = new RequestReconnaissanceJob();
activationChangeListener = new RefreshActivationListener();
this.refreshActivationsJob = new RefreshActivationsJob();
preferenceListener = new InternalPreferenceListener();
javaSelectionListener = new ISelectionListener() {
@Override
public void selectionChanged(IWorkbenchPart part,
ISelection selection) {
updateForSelection(selection);
}
};
}
/**
* @param selection
*/
protected void updateForSelection(ISelection selection) {
ArrayList<IJavaElement> javaElements = new ArrayList<IJavaElement>();
if (selection instanceof IStructuredSelection) {
IStructuredSelection ss = (IStructuredSelection) selection;
Iterator<?> iterator = ss.iterator();
while (iterator.hasNext()) {
Object o = iterator.next();
if (o instanceof IAdaptable) {
IJavaElement element = (IJavaElement) ((IAdaptable) o)
.getAdapter(IJavaElement.class);
if (element instanceof IType) {
javaElements.add(element);
} else if (element instanceof IMethod) {
javaElements.add(element);
}
}
}
}
if (javaElements.size() > 0) {
this.javaSelection = javaElements;
rangeJob.cancel();
rangeJob.schedule(javaElements
.toArray(new IJavaElement[javaElements.size()]));
}
}
public void setInput(IThread newInput) {
if (newInput == thread) {
return;
}
if (thread != null) {
thread.getTrace().removeListener(activationChangeListener);
}
thread = newInput;
if (thread != null) {
thread.getTrace().addListener(activationChangeListener);
setPartName(thread.getName());
}
final IActivation activation = thread.getRoot().getActivation();
resetExpansionStates(activation);
}
/**
*
*/
public void resetExpansionStates(final IActivation activation) {
IRunnableWithProgress initializer = new IRunnableWithProgress() {
@Override
public void run(IProgressMonitor monitor) {
monitor.beginTask("Initializing Sequence Diagram", IProgressMonitor.UNKNOWN);
presentationListener.setProgress(monitor);
if (viewer != null) {
resetViewers();
PresentationData pd = PresentationData.connect(getSketch());
if (pd != null) {
try {
if (pd.isExpanded(activation)) {
viewer.setExpanded(activation,
true);
}
} finally {
pd.disconnect();
}
}
if (enableReconnaissanceAction.isChecked()) {
requestReconnaissanceJob.cancel();
requestReconnaissanceJob.schedule();
}
}
updateForReconnaissanceFiltering();
monitor.done();
}
};
try {
getSite().getWorkbenchWindow().getWorkbench().getProgressService().runInUI(getSite().getWorkbenchWindow(), initializer, presentationListener);
} catch (InvocationTargetException e) {
SketchPlugin.getDefault().log(e);
} catch (InterruptedException e) {
}
}
/**
* Just sets the background color for when reconnaissance filtering is enabled
* to make sure that the user can know whether the current visualized thread
* is in the active trace.
*/
private void updateForReconnaissanceFiltering() {
UMLSequenceChart chart = viewer.getChart();
IProgramSketch activeSketch = SketchPlugin.getDefault().getActiveSketch();
chart.setBackground(Display.getCurrent().getSystemColor(SWT.COLOR_WHITE));
if (reconnaissanceEnabled()) {
if (activeSketch != null) {
if (!activeSketch.equals(SketchPlugin.getDefault().getSketch(thread))) {
chart.setBackground(Display.getCurrent().getSystemColor(SWT.COLOR_GRAY));
}
}
}
}
/**
*
*/
protected void internalResetExpansionStates(IActivation activation) {
if (!viewer.getExpanded(activation))
return;
PresentationData pd = PresentationData.connect(getSketch());
if (pd != null) {
try {
// use the widget itself because it will be faster than
// querying the content provider again
viewer.getChart().setRedraw(false);
Widget w = viewer.testFindItem(activation);
if (w instanceof Activation) {
Activation aw = (Activation) w;
for (Message m : aw.getMessages()) {
//read and dispatch so things don't get look like they
//hang
if (m instanceof Call) {
Call c = (Call) m;
Activation target = c.getTarget();
if (target != null && !target.isDisposed()
&& target.getData() instanceof IActivation) {
IActivation ta = (IActivation) target.getData();
viewer.setExpanded(ta, pd.isExpanded(ta));
viewer.getChart().getDisplay().readAndDispatch();
}
}
}
for (MessageGroup group : aw.getMessageGroups()) {
IMessageGrouping o = (IMessageGrouping) group.getData();
if (o instanceof IAdaptable) {
ASTMessageGroupingTree node = (ASTMessageGroupingTree) ((IAdaptable) o)
.getAdapter(ASTMessageGroupingTree.class);
if (node != null) {
viewer.setGroupingExpanded(o, pd
.isGroupExpanded(activation, node));
viewer.getChart().getDisplay().readAndDispatch();
}
}
}
}
} catch (Exception e) {
SketchPlugin.getDefault().log(e);
} finally {
pd.disconnect();
viewer.getChart().setRedraw(true);
}
}
}
protected ASTMessageGroupingTree getGroupIng(IMessageGrouping group) {
if (group instanceof IAdaptable) {
IAdaptable adapt = (IAdaptable) group;
return (ASTMessageGroupingTree) adapt
.getAdapter(ASTMessageGroupingTree.class);
}
return null;
}
protected IProgramSketch getSketch() {
return SketchPlugin.getDefault().getSketch(thread);
}
/*
* (non-Javadoc)
* @see org.eclipse.ui.part.ViewPart#saveState(org.eclipse.ui.IMemento)
*/
@Override
public void saveState(IMemento memento) {
if (memento == null) {
return;
}
if (thread == null) {
return;
}
memento.putString(LAST_TRACE, thread.getTrace().getLaunchID());
memento.putString(LAST_THREAD, thread.getIdentifier());
super.saveState(memento);
}
/*
* (non-Javadoc)
* @see org.eclipse.ui.part.ViewPart#init(org.eclipse.ui.IViewSite,
* org.eclipse.ui.IMemento)
*/
@Override
public void init(IViewSite site, IMemento memento) throws PartInitException {
super.init(site, memento);
SketchPlugin.getDefault().getDOI().addSketchInterestListener(this);
// if (memento != null) {
// String lastTrace = memento.getString(LAST_TRACE);
// String lastThread = memento.getString(LAST_THREAD);
// if (lastTrace != null && lastThread != null) {
// IProgramSketch sketch =
// SketchPlugin.getDefault().getSketch(lastTrace);
// if (sketch != null) {
// ITrace trace = sketch.getTraceData();
// for (IThread thread : trace.getThreads()) {
// if (thread.getIdentifier().equals(lastThread)) {
// setInput(thread);
// return;
// }
// }
// }
// }
// }
}
@Override
public void createPartControl(Composite parent) {
filterImages = new ImageDescriptor[4];
ImageRegistry reg = SketchPlugin.getDefault().getImageRegistry();
filterImages[0] = reg.getDescriptor(ISketchImageConstants.ICON_ELEMENT_VISIBLE);
filterImages[1] = reg.getDescriptor(ISketchImageConstants.ICON_ELEMENT_VISIBLE+"2-3");
filterImages[2] = reg.getDescriptor(ISketchImageConstants.ICON_ELEMENT_VISIBLE+"1-3");
filterImages[3] = reg.getDescriptor(ISketchImageConstants.ICON_ELEMENT_FILTERED);
Composite page = new Composite(parent, SWT.NONE);
GridLayout layout = new GridLayout(1, false);
page.setLayout(layout);
breadcrumb = new BreadCrumbViewer(page, SWT.BORDER);
breadcrumb.setContentProvider(new BreadCrumbContentProvider());
breadcrumb.setLabelProvider(new TraceThreadLabelProvider());
breadcrumb.getControl().setLayoutData(
new GridData(SWT.FILL, SWT.FILL, true, false));
viewer = new UMLSequenceViewer(page, SWT.V_SCROLL | SWT.H_SCROLL
| SWT.VIRTUAL);
viewer.setUseHashlookup(true);
viewer.setContentProvider(new TraceThreadContentProvider());
viewer.setLabelProvider(new TraceThreadLabelProvider());
viewer.setMessageGrouper(new ASTMessageGrouper());
viewer.addFilter(new ViewerFilter(){
@Override
public boolean select(Viewer viewer, Object parentElement,
Object element) {
boolean reconFilter =
SketchPlugin.getDefault().getPreferenceStore().getBoolean(ISketchPluginPreferences.DIAGRAM_RECON_HIDE);
if (reconFilter && enableReconnaissanceAction.isChecked() && element instanceof ICall) {
ICall call = (ICall) element;
double interest = SketchPlugin.getDefault().getDOI().getInterest(call);
if (interest < .3) {
return false;
}
}
return true;
}});
internalSelectionListener = new InternalSelectionChangedListener();
viewer.addSelectionChangedListener(internalSelectionListener);
viewer.getControl().addMouseListener(new NavigateToCodeListener());
viewer.getControl().setBackground(
parent.getDisplay().getSystemColor(SWT.COLOR_WHITE));
viewer.getControl().setLayoutData(
new GridData(SWT.FILL, SWT.FILL, true, true));
presentationListener = new PresentationListener();
viewer.addSequenceListener(presentationListener);
new BreadCrumbHook(breadcrumb, viewer);
createTimeRange(page, thread);
viewer.setInput(thread);
createActions();
createContextMenu();
getViewSite().getActionBars().getToolBarManager().add(enableReconnaissanceAction);
getViewSite().getActionBars().getMenuManager().add(toggleReconFilterAction);
//add the drop-down menu
IMenuManager manager = getViewSite().getActionBars().getMenuManager();
manager.add(new Separator("presentation"));
getViewSite().getPage().addSelectionListener(javaSelectionListener);
selectionProvider = new InternalSelectionProvider();
getViewSite().setSelectionProvider(selectionProvider);
sketchListener = new ISketchEventListenerImplementation();
SketchPlugin.getDefault().addSketchEventListener(sketchListener);
SketchPlugin.getDefault().getPreferenceStore().addPropertyChangeListener(preferenceListener);
}
/*
* (non-Javadoc)
* @see org.eclipse.ui.part.WorkbenchPart#dispose()
*/
@Override
public void dispose() {
viewer.removeSequenceListener(presentationListener);
viewer.removeSelectionChangedListener(internalSelectionListener);
selectionProvider.dispose();
if (thread != null) {
thread.getTrace().removeListener(activationChangeListener);
}
getViewSite().getPage().removeSelectionListener(javaSelectionListener);
SketchPlugin.getDefault().removeSketchEventListener(sketchListener);
SketchPlugin.getDefault().getPreferenceStore().removePropertyChangeListener(preferenceListener);
SketchPlugin.getDefault().getDOI().removeSketchInterestListener(this);
super.dispose();
}
/**
* @param page
*/
private void createTimeRange(Composite page, IThread thread) {
Composite rangeComposite = new Composite(page, SWT.NONE);
GridData gd = new GridData(SWT.FILL, SWT.FILL, true, false);
rangeComposite.setLayoutData(gd);
GridLayout layout = new GridLayout(3, false);
layout.horizontalSpacing = 3;
layout.verticalSpacing = 0;
layout.marginWidth = 0;
layout.marginHeight = 0;
rangeComposite.setLayout(layout);
minTime = new TimeField(rangeComposite, SWT.NONE);
gd = new GridData(SWT.FILL, SWT.FILL, false, false);
gd.heightHint = 15;
minTime.setLayoutData(gd);
timeRange = new RangeSlider(rangeComposite, SWT.NONE);
timeRange.setForeground(page.getDisplay().getSystemColor(
SWT.COLOR_DARK_GRAY));
timeRange.setBackground(page.getDisplay().getSystemColor(
SWT.COLOR_GREEN));
gd = new GridData(SWT.FILL, SWT.CENTER, true, false);
gd.heightHint = 15;
timeRange.setLayoutData(gd);
if (thread != null) {
long min = thread.getRoot().getActivation().getTime();
long max = thread.getRoot().getActivation().getDuration() + min;
timeRange.setMinimum(min);
timeRange.setMaximum(max);
timeRange.setSelectedMinimum(min);
timeRange.setSelectedMaximum(max);
}
maxTime = new TimeField(rangeComposite, SWT.NONE);
gd = new GridData(SWT.FILL, SWT.FILL, false, false);
gd.heightHint = 15;
maxTime.setLayoutData(gd);
minTime.setTime(timeRange.getMinimum());
maxTime.setTime(timeRange.getMaximum());
timeRange.addSelectionListener(new SelectionListener() {
public void widgetDefaultSelected(SelectionEvent e) {
}
public void widgetSelected(SelectionEvent e) {
if (e.width < 0 || e.height < 0) {
if (e.data instanceof InvocationReference) {
InvocationReference ref = (InvocationReference) e.data;
StructuredSelection selection = new StructuredSelection(ref.activation);
selectionProvider.setSelection(selection);
}
return;
}
boolean changed = false;
if (minTime.getTime() != timeRange.getSelectedMinimum()) {
minTime.setTime(timeRange.getSelectedMinimum());
changed = true;
}
if (maxTime.getTime() != timeRange.getSelectedMaximum()) {
maxTime.setTime(timeRange.getSelectedMaximum());
changed = true;
}
if (changed) {
refreshJob.cancel();
refreshJob.schedule(2000);
}
}
});
viewer.addFilter(new TimeFilter(timeRange));
ModifyListener typedTimeListener = new ModifyListener() {
@Override
public void modifyText(ModifyEvent e) {
if (e.widget == maxTime) {
timeRange.setSelectedMaximum(maxTime.getTime());
} else if (e.widget == minTime) {
timeRange.setSelectedMinimum(minTime.getTime());
}
refreshJob.cancel();
refreshJob.schedule(2000);
}
};
minTime.addModifyListener(typedTimeListener);
maxTime.addModifyListener(typedTimeListener);
rangeComposite.pack();
rangeJob = new MarkRangeForSelectionJob(this);
new TimeLineTooltip(this);
new TimeLineAnnotationHook(this);
}
/**
*
*/
protected void resetViewers() {
if (viewer == null || viewer.getChart().isDisposed()) {
return;
}
if (viewer.getInput() != thread) {
viewer.setInput(thread);
}
if (thread == null) {
minTime.setTime(0);
maxTime.setTime(0);
return;
}
IWorkbenchPage page = getViewSite().getPage();
Display display = getSite().getShell().getDisplay();
// add annotations for the pause/resume events
List<ITraceMetaEvent> events = thread.getTrace().getEvents();
IProgramSketch sketch = SketchPlugin.getDefault().getSketch(thread);
RangeAnnotation annotation = null;
// first remove all of the old annotations
for (RangeAnnotation a : timeRange.getRanges()) {
if ("PAUSE".equals(a.getText())) {
a.dispose();
}
}
if (sketch != null) {
// search for the newest thread for the sketch, as it may have
// changed
for (IThread t : sketch.getTraceData().getThreads()) {
if (t.getName().equals(thread.getName())) {
if (t.getID() == thread.getID()) {
if (this.thread != t) {
this.thread = t;
}
}
break;
}
}
}
if (thread != null) {
long min = thread.getRoot().getActivation().getTime();
long max = thread.getRoot().getActivation().getDuration() + min;
timeRange.setMinimum(min);
timeRange.setMaximum(max);
timeRange.setSelectedMinimum(min);
timeRange.setSelectedMaximum(max);
minTime.setTime(min);
maxTime.setTime(max);
} else {
minTime.setTime(0);
maxTime.setTime(0);
}
for (ITraceMetaEvent event : events) {
String text = event.getText();
if (text.equals("PAUSE IN THREAD " + thread.getID())) {
if (annotation != null) {
annotation.setLength(event.getTime()
- annotation.getOffset());
}
annotation = new RangeAnnotation(timeRange);
annotation.setOffset(event.getTime());
annotation.setText("PAUSE");
annotation.setBackground(display
.getSystemColor(SWT.COLOR_YELLOW));
} else if (text.equals("RESUME IN THREAD " + thread.getID())) {
if (annotation == null) {
annotation = new RangeAnnotation(timeRange);
annotation.setText("PAUSE");
annotation.setBackground(display
.getSystemColor(SWT.COLOR_YELLOW));
annotation.setOffset(thread.getRoot().getTime());
}
annotation.setLength(event.getTime() - annotation.getOffset());
annotation = null;
}
}
updateForSelection(page.getSelection());
if (thread != viewer.getInput()) {
viewer.setInput(thread);
}
viewer.refresh();
}
/**
*
*/
private void createActions() {
focusInAction = createContributionItem(FocusInHandler.COMMAND_ID);
expandAllAction = createContributionItem(ExpandAllHandler.COMMAND_ID);
collapseAllAction = createContributionItem(CollapseAllHandler.COMMAND_ID);
focusUpAction = createContributionItem(FocusUpHandler.COMMAND_ID);
enableReconnaissanceAction = new RequestReconnaissanceAction();
enableReconnaissanceAction.setText("Filter");
enableReconnaissanceAction.setImageDescriptor(SketchPlugin.getDefault().getImageRegistry().getDescriptor(ISketchImageConstants.ICON_ELEMENT_VISIBLE));
IPreferenceStore store = SketchPlugin.getDefault().getPreferenceStore();
enableReconnaissanceAction.setChecked(store.getBoolean(ISketchPluginPreferences.DIAGRAM_RECONNAISSANCE));
this.toggleReconFilterAction = new ToggleReconFilterAction();
toggleReconFilterAction.setChecked(store.getBoolean(ISketchPluginPreferences.DIAGRAM_RECON_HIDE));
toggleReconFilterAction.setText("Hide Unnecessary Calls");
// focusUpAction = new FocusUpHandler(viewer);
// focusUpAction.setText("Focus On Parent");
// focusUpAction.setImageDescriptor(
// SketchPlugin.imageDescriptorFromPlugin("images/etool16/up.gif")
// );
// expandAllAction = new ExpandAllHandler(viewer);
// expandAllAction.setText("Expand All Children");
// expandAllAction.setImageDescriptor(
// SketchPlugin.imageDescriptorFromPlugin("images/etool16/expandAll.gif")
// );
// collapseAllAction = new CollapseAllHandler(viewer);
// collapseAllAction.setText("Collapse All Children");
// collapseAllAction.setImageDescriptor(
// SketchPlugin.imageDescriptorFromPlugin("images/etool16/collapseAll.gif")
// );
}
private CommandContributionItem createContributionItem(String commandId) {
CommandContributionItemParameter parameters = new CommandContributionItemParameter(
SketchPlugin.getDefault().getWorkbench(), null, commandId, SWT.PUSH);
return new CommandContributionItem(parameters);
}
private void createContextMenu() {
MenuManager manager = new MenuManager("JavaSketchEditor",
"#JavaSketchEditorPopUp");
Menu menu = manager.createContextMenu(viewer.getChart());
// getSite().registerContextMenu(manager, viewer);
manager.setRemoveAllWhenShown(true);
manager.addMenuListener(new IMenuListener() {
@Override
public void menuAboutToShow(IMenuManager manager) {
Point location = Display.getCurrent().getCursorLocation();
location = viewer.getChart().toControl(location);
Object element = viewer.elementAt(location.x, location.y);
fillContextMenu(manager, element);
}
});
viewer.getChart().setMenu(menu);
getSite().registerContextMenu("#JavaSketchEditorPopUp", manager, selectionProvider);
}
/**
* Opens the context menu to be filled with actions.
*
* @param manager
*/
private void fillContextMenu(IMenuManager manager, Object elementUnderCursor) {
if (elementUnderCursor instanceof IMessageGrouping) {
IMessageGrouping grouping = (IMessageGrouping) elementUnderCursor;
if (elementUnderCursor instanceof IAdaptable) {
ASTMessageGroupingTree node = (ASTMessageGroupingTree) ((IAdaptable) elementUnderCursor)
.getAdapter(ASTMessageGroupingTree.class);
if (node != null) {
IActivation activation = (IActivation) grouping
.getActivationElement();
ASTMessageGroupingTree[] iterations = node.getIterations();
int selected = 0;
for (int i = 0; i < iterations.length; i++) {
ASTMessageGroupingTree iteration = iterations[i];
if (!isEmptyIteration(iteration)) {
selected++;
IAction swapAction = new SwapLoopAction(activation,
iteration);
swapAction.setText("Iteration "
+ iteration.getIteration());
manager.add(swapAction);
if (selected >= 9) {
SelectIterationAction selector = new SelectIterationAction(
activation, iterations, this);
selector.setText("Select Iteration...");
manager.add(selector);
break;
}
}
}
}
return;
}
}
if (focusInAction.isEnabled()) {
manager.add(focusInAction);
}
if (focusUpAction.isEnabled()) {
manager.add(focusUpAction);
}
if (collapseAllAction.isEnabled()) {
manager.add(collapseAllAction);
}
if (expandAllAction.isEnabled()) {
manager.add(expandAllAction);
}
manager.add(createContributionItem(ScreenshotHandler.COMMAND_ID));
}
/**
* @param iteration
* @return
*/
private boolean isEmptyIteration(ASTMessageGroupingTree iteration) {
if (!reconnaissanceEnabled() || !hidingUnusedCalls()) {
return false;
}
for (String id : iteration.getMessageIdentifiers()) {
ITraceModelProxy proxy = getThread().getTrace().getElement(id);
IOriginMessage message = (IOriginMessage) proxy.getElement();
double interest = SketchPlugin.getDefault().getDOI().getInterest(message);
if (interest > .3) {
return false;
}
}
return true;
}
@Override
public void setFocus() {}
/*
* (non-Javadoc)
* @see org.eclipse.ui.part.WorkbenchPart#getAdapter(java.lang.Class)
*/
@SuppressWarnings("unchecked")
@Override
public Object getAdapter(Class adapter) {
if (IContentOutlinePage.class.equals(adapter)) {
if (outlinePage == null) {
outlinePage = new ThumbnailOutlinePage(viewer.getChart());
}
return outlinePage;
} else if (IPropertySheetPage.class.equals(adapter)) {
return new TabbedPropertySheetPage(this);
}
return super.getAdapter(adapter);
}
public RangeSlider getTimeRange() {
return timeRange;
}
/**
* @return
*/
public UMLSequenceViewer getSequenceChartViewer() {
return viewer;
}
/*
* (non-Javadoc)
* @see
* ca.uvic.chisel.javasketch.ui.internal.presentation.IJavaSketchPresenter
* #getThread()
*/
@Override
public IThread getThread() {
return thread;
}
/**
* @param thread2
* @param first
*/
public void reveal(ITraceModel element, String threadIdentifier) {
if (element != null) {
if (viewer.isVisible(element)) {
//simply reveal it
viewer.reveal(element);
return;
}
LinkedList<Object> pathToRoot = new LinkedList<Object>();
final IActivation activation = findFirstActivation(element, threadIdentifier);
if (activation == null) return;
Object newInput = activation.getArrival().getThread();
Object input = viewer.getInput();
if (input != newInput) {
setInput((IThread)newInput);
}
input = newInput;
if (newInput == null)
return;
ISequenceContentExtension2 provider = (ISequenceContentExtension2) viewer
.getContentProvider();
Object[] roots = ((IStructuredContentProvider) provider)
.getElements(input);
if (roots.length <= 0)
return;
Object currentRoot = roots[0];
Object currentParent = activation;
while (currentParent != null && !currentParent.equals(currentRoot)) {
pathToRoot.addFirst(currentParent);
Object call = provider.getCall(currentParent);
if (call != null) {
currentParent = provider.getOriginActivation(call);
} else {
currentParent = null;
}
}
pathToRoot.addFirst(currentRoot);
TimeTriggeredProgressMonitorDialog progress = new TimeTriggeredProgressMonitorDialog(
viewer.getControl().getShell(), 1000);
try {
progress.run(false, true, new ExpandToRootRunnable(viewer,
pathToRoot, false) {
/*
* (non-Javadoc)
* @seeca.uvic.chisel.javasketch.ui.internal.presentation.
* ExpandToRootRunnable
* #run(org.eclipse.core.runtime.IProgressMonitor)
*/
@Override
public void run(IProgressMonitor monitor)
throws InvocationTargetException,
InterruptedException {
super.run(monitor);
viewer.reveal(activation);
}
});
} catch (InvocationTargetException ex) {
SketchPlugin.getDefault().log(ex);
} catch (InterruptedException e1) {
}
}
}
/**
* @param event
* @param tm
*/
private IActivation findFirstActivation(ITraceModel tm, String threadId) {
if (tm != null) {
try {
Connection c = ((TraceImpl) tm.getTrace()).getConnection();
Statement s = c.createStatement();
if (tm instanceof IActivation) {
return (IActivation) tm;
} else if (tm instanceof IThread) {
try {
return ((IThread) tm).getRoot().getActivation();
} catch (NullPointerException e) {
}
} else if (tm instanceof ITraceClass) {
ITraceClass tc = (ITraceClass) tm;
String queryString =
"SELECT a.model_id FROM Activation a, Message m WHERE a.type_name = '"
+ tc.getName()
+ "' AND a.model_id = m.activation_id"
+ " ORDER BY m.time, a.model_id";
if (threadId != null) {
ITraceModelProxy proxy = tm.getTrace().getElement(threadId);
if (proxy != null) {
ITraceModel thread = (IThread) proxy.getElement();
if (thread instanceof ThreadImpl) {
queryString = "SELECT a.model_id FROM Activation a, Message m WHERE a.type_name = '"
+ tc.getName()
+ "' AND a.model_id = m.activation_id"
+ " AND thread_id = " + ((ThreadImpl)thread).getModelID()
+ " ORDER BY m.time, a.model_id";
}
}
}
ResultSet results = s
.executeQuery(queryString);
if (results.next()) {
String identifier = ActivationImpl
.getIdentifierFromModel(results.getString(1));
ITraceModelProxy proxy = tm.getTrace().getElement(
identifier);
if (proxy != null) {
return (IActivation) proxy.getElement();
}
}
} else if (tm instanceof ITraceClassMethod) {
ITraceClassMethod tcm = (ITraceClassMethod) tm;
String queryString =
"SELECT a.model_id FROM Activation a, Message m WHERE a.type_name = '"
+ tcm.getTraceClass().getName()
+ "' AND a.method_name = '"
+ tcm.getName()
+ "' AND a.method_signature = '"
+ tcm.getSignature()
+ "' AND a.model_id = m.activation_id"
+ " ORDER BY m.time, a.model_id";
if (threadId != null) {
ITraceModelProxy proxy = tm.getTrace().getElement(threadId);
if (proxy != null) {
ITraceModel thread = (IThread) proxy.getElement();
if (thread instanceof ThreadImpl) {
queryString =
"SELECT a.model_id FROM Activation a, Message m WHERE a.type_name = '"
+ tcm.getTraceClass().getName()
+ "' AND a.method_name = '"
+ tcm.getName()
+ "' AND a.method_signature = '"
+ tcm.getSignature()
+ "' AND thread_id = "
+ ((ThreadImpl)thread).getModelID()
+ " AND a.model_id = m.activation_id"
+ " ORDER BY m.time, a.model_id";
}
}
}
ResultSet results = s
.executeQuery(queryString);
if (results.next()) {
String modelId = results.getString(1);
String identifier = ActivationImpl
.getIdentifierFromModel(modelId);
ITraceModelProxy proxy = tm.getTrace().getElement(
identifier);
if (proxy != null) {
return (IActivation) proxy.getElement();
}
}
} else if (tm instanceof ITargetMessage) {
return ((IMessage) tm).getActivation();
} else if (tm instanceof IOriginMessage) {
return ((IOriginMessage)tm).getTarget().getActivation();
} else if (tm instanceof IActivation) {
return (IActivation) tm;
}
} catch (SQLException e) {
SketchPlugin.getDefault().log(e);
}
}
return null;
}
/*
* (non-Javadoc)
* @see
* org.eclipse.ui.views.properties.tabbed.ITabbedPropertySheetPageContributor
* #getContributorId()
*/
@Override
public String getContributorId() {
return "ca.uvic.chisel.javasketch.modelProperties";
}
/* (non-Javadoc)
* @see ca.uvic.chisel.javasketch.ISketchInterestListener#sketchInterestChanged(ca.uvic.chisel.javasketch.SketchInterestEvent)
*/
@Override
public synchronized void sketchInterestChanged(SketchInterestEvent event) {
if (requestReconnaissanceJob != null) {
requestReconnaissanceJob.cancel();
}
if (enableReconnaissanceAction != null && enableReconnaissanceAction.isChecked()) {
requestReconnaissanceJob.schedule();
}
}
public boolean reconnaissanceEnabled() {
boolean reconEnabled =
SketchPlugin.getDefault().getPreferenceStore().getBoolean(ISketchPluginPreferences.DIAGRAM_RECONNAISSANCE);
return reconEnabled;
}
public boolean hidingUnusedCalls() {
boolean reconHide =
SketchPlugin.getDefault().getPreferenceStore().getBoolean(ISketchPluginPreferences.DIAGRAM_RECON_HIDE);
return reconHide;
}
/**
*
*/
protected void updateAll() {
if (Display.getCurrent() == null) {
return;
}
UMLSequenceChart chart = viewer.getChart();
if (!chart.isDisposed()) {
UMLItem[] items = chart.getItems();
for (UMLItem item : items) {
if (chart.isDisposed()) {
break;
}
if (item != null && !item.isDisposed()) {
viewer.update(item.getData(), null);
}
Display.getCurrent().readAndDispatch();
}
}
}
}