public void createPartControl(Composite parent) {
super.createPartControl(parent);
// add "Check active" Button to TimeGraphFilterDialog
- super.getTimeGraphCombo().addTimeGraphFilterCheckActiveButton(
+ getTimeGraphViewer().getShowFilterDialogAction().getFilterDialog().addTimeGraphFilterCheckActiveButton(
new ControlFlowCheckActiveProvider(Messages.ControlFlowView_checkActiveLabel, Messages.ControlFlowView_checkActiveToolTip));
// add "Uncheck inactive" Button to TimeGraphFilterDialog
- super.getTimeGraphCombo().addTimeGraphFilterUncheckInactiveButton(
+ getTimeGraphViewer().getShowFilterDialogAction().getFilterDialog().addTimeGraphFilterUncheckInactiveButton(
new ControlFlowCheckActiveProvider(Messages.ControlFlowView_uncheckInactiveLabel, Messages.ControlFlowView_uncheckInactiveToolTip));
}
section = settings.addNewSection(getClass().getName());
}
- IAction hideArrowsAction = getTimeGraphCombo().getTimeGraphViewer().getHideArrowsAction(section);
+ IAction hideArrowsAction = getTimeGraphViewer().getHideArrowsAction(section);
manager.add(hideArrowsAction);
- IAction followArrowBwdAction = getTimeGraphCombo().getTimeGraphViewer().getFollowArrowBwdAction();
+ IAction followArrowBwdAction = getTimeGraphViewer().getFollowArrowBwdAction();
followArrowBwdAction.setText(Messages.ControlFlowView_followCPUBwdText);
followArrowBwdAction.setToolTipText(Messages.ControlFlowView_followCPUBwdText);
manager.add(followArrowBwdAction);
- IAction followArrowFwdAction = getTimeGraphCombo().getTimeGraphViewer().getFollowArrowFwdAction();
+ IAction followArrowFwdAction = getTimeGraphViewer().getFollowArrowFwdAction();
followArrowFwdAction.setText(Messages.ControlFlowView_followCPUFwdText);
followArrowFwdAction.setToolTipText(Messages.ControlFlowView_followCPUFwdText);
manager.add(followArrowFwdAction);
if (element instanceof ControlFlowEntry) {
ControlFlowEntry entry = (ControlFlowEntry) element;
if (entry.getThreadId() == selected) {
- getTimeGraphCombo().setSelection(entry);
+ getTimeGraphViewer().setSelection(entry, true);
break;
}
}
import org.eclipse.tracecompass.tmf.core.timestamp.TmfTimestampFormat;
import org.eclipse.tracecompass.tmf.ui.swtbot.tests.shared.ConditionHelpers;
import org.eclipse.tracecompass.tmf.ui.swtbot.tests.shared.ConditionHelpers.SWTBotTestCondition;
+import org.eclipse.tracecompass.tmf.ui.swtbot.tests.shared.SWTBotTimeGraph;
+import org.eclipse.tracecompass.tmf.ui.swtbot.tests.shared.SWTBotTimeGraphEntry;
import org.eclipse.tracecompass.tmf.ui.swtbot.tests.shared.SWTBotUtils;
import org.eclipse.tracecompass.tmf.ui.views.timegraph.AbstractTimeGraphView;
import org.eclipse.tracecompass.tmf.ui.widgets.timegraph.widgets.Utils;
// Create a known state
applyFilter();
final SWTBotTree tree = fViewBot.bot().tree();
- SWTBotTreeItem item = SWTBotUtils.getTreeItem(fBot, tree, TRACE_NAME, SYSTEMD_PROCESS_NAME);
- item.select();
-
- testProcessSorting(tree);
- testTidSorting(tree);
- testPidSorting(tree);
- testBirthtimeSorting(tree);
+ final SWTBotTimeGraph timeGraph = new SWTBotTimeGraph(fViewBot.bot());
+ final SWTBotTimeGraphEntry timeGraphEntry = timeGraph.getEntry(TRACE_NAME, SYSTEMD_PROCESS_NAME);
+ timeGraphEntry.select();
+
+ testProcessSorting(tree, timeGraph);
+ testTidSorting(tree, timeGraph);
+ testPidSorting(tree, timeGraph);
+ testBirthtimeSorting(tree, timeGraph);
}
// ------------------------------------------------------------------------
UIThreadRunnable.syncExec(treeCheckCounter);
}
- private static void testProcessSorting(final SWTBotTree tree) {
+ private static void testProcessSorting(final SWTBotTree tree, final SWTBotTimeGraph timeGraph) {
SWTBotTreeColumn column = tree.header(PROCESS_COLUMN);
String[] expected = { KTHREAD_PROCESS_NAME, LTTNG_CONSUMER_PROCESS_NAME, SYSTEMD_PROCESS_NAME };
/* Sort direction Up */
- SWTBotTestCondition condition = getSortCondition(PROCESS_COLUMN, PROCESS_COLUMN_ID, expected, tree, false);
+ SWTBotTestCondition condition = getSortCondition(PROCESS_COLUMN, PROCESS_COLUMN_ID, expected, timeGraph, false);
clickColumn(tree, column, condition);
/* Sort direction Down */
- condition = getSortCondition(PROCESS_COLUMN, 0, expected, tree, true);
+ condition = getSortCondition(PROCESS_COLUMN, 0, expected, timeGraph, true);
clickColumn(tree, column, condition);
}
- private static void testTidSorting(final SWTBotTree tree) {
+ private static void testTidSorting(final SWTBotTree tree, final SWTBotTimeGraph timeGraph) {
String[] expected = { SYSTEMD_TID, KTHREAD_TID, LTTNG_CONSUMER_TID };
SWTBotTreeColumn column = tree.header(TID_COLUMN);
/* Sort direction Up */
- SWTBotTestCondition condition = getSortCondition(TID_COLUMN, TID_COLUMN_ID, expected, tree, false);
+ SWTBotTestCondition condition = getSortCondition(TID_COLUMN, TID_COLUMN_ID, expected, timeGraph, false);
clickColumn(tree, column, condition);
/* Sort direction Down */
- condition = getSortCondition(TID_COLUMN, TID_COLUMN_ID, expected, tree, true);
+ condition = getSortCondition(TID_COLUMN, TID_COLUMN_ID, expected, timeGraph, true);
clickColumn(tree, column, condition);
}
* lttng-consumerd has PTID -1 that is unknown. Currently
* in CFV PTID is only shown when it's greater than 0.
*/
- private static void testPidSorting(final SWTBotTree tree) {
+ private static void testPidSorting(final SWTBotTree tree, final SWTBotTimeGraph timeGraph) {
SWTBotTreeColumn column = tree.header(PTID_COLUMN);
String[] expected = { LTTNG_CONSUMER_PROCESS_NAME, SYSTEMD_PROCESS_NAME, KTHREAD_PROCESS_NAME };
/* Sort direction Up */
- SWTBotTestCondition condition = getSortCondition(PTID_COLUMN, PROCESS_COLUMN_ID, expected, tree, false);
+ SWTBotTestCondition condition = getSortCondition(PTID_COLUMN, PROCESS_COLUMN_ID, expected, timeGraph, false);
clickColumn(tree, column, condition);
/* Sort direction Down */
String[] expected2 = { SYSTEMD_PROCESS_NAME, KTHREAD_PROCESS_NAME, LTTNG_CONSUMER_PROCESS_NAME };
- condition = getSortCondition(PTID_COLUMN, PROCESS_COLUMN_ID, expected2, tree, false);
+ condition = getSortCondition(PTID_COLUMN, PROCESS_COLUMN_ID, expected2, timeGraph, false);
clickColumn(tree, column, condition);
}
- private static void testBirthtimeSorting(final SWTBotTree tree) {
+ private static void testBirthtimeSorting(final SWTBotTree tree, final SWTBotTimeGraph timeGraph) {
SWTBotTreeColumn column = tree.header(BIRTH_COLUMN);
String[] expected = {
Utils.formatTime(LTTNG_CONSUMER_BIRTHTIME, TimeFormat.CALENDAR, Resolution.NANOSEC),
Utils.formatTime(KTHREAD_BIRTHTIME, TimeFormat.CALENDAR, Resolution.NANOSEC) };
/* Sort direction Up */
- SWTBotTestCondition condition = getSortCondition(BIRTH_COLUMN, BIRTH_COLUMN_ID, expected, tree, false);
+ SWTBotTestCondition condition = getSortCondition(BIRTH_COLUMN, BIRTH_COLUMN_ID, expected, timeGraph, false);
clickColumn(tree, column, condition);
/* Sort direction Down */
- condition = getSortCondition(BIRTH_COLUMN, BIRTH_COLUMN_ID, expected, tree, true);
+ condition = getSortCondition(BIRTH_COLUMN, BIRTH_COLUMN_ID, expected, timeGraph, true);
clickColumn(tree, column, condition);
}
fBot.waitUntil(condition);
}
- private static SWTBotTestCondition getSortCondition(final String testCase, final int cell, final String[] expected, final SWTBotTree tree, final boolean reverse) {
+ private static SWTBotTestCondition getSortCondition(final String testCase, final int column, final String[] expected, final SWTBotTimeGraph timeGraph, final boolean reverse) {
return new SWTBotTestCondition() {
@Override
public boolean test() throws Exception {
- SWTBotTreeItem[] items = tree.getTreeItem(TRACE_NAME).getItems();
+ SWTBotTimeGraphEntry[] entries = timeGraph.getEntry(TRACE_NAME).getEntries();
if (reverse) {
for (int i = expected.length - 1; i > 0; i--) {
- if (!expected[i].equals(items[expected.length - (i + 1)].cell(cell))) {
+ if (!expected[i].equals(entries[expected.length - (i + 1)].getText(column))) {
return false;
}
}
} else {
for (int i = 0; i < expected.length; i++) {
- if (!expected[i].equals(items[i].cell(cell))) {
+ if (!expected[i].equals(entries[i].getText(column))) {
return false;
}
}
timeGraphIsReadyCondition(new TmfTimeRange(START_TIME, START_TIME));
SWTBotView viewBot = getViewBot();
- final SWTBotTree tree = viewBot.bot().tree();
/* set focus on time graph */
SWTBotTimeGraph timeGraph = new SWTBotTimeGraph(viewBot.bot());
viewBot.toolbarButton(FOLLOW_CPU_FORWARD).click();
timeGraphIsReadyCondition(new TmfTimeRange(TID2_TIME2, TID2_TIME2));
fBot.waitUntil(ConditionHelpers.selectionRange(new TmfTimeRange(TID2_TIME2, TID2_TIME2)));
- fBot.waitUntil(ConditionHelpers.treeSelectionContains(tree, 1, "2"));
+ fBot.waitUntil(ConditionHelpers.timeGraphSelectionContains(timeGraph, 1, "2"));
assertTrue(TmfTraceManager.getInstance().getCurrentTraceContext().getWindowRange().contains(TID2_TIME2));
/* shift-click "Follow CPU Forward" 3 times */
viewBot.toolbarButton(FOLLOW_CPU_FORWARD).click(SWT.SHIFT);
timeGraphIsReadyCondition(new TmfTimeRange(TID2_TIME2, TID2_TIME4));
fBot.waitUntil(ConditionHelpers.selectionRange(new TmfTimeRange(TID2_TIME2, TID5_TIME1)));
- fBot.waitUntil(ConditionHelpers.treeSelectionContains(tree, 1, "5"));
+ fBot.waitUntil(ConditionHelpers.timeGraphSelectionContains(timeGraph, 1, "5"));
assertTrue(TmfTraceManager.getInstance().getCurrentTraceContext().getWindowRange().contains(TID5_TIME1));
/* shift-click "Follow CPU Backward" 4 times */
viewBot.toolbarButton(FOLLOW_CPU_BACKWARD).click(SWT.SHIFT);
timeGraphIsReadyCondition(new TmfTimeRange(TID2_TIME2, TID2_TIME1));
fBot.waitUntil(ConditionHelpers.selectionRange(new TmfTimeRange(TID2_TIME2, TID2_TIME1)));
- fBot.waitUntil(ConditionHelpers.treeSelectionContains(tree, 1, "2"));
+ fBot.waitUntil(ConditionHelpers.timeGraphSelectionContains(timeGraph, 1, "2"));
assertTrue(TmfTraceManager.getInstance().getCurrentTraceContext().getWindowRange().contains(TID2_TIME1));
/* click "Follow CPU Forward" 2 times */
viewBot.toolbarButton(FOLLOW_CPU_FORWARD).click();
timeGraphIsReadyCondition(new TmfTimeRange(TID2_TIME3, TID2_TIME3));
fBot.waitUntil(ConditionHelpers.selectionRange(new TmfTimeRange(TID2_TIME3, TID2_TIME3)));
- fBot.waitUntil(ConditionHelpers.treeSelectionContains(tree, 1, "2"));
+ fBot.waitUntil(ConditionHelpers.timeGraphSelectionContains(timeGraph, 1, "2"));
assertTrue(TmfTraceManager.getInstance().getCurrentTraceContext().getWindowRange().contains(TID2_TIME3));
/* shift-click "Follow CPU Backward" 3 times */
viewBot.toolbarButton(FOLLOW_CPU_BACKWARD).click(SWT.SHIFT);
timeGraphIsReadyCondition(new TmfTimeRange(TID2_TIME3, TID1_TIME1));
fBot.waitUntil(ConditionHelpers.selectionRange(new TmfTimeRange(TID2_TIME3, TID1_TIME1)));
- fBot.waitUntil(ConditionHelpers.treeSelectionContains(tree, 1, "1"));
+ fBot.waitUntil(ConditionHelpers.timeGraphSelectionContains(timeGraph, 1, "1"));
assertTrue(TmfTraceManager.getInstance().getCurrentTraceContext().getWindowRange().contains(TID1_TIME1));
/* shift-click "Follow CPU Forward" 4 times */
viewBot.toolbarButton(FOLLOW_CPU_FORWARD).click(SWT.SHIFT);
timeGraphIsReadyCondition(new TmfTimeRange(TID2_TIME3, TID2_TIME4));
fBot.waitUntil(ConditionHelpers.selectionRange(new TmfTimeRange(TID2_TIME3, TID2_TIME4)));
- fBot.waitUntil(ConditionHelpers.treeSelectionContains(tree, 1, "2"));
+ fBot.waitUntil(ConditionHelpers.timeGraphSelectionContains(timeGraph, 1, "2"));
assertTrue(TmfTraceManager.getInstance().getCurrentTraceContext().getWindowRange().contains(TID2_TIME4));
/* click "Follow CPU Backward" 5 times */
*/
@Test
public void testFull() {
- SWTBotTree treeCfv = fViewBotCfv.bot().tree();
+ SWTBotTimeGraph timeGraphCfv = new SWTBotTimeGraph(fViewBotCfv.bot());
SWTBotTree treeCp = fViewBotCp.bot().tree();
SWTBotTimeGraph timeGraphCp = new SWTBotTimeGraph(fViewBotCp.bot());
- assertNotNull(treeCfv.widget);
+ assertNotNull(timeGraphCfv.widget);
assertNotNull(treeCp.widget);
SWTBotTreeItem[] allItems = treeCp.getAllItems();
for (int i = 0; i < allItems.length; i++) {
ITmfTrace trace = TmfTraceManager.getInstance().getActiveTrace();
assertNotNull(trace);
- SWTBotTreeItem entry = treeCfv.expandNode(trace.getName(), "systemd", "we", PROCESS);
+ SWTBotTimeGraphEntry entry = timeGraphCfv.getEntry(trace.getName(), "systemd", "we", PROCESS);
assertNotNull(entry);
entry.select();
import org.eclipse.swtbot.swt.finder.widgets.SWTBotShell;
import org.eclipse.swtbot.swt.finder.widgets.SWTBotTable;
import org.eclipse.swtbot.swt.finder.widgets.SWTBotToolbarButton;
-import org.eclipse.swtbot.swt.finder.widgets.SWTBotTree;
import org.eclipse.swtbot.swt.finder.widgets.SWTBotTreeItem;
import org.eclipse.tracecompass.testtraces.ctf.CtfTestTrace;
import org.eclipse.tracecompass.tmf.core.signal.TmfSelectionRangeUpdatedSignal;
}
private static List<String> getVisibleStackFrames(final SWTBotView viewBot) {
- SWTBotTree tree = viewBot.bot().tree();
+ SWTBotTimeGraph timeGraph = new SWTBotTimeGraph(viewBot.bot());
List<String> stackFrames = new ArrayList<>();
- for (SWTBotTreeItem treeItem : tree.expandNode(TRACE, PROCESS, THREAD).getItems()) {
- String name = treeItem.cell(0);
+ for (SWTBotTimeGraphEntry entry : timeGraph.getEntry(TRACE, PROCESS, THREAD).getEntries()) {
+ String name = entry.getText();
if (!name.isEmpty()) {
stackFrames.add(name);
}
SWTBotTimeGraph timeGraph = new SWTBotTimeGraph(viewBot.bot());
SWTBotTimeGraphEntry[] threads = timeGraph.getEntry(TRACE, PROCESS).getEntries();
assertEquals(1, threads.length);
- assertEquals(THREAD, threads[0].getText());
+ assertEquals(THREAD, threads[0].getText(0));
assertEquals(Arrays.asList("main", "event_loop", "handle_event"), getVisibleStackFrames(viewBot));
}
import java.util.Objects;
import org.eclipse.jface.viewers.ISelection;
+import org.eclipse.jface.viewers.ITableLabelProvider;
import org.eclipse.jface.viewers.StructuredSelection;
import org.eclipse.swt.SWT;
import org.eclipse.swt.graphics.Rectangle;
*/
public SWTBotTimeGraphEntry getEntry(String... names) throws WidgetNotFoundException {
List<ITimeGraphEntry> entries = Arrays.asList(widget.getExpandedElements());
+ ITableLabelProvider labelProvider = widget.getLabelProvider();
ITimeGraphEntry parent = null;
for (String name : names) {
boolean found = false;
for (ITimeGraphEntry entry : entries) {
- String label = entry.getName();
+ String label = labelProvider == null ? entry.getName() : labelProvider.getColumnText(entry, 0);
if (Objects.equals(entry.getParent(), parent) && name.equals(label)) {
parent = entry;
found = true;
if (element instanceof ITimeGraphEntry) {
TableRow tableRow = new TableRow();
SWTBotTimeGraphEntry entry = new SWTBotTimeGraphEntry(widget, (ITimeGraphEntry) element);
- tableRow.add(entry.getText());
+ for (int i = 0; i < widget.getTree().getColumnCount(); i++) {
+ tableRow.add(entry.getText(i));
+ }
collection.add(tableRow);
}
}
import java.util.ArrayList;
import java.util.List;
+import org.eclipse.jface.viewers.ITableLabelProvider;
import org.eclipse.swt.SWT;
import org.eclipse.swt.graphics.Rectangle;
import org.eclipse.swt.widgets.Control;
return syncExec(new Result<SWTBotTimeGraphEntry>() {
@Override
public SWTBotTimeGraphEntry run() {
+ ITableLabelProvider labelProvider = widget.getLabelProvider();
for (ITimeGraphEntry entry : widget.getExpandedElements()) {
if (fEntry.equals(entry.getParent())) {
- String label = entry.getName();
+ String label = labelProvider == null ? entry.getName() : labelProvider.getColumnText(entry, 0);
if (name.equals(label)) {
return new SWTBotTimeGraphEntry(widget, entry);
}
*/
@Override
public String getText() {
- return fEntry.getName();
+ return getText(0);
+ }
+
+ /**
+ * Get the text of this entry for the given column index
+ *
+ * @param column
+ * the column index
+ * @return the column text
+ */
+ public String getText(int column) {
+ ITableLabelProvider labelProvider = widget.getLabelProvider();
+ return labelProvider != null ? labelProvider.getColumnText(fEntry, column) : column == 0 ? fEntry.getName() : "";
}
/**
SWTBotView viewBot = fBot.viewById(viewId);
switch (viewId) {
case HistogramView.ID:
- case CallStackView.ID:
return new SWTBotSash(viewBot.bot().widget(WidgetOfType.widgetOfType(Sash.class)));
+ case CallStackView.ID:
case TimeChartView.ID:
return new SWTBotTimeGraph(viewBot.bot().widget(WidgetOfType.widgetOfType(TimeGraphControl.class)));
default:
/*******************************************************************************
- * Copyright (c) 2009, 2015 Ericsson
+ * Copyright (c) 2009, 2016 Ericsson
*
* All rights reserved. This program and the accompanying materials are
* made available under the terms of the Eclipse Public License v1.0 which
+ "\nClass Name: "
+ selTrace.getClassName());
- synchViewer.setSelection(selTrace);
+ synchViewer.setSelection(selTrace, true);
} else {
System.out
.println("TsfTmIncubatorListener.tsfTmProcessEvent() Unexpected event source received: "
</message_arguments>
</filter>
</resource>
+ <resource path="src/org/eclipse/tracecompass/tmf/ui/widgets/timegraph/model/ITimeGraphEntry.java" type="org.eclipse.tracecompass.tmf.ui.widgets.timegraph.model.ITimeGraphEntry">
+ <filter comment="API preference INTERFACE_ELEMENT_TYPE_ADDED_DEFAULT_METHOD=Ignore is not properly supported (Bug 507246)" id="403984517">
+ <message_arguments>
+ <message_argument value="org.eclipse.tracecompass.tmf.ui.widgets.timegraph.model.ITimeGraphEntry"/>
+ <message_argument value="org.eclipse.jface.viewers.ISelection"/>
+ <message_argument value="isEmpty()"/>
+ </message_arguments>
+ </filter>
+ </resource>
</component>
import org.eclipse.jface.resource.ImageDescriptor;
import org.eclipse.jface.util.IPropertyChangeListener;
import org.eclipse.jface.util.PropertyChangeEvent;
-import org.eclipse.jface.viewers.DoubleClickEvent;
-import org.eclipse.jface.viewers.IDoubleClickListener;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.swt.SWT;
}
});
- getTimeGraphCombo().getTreeViewer().addDoubleClickListener(new IDoubleClickListener() {
+ getTimeGraphViewer().getTimeGraphControl().addMouseListener(new MouseAdapter() {
@Override
- public void doubleClick(DoubleClickEvent event) {
- Object selection = ((IStructuredSelection) event.getSelection()).getFirstElement();
+ public void mouseDoubleClick(MouseEvent event) {
+ Object selection = getTimeGraphViewer().getSelection();
if (selection instanceof CallStackEntry) {
CallStackEntry entry = (CallStackEntry) selection;
if (entry.getFunctionName().length() > 0) {
Display.getDefault().asyncExec(new Runnable() {
@Override
public void run() {
- if (getTimeGraphCombo().isDisposed()) {
+ if (getTimeGraphViewer().getControl().isDisposed()) {
return;
}
if (beginTime == endTime) {
if (stackLevelState.unboxInt() == callStackEntry.getStackLevel() || stackLevelState.isNull()) {
fSyncSelection = false;
Display.getDefault().asyncExec(() -> {
- getTimeGraphCombo().setSelection(callStackEntry);
+ getTimeGraphViewer().setSelection(callStackEntry, true);
getTimeGraphViewer().getTimeGraphControl().fireSelectionChanged();
});
}
};
traceEntries.forEach(consumer);
if (Display.getCurrent() != null) {
- getTimeGraphCombo().refresh();
+ getTimeGraphViewer().refresh();
}
}
manager.add(getSortByIdAction());
manager.add(getSortByTimeAction());
manager.add(new Separator());
- manager.add(getTimeGraphCombo().getShowFilterDialogAction());
+ manager.add(getTimeGraphViewer().getShowFilterDialogAction());
manager.add(new Separator());
manager.add(getTimeGraphViewer().getResetScaleAction());
manager.add(getPreviousEventAction());
stackInterval = ss.querySingleState(Math.min(ss.getCurrentEndTime(), newTime), quark);
int stackLevel = stackInterval.getStateValue().unboxInt();
ITimeGraphEntry selectedEntry = parentEntry.getChildren().get(Math.max(0, stackLevel - 1));
- getTimeGraphCombo().setSelection(selectedEntry);
+ viewer.setSelection(selectedEntry, true);
viewer.getTimeGraphControl().fireSelectionChanged();
startZoomThread(viewer.getTime0(), viewer.getTime1());
fPrevEventAction = new Action() {
@Override
public void run() {
- TimeGraphViewer viewer = getTimeGraphCombo().getTimeGraphViewer();
+ TimeGraphViewer viewer = getTimeGraphViewer();
ITimeGraphEntry entry = viewer.getSelection();
if (entry instanceof CallStackEntry) {
try {
viewer.setSelectedTimeNotify(stackInterval.getStartTime(), true);
int stackLevel = stackInterval.getStateValue().unboxInt();
ITimeGraphEntry selectedEntry = parentEntry.getChildren().get(Math.max(0, stackLevel - 1));
- getTimeGraphCombo().setSelection(selectedEntry);
+ viewer.setSelection(selectedEntry, true);
viewer.getTimeGraphControl().fireSelectionChanged();
startZoomThread(viewer.getTime0(), viewer.getTime1());
ITmfTrace trace = signal.getTrace();
for (int i = 0; i < fTimeAnalysisEntries.size(); i++) {
if (fTimeAnalysisEntries.get(i).getTrace().equals(trace)) {
- fViewer.setSelection(fTimeAnalysisEntries.get(i));
+ fViewer.setSelection(fTimeAnalysisEntries.get(i), true);
break;
}
}
import org.eclipse.jdt.annotation.Nullable;
import org.eclipse.jface.action.Action;
import org.eclipse.jface.action.GroupMarker;
-import org.eclipse.jface.action.IAction;
import org.eclipse.jface.action.IMenuListener;
import org.eclipse.jface.action.IMenuManager;
import org.eclipse.jface.action.IStatusLineManager;
import org.eclipse.jface.viewers.AbstractTreeViewer;
import org.eclipse.jface.viewers.ILabelProvider;
import org.eclipse.jface.viewers.ILabelProviderListener;
-import org.eclipse.jface.viewers.ISelectionProvider;
import org.eclipse.jface.viewers.ITableLabelProvider;
import org.eclipse.jface.viewers.ITreeContentProvider;
-import org.eclipse.jface.viewers.TreeSelection;
-import org.eclipse.jface.viewers.TreeViewer;
import org.eclipse.jface.viewers.ViewerFilter;
import org.eclipse.osgi.util.NLS;
import org.eclipse.swt.SWT;
import org.eclipse.tracecompass.tmf.ui.widgets.timegraph.ITimeGraphContentProvider;
import org.eclipse.tracecompass.tmf.ui.widgets.timegraph.ITimeGraphPresentationProvider2;
import org.eclipse.tracecompass.tmf.ui.widgets.timegraph.ITimeGraphRangeListener;
-import org.eclipse.tracecompass.tmf.ui.widgets.timegraph.ITimeGraphSelectionListener;
import org.eclipse.tracecompass.tmf.ui.widgets.timegraph.ITimeGraphTimeListener;
import org.eclipse.tracecompass.tmf.ui.widgets.timegraph.TimeGraphBookmarkEvent;
import org.eclipse.tracecompass.tmf.ui.widgets.timegraph.TimeGraphCombo;
/**
* An abstract view all time graph views can inherit
*
- * This view contains either a time graph viewer, or a time graph combo which is
- * divided between a tree viewer on the left and a time graph viewer on the right.
+ * This view contains a time graph viewer.
*/
public abstract class AbstractTimeGraphView extends TmfView implements ITmfTimeAligned, IResourceChangeListener {
// Fields
// ------------------------------------------------------------------------
- /** The timegraph wrapper */
- private ITimeGraphWrapper fTimeGraphWrapper;
+ /** The time graph viewer */
+ private TimeGraphViewer fTimeGraphViewer;
private AtomicInteger fDirty = new AtomicInteger();
/** The presentation provider for this view */
private final TimeGraphPresentationProvider fPresentation;
- /** The tree column label array, or null if combo is not used */
+ /** The tree column label array, or null for a single default column */
private String[] fColumns;
private Comparator<ITimeGraphEntry>[] fColumnComparators;
- /** The tree label provider, or null if combo is not used */
- private TreeLabelProvider fLabelProvider = null;
+ /** The time graph label provider */
+ private ITableLabelProvider fLabelProvider = new TreeLabelProvider();
/** The time graph content provider */
private @NonNull ITimeGraphContentProvider fTimeGraphContentProvider = new TimeGraphContentProvider();
- /** The relative weight of the sash, ignored if combo is not used */
+ /** The relative weight of the time graph viewer parts */
private int[] fWeight = { 1, 3 };
/** The filter column label array, or null if filter is not used */
private String[] fFilterColumns;
- /** The pack done flag */
- private boolean fPackDone = false;
-
/** The filter content provider, or null if filter is not used */
private ITreeContentProvider fFilterContentProvider;
/**
* Menu Manager for context-sensitive menu for time graph entries.
- * This will be used on the tree viewer in case of the time graph combo
- * or the on the namespace in case of a single time graph viewer.
+ * This will be used on the name space of the time graph viewer.
*/
private final @NonNull MenuManager fEntryMenuManager = new MenuManager();
// Classes
// ------------------------------------------------------------------------
- private interface ITimeGraphWrapper {
-
- void setTimeGraphContentProvider(ITimeGraphContentProvider timeGraphContentProvider);
-
- void setTimeGraphPresentationProvider(TimeGraphPresentationProvider timeGraphPresentationProvider);
-
- TimeGraphViewer getTimeGraphViewer();
-
- void addSelectionListener(ITimeGraphSelectionListener listener);
-
- ISelectionProvider getSelectionProvider();
-
- void setFocus();
-
- boolean isDisposed();
-
- void refresh();
-
- void setInput(Object input);
-
- Object getInput();
-
- void setFilters(@NonNull ViewerFilter[] filters);
-
- @NonNull ViewerFilter[] getFilters();
-
- void redraw();
-
- void update();
-
- void setAutoExpandLevel(int level);
-
- boolean getExpandedState(ITimeGraphEntry entry);
-
- void setExpandedState(ITimeGraphEntry entry, boolean expanded);
-
- void setFilterColumns(String[] columnNames);
-
- void setFilterContentProvider(ITreeContentProvider contentProvider);
-
- void setFilterLabelProvider(ITableLabelProvider labelProvider);
-
- IAction getShowFilterDialogAction();
-
- void performAlign(int offset, int width);
-
- TmfTimeViewAlignmentInfo getTimeViewAlignmentInfo();
-
- int getAvailableWidth(int requestedOffset);
-
- ITimeGraphEntry getSelection();
-
- void setSelection(ITimeGraphEntry selection);
-
- void selectAndReveal(@NonNull ITimeGraphEntry selection);
-
- }
-
- private class TimeGraphViewerWrapper implements ITimeGraphWrapper {
- private TimeGraphViewer viewer;
-
- private TimeGraphViewerWrapper(Composite parent, int style) {
- viewer = new TimeGraphViewer(parent, style);
- }
-
- @Override
- public void setTimeGraphContentProvider(ITimeGraphContentProvider timeGraphContentProvider) {
- viewer.setTimeGraphContentProvider(timeGraphContentProvider);
- }
-
- @Override
- public void setTimeGraphPresentationProvider(TimeGraphPresentationProvider timeGraphPresentationProvider) {
- viewer.setTimeGraphProvider(timeGraphPresentationProvider);
- }
-
- @Override
- public TimeGraphViewer getTimeGraphViewer() {
- return viewer;
- }
-
- @Override
- public void addSelectionListener(ITimeGraphSelectionListener listener) {
- viewer.addSelectionListener(listener);
- }
-
- @Override
- public ISelectionProvider getSelectionProvider() {
- return viewer.getSelectionProvider();
- }
-
- @Override
- public void setFocus() {
- viewer.setFocus();
- }
-
- @Override
- public boolean isDisposed() {
- return viewer.getControl().isDisposed();
- }
-
- @Override
- public void setInput(Object input) {
- viewer.setInput(input);
- }
-
- @Override
- public Object getInput() {
- return viewer.getInput();
- }
-
- @Override
- public void setFilterColumns(String[] columnNames) {
- viewer.setFilterColumns(columnNames);
- }
-
- @Override
- public void setFilterContentProvider(ITreeContentProvider contentProvider) {
- viewer.setFilterContentProvider(contentProvider);
- }
-
- @Override
- public void setFilterLabelProvider(ITableLabelProvider labelProvider) {
- viewer.setFilterLabelProvider(labelProvider);
- }
-
- @Override
- public void setFilters(@NonNull ViewerFilter[] filters) {
- viewer.setFilters(filters);
- }
-
- @Override
- public @NonNull ViewerFilter[] getFilters() {
- return viewer.getFilters();
- }
-
- @Override
- public IAction getShowFilterDialogAction() {
- return viewer.getShowFilterDialogAction();
- }
-
- @Override
- public void refresh() {
- viewer.refresh();
- }
-
- @Override
- public void redraw() {
- viewer.getControl().redraw();
- }
-
- @Override
- public void update() {
- viewer.getControl().update();
- }
-
- @Override
- public void setAutoExpandLevel(int level) {
- viewer.setAutoExpandLevel(level);
- }
-
- @Override
- public boolean getExpandedState(ITimeGraphEntry entry) {
- return viewer.getExpandedState(entry);
- }
-
- @Override
- public void setExpandedState(ITimeGraphEntry entry, boolean expanded) {
- viewer.setExpandedState(entry, expanded);
- }
-
- @Override
- public void performAlign(int offset, int width) {
- viewer.performAlign(offset, width);
- }
-
- @Override
- public TmfTimeViewAlignmentInfo getTimeViewAlignmentInfo() {
- return viewer.getTimeViewAlignmentInfo();
- }
-
- @Override
- public int getAvailableWidth(int requestedOffset) {
- return viewer.getAvailableWidth(requestedOffset);
- }
-
- @Override
- public ITimeGraphEntry getSelection() {
- return viewer.getSelection();
- }
-
- @Override
- public void setSelection(ITimeGraphEntry selection) {
- viewer.setSelection(selection);
- }
-
- @Override
- public void selectAndReveal(@NonNull ITimeGraphEntry selection) {
- viewer.selectAndReveal(selection);
- }
- }
-
- private class TimeGraphComboWrapper implements ITimeGraphWrapper {
- private TimeGraphCombo combo;
-
- private TimeGraphComboWrapper(Composite parent, int style) {
- combo = new TimeGraphCombo(parent, style, fWeight);
- }
-
- @Override
- public void setTimeGraphContentProvider(ITimeGraphContentProvider timeGraphContentProvider) {
- combo.setTimeGraphContentProvider(timeGraphContentProvider);
- }
-
- @Override
- public void setTimeGraphPresentationProvider(TimeGraphPresentationProvider timeGraphPresentationProvider) {
- combo.setTimeGraphProvider(timeGraphPresentationProvider);
- }
-
- @Override
- public TimeGraphViewer getTimeGraphViewer() {
- return combo.getTimeGraphViewer();
- }
-
- @Override
- public void addSelectionListener(ITimeGraphSelectionListener listener) {
- combo.addSelectionListener(listener);
- }
-
- @Override
- public ISelectionProvider getSelectionProvider() {
- return combo.getTreeViewer();
- }
-
- @Override
- public void setFocus() {
- combo.setFocus();
- }
-
- @Override
- public boolean isDisposed() {
- return combo.isDisposed();
- }
-
- @Override
- public void setInput(Object input) {
- combo.setInput(input);
- }
-
- @Override
- public Object getInput() {
- return combo.getInput();
- }
-
- @Override
- public void setFilterColumns(String[] columnNames) {
- combo.setFilterColumns(columnNames);
- }
-
- @Override
- public void setFilterContentProvider(ITreeContentProvider contentProvider) {
- combo.setFilterContentProvider(contentProvider);
- }
-
- @Override
- public void setFilterLabelProvider(ITableLabelProvider labelProvider) {
- combo.setFilterLabelProvider(labelProvider);
- }
-
- @Override
- public void setFilters(@NonNull ViewerFilter[] filters) {
- combo.setFilters(filters);
- }
-
- @Override
- public @NonNull ViewerFilter[] getFilters() {
- return combo.getFilters();
- }
-
- @Override
- public IAction getShowFilterDialogAction() {
- return combo.getShowFilterDialogAction();
- }
-
- @Override
- public void refresh() {
- combo.refresh();
- }
-
- @Override
- public void redraw() {
- combo.redraw();
- }
-
- @Override
- public void update() {
- combo.update();
- }
-
- @Override
- public void setAutoExpandLevel(int level) {
- combo.setAutoExpandLevel(level);
- }
-
- @Override
- public boolean getExpandedState(ITimeGraphEntry entry) {
- return combo.getExpandedState(entry);
- }
-
- @Override
- public void setExpandedState(ITimeGraphEntry entry, boolean expanded) {
- combo.setExpandedState(entry, expanded);
- }
-
- TimeGraphCombo getTimeGraphCombo() {
- return combo;
- }
-
- TreeViewer getTreeViewer() {
- return combo.getTreeViewer();
- }
-
- @Override
- public void performAlign(int offset, int width) {
- combo.performAlign(offset, width);
- }
-
- @Override
- public TmfTimeViewAlignmentInfo getTimeViewAlignmentInfo() {
- return combo.getTimeViewAlignmentInfo();
- }
-
- @Override
- public int getAvailableWidth(int requestedOffset) {
- return combo.getAvailableWidth(requestedOffset);
- }
-
- @Override
- public ITimeGraphEntry getSelection() {
- return combo.getTimeGraphViewer().getSelection();
- }
-
- @Override
- public void setSelection(ITimeGraphEntry selection) {
- combo.setSelection(selection);
- }
-
- @Override
- public void selectAndReveal(@NonNull ITimeGraphEntry selection) {
- combo.selectAndReveal(selection);
- }
- }
-
/**
* Base class to provide the labels for the tree viewer. Views extending
* this class typically need to override the getColumnText method if they
markers.addAll(getTraceMarkerList(getZoomStartTime(), getZoomEndTime(), getResolution(), getMonitor()));
applyResults(() -> {
if (events != null) {
- fTimeGraphWrapper.getTimeGraphViewer().setLinks(events);
+ fTimeGraphViewer.setLinks(events);
}
- fTimeGraphWrapper.getTimeGraphViewer().setMarkerCategories(getMarkerCategories());
- fTimeGraphWrapper.getTimeGraphViewer().setMarkers(markers);
+ fTimeGraphViewer.setMarkerCategories(getMarkerCategories());
+ fTimeGraphViewer.setMarkers(markers);
redraw();
});
}
// ------------------------------------------------------------------------
/**
- * Constructs a time graph view that contains either a time graph viewer or
- * a time graph combo.
+ * Constructs a time graph view that contains a time graph viewer.
*
- * By default, the view uses a time graph viewer. To use a time graph combo,
- * the subclass constructor must call {@link #setTreeColumns(String[])} and
+ * By default, the view uses a single default column in the name space that
+ * shows the time graph entry name. To use multiple columns and/or
+ * customized label texts, the subclass constructor must call
+ * {@link #setTreeColumns(String[])} and/or
* {@link #setTreeLabelProvider(TreeLabelProvider)}.
*
* @param id
// ------------------------------------------------------------------------
/**
- * Getter for the time graph combo
+ * Getter for the time graph combo. No longer used.
*
- * @return The time graph combo, or null if combo is not used
+ * @return null
+ * @deprecated Use {@link #getTimeGraphViewer()} instead.
*/
+ @Deprecated
protected TimeGraphCombo getTimeGraphCombo() {
- if (fTimeGraphWrapper instanceof TimeGraphComboWrapper) {
- return ((TimeGraphComboWrapper) fTimeGraphWrapper).getTimeGraphCombo();
- }
return null;
}
* @return The time graph viewer
*/
protected TimeGraphViewer getTimeGraphViewer() {
- return fTimeGraphWrapper.getTimeGraphViewer();
+ return fTimeGraphViewer;
}
/**
}
/**
- * Sets the relative weight of each part of the time graph combo.
- * <p>
- * This should be called from the constructor.
+ * Sets the relative weight of each part of the time graph viewer. The first
+ * number is the name space width, and the second number is the time space
+ * width.
*
* @param weights
- * The array (length 2) of relative weights of each part of the combo
+ * The array of relative weights of each part of the viewer
*/
protected void setWeight(final int[] weights) {
- checkPartNotCreated();
fWeight = weights;
+ if (fTimeGraphViewer != null) {
+ fTimeGraphViewer.setWeights(weights);
+ }
}
/**
*/
protected void setAutoExpandLevel(int level) {
fAutoExpandLevel = level;
- ITimeGraphWrapper tgWrapper = fTimeGraphWrapper;
- if (tgWrapper != null) {
- tgWrapper.setAutoExpandLevel(level);
+ if (fTimeGraphViewer != null) {
+ fTimeGraphViewer.setAutoExpandLevel(level);
}
}
@Override
public void createPartControl(Composite parent) {
super.createPartControl(parent);
- if (fColumns == null || fLabelProvider == null) {
- fTimeGraphWrapper = new TimeGraphViewerWrapper(parent, SWT.NONE);
- } else {
- TimeGraphComboWrapper wrapper = new TimeGraphComboWrapper(parent, SWT.NONE);
- fTimeGraphWrapper = wrapper;
- TimeGraphCombo combo = wrapper.getTimeGraphCombo();
- combo.setTreeContentProvider(fTimeGraphContentProvider);
- combo.setTreeLabelProvider(fLabelProvider);
- combo.setTreeColumns(fColumns);
+ fTimeGraphViewer = new TimeGraphViewer(parent, SWT.NONE);
+ if (fLabelProvider != null) {
+ fTimeGraphViewer.setTimeGraphLabelProvider(fLabelProvider);
+ }
+ if (fColumns != null) {
+ fTimeGraphViewer.setColumns(fColumns);
if (fColumnComparators != null) {
- createColumnSelectionListener(combo.getTreeViewer());
+ createColumnSelectionListener(fTimeGraphViewer.getTree());
}
- // Add double click listener to tree viewer
- createDoubleClickListener(combo.getTreeViewer());
}
- fTimeGraphWrapper.setTimeGraphContentProvider(fTimeGraphContentProvider);
- fTimeGraphWrapper.setFilterContentProvider(fFilterContentProvider != null ? fFilterContentProvider : fTimeGraphContentProvider);
- fTimeGraphWrapper.setFilterLabelProvider(fFilterLabelProvider);
- fTimeGraphWrapper.setFilterColumns(fFilterColumns);
+ fTimeGraphViewer.setTimeGraphContentProvider(fTimeGraphContentProvider);
+ fTimeGraphViewer.setFilterContentProvider(fFilterContentProvider != null ? fFilterContentProvider : fTimeGraphContentProvider);
+ fTimeGraphViewer.setFilterLabelProvider(fFilterLabelProvider);
+ fTimeGraphViewer.setFilterColumns(fFilterColumns);
- fTimeGraphWrapper.setTimeGraphPresentationProvider(fPresentation);
- fTimeGraphWrapper.setAutoExpandLevel(fAutoExpandLevel);
+ fTimeGraphViewer.setTimeGraphProvider(fPresentation);
+ fTimeGraphViewer.setAutoExpandLevel(fAutoExpandLevel);
- fTimeGraphWrapper.getTimeGraphViewer().addRangeListener(new ITimeGraphRangeListener() {
+ fTimeGraphViewer.setWeights(fWeight);
+
+ fTimeGraphViewer.addRangeListener(new ITimeGraphRangeListener() {
@Override
public void timeRangeUpdated(TimeGraphRangeUpdateEvent event) {
final long startTime = event.getStartTime();
}
});
- fTimeGraphWrapper.getTimeGraphViewer().addTimeListener(new ITimeGraphTimeListener() {
+ fTimeGraphViewer.addTimeListener(new ITimeGraphTimeListener() {
@Override
public void timeSelected(TimeGraphTimeEvent event) {
ITmfTimestamp startTime = TmfTimestamp.fromNanos(event.getBeginTime());
}
});
- fTimeGraphWrapper.getTimeGraphViewer().addBookmarkListener(new ITimeGraphBookmarkListener() {
+ fTimeGraphViewer.addBookmarkListener(new ITimeGraphBookmarkListener() {
@Override
public void bookmarkAdded(final TimeGraphBookmarkEvent event) {
try {
}
});
- fTimeGraphWrapper.getTimeGraphViewer().setTimeFormat(TimeFormat.CALENDAR);
+ fTimeGraphViewer.setTimeFormat(TimeFormat.CALENDAR);
IStatusLineManager statusLineManager = getViewSite().getActionBars().getStatusLineManager();
- fTimeGraphWrapper.getTimeGraphViewer().getTimeGraphControl().setStatusLineManager(statusLineManager);
+ fTimeGraphViewer.getTimeGraphControl().setStatusLineManager(statusLineManager);
// View Action Handling
makeActions();
}
// make selection available to other views
- getSite().setSelectionProvider(fTimeGraphWrapper.getSelectionProvider());
+ getSite().setSelectionProvider(fTimeGraphViewer.getSelectionProvider());
ResourcesPlugin.getWorkspace().addResourceChangeListener(this, IResourceChangeEvent.POST_CHANGE);
@Override
public void setFocus() {
- fTimeGraphWrapper.setFocus();
+ fTimeGraphViewer.setFocus();
}
@Override
public void resourceChanged(final IResourceChangeEvent event) {
for (final IMarkerDelta delta : event.findMarkerDeltas(IMarker.BOOKMARK, false)) {
if (delta.getResource().equals(fEditorFile)) {
- fTimeGraphWrapper.getTimeGraphViewer().setBookmarks(refreshBookmarks(fEditorFile));
+ fTimeGraphViewer.setBookmarks(refreshBookmarks(fEditorFile));
redraw();
return;
}
Display.getDefault().asyncExec(new Runnable() {
@Override
public void run() {
- if (fTimeGraphWrapper.isDisposed()) {
+ if (fTimeGraphViewer.getControl().isDisposed()) {
return;
}
if (beginTime == endTime) {
- fTimeGraphWrapper.getTimeGraphViewer().setSelectedTime(beginTime, true);
+ fTimeGraphViewer.setSelectedTime(beginTime, true);
} else {
- fTimeGraphWrapper.getTimeGraphViewer().setSelectionRange(beginTime, endTime, true);
+ fTimeGraphViewer.setSelectionRange(beginTime, endTime, true);
}
- synchingToTime(fTimeGraphWrapper.getTimeGraphViewer().getSelectionBegin());
+ synchingToTime(fTimeGraphViewer.getSelectionBegin());
}
});
}
Display.getDefault().asyncExec(new Runnable() {
@Override
public void run() {
- if (fTimeGraphWrapper.isDisposed()) {
+ if (fTimeGraphViewer.getControl().isDisposed()) {
return;
}
- fTimeGraphWrapper.getTimeGraphViewer().setStartFinishTime(startTime, endTime);
+ fTimeGraphViewer.setStartFinishTime(startTime, endTime);
startZoomThread(startTime, endTime);
}
});
*/
@TmfSignalHandler
public void updateTimeFormat( final TmfTimestampFormatUpdateSignal signal){
- fTimeGraphWrapper.refresh();
+ fTimeGraphViewer.refresh();
}
/**
}
if (fTrace != null) {
/* save the filters of the previous trace */
- fFiltersMap.put(fTrace, fTimeGraphWrapper.getFilters());
- fViewContext.put(fTrace, new ViewContext(fCurrentSortColumn, fSortDirection, fTimeGraphWrapper.getSelection()));
+ fFiltersMap.put(fTrace, fTimeGraphViewer.getFilters());
+ fViewContext.put(fTrace, new ViewContext(fCurrentSortColumn, fSortDirection, fTimeGraphViewer.getSelection()));
}
fTrace = trace;
@Override
public void run() {
LOGGER.info(() -> getLogMessage("RefreshStart", null)); //$NON-NLS-1$
- if (fTimeGraphWrapper.isDisposed()) {
+ if (fTimeGraphViewer.getControl().isDisposed()) {
return;
}
fDirty.incrementAndGet();
- boolean hasEntries = false;
synchronized (fEntryListMap) {
fEntryList = fEntryListMap.get(fTrace);
if (fEntryList == null) {
fEntryList.clear();
fEntryList.addAll(list);
}
- hasEntries = !fEntryList.isEmpty();
}
- boolean inputChanged = fEntryList != fTimeGraphWrapper.getInput();
- TimeGraphCombo combo = getTimeGraphCombo();
- try {
- // Set redraw to false to only draw once
- if (combo != null) {
- combo.getTreeViewer().getTree().setRedraw(false);
- }
- getTimeGraphViewer().getTimeGraphControl().setRedraw(false);
- if (inputChanged) {
- fTimeGraphWrapper.setInput(fEntryList);
- /* restore the previously saved filters, if any */
- fTimeGraphWrapper.setFilters(fFiltersMap.get(fTrace));
- fTimeGraphWrapper.getTimeGraphViewer().setLinks(null);
- fTimeGraphWrapper.getTimeGraphViewer().setBookmarks(refreshBookmarks(fEditorFile));
- fTimeGraphWrapper.getTimeGraphViewer().setMarkerCategories(getMarkerCategories());
- fTimeGraphWrapper.getTimeGraphViewer().setMarkers(null);
- applyViewContext();
- } else {
- fTimeGraphWrapper.refresh();
- }
- // reveal selection
- if (fIsRevealSelection) {
- fIsRevealSelection = false;
- ITimeGraphEntry entry1 = fTimeGraphWrapper.getSelection();
- fTimeGraphWrapper.setSelection(entry1);
- }
- } finally {
- if (combo != null) {
- combo.getTreeViewer().getTree().setRedraw(true);
- }
- getTimeGraphViewer().getTimeGraphControl().setRedraw(true);
+ boolean inputChanged = fEntryList != fTimeGraphViewer.getInput();
+ if (inputChanged) {
+ fTimeGraphViewer.setInput(fEntryList);
+ /* restore the previously saved filters, if any */
+ fTimeGraphViewer.setFilters(fFiltersMap.get(fTrace));
+ fTimeGraphViewer.setLinks(null);
+ fTimeGraphViewer.setBookmarks(refreshBookmarks(fEditorFile));
+ fTimeGraphViewer.setMarkerCategories(getMarkerCategories());
+ fTimeGraphViewer.setMarkers(null);
+ applyViewContext();
+ } else {
+ fTimeGraphViewer.refresh();
+ }
+ // reveal selection
+ if (fIsRevealSelection) {
+ fIsRevealSelection = false;
+ fTimeGraphViewer.setSelection(fTimeGraphViewer.getSelection(), true);
}
long startBound = (fStartTime == Long.MAX_VALUE ? SWT.DEFAULT : fStartTime);
long endBound = (fEndTime == Long.MIN_VALUE ? SWT.DEFAULT : fEndTime);
- fTimeGraphWrapper.getTimeGraphViewer().setTimeBounds(startBound, endBound);
+ fTimeGraphViewer.setTimeBounds(startBound, endBound);
TmfTraceContext ctx = TmfTraceManager.getInstance().getCurrentTraceContext();
long selectionBeginTime = fTrace == null ? SWT.DEFAULT : ctx.getSelectionRange().getStartTime().toNanos();
long endTime = fTrace == null ? SWT.DEFAULT : ctx.getWindowRange().getEndTime().toNanos();
startTime = (fStartTime == Long.MAX_VALUE ? SWT.DEFAULT : Math.max(startTime, fStartTime));
endTime = (fEndTime == Long.MIN_VALUE ? SWT.DEFAULT : Math.min(endTime, fEndTime));
- fTimeGraphWrapper.getTimeGraphViewer().setSelectionRange(selectionBeginTime, selectionEndTime, false);
- fTimeGraphWrapper.getTimeGraphViewer().setStartFinishTime(startTime, endTime);
+ fTimeGraphViewer.setSelectionRange(selectionBeginTime, selectionEndTime, false);
+ fTimeGraphViewer.setStartFinishTime(startTime, endTime);
if (inputChanged && selectionBeginTime != SWT.DEFAULT) {
synchingToTime(selectionBeginTime);
}
- if (fTimeGraphWrapper instanceof TimeGraphComboWrapper && !fPackDone) {
- for (TreeColumn column : ((TimeGraphComboWrapper) fTimeGraphWrapper).getTreeViewer().getTree().getColumns()) {
- column.pack();
- }
- if (hasEntries) {
- fPackDone = true;
- }
- }
-
if (!zoomThread) {
startZoomThread(startTime, endTime);
}
@Override
public void run() {
LOGGER.info(() -> getLogMessage("RedrawStart", null)); //$NON-NLS-1$
- if (fTimeGraphWrapper.isDisposed()) {
+ if (fTimeGraphViewer.getControl().isDisposed()) {
return;
}
- fTimeGraphWrapper.redraw();
- fTimeGraphWrapper.update();
+ fTimeGraphViewer.getControl().redraw();
+ fTimeGraphViewer.getControl().update();
synchronized (fSyncObj) {
if (fRedrawState == State.PENDING) {
fRedrawState = State.IDLE;
}
private void makeActions() {
- fPreviousResourceAction = fTimeGraphWrapper.getTimeGraphViewer().getPreviousItemAction();
+ fPreviousResourceAction = fTimeGraphViewer.getPreviousItemAction();
fPreviousResourceAction.setText(getPrevText());
fPreviousResourceAction.setToolTipText(getPrevTooltip());
- fNextResourceAction = fTimeGraphWrapper.getTimeGraphViewer().getNextItemAction();
+ fNextResourceAction = fTimeGraphViewer.getNextItemAction();
fNextResourceAction.setText(getNextText());
fNextResourceAction.setToolTipText(getNextTooltip());
}
*/
protected void fillLocalToolBar(IToolBarManager manager) {
if (fFilterColumns != null && fFilterLabelProvider != null && fFilterColumns.length > 0) {
- manager.add(fTimeGraphWrapper.getShowFilterDialogAction());
+ manager.add(fTimeGraphViewer.getShowFilterDialogAction());
}
- manager.add(fTimeGraphWrapper.getTimeGraphViewer().getShowLegendAction());
+ manager.add(fTimeGraphViewer.getShowLegendAction());
manager.add(new Separator());
- manager.add(fTimeGraphWrapper.getTimeGraphViewer().getResetScaleAction());
- manager.add(fTimeGraphWrapper.getTimeGraphViewer().getPreviousEventAction());
- manager.add(fTimeGraphWrapper.getTimeGraphViewer().getNextEventAction());
+ manager.add(fTimeGraphViewer.getResetScaleAction());
+ manager.add(fTimeGraphViewer.getPreviousEventAction());
+ manager.add(fTimeGraphViewer.getNextEventAction());
manager.add(new Separator());
- manager.add(fTimeGraphWrapper.getTimeGraphViewer().getToggleBookmarkAction());
- manager.add(fTimeGraphWrapper.getTimeGraphViewer().getPreviousMarkerAction());
- manager.add(fTimeGraphWrapper.getTimeGraphViewer().getNextMarkerAction());
+ manager.add(fTimeGraphViewer.getToggleBookmarkAction());
+ manager.add(fTimeGraphViewer.getPreviousMarkerAction());
+ manager.add(fTimeGraphViewer.getNextMarkerAction());
manager.add(new Separator());
manager.add(fPreviousResourceAction);
manager.add(fNextResourceAction);
- manager.add(fTimeGraphWrapper.getTimeGraphViewer().getZoomInAction());
- manager.add(fTimeGraphWrapper.getTimeGraphViewer().getZoomOutAction());
+ manager.add(fTimeGraphViewer.getZoomInAction());
+ manager.add(fTimeGraphViewer.getZoomOutAction());
manager.add(new Separator());
}
* @since 2.0
*/
protected void fillLocalMenu(IMenuManager manager) {
- manager.add(fTimeGraphWrapper.getTimeGraphViewer().getMarkersMenu());
+ manager.add(fTimeGraphViewer.getMarkersMenu());
}
/**
*/
@Override
public TmfTimeViewAlignmentInfo getTimeViewAlignmentInfo() {
- if (fTimeGraphWrapper == null) {
+ if (fTimeGraphViewer == null) {
return null;
}
- return fTimeGraphWrapper.getTimeViewAlignmentInfo();
+ return fTimeGraphViewer.getTimeViewAlignmentInfo();
}
/**
*/
@Override
public int getAvailableWidth(int requestedOffset) {
- if (fTimeGraphWrapper == null) {
+ if (fTimeGraphViewer == null) {
return 0;
}
- return fTimeGraphWrapper.getAvailableWidth(requestedOffset);
+ return fTimeGraphViewer.getAvailableWidth(requestedOffset);
}
/**
*/
@Override
public void performAlign(int offset, int width) {
- if (fTimeGraphWrapper != null) {
- fTimeGraphWrapper.performAlign(offset, width);
+ if (fTimeGraphViewer != null) {
+ fTimeGraphViewer.performAlign(offset, width);
}
}
// If the time graph control hasn't updated all the way to the end of
// the window range then it's dirty. A refresh should happen later.
- if (fTimeGraphWrapper.getTimeGraphViewer().getTime0() != startTime || fTimeGraphWrapper.getTimeGraphViewer().getTime1() != endTime) {
+ if (fTimeGraphViewer.getTime0() != startTime || fTimeGraphViewer.getTime1() != endTime) {
return true;
}
return fDirty.get() != 0 || fZoomThread.getZoomStartTime() != startTime || fZoomThread.getZoomEndTime() != endTime;
}
- private void createColumnSelectionListener(TreeViewer treeViewer) {
+ private void createColumnSelectionListener(Tree tree) {
for (int i = 0; i < fColumnComparators.length; i++) {
final int index = i;
final Comparator<ITimeGraphEntry> comp = fColumnComparators[index];
- final Tree tree = treeViewer.getTree();
final TreeColumn column = tree.getColumn(i);
if (comp != null) {
}
setEntryComparator(comparator);
fIsRevealSelection = true;
- if (fTimeGraphWrapper instanceof TimeGraphComboWrapper) {
- ((TimeGraphComboWrapper) fTimeGraphWrapper).getTreeViewer().getControl().setFocus();
- }
+ fTimeGraphViewer.getControl().setFocus();
refresh();
}
});
}
}
- private void createDoubleClickListener(TreeViewer treeViewer) {
- treeViewer.addDoubleClickListener(event -> {
- if (event.getSelection() instanceof TreeSelection) {
- TreeSelection selection = (TreeSelection) event.getSelection();
- if (selection.getFirstElement() instanceof ITimeGraphEntry) {
- ITimeGraphEntry entry = (ITimeGraphEntry) selection.getFirstElement();
- if (entry.hasChildren()) {
- fTimeGraphWrapper.setExpandedState(entry, !fTimeGraphWrapper.getExpandedState(entry));
- }
- }
- }
- });
- }
-
-
private void restoreViewContext() {
- TimeGraphCombo combo = getTimeGraphCombo();
ViewContext viewContext = fViewContext.get(fTrace);
- if (combo != null) {
- if (fColumnComparators != null) {
- // restore sort settings
- fSortDirection = SWT.DOWN;
- fCurrentSortColumn = fInitialSortColumn;
- if (viewContext != null) {
- fSortDirection = viewContext.getSortDirection();
- fCurrentSortColumn = viewContext.getSortColumn();
+ if (fColumnComparators != null) {
+ // restore sort settings
+ fSortDirection = SWT.DOWN;
+ fCurrentSortColumn = fInitialSortColumn;
+ if (viewContext != null) {
+ fSortDirection = viewContext.getSortDirection();
+ fCurrentSortColumn = viewContext.getSortColumn();
+ }
+ if ((fCurrentSortColumn < fColumnComparators.length) && (fColumnComparators[fCurrentSortColumn] != null)) {
+ Comparator<ITimeGraphEntry> comparator = fColumnComparators[fCurrentSortColumn];
+ if (comparator instanceof ITimeGraphEntryComparator) {
+ ((ITimeGraphEntryComparator) comparator).setDirection(fSortDirection);
}
- if ((fCurrentSortColumn < fColumnComparators.length) && (fColumnComparators[fCurrentSortColumn] != null)) {
- Comparator<ITimeGraphEntry> comparator = fColumnComparators[fCurrentSortColumn];
- if (comparator instanceof ITimeGraphEntryComparator) {
- ((ITimeGraphEntryComparator) comparator).setDirection(fSortDirection);
- }
- if (fSortDirection != SWT.DOWN) {
- comparator = checkNotNull(Collections.reverseOrder(comparator));
- }
- setEntryComparator(comparator);
+ if (fSortDirection != SWT.DOWN) {
+ comparator = checkNotNull(Collections.reverseOrder(comparator));
}
+ setEntryComparator(comparator);
}
}
}
private void applyViewContext() {
- TimeGraphCombo combo = getTimeGraphCombo();
ViewContext viewContext = fViewContext.get(fTrace);
- if (combo != null) {
- TreeViewer treeViewer = combo.getTreeViewer();
- final Tree tree = treeViewer.getTree();
+ if (fColumnComparators != null) {
+ final Tree tree = fTimeGraphViewer.getTree();
final TreeColumn column = tree.getColumn(fCurrentSortColumn);
tree.setSortDirection(fSortDirection);
tree.setSortColumn(column);
- combo.getTreeViewer().getControl().setFocus();
}
+ fTimeGraphViewer.getControl().setFocus();
// restore and reveal selection
if ((viewContext != null) && (viewContext.getSelection() != null)) {
- fTimeGraphWrapper.setSelection(viewContext.getSelection());
+ fTimeGraphViewer.setSelection(viewContext.getSelection(), true);
}
fViewContext.remove(fTrace);
}
}
private void createContextMenu() {
- TimeGraphCombo combo = getTimeGraphCombo();
fEntryMenuManager.setRemoveAllWhenShown(true);
- if (combo != null) {
- TreeViewer treeViewer = combo.getTreeViewer();
- Tree tree = treeViewer.getTree();
- Menu menu = fEntryMenuManager.createContextMenu(tree);
- tree.setMenu(menu);
- } else {
- TimeGraphControl timeGraphControl = getTimeGraphViewer().getTimeGraphControl();
- final Menu entryMenu = fEntryMenuManager.createContextMenu(timeGraphControl);
- timeGraphControl.addTimeGraphEntryMenuListener(new MenuDetectListener() {
- @Override
- public void menuDetected(MenuDetectEvent event) {
- Point p = timeGraphControl.toControl(event.x, event.y);
- /*
- * The TimeGraphControl will call the TimeGraphEntryMenuListener
- * before the TimeEventMenuListener. If the event is
- * triggered on the namespace then show the menu else
- * clear the menu.
- */
- if (p.x < getTimeGraphViewer().getNameSpace()) {
- timeGraphControl.setMenu(entryMenu);
- } else {
- timeGraphControl.setMenu(null);
- event.doit = false;
- }
+ TimeGraphControl timeGraphControl = getTimeGraphViewer().getTimeGraphControl();
+ final Menu entryMenu = fEntryMenuManager.createContextMenu(timeGraphControl);
+ timeGraphControl.addTimeGraphEntryMenuListener(new MenuDetectListener() {
+ @Override
+ public void menuDetected(MenuDetectEvent event) {
+ Point p = timeGraphControl.toControl(event.x, event.y);
+ /*
+ * The TimeGraphControl will call the TimeGraphEntryMenuListener
+ * before the TimeEventMenuListener. If the event is triggered
+ * on the name space then show the menu else clear the menu.
+ */
+ if (p.x < getTimeGraphViewer().getNameSpace()) {
+ timeGraphControl.setMenu(entryMenu);
+ } else {
+ timeGraphControl.setMenu(null);
+ event.doit = false;
}
- });
- }
+ }
+ });
fEntryMenuManager.addMenuListener(new IMenuListener() {
@Override
public void menuAboutToShow(IMenuManager manager) {
fEntryMenuManager.add(new GroupMarker(IWorkbenchActionConstants.MB_ADDITIONS));
}
});
- getSite().registerContextMenu(fEntryMenuManager, fTimeGraphWrapper.getSelectionProvider());
+ getSite().registerContextMenu(fEntryMenuManager, fTimeGraphViewer.getSelectionProvider());
}
/**
*/
class FindTarget {
public ITimeGraphEntry getSelection() {
- return fTimeGraphWrapper.getSelection();
+ return fTimeGraphViewer.getSelection();
}
public void selectAndReveal(@NonNull ITimeGraphEntry entry) {
- fTimeGraphWrapper.selectAndReveal(entry);
+ fTimeGraphViewer.selectAndReveal(entry);
}
public ITimeGraphEntry[] getEntries() {
* on the right)
*
* @author Patrick Tasse
+ * @deprecated Use {@link #getTimeGraphViewer()} instead.
*/
+@Deprecated
public class TimeGraphCombo extends Composite {
// ------------------------------------------------------------------------
tree.setLinesVisible(true);
fTimeGraphViewer = new TimeGraphViewerExtension(fSashForm, SWT.NONE, tree);
+ fTimeGraphViewer.setColumns(new String[0]);
+ fTimeGraphViewer.setNameWidthPref(0);
+ fTimeGraphViewer.setWeights(new int[] { 0, 1 } );
if (fScrollBarsInTreeWorkaround) {
// Feature in Windows. The tree vertical bar reappears when
if (treeItems.isEmpty()) {
event.doit = false;
fTreeViewer.setSelection(new StructuredSelection());
- fTimeGraphViewer.setSelection(null);
+ fTimeGraphViewer.setSelection(null, false);
return;
}
TreeItem lastTreeItem = treeItems.get(treeItems.size() - 1);
}
if (event.keyCode == SWT.ARROW_DOWN) {
int index = Math.min(fTimeGraphViewer.getSelectionIndex() + 1, treeItems.size() - 1);
- fTimeGraphViewer.setSelection((ITimeGraphEntry) treeItems.get(index).getData());
+ fTimeGraphViewer.setSelection((ITimeGraphEntry) treeItems.get(index).getData(), true);
event.doit = false;
} else if (event.keyCode == SWT.PAGE_DOWN) {
int height = tree.getSize().y - tree.getHeaderHeight() - tree.getHorizontalBar().getSize().y;
if (event.getSelection() instanceof IStructuredSelection) {
Object selection = ((IStructuredSelection) event.getSelection()).getFirstElement();
if (selection instanceof ITimeGraphEntry) {
- fTimeGraphViewer.setSelection((ITimeGraphEntry) selection);
+ fTimeGraphViewer.setSelection((ITimeGraphEntry) selection, true);
}
alignTreeItems(false);
}
* the new selection
*/
public void setSelection(ITimeGraphEntry selection) {
- fTimeGraphViewer.setSelection(selection);
+ fTimeGraphViewer.setSelection(selection, true);
setSelectionInTree(selection);
}
import org.eclipse.jface.dialogs.IDialogSettings;
import org.eclipse.jface.resource.ImageDescriptor;
import org.eclipse.jface.viewers.AbstractTreeViewer;
+import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.ISelectionProvider;
+import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jface.viewers.ITableLabelProvider;
import org.eclipse.jface.viewers.ITreeContentProvider;
+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.jface.window.Window;
import org.eclipse.swt.SWT;
import org.eclipse.swt.events.MenuDetectListener;
import org.eclipse.swt.events.MouseEvent;
import org.eclipse.swt.events.MouseWheelListener;
+import org.eclipse.swt.events.PaintEvent;
+import org.eclipse.swt.events.PaintListener;
import org.eclipse.swt.events.SelectionAdapter;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.events.SelectionListener;
import org.eclipse.swt.widgets.Listener;
import org.eclipse.swt.widgets.Menu;
import org.eclipse.swt.widgets.Slider;
+import org.eclipse.swt.widgets.Tree;
+import org.eclipse.swt.widgets.TreeColumn;
import org.eclipse.tracecompass.internal.tmf.ui.Activator;
import org.eclipse.tracecompass.internal.tmf.ui.ITmfImageConstants;
import org.eclipse.tracecompass.internal.tmf.ui.Messages;
*
* @author Patrick Tasse, and others
*/
-public class TimeGraphViewer implements ITimeDataProvider, IMarkerAxisListener, SelectionListener {
+public class TimeGraphViewer extends Viewer implements ITimeDataProvider, IMarkerAxisListener, SelectionListener {
/** Constant indicating that all levels of the time graph should be expanded */
public static final int ALL_LEVELS = AbstractTreeViewer.ALL_LEVELS;
private static final int DEFAULT_NAME_WIDTH = 200;
- private static final int MIN_NAME_WIDTH = 6;
+ private static final int MIN_NAME_WIDTH = 3;
private static final int MAX_NAME_WIDTH = 1000;
private static final int DEFAULT_HEIGHT = 22;
private static final String HIDE_ARROWS_KEY = "hide.arrows"; //$NON-NLS-1$
private int fNameWidthPref = DEFAULT_NAME_WIDTH;
private int fMinNameWidth = MIN_NAME_WIDTH;
private int fNameWidth;
+ private int[] fWeights;
private Composite fDataViewer;
private TimeGraphControl fTimeGraphCtrl;
+ private Tree fTree;
private TimeGraphScale fTimeScaleCtrl;
private TimeGraphMarkerAxis fMarkerAxisCtrl;
private Slider fHorizontalScrollBar;
private Object fInputElement;
private ITimeGraphContentProvider fTimeGraphContentProvider;
private ITimeGraphPresentationProvider fTimeGraphProvider;
+ private ITableLabelProvider fLabelProvider;
private @NonNull ITimeDataProvider fTimeDataProvider = this;
private TimeGraphTooltipHandler fToolTipHandler;
fToolTipHandler.activateHoverHelp(fTimeGraphCtrl);
}
+ /**
+ * Sets the tree label provider used for the name space
+ *
+ * @param labelProvider the tree label provider
+ * @since 2.3
+ */
+ public void setTimeGraphLabelProvider(ITableLabelProvider labelProvider) {
+ fLabelProvider = labelProvider;
+ if (fTimeGraphCtrl != null) {
+ fTimeGraphCtrl.setLabelProvider(labelProvider);
+ }
+ }
+
/**
* Sets the tree columns for this time graph combo's filter dialog.
*
getShowFilterDialogAction().getFilterDialog().setLabelProvider(labelProvider);
}
- /**
- * Sets or clears the input for this time graph viewer.
- *
- * @param inputElement
- * The input of this time graph viewer, or <code>null</code> if
- * none
- */
+ @Override
public void setInput(Object inputElement) {
+ Object oldInput = fInputElement;
+ fTimeGraphContentProvider.inputChanged(this, oldInput, inputElement);
fInputElement = inputElement;
ITimeGraphEntry[] input = fTimeGraphContentProvider.getElements(inputElement);
fListenerNotifier = null;
}
}
- /**
- * Gets the input for this time graph viewer.
- *
- * @return The input of this time graph viewer, or <code>null</code> if none
- */
+ @Override
public Object getInput() {
return fInputElement;
}
}
}
- /**
- * Refresh the view
- */
+ @Override
public void refresh() {
ITimeGraphEntry[] input = fTimeGraphContentProvider.getElements(fInputElement);
setTimeRange(input);
fDataViewer = new Composite(parent, style) {
@Override
public void redraw() {
+ fTree.redraw();
fTimeScaleCtrl.redraw();
fTimeGraphCtrl.redraw();
fMarkerAxisCtrl.redraw();
super.redraw();
}
};
- GridLayout gl2 = new GridLayout(1, false);
+ GridLayout gl2 = new GridLayout(2, false);
gl2.marginHeight = fBorderWidth;
gl2.marginWidth = 0;
gl2.verticalSpacing = 0;
fTimeAlignedComposite.setLayout(gl2);
fTimeAlignedComposite.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true));
+ fTree = new Tree(fTimeAlignedComposite, SWT.NO_SCROLL);
+ fTree.setLayoutData(new GridData(SWT.FILL, SWT.FILL, false, false));
+ fTree.setHeaderVisible(true);
+ // add a default column
+ TreeColumn column = new TreeColumn(fTree, SWT.LEFT);
+ column.setResizable(false);
+
+ /*
+ * Bug in Linux. The tree header height is 0 in constructor, so we need
+ * to reset it later when the control is painted. This work around used
+ * to be done on control resized but the header height was not
+ * initialized on the initial resize on GTK3.
+ */
+ fTree.addPaintListener(new PaintListener() {
+ @Override
+ public void paintControl(PaintEvent e) {
+ int headerHeight = fTree.getHeaderHeight();
+ if (headerHeight > 0) {
+ fTree.removePaintListener(this);
+ setHeaderHeight(headerHeight);
+ }
+ }
+ });
+
fTimeScaleCtrl = new TimeGraphScale(fTimeAlignedComposite, fColorScheme);
fTimeScaleCtrl.setTimeProvider(fTimeDataProvider);
fTimeScaleCtrl.setLayoutData(new GridData(SWT.FILL, SWT.DEFAULT, true, false));
fTimeGraphCtrl = createTimeGraphControl(fTimeAlignedComposite, fColorScheme);
fTimeGraphCtrl.setTimeProvider(this);
+ fTimeGraphCtrl.setLabelProvider(fLabelProvider);
+ fTimeGraphCtrl.setTree(fTree);
fTimeGraphCtrl.setTimeGraphScale(fTimeScaleCtrl);
fTimeGraphCtrl.addSelectionListener(this);
- fTimeGraphCtrl.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true));
+ fTimeGraphCtrl.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true, 2, 1));
fTimeGraphCtrl.addMouseWheelListener(new MouseWheelListener() {
@Override
public void mouseScrolled(MouseEvent e) {
});
fMarkerAxisCtrl = createTimeGraphMarkerAxis(fTimeAlignedComposite, fColorScheme, this);
- fMarkerAxisCtrl.setLayoutData(new GridData(SWT.FILL, SWT.DEFAULT, true, false));
+ fMarkerAxisCtrl.setLayoutData(new GridData(SWT.FILL, SWT.DEFAULT, true, false, 2, 1));
fMarkerAxisCtrl.addMarkerAxisListener(this);
fMarkerAxisCtrl.addMouseWheelListener(new MouseWheelListener() {
@Override
return;
}
+ if (fWeights != null) {
+ setWeights(fWeights);
+ fWeights = null;
+ }
int width = r.width;
if (fNameWidth > width - fMinNameWidth) {
fNameWidth = width - fMinNameWidth;
if (fNameWidth < fMinNameWidth) {
fNameWidth = fMinNameWidth;
}
+ if (fTree.getColumnCount() == 1) {
+ fTree.getColumn(0).setWidth(fNameWidth);
+ }
adjustHorizontalScrollBar();
adjustVerticalScrollBar();
}
*
* @return The entry that is selected
*/
+ @Override
public ITimeGraphEntry getSelection() {
return fTimeGraphCtrl.getSelectedTrace();
}
return fMinTimeInterval;
}
+ /**
+ * Sets the relative horizontal weight of each part of the time graph
+ * viewer. The first number is the name space weight, and the second number
+ * is the time space weight.
+ *
+ * @param weights
+ * The array of relative weights of each part of the viewer
+ * @since 2.3
+ */
+ public void setWeights(final int[] weights) {
+ if (weights.length != 2) {
+ return;
+ }
+ int width = fTimeAlignedComposite.getSize().x;
+ if (width == 0) {
+ /* the weigths will be applied when the control is resized */
+ fWeights = weights;
+ return;
+ }
+ setNameSpace(width * weights[0] / (weights[0] + weights[1]));
+ }
+
@Override
public int getNameSpace() {
return fNameWidth;
if (fNameWidth < MIN_NAME_WIDTH) {
fNameWidth = MIN_NAME_WIDTH;
}
+ GridData gd = (GridData) fTree.getLayoutData();
+ gd.widthHint = fNameWidth;
+ if (fTree.getColumnCount() == 1) {
+ fTree.getColumn(0).setWidth(fNameWidth);
+ }
+ fTimeAlignedComposite.layout();
+ fTree.redraw();
fTimeGraphCtrl.redraw();
fTimeScaleCtrl.redraw();
fMarkerAxisCtrl.redraw();
for (ITimeGraphSelectionListener listener : fSelectionListeners) {
listener.selectionChanged(event);
}
+
+ ISelection structuredSelection = (selection == null) ? StructuredSelection.EMPTY : new StructuredSelection(selection);
+ fireSelectionChanged(new SelectionChangedEvent(this, structuredSelection));
}
/**
}
/**
- * Callback for a trace selection
+ * Sets a new selection for this viewer and makes it visible.
*
- * @param trace
- * The trace that was selected
+ * @param entry
+ * The entry to select
+ * @deprecated Use {@link #setSelection(ISelection, boolean)} instead.
*/
- public void setSelection(ITimeGraphEntry trace) {
+ @Deprecated
+ public void setSelection(ITimeGraphEntry entry) {
+ setSelection(entry, true);
+ }
+
+ @Override
+ public void setSelection(ISelection selection, boolean reveal) {
/* if there is a pending selection, ignore this one */
if (fListenerNotifier != null && fListenerNotifier.hasSelectionChanged()) {
return;
}
- fSelectedEntry = trace;
- fTimeGraphCtrl.selectItem(trace, false);
+ Object element = selection;
+ if (selection instanceof IStructuredSelection) {
+ element = ((IStructuredSelection) selection).getFirstElement();
+ }
+ if (!(element instanceof ITimeGraphEntry)) {
+ return;
+ }
+ ITimeGraphEntry entry = (ITimeGraphEntry) element;
+ fSelectedEntry = entry;
+ fTimeGraphCtrl.selectItem(entry, false, reveal);
adjustVerticalScrollBar();
}
return fNameWidthPref;
}
- /**
- * Returns the primary control associated with this viewer.
- *
- * @return the SWT control which displays this viewer's content
- */
+ @Override
public Control getControl() {
return fDataViewer;
}
return fTimeGraphCtrl;
}
+ /**
+ * Returns the tree control associated with this viewer. The tree is only
+ * used for column handling of the name space and contains no tree items.
+ *
+ * @return the tree control
+ * @since 2.3
+ */
+ public Tree getTree() {
+ return fTree;
+ }
+
+ /**
+ * Sets the columns for this time graph viewer's name space.
+ *
+ * @param columnNames
+ * the column names
+ * @since 2.3
+ */
+ public void setColumns(String[] columnNames) {
+ fTimeGraphCtrl.setColumns(columnNames);
+ }
+
/**
* Returns the time graph scale associated with this viewer.
*
/*******************************************************************************
- * Copyright (c) 2009, 2014 Ericsson
+ * Copyright (c) 2009, 2016 Ericsson
*
* All rights reserved. This program and the accompanying materials are
* made available under the terms of the Eclipse Public License v1.0 which
import java.util.regex.Pattern;
import org.eclipse.jdt.annotation.NonNull;
+import org.eclipse.jface.viewers.ISelection;
/**
* Interface for an entry (row) in the time graph view
* @author Alvaro Sanchez-Leon
* @author Patrick Tasse
*/
-public interface ITimeGraphEntry {
+public interface ITimeGraphEntry extends ISelection {
/**
* Returns the parent of this entry, or <code>null</code> if it has none.
* @since 2.0
*/
boolean matches(@NonNull Pattern pattern);
+
+ @Override
+ default boolean isEmpty() {
+ return false;
+ }
}
import org.eclipse.jface.viewers.ISelectionChangedListener;
import org.eclipse.jface.viewers.ISelectionProvider;
import org.eclipse.jface.viewers.IStructuredSelection;
+import org.eclipse.jface.viewers.ITableLabelProvider;
import org.eclipse.jface.viewers.SelectionChangedEvent;
import org.eclipse.jface.viewers.StructuredSelection;
import org.eclipse.jface.viewers.ViewerFilter;
import org.eclipse.osgi.util.NLS;
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.widgets.Event;
import org.eclipse.swt.widgets.Listener;
import org.eclipse.swt.widgets.Menu;
+import org.eclipse.swt.widgets.Tree;
+import org.eclipse.swt.widgets.TreeColumn;
import org.eclipse.tracecompass.common.core.math.SaturatedArithmetic;
import org.eclipse.tracecompass.tmf.core.signal.TmfSignalManager;
import org.eclipse.tracecompass.tmf.ui.signal.TmfTimeViewAlignmentInfo;
private static final double ZOOM_IN_FACTOR = 0.8;
private static final double ZOOM_OUT_FACTOR = 1.25;
- private static final int SNAP_WIDTH = 2;
+ private static final int SNAP_WIDTH = 3;
private static final int ARROW_HOVER_MAX_DIST = 5;
+ private static double ARROW_RATIO = Math.sqrt(3) / 2; // base to height ratio
+
private static final int NO_STATUS = -1;
private static final int STATUS_WITHOUT_CURSOR_TIME = -2;
private static final int VERTICAL_ZOOM_DELAY = 400;
+ private static final String PREFERRED_WIDTH = "width"; //$NON-NLS-1$
+
/** Resource manager */
private LocalResourceManager fResourceManager = new LocalResourceManager(JFaceResources.getResources());
private Color[] fEventColorMap = null;
private ITimeDataProvider fTimeProvider;
+ private ITableLabelProvider fLabelProvider;
private IStatusLineManager fStatusLineManager = null;
+ private Tree fTree = null;
private TimeGraphScale fTimeGraphScale = null;
private boolean fIsInFocus = false;
private boolean fHasNamespaceFocus = false;
private long fDragTime0 = 0; // used to preserve accuracy of modified selection
private int fIdealNameSpace = 0;
+ private boolean fAutoResizeColumns = true;
private long fTime0bak;
private long fTime1bak;
private ITimeGraphPresentationProvider fTimeGraphProvider = null;
redraw();
}
+ /**
+ * Set the label provider for the name space
+ *
+ * @param labelProvider
+ * The label provider
+ * @since 2.3
+ */
+ public void setLabelProvider(ITableLabelProvider labelProvider) {
+ fLabelProvider = labelProvider;
+ redraw();
+ }
+
+ /**
+ * Get the label provider for the name space
+ *
+ * @return The label provider
+ * @since 2.3
+ */
+ public ITableLabelProvider getLabelProvider() {
+ return fLabelProvider;
+ }
+
/**
* Assign the status line manager
*
fStatusLineManager = statusLineManager;
}
+ /**
+ * Assign the tree that represents the name space header
+ *
+ * @param tree
+ * The tree
+ * @since 2.3
+ */
+ public void setTree(Tree tree) {
+ fTree = tree;
+ }
+
+ /**
+ * Returns the tree control associated with this time graph control. The
+ * tree is only used for column handling of the name space and contains no
+ * tree items.
+ *
+ * @return the tree control
+ * @since 2.3
+ */
+ public Tree getTree() {
+ return fTree;
+ }
+
+ /**
+ * Sets the columns for this time graph control's name space.
+ *
+ * @param columnNames
+ * the column names
+ * @since 2.3
+ */
+ public void setColumns(String[] columnNames) {
+ for (TreeColumn column : fTree.getColumns()) {
+ column.dispose();
+ }
+ ControlListener controlListener = new ControlListener() {
+ @Override
+ public void controlResized(ControlEvent e) {
+ if (fAutoResizeColumns && ((TreeColumn) e.widget).getWidth() < (Integer) e.widget.getData(PREFERRED_WIDTH)) {
+ fAutoResizeColumns = false;
+ }
+ redraw();
+ }
+ @Override
+ public void controlMoved(ControlEvent e) {
+ redraw();
+ }
+ };
+ for (String columnName : columnNames) {
+ TreeColumn column = new TreeColumn(fTree, SWT.LEFT);
+ column.setMoveable(true);
+ column.setText(columnName);
+ column.pack();
+ column.setData(PREFERRED_WIDTH, column.getWidth());
+ column.addControlListener(controlListener);
+ }
+ }
+
/**
* Assign the time graph scale
*
return false;
}
int nameWidth = fTimeProvider.getNameSpace();
- return Math.abs(x - nameWidth) < SNAP_WIDTH;
+ return Math.abs(x - nameWidth) <= SNAP_WIDTH;
}
boolean isOverTimeSpace(int x, int y) {
}
void selectItem(int idx, boolean addSelection) {
+ selectItem(idx, addSelection, true);
+ }
+
+ void selectItem(int idx, boolean addSelection, boolean reveal) {
boolean changed = false;
if (addSelection) {
if (idx >= 0 && idx < fItemData.fExpandedItems.length) {
item.fSelected = i == idx;
}
}
- changed |= ensureVisibleItem(idx, true);
+ if (reveal) {
+ changed |= ensureVisibleItem(idx, true);
+ }
if (changed) {
redraw();
}
}
/**
- * Callback for item selection
+ * Select an entry and make it visible
*
- * @param trace
- * The entry matching the trace
+ * @param entry
+ * The entry to select
* @param addSelection
- * If the selection is added or removed
+ * <code>true</code> to add the entry to the current selection,
+ * or <code>false</code> to set a new selection
*/
- public void selectItem(ITimeGraphEntry trace, boolean addSelection) {
- int idx = fItemData.findItemIndex(trace);
+ public void selectItem(ITimeGraphEntry entry, boolean addSelection) {
+ int idx = fItemData.findItemIndex(entry);
selectItem(idx, addSelection);
}
+ /**
+ * Select an entry
+ *
+ * @param entry
+ * The entry to select
+ * @param addSelection
+ * <code>true</code> to add the entry to the current selection,
+ * or <code>false</code> to set a new selection
+ * @param reveal
+ * <code>true</code> if the selection is to be made visible, and
+ * <code>false</code> otherwise
+ * @since 2.3
+ */
+ public void selectItem(ITimeGraphEntry entry, boolean addSelection, boolean reveal) {
+ int idx = fItemData.findItemIndex(entry);
+ selectItem(idx, addSelection, reveal);
+ }
+
/**
* Retrieve the number of entries shown per page.
*
}
}
- // draw drag line
- if (DRAG_SPLIT_LINE == fDragState) {
- gc.setForeground(getColorScheme().getColor(TimeGraphColorScheme.BLACK));
- gc.drawLine(bounds.x + nameSpace, bounds.y, bounds.x + nameSpace, bounds.y + bounds.height - 1);
- } else if (DRAG_ZOOM == fDragState && Math.max(fDragX, fDragX0) > nameSpace) {
+ // draw split line
+ if (DRAG_SPLIT_LINE == fDragState ||
+ (DRAG_NONE == fDragState && fMouseOverSplitLine && fTimeProvider.getNameSpace() > 0)) {
+ gc.setBackground(getColorScheme().getColor(TimeGraphColorScheme.DARK_GRAY));
+ } else {
+ gc.setBackground(getColorScheme().getColor(TimeGraphColorScheme.GRAY));
+ }
+ gc.fillRectangle(bounds.x + nameSpace - SNAP_WIDTH, bounds.y, SNAP_WIDTH, bounds.height);
+
+ if (DRAG_ZOOM == fDragState && Math.max(fDragX, fDragX0) > nameSpace) {
gc.setForeground(getColorScheme().getColor(TimeGraphColorScheme.TOOL_FOREGROUND));
gc.drawLine(fDragX0, bounds.y, fDragX0, bounds.y + bounds.height - 1);
if (fDragX != fDragX0) {
if (fDragX != fDragX0) {
gc.drawLine(fDragX, bounds.y, fDragX, bounds.y + bounds.height - 1);
}
- } else if (DRAG_NONE == fDragState && fMouseOverSplitLine && fTimeProvider.getNameSpace() > 0) {
- gc.setForeground(getColorScheme().getColor(TimeGraphColorScheme.RED));
- gc.drawLine(bounds.x + nameSpace, bounds.y, bounds.x + nameSpace, bounds.y + bounds.height - 1);
}
gc.setAlpha(alpha);
gc.setBackground(getColorScheme().getBkColor(true, fIsInFocus, false));
gc.fillRectangle(nameSpace, itemRect.y, itemRect.width - nameSpace, itemRect.height);
}
- // draw the name and middle line
- if (! item.fEntry.hasTimeEvents()) {
- drawName(item, itemRect, gc);
- } else {
- Rectangle nameRect = new Rectangle(itemRect.x, itemRect.y, nameSpace, itemRect.height);
- drawName(item, nameRect, gc);
+ // draw the name space
+ Rectangle nameRect = new Rectangle(itemRect.x, itemRect.y, nameSpace, itemRect.height);
+ drawName(item, nameRect, gc);
+ if (item.fEntry.hasTimeEvents()) {
Rectangle rect = new Rectangle(nameSpace, itemRect.y, itemRect.width - nameSpace, itemRect.height);
drawMidLine(rect, gc);
}
}
/**
- * Draw the name of an item.
+ * Draw the name space of an item.
*
* @param item
* Item object
* Graphics context
*/
protected void drawName(Item item, Rectangle bounds, GC gc) {
- boolean hasTimeEvents = item.fEntry.hasTimeEvents();
-
- // No name to be drawn
+ // No name space to be drawn
if (fTimeProvider.getNameSpace() == 0) {
return;
}
+ boolean hasTimeEvents = item.fEntry.hasTimeEvents();
+ if (hasTimeEvents) {
+ gc.setClipping(bounds);
+ }
+
int height = bounds.height - getMarginForHeight(bounds.height);
setFontForHeight(height, gc);
- int leftMargin = MARGIN + item.fLevel * EXPAND_SIZE;
- if (item.fHasChildren) {
- gc.setForeground(getColorScheme().getFgColorGroup(false, false));
- gc.setBackground(getColorScheme().getBkColor(false, false, false));
- Rectangle rect = Utils.clone(bounds);
- rect.x += leftMargin;
- rect.y += (bounds.height - EXPAND_SIZE) / 2;
- rect.width = EXPAND_SIZE;
- rect.height = EXPAND_SIZE;
- gc.fillRectangle(rect);
- gc.drawRectangle(rect.x, rect.y, rect.width - 1, rect.height - 1);
- int midy = rect.y + rect.height / 2;
- gc.drawLine(rect.x + 2, midy, rect.x + rect.width - 3, midy);
- if (!item.fExpanded) {
- int midx = rect.x + rect.width / 2;
- gc.drawLine(midx, rect.y + 2, midx, rect.y + rect.height - 3);
- }
- }
- leftMargin += EXPAND_SIZE + MARGIN;
-
- Image img = fTimeGraphProvider.getItemImage(item.fEntry);
- if (img != null) {
- // draw icon
- int imgHeight = img.getImageData().height;
- int imgWidth = img.getImageData().width;
- int x = leftMargin;
- int y = bounds.y + (bounds.height - imgHeight) / 2;
- gc.drawImage(img, x, y);
- leftMargin += imgWidth + MARGIN;
- }
- String name = item.fName;
- Point size = gc.stringExtent(name);
- if (fIdealNameSpace < leftMargin + size.x + MARGIN) {
- fIdealNameSpace = leftMargin + size.x + MARGIN;
- }
- if (hasTimeEvents) {
- // cut long string with "..."
- int width = bounds.width - leftMargin;
- int cuts = 0;
- while (size.x > width && name.length() > 1) {
- cuts++;
- name = name.substring(0, name.length() - 1);
- size = gc.stringExtent(name + "..."); //$NON-NLS-1$
- }
- if (cuts > 0) {
- name += "..."; //$NON-NLS-1$
- }
- }
+ String name = fLabelProvider == null ? item.fName : fLabelProvider.getColumnText(item.fEntry, 0);
Rectangle rect = Utils.clone(bounds);
- rect.x += leftMargin;
- rect.width -= leftMargin;
- // draw text
- if (rect.width > 0) {
- rect.y += (bounds.height - gc.stringExtent(name).y) / 2;
+ rect.y += (bounds.height - gc.stringExtent(name).y) / 2;
+ TreeColumn[] columns = fTree.getColumns();
+ int idealNameSpace = 0;
+ for (int i = 0; i < columns.length; i++) {
+ int columnIndex = fTree.getColumnOrder()[i];
+ TreeColumn column = columns[columnIndex];
+ rect.width = column.getWidth();
+ gc.setClipping(rect.x, bounds.y, Math.min(rect.width, bounds.x + bounds.width - rect.x - SNAP_WIDTH), bounds.height);
+ int width = MARGIN;
+ if (i == 0) {
+ // first visible column
+ width += item.fLevel * EXPAND_SIZE;
+ if (item.fHasChildren) {
+ // draw expand/collapse arrow
+ gc.setBackground(getColorScheme().getColor(TimeGraphColorScheme.DARK_GRAY));
+ int arrowHeightHint = (height < 4) ? height : (height < 6) ? height - 1 : height - 2;
+ int arrowHalfHeight = Math.max(1, Math.min(arrowHeightHint, (int) Math.round((EXPAND_SIZE - 2) / ARROW_RATIO))) / 2;
+ int arrowHalfWidth = (Math.max(1, Math.min(EXPAND_SIZE - 2, (int) Math.round(arrowHeightHint * ARROW_RATIO))) + 1) / 2;
+ int x1 = bounds.x + width + 1;
+ int x2 = x1 + 2 * arrowHalfWidth;
+ int midy = bounds.y + bounds.height / 2;
+ int y1 = midy - arrowHalfHeight;
+ int y2 = midy + arrowHalfHeight;
+ if (!item.fExpanded) { // >
+ gc.fillPolygon(new int[] { x1, y1, x2, midy, x1, y2 });
+ } else { // v
+ int midx = x1 + arrowHalfWidth;
+ gc.fillPolygon(new int[] { x1, y1, x2, y1, midx, y2 });
+ }
+ }
+ width += EXPAND_SIZE + MARGIN;
+
+ Image img = fLabelProvider != null ? fLabelProvider.getColumnImage(item.fEntry, columnIndex)
+ : columnIndex == 0 ? fTimeGraphProvider.getItemImage(item.fEntry) : null;
+ if (img != null) {
+ // draw icon
+ int imgHeight = img.getImageData().height;
+ int imgWidth = img.getImageData().width;
+ int x = width;
+ int y = bounds.y + (bounds.height - imgHeight) / 2;
+ gc.drawImage(img, x, y);
+ width += imgWidth + MARGIN;
+ }
+ } else {
+ if (fLabelProvider == null) {
+ break;
+ }
+ }
+ String label = fLabelProvider != null ? fLabelProvider.getColumnText(item.fEntry, columnIndex)
+ : columnIndex == 0 ? item.fName : ""; //$NON-NLS-1$
gc.setForeground(getColorScheme().getFgColor(item.fSelected, fIsInFocus));
- int textWidth = Utils.drawText(gc, name, rect, true);
- leftMargin += textWidth + MARGIN;
-
- if (hasTimeEvents) {
- // draw middle line
- rect.x = bounds.x + leftMargin;
- rect.y = bounds.y;
- rect.width = bounds.width - rect.x;
- drawMidLine(rect, gc);
+ Rectangle textRect = new Rectangle(rect.x + width, rect.y, rect.width - width, rect.height);
+ int textWidth = Utils.drawText(gc, label, textRect, true);
+ width += textWidth + MARGIN;
+ if (textWidth > 0) {
+ idealNameSpace = rect.x + width;
+ }
+ if (columns.length == 1) {
+ drawMidLine(new Rectangle(bounds.x + width, bounds.y, bounds.x + bounds.width, bounds.height), gc);
}
+ if (fAutoResizeColumns && width > column.getWidth()) {
+ column.setData(PREFERRED_WIDTH, width);
+ column.setWidth(width);
+ }
+ gc.setForeground(getColorScheme().getColor(TimeGraphColorScheme.MID_LINE));
+ if (i < columns.length - 1) {
+ // not the last visible column: draw the vertical cell border
+ int x = rect.x + rect.width - 1;
+ gc.drawLine(x, bounds.y, x, bounds.y + bounds.height);
+ }
+ rect.x += rect.width;
}
+ fIdealNameSpace = Math.max(fIdealNameSpace, idealNameSpace);
+
+ gc.setClipping((Rectangle) null);
}
/**
@Override
public void mouseDown(MouseEvent e) {
- if (fDragState != DRAG_NONE || null == fTimeProvider ||
- fTimeProvider.getTime0() == fTimeProvider.getTime1() ||
- getSize().x - fTimeProvider.getNameSpace() <= 0) {
+ if (fDragState != DRAG_NONE) {
return;
}
- int idx;
if (1 == e.button && (e.stateMask & SWT.MODIFIER_MASK) == 0) {
int nameSpace = fTimeProvider.getNameSpace();
if (nameSpace != 0 && isOverSplitLine(e.x)) {
fDragButton = e.button;
fDragX = e.x;
fDragX0 = fDragX;
- fTime0bak = fTimeProvider.getTime0();
- fTime1bak = fTimeProvider.getTime1();
redraw();
updateCursor(e.x, e.stateMask);
return;
}
}
+ if (fTimeProvider == null ||
+ fTimeProvider.getTime0() == fTimeProvider.getTime1() ||
+ getSize().x - fTimeProvider.getNameSpace() <= 0) {
+ return;
+ }
+ int idx;
if (1 == e.button && ((e.stateMask & SWT.MODIFIER_MASK) == 0 || (e.stateMask & SWT.MODIFIER_MASK) == SWT.SHIFT)) {
int nameSpace = fTimeProvider.getNameSpace();
idx = getItemIndexAtY(e.y);
MouseListener, MouseMoveListener {
private static final int BASE_10 = 10;
- private static final int X_OFFSET = 4;
private static final int Y_OFFSET = 4;
private static final int MIN_SECOND_FACTOR = 20;
long time0 = fTimeProvider.getTime0();
long time1 = fTimeProvider.getTime1();
- int leftSpace = fTimeProvider.getNameSpace();
int timeSpace = fTimeProvider.getTimeSpace();
gc.setBackground(getColorScheme().getColor(TimeGraphColorScheme.TOOL_BACKGROUND));
Rectangle rect0 = new Rectangle(0, 0, 0, 0);
Utils.init(rect0, rect);
- // draw top left area
- rect0.width = leftSpace;
- rect0.x += X_OFFSET;
- rect0.width -= X_OFFSET;
- Rectangle absHeaderRect = new Rectangle(rect0.x, rect0.y, rect0.width, rect0.height);
- rect0.x -= X_OFFSET;
- rect0.width += X_OFFSET;
-
- // prepare and draw right rect of the timescale
- rect0.x += leftSpace;
- rect0.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);
// draw range decorators
if (DRAG_EXTERNAL == fDragState) {
- int x1 = leftSpace + fDragX0;
- int x2 = leftSpace + fDragX;
+ int x1 = fDragX0;
+ int x2 = fDragX;
drawRangeDecorators(rect0, gc, x1, x2);
} else {
- int x1;
- int x2;
long selectionBegin = fTimeProvider.getSelectionBegin();
long selectionEnd = fTimeProvider.getSelectionEnd();
- x1 = SaturatedArithmetic.add(leftSpace, (int) ((selectionBegin - time0) * pixelsPerNanoSec));
- x2 = SaturatedArithmetic.add(leftSpace, (int) ((selectionEnd - time0) * pixelsPerNanoSec));
+ int x1 = (int) ((selectionBegin - time0) * pixelsPerNanoSec);
+ int x2 = (int) ((selectionEnd - time0) * pixelsPerNanoSec);
drawRangeDecorators(rect0, gc, x1, x2);
}
- if (rect0.isEmpty()) {
- return;
- }
-
// draw time scale ticks
rect0.y = rect.y;
rect0.height = rect.height - Y_OFFSET;
int y = rect0.y + rect0.height;
- if (fTimeProvider != null && fTimeProvider.getTimeFormat() == TimeFormat.CALENDAR) {
- timeDraw.drawAbsHeader(gc, time, absHeaderRect);
- }
-
List<Integer> tickList = new ArrayList<>();
while (true) {
- int x = SaturatedArithmetic.add(rect.x + leftSpace, (int) (Math.floor((time - time0) * pixelsPerNanoSec)));
- if (x >= rect.x + leftSpace + rect.width - rect0.width) {
+ int x = SaturatedArithmetic.add(rect.x, (int) (Math.floor((time - time0) * pixelsPerNanoSec)));
+ if (x >= rect.x + rect.width - rect0.width) {
break;
}
- if (x >= rect.x + leftSpace) {
+ if (x >= rect.x) {
gc.drawLine(x, y, x, y + Y_OFFSET);
rect0.x = x;
if (x + rect0.width <= rect.x + rect.width) {
timeDraw.draw(gc, time, rect0);
}
- tickList.add(x);
+ tickList.add(x + fTimeProvider.getNameSpace());
}
if (pixelsPerNanoSec == 0 || time > Long.MAX_VALUE - timeDelta || timeDelta == 0) {
break;
projects / deliverable / tracecompass.git / commitdiff
