659 lines
29 KiB
Java
659 lines
29 KiB
Java
/*******************************************************************************
|
|
* Copyright (c) 2014, 2015 MINRES Technologies GmbH and others.
|
|
* All rights reserved. This program and the accompanying materials
|
|
* are made available under the terms of the Eclipse Public License v1.0
|
|
* which accompanies this distribution, and is available at
|
|
* http://www.eclipse.org/legal/epl-v10.html
|
|
*
|
|
* Contributors:
|
|
* MINRES Technologies GmbH - initial API and implementation
|
|
*******************************************************************************/
|
|
package com.minres.scviewer.database.swt;
|
|
|
|
import java.beans.PropertyChangeEvent;
|
|
import java.beans.PropertyChangeListener;
|
|
import java.util.Collection;
|
|
import java.util.Collections;
|
|
import java.util.HashMap;
|
|
import java.util.List;
|
|
import java.util.Map.Entry;
|
|
import java.util.TreeMap;
|
|
import java.util.Vector;
|
|
|
|
import org.eclipse.core.runtime.ListenerList;
|
|
import org.eclipse.jface.util.LocalSelectionTransfer;
|
|
import org.eclipse.jface.viewers.ISelection;
|
|
import org.eclipse.jface.viewers.ISelectionChangedListener;
|
|
import org.eclipse.jface.viewers.ISelectionProvider;
|
|
import org.eclipse.jface.viewers.IStructuredSelection;
|
|
import org.eclipse.jface.viewers.SelectionChangedEvent;
|
|
import org.eclipse.jface.viewers.StructuredSelection;
|
|
import org.eclipse.swt.SWT;
|
|
import org.eclipse.swt.custom.CLabel;
|
|
import org.eclipse.swt.custom.SashForm;
|
|
import org.eclipse.swt.custom.ScrolledComposite;
|
|
import org.eclipse.swt.dnd.DND;
|
|
import org.eclipse.swt.dnd.DragSource;
|
|
import org.eclipse.swt.dnd.DragSourceEvent;
|
|
import org.eclipse.swt.dnd.DragSourceListener;
|
|
import org.eclipse.swt.dnd.DropTarget;
|
|
import org.eclipse.swt.dnd.DropTargetEvent;
|
|
import org.eclipse.swt.dnd.DropTargetListener;
|
|
import org.eclipse.swt.dnd.TextTransfer;
|
|
import org.eclipse.swt.dnd.Transfer;
|
|
import org.eclipse.swt.events.ControlAdapter;
|
|
import org.eclipse.swt.events.ControlEvent;
|
|
import org.eclipse.swt.events.MouseEvent;
|
|
import org.eclipse.swt.events.MouseListener;
|
|
import org.eclipse.swt.events.SelectionAdapter;
|
|
import org.eclipse.swt.events.SelectionEvent;
|
|
import org.eclipse.swt.graphics.Font;
|
|
import org.eclipse.swt.graphics.GC;
|
|
import org.eclipse.swt.graphics.Point;
|
|
import org.eclipse.swt.graphics.Rectangle;
|
|
import org.eclipse.swt.graphics.TextLayout;
|
|
import org.eclipse.swt.layout.FillLayout;
|
|
import org.eclipse.swt.layout.GridData;
|
|
import org.eclipse.swt.layout.GridLayout;
|
|
import org.eclipse.swt.widgets.Canvas;
|
|
import org.eclipse.swt.widgets.Composite;
|
|
import org.eclipse.swt.widgets.Control;
|
|
import org.eclipse.swt.widgets.Event;
|
|
import org.eclipse.swt.widgets.Label;
|
|
import org.eclipse.swt.widgets.Listener;
|
|
import org.eclipse.swt.widgets.ScrollBar;
|
|
import org.eclipse.wb.swt.SWTResourceManager;
|
|
|
|
import swing2swt.layout.BorderLayout;
|
|
|
|
import com.google.common.collect.Lists;
|
|
import com.minres.scviewer.database.ISignal;
|
|
import com.minres.scviewer.database.ITx;
|
|
import com.minres.scviewer.database.ITxEvent;
|
|
import com.minres.scviewer.database.ITxStream;
|
|
import com.minres.scviewer.database.IWaveform;
|
|
import com.minres.scviewer.database.IWaveformEvent;
|
|
import com.minres.scviewer.database.swt.internal.CursorPainter;
|
|
import com.minres.scviewer.database.swt.internal.IWaveformPainter;
|
|
import com.minres.scviewer.database.swt.internal.ObservableList;
|
|
import com.minres.scviewer.database.swt.internal.Ruler;
|
|
import com.minres.scviewer.database.swt.internal.SignalPainter;
|
|
import com.minres.scviewer.database.swt.internal.StreamPainter;
|
|
import com.minres.scviewer.database.swt.internal.TrackPainter;
|
|
import com.minres.scviewer.database.swt.internal.WaveformCanvas;
|
|
|
|
public class TxDisplay implements PropertyChangeListener, ISelectionProvider, MouseListener {
|
|
private ListenerList listeners = new ListenerList();
|
|
|
|
private static final String SELECTION = "selection";
|
|
private ITx currentSelection;
|
|
private IWaveform<? extends IWaveformEvent> currentWaveformSelection;
|
|
|
|
private ScrolledComposite nameListScrolled;
|
|
private ScrolledComposite valueListScrolled;
|
|
|
|
private Canvas nameList;
|
|
private Canvas valueList;
|
|
WaveformCanvas trackList;
|
|
|
|
private Composite top;
|
|
|
|
protected ObservableList<IWaveform<? extends IWaveformEvent>> streams;
|
|
Vector<CursorPainter> cursorPainters;
|
|
|
|
private Composite trackPane;
|
|
private Ruler ruler;
|
|
private int trackVerticalHeight;
|
|
private TreeMap<Integer, IWaveform<? extends IWaveformEvent>> trackVerticalOffset;
|
|
private HashMap<IWaveform<? extends IWaveformEvent>, String> actualValues;
|
|
// private long maxTime=0;
|
|
private Font nameFont, nameFontB;
|
|
|
|
public TxDisplay(Composite parent) {
|
|
trackVerticalOffset = new TreeMap<Integer, IWaveform<? extends IWaveformEvent>>();
|
|
trackVerticalHeight=0;
|
|
actualValues = new HashMap<IWaveform<? extends IWaveformEvent>, String>();
|
|
cursorPainters = new Vector<CursorPainter>();
|
|
|
|
nameFont = parent.getDisplay().getSystemFont();
|
|
nameFontB = SWTResourceManager.getBoldFont(nameFont);
|
|
|
|
streams = new ObservableList<IWaveform<? extends IWaveformEvent>>();
|
|
streams.addPropertyChangeListener(this);
|
|
|
|
top = new Composite(parent, SWT.NONE);
|
|
top.setLayout(new FillLayout(SWT.HORIZONTAL));
|
|
|
|
SashForm topSash = new SashForm(top, SWT.SMOOTH);
|
|
topSash.setBackground(topSash.getDisplay().getSystemColor(SWT.COLOR_GRAY));
|
|
|
|
Composite composite = new Composite(topSash, SWT.NONE);
|
|
composite.setLayout(new FillLayout(SWT.HORIZONTAL));
|
|
|
|
SashForm leftSash = new SashForm(composite, SWT.SMOOTH);
|
|
leftSash.setBackground(leftSash.getDisplay().getSystemColor(SWT.COLOR_GRAY));
|
|
|
|
Composite namePane = createTextPane(leftSash, "Name");
|
|
namePane.setBackground(namePane.getDisplay().getSystemColor(SWT.COLOR_WIDGET_BACKGROUND));
|
|
|
|
nameListScrolled = new ScrolledComposite(namePane, SWT.H_SCROLL | SWT.V_SCROLL);
|
|
nameListScrolled.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true, 1, 1));
|
|
nameListScrolled.setExpandHorizontal(true);
|
|
nameListScrolled.setExpandVertical(true);
|
|
nameListScrolled.setAlwaysShowScrollBars(true);
|
|
nameListScrolled.addControlListener(new ControlAdapter() {
|
|
@Override
|
|
public void controlResized(ControlEvent e) {
|
|
nameListScrolled.getVerticalBar().setVisible(false);
|
|
|
|
}
|
|
});
|
|
nameList = new Canvas(nameListScrolled, SWT.NONE) {
|
|
@Override
|
|
public Point computeSize(int wHint, int hHint, boolean changed) {
|
|
Rectangle bounds = super.getClientArea();
|
|
return new Point(bounds.width, bounds.height);
|
|
}
|
|
};
|
|
nameList.addListener(SWT.Paint, new Listener() {
|
|
@Override
|
|
public void handleEvent(Event event) {
|
|
GC gc = event.gc;
|
|
Rectangle rect = ((Canvas) event.widget).getClientArea();
|
|
paintNames(gc, rect);
|
|
}
|
|
});
|
|
nameList.addMouseListener(this);
|
|
nameListScrolled.setContent(nameList);
|
|
|
|
Composite valuePane = createTextPane(leftSash, "Value");
|
|
valuePane.setBackground(valuePane.getDisplay().getSystemColor(SWT.COLOR_WIDGET_BACKGROUND));
|
|
valueListScrolled = new ScrolledComposite(valuePane, SWT.H_SCROLL | SWT.V_SCROLL);
|
|
valueListScrolled.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true, 1, 1));
|
|
valueListScrolled.setExpandHorizontal(true);
|
|
valueListScrolled.setExpandVertical(true);
|
|
valueListScrolled.setAlwaysShowScrollBars(true);
|
|
valueListScrolled.addControlListener(new ControlAdapter() {
|
|
@Override
|
|
public void controlResized(ControlEvent e) {
|
|
valueListScrolled.getVerticalBar().setVisible(false);
|
|
|
|
}
|
|
});
|
|
valueList = new Canvas(valueListScrolled, SWT.NONE) {
|
|
@Override
|
|
public Point computeSize(int wHint, int hHint, boolean changed) {
|
|
Rectangle bounds = super.getClientArea();
|
|
return new Point(bounds.width, bounds.height);
|
|
}
|
|
};
|
|
valueList.addListener(SWT.Paint, new Listener() {
|
|
@Override
|
|
public void handleEvent(Event event) {
|
|
GC gc = event.gc;
|
|
Rectangle rect = ((Canvas) event.widget).getClientArea();
|
|
paintValues(gc, rect);
|
|
}
|
|
});
|
|
valueList.addMouseListener(this);
|
|
valueListScrolled.setContent(valueList);
|
|
|
|
trackPane = new Composite(topSash, SWT.NONE);
|
|
trackPane.setLayout(new BorderLayout(0, 0));
|
|
ruler = new Ruler(trackPane, SWT.NONE);
|
|
ruler.setLayoutData(BorderLayout.NORTH);
|
|
|
|
trackList = new WaveformCanvas(trackPane, SWT.NONE);
|
|
trackList.setLayoutData(BorderLayout.CENTER);
|
|
trackList.setStreams(streams);
|
|
trackList.setRuler(ruler);
|
|
trackList.addPainter(new TrackPainter(trackList));
|
|
CursorPainter cp = new CursorPainter(trackList, trackList.getScaleFactor() * 10);
|
|
trackList.addPainter(cp);
|
|
cursorPainters.add(cp);
|
|
trackList.setMaxTime(1);
|
|
trackList.addMouseListener(this);
|
|
|
|
nameListScrolled.getVerticalBar().addSelectionListener(new SelectionAdapter() {
|
|
public void widgetSelected(SelectionEvent e) {
|
|
int y = ((ScrollBar) e.widget).getSelection();
|
|
Point v = valueListScrolled.getOrigin();
|
|
valueListScrolled.setOrigin(v.x, y);
|
|
Point t = trackList.getOrigin();
|
|
trackList.setOrigin(t.x, -y);
|
|
}
|
|
});
|
|
valueListScrolled.getVerticalBar().addSelectionListener(new SelectionAdapter() {
|
|
public void widgetSelected(SelectionEvent e) {
|
|
int y = ((ScrollBar) e.widget).getSelection();
|
|
nameListScrolled.setOrigin(nameListScrolled.getOrigin().x, y);
|
|
trackList.setOrigin(trackList.getOrigin().x, -y);
|
|
}
|
|
});
|
|
trackList.addSelectionListener(new SelectionAdapter() {
|
|
public void widgetSelected(SelectionEvent e) {
|
|
int y = trackList.getVerticalBar().getSelection();
|
|
nameListScrolled.setOrigin(nameListScrolled.getOrigin().x, y);
|
|
valueListScrolled.setOrigin(valueListScrolled.getOrigin().x, y);
|
|
}
|
|
});
|
|
topSash.setWeights(new int[] { 30, 70 });
|
|
leftSash.setWeights(new int[] { 75, 25 });
|
|
|
|
createDragSource(nameList);
|
|
createDragSource(valueList);
|
|
createDropTarget(nameList);
|
|
createDropTarget(valueList);
|
|
}
|
|
|
|
private Composite createTextPane(SashForm leftSash, String text) {
|
|
Composite namePane = new Composite(leftSash, SWT.NONE);
|
|
GridLayout gl_namePane = new GridLayout(1, false);
|
|
gl_namePane.verticalSpacing = 0;
|
|
gl_namePane.marginWidth = 0;
|
|
gl_namePane.horizontalSpacing = 0;
|
|
gl_namePane.marginHeight = 0;
|
|
namePane.setLayout(gl_namePane);
|
|
|
|
CLabel nameLabel = new CLabel(namePane, SWT.NONE);
|
|
GridData gd_nameLabel = new GridData(SWT.CENTER, SWT.CENTER, true, false, 1, 1);
|
|
gd_nameLabel.heightHint = Ruler.height - 2;
|
|
nameLabel.setLayoutData(gd_nameLabel);
|
|
nameLabel.setText(text);
|
|
|
|
Label nameSep = new Label(namePane, SWT.SEPARATOR | SWT.HORIZONTAL);
|
|
nameSep.setBackground(SWTResourceManager.getColor(SWT.COLOR_DARK_GRAY));
|
|
nameSep.setForeground(SWTResourceManager.getColor(SWT.COLOR_BLACK));
|
|
GridData gd_nameSep = new GridData(SWT.FILL, SWT.CENTER, true, false, 1, 1);
|
|
gd_nameSep.heightHint = 2;
|
|
nameSep.setLayoutData(gd_nameSep);
|
|
return namePane;
|
|
}
|
|
|
|
@Override
|
|
public void propertyChange(PropertyChangeEvent pce) {
|
|
if ("size".equals(pce.getPropertyName()) || "content".equals(pce.getPropertyName())) {
|
|
updateTracklist();
|
|
}
|
|
}
|
|
|
|
@SuppressWarnings("unchecked")
|
|
protected void updateTracklist() {
|
|
int trackVerticalHeight = 0;
|
|
int nameMaxWidth = 0;
|
|
int previousHeight = trackVerticalOffset.size() == 0 ? 0 : trackVerticalOffset.lastKey();
|
|
IWaveformPainter painter = null;
|
|
trackVerticalOffset.clear();
|
|
actualValues.clear();
|
|
trackList.clearAllWavefromPainter();
|
|
boolean even = true;
|
|
TextLayout tl = new TextLayout(trackList.getDisplay());
|
|
tl.setFont(nameFontB);
|
|
for (IWaveform<? extends IWaveformEvent> waveform : streams) {
|
|
int height = trackList.getTrackHeight();
|
|
if (waveform instanceof ITxStream<?>) {
|
|
height *= ((ITxStream<? extends ITxEvent>) waveform).getMaxConcurrency();
|
|
painter = new StreamPainter(trackList, even, height, (ITxStream<? extends ITxEvent>) waveform);
|
|
actualValues.put(waveform, "");
|
|
} else if (waveform instanceof ISignal<?>) {
|
|
painter = new SignalPainter(trackList, even, height, (ISignal<?>) waveform);
|
|
actualValues.put(waveform, "---");
|
|
}
|
|
trackList.addWavefromPainter(trackVerticalHeight, painter);
|
|
trackVerticalOffset.put(trackVerticalHeight, waveform);
|
|
tl.setText(waveform.getFullName());
|
|
nameMaxWidth = Math.max(nameMaxWidth, tl.getBounds().width);
|
|
trackVerticalHeight += height;
|
|
even = !even;
|
|
}
|
|
nameList.setSize(nameMaxWidth + 15, trackVerticalHeight);
|
|
nameListScrolled.setMinSize(nameMaxWidth + 15, trackVerticalHeight);
|
|
valueList.setSize(calculateValueWidth(), trackVerticalHeight);
|
|
valueListScrolled.setMinSize(calculateValueWidth(), trackVerticalHeight);
|
|
nameList.redraw();
|
|
valueList.redraw();
|
|
trackList.redraw();
|
|
top.layout(new Control[] { valueList, nameList, trackList });
|
|
if (previousHeight > trackVerticalOffset.lastKey()) {
|
|
Point o = trackList.getOrigin();
|
|
trackList.setOrigin(o.x, o.y - (previousHeight - trackVerticalOffset.lastKey()));
|
|
}
|
|
setSelection(new StructuredSelection());
|
|
}
|
|
|
|
private int calculateValueWidth() {
|
|
TextLayout tl = new TextLayout(trackList.getDisplay());
|
|
tl.setFont(nameFontB);
|
|
int valueMaxWidth = 0;
|
|
for (String v : actualValues.values()) {
|
|
tl.setText(v);
|
|
valueMaxWidth = Math.max(valueMaxWidth, tl.getBounds().width);
|
|
}
|
|
return valueMaxWidth + 15;
|
|
}
|
|
|
|
@Override
|
|
public void addSelectionChangedListener(ISelectionChangedListener listener) {
|
|
listeners.add(listener);
|
|
}
|
|
|
|
@Override
|
|
public void removeSelectionChangedListener(ISelectionChangedListener listener) {
|
|
listeners.remove(listener);
|
|
}
|
|
|
|
public Control getControl() {
|
|
return top;
|
|
}
|
|
|
|
@Override
|
|
public ISelection getSelection() {
|
|
if (currentSelection != null)
|
|
return new StructuredSelection(currentSelection);
|
|
else if (currentWaveformSelection != null)
|
|
return new StructuredSelection(currentWaveformSelection);
|
|
else
|
|
return null;
|
|
}
|
|
|
|
@SuppressWarnings("unchecked")
|
|
@Override
|
|
public void setSelection(ISelection selection) {
|
|
boolean selectionChanged = false;
|
|
if (selection instanceof IStructuredSelection) {
|
|
if(((IStructuredSelection) selection).size()==0){
|
|
selectionChanged = currentSelection!=null||currentWaveformSelection!=null;
|
|
currentSelection = null;
|
|
currentWaveformSelection = null;
|
|
} else {
|
|
Object sel = ((IStructuredSelection) selection).getFirstElement();
|
|
if (sel instanceof ITx && currentSelection != sel) {
|
|
currentSelection = (ITx) sel;
|
|
currentWaveformSelection = currentSelection.getStream();
|
|
selectionChanged = true;
|
|
} else if (sel instanceof IWaveform<?> && currentWaveformSelection != sel) {
|
|
currentSelection = null;
|
|
currentWaveformSelection = (IWaveform<? extends IWaveformEvent>) sel;
|
|
selectionChanged = true;
|
|
}
|
|
}
|
|
} else {
|
|
if (currentSelection != null || currentWaveformSelection != null)
|
|
selectionChanged = true;
|
|
currentSelection = null;
|
|
currentWaveformSelection = null;
|
|
}
|
|
if (currentWaveformSelection != null && !streams.contains(currentWaveformSelection)) {
|
|
streams.add(currentWaveformSelection);
|
|
}
|
|
if (selectionChanged) {
|
|
trackList.setSelected(currentSelection, currentWaveformSelection);
|
|
nameList.setData(SELECTION, currentWaveformSelection);
|
|
valueList.redraw();
|
|
nameList.redraw();
|
|
Object[] list = listeners.getListeners();
|
|
for (int i = 0; i < list.length; i++) {
|
|
((ISelectionChangedListener) list[i]).selectionChanged(new SelectionChangedEvent(this, selection));
|
|
}
|
|
}
|
|
}
|
|
|
|
@SuppressWarnings("unchecked")
|
|
public void moveSelection(GotoDirection direction) {
|
|
if (currentWaveformSelection instanceof ITxStream<?>) {
|
|
ITxStream<ITxEvent> stream = (ITxStream<ITxEvent>) currentWaveformSelection;
|
|
ITx transaction = null;
|
|
if (direction == GotoDirection.NEXT) {
|
|
List<ITxEvent> thisEntryList = stream.getEvents().get(currentSelection.getBeginTime());
|
|
boolean meFound=false;
|
|
for (ITxEvent evt : thisEntryList) {
|
|
if (evt.getType() == ITxEvent.Type.BEGIN) {
|
|
if(meFound){
|
|
transaction = evt.getTransaction();
|
|
break;
|
|
}
|
|
meFound|= evt.getTransaction().getId()==currentSelection.getId();
|
|
}
|
|
}
|
|
if (transaction == null){
|
|
Entry<Long, List<ITxEvent>> entry = stream.getEvents().higherEntry(currentSelection.getBeginTime());
|
|
if (entry != null) do {
|
|
for (ITxEvent evt : entry.getValue()) {
|
|
if (evt.getType() == ITxEvent.Type.BEGIN) {
|
|
transaction = evt.getTransaction();
|
|
break;
|
|
}
|
|
}
|
|
if (transaction == null)
|
|
entry = stream.getEvents().higherEntry(entry.getKey());
|
|
} while (entry != null && transaction == null);
|
|
}
|
|
} else if (direction == GotoDirection.PREV) {
|
|
List<ITxEvent> thisEntryList = stream.getEvents().get(currentSelection.getBeginTime());
|
|
boolean meFound=false;
|
|
for (ITxEvent evt : Lists.reverse(thisEntryList)) {
|
|
if (evt.getType() == ITxEvent.Type.BEGIN) {
|
|
if(meFound){
|
|
transaction = evt.getTransaction();
|
|
break;
|
|
}
|
|
meFound|= evt.getTransaction().getId()==currentSelection.getId();
|
|
}
|
|
}
|
|
if (transaction == null){
|
|
Entry<Long, List<ITxEvent>> entry = stream.getEvents().lowerEntry(currentSelection.getBeginTime());
|
|
if (entry != null)
|
|
do {
|
|
for (ITxEvent evt : Lists.reverse(entry.getValue())) {
|
|
if (evt.getType() == ITxEvent.Type.BEGIN) {
|
|
transaction = evt.getTransaction();
|
|
break;
|
|
}
|
|
}
|
|
if (transaction == null)
|
|
entry = stream.getEvents().lowerEntry(entry.getKey());
|
|
} while (entry != null && transaction == null);
|
|
}
|
|
}
|
|
if (transaction != null) {
|
|
setSelection(new StructuredSelection(transaction));
|
|
}
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void mouseDoubleClick(MouseEvent e) {
|
|
}
|
|
|
|
@Override
|
|
public void mouseDown(MouseEvent e) {
|
|
if (e.button == 1 || e.button == 3) {
|
|
if (e.widget == trackList) {
|
|
Object o = trackList.getClicked(new Point(e.x, e.y));
|
|
if (o != null)
|
|
setSelection(new StructuredSelection(o));
|
|
} else if (e.widget == valueList || e.widget == nameList) {
|
|
Entry<Integer, IWaveform<? extends IWaveformEvent>> entry = trackVerticalOffset.floorEntry(e.y);
|
|
if (entry != null)
|
|
setSelection(new StructuredSelection(entry.getValue()));
|
|
}
|
|
}
|
|
if (e.button == 3) {
|
|
top.getMenu().setVisible(true);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void mouseUp(MouseEvent e) {
|
|
}
|
|
|
|
public List<IWaveform<? extends IWaveformEvent>> getStreamList() {
|
|
return streams;
|
|
}
|
|
|
|
protected void paintNames(GC gc, Rectangle rect) {
|
|
if (streams.size() > 0) {
|
|
@SuppressWarnings("unchecked")
|
|
IWaveform<? extends IWaveformEvent> wave = (IWaveform<? extends IWaveformEvent>) nameList.getData(SELECTION);
|
|
Integer firstKey = trackVerticalOffset.floorKey(rect.y);
|
|
if (firstKey == null)
|
|
firstKey = trackVerticalOffset.firstKey();
|
|
Integer lastKey = trackVerticalOffset.floorKey(rect.y + rect.height);
|
|
Rectangle subArea = new Rectangle(rect.x, 0, rect.width, trackList.getTrackHeight());
|
|
if (lastKey == firstKey) {
|
|
IWaveform<? extends IWaveformEvent> w = trackVerticalOffset.get(firstKey);
|
|
if (w instanceof ITxStream<?>)
|
|
subArea.height *= ((ITxStream<?>) w).getMaxConcurrency();
|
|
drawTextFormat(gc, subArea, firstKey, w.getFullName(), wave != null && w.getId() == wave.getId());
|
|
} else {
|
|
for (Entry<Integer, IWaveform<? extends IWaveformEvent>> entry : trackVerticalOffset.subMap(firstKey, true, lastKey, true)
|
|
.entrySet()) {
|
|
IWaveform<? extends IWaveformEvent> w = entry.getValue();
|
|
subArea.height = trackList.getTrackHeight();
|
|
if (w instanceof ITxStream<?>)
|
|
subArea.height *= ((ITxStream<?>) w).getMaxConcurrency();
|
|
drawTextFormat(gc, subArea, entry.getKey(), w.getFullName(), wave != null && w.getId() == wave.getId());
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
@SuppressWarnings("unchecked")
|
|
protected void paintValues(GC gc, Rectangle rect) {
|
|
if (streams.size() > 0) {
|
|
IWaveform<? extends IWaveformEvent> wave = (IWaveform<? extends IWaveformEvent>) nameList.getData(SELECTION);
|
|
Integer firstKey = trackVerticalOffset.floorKey(rect.y);
|
|
if (firstKey == null)
|
|
firstKey = trackVerticalOffset.firstKey();
|
|
Integer lastKey = trackVerticalOffset.floorKey(rect.y + rect.height);
|
|
Rectangle subArea = new Rectangle(rect.x, 0, rect.width, trackList.getTrackHeight());
|
|
if (lastKey == firstKey) {
|
|
IWaveform<? extends IWaveformEvent> w = trackVerticalOffset.get(firstKey);
|
|
if (w instanceof ITxStream<?>)
|
|
subArea.height *= ((ITxStream<?>) w).getMaxConcurrency();
|
|
drawTextFormat(gc, subArea, firstKey, actualValues.get(w), wave != null && w.getId() == wave.getId());
|
|
} else {
|
|
for (Entry<Integer, IWaveform<? extends IWaveformEvent>> entry : trackVerticalOffset.subMap(firstKey, true, lastKey, true)
|
|
.entrySet()) {
|
|
IWaveform<? extends IWaveformEvent> w = entry.getValue();
|
|
subArea.height = trackList.getTrackHeight();
|
|
if (w instanceof ITxStream<?>)
|
|
subArea.height *= ((ITxStream<?>) w).getMaxConcurrency();
|
|
drawTextFormat(gc, subArea, entry.getKey(), actualValues.get(w), wave != null && w.getId() == wave.getId());
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
protected void drawTextFormat(GC gc, Rectangle subArea, int yOffset, String value, boolean highlite) {
|
|
Point size = gc.textExtent(value);
|
|
if (highlite) {
|
|
gc.setBackground(SWTResourceManager.getColor(SWT.COLOR_LIST_SELECTION));
|
|
gc.setForeground(SWTResourceManager.getColor(SWT.COLOR_LIST_SELECTION_TEXT));
|
|
gc.fillRectangle(subArea.x, subArea.y + yOffset, subArea.width, subArea.height);
|
|
gc.setFont(nameFontB);
|
|
} else {
|
|
gc.setBackground(SWTResourceManager.getColor(SWT.COLOR_LIST_BACKGROUND));
|
|
gc.setForeground(SWTResourceManager.getColor(SWT.COLOR_LIST_FOREGROUND));
|
|
gc.setFont(nameFont);
|
|
}
|
|
gc.drawText(value, subArea.x + 5, subArea.y + yOffset + (trackList.getTrackHeight() - size.y) / 2, true);
|
|
}
|
|
|
|
public long getMaxTime() {
|
|
return trackList.getMaxTime();
|
|
}
|
|
|
|
public void setMaxTime(long maxTime) {
|
|
this.trackList.setMaxTime(maxTime);
|
|
}
|
|
|
|
public void setZoomLevel(int scale) {
|
|
trackList.setZoomLevel(scale);
|
|
}
|
|
|
|
public int getZoomLevel() {
|
|
return trackList.getZoomLevel();
|
|
}
|
|
|
|
private void createDragSource(final Canvas sourceText) {
|
|
Transfer[] types = new Transfer[] { LocalSelectionTransfer.getTransfer() };
|
|
DragSource dragSource = new DragSource(sourceText, DND.DROP_MOVE);
|
|
dragSource.setTransfer(types);
|
|
dragSource.addDragListener(new DragSourceListener() {
|
|
|
|
public void dragStart(DragSourceEvent event) {
|
|
if (event.y < trackVerticalHeight) {
|
|
// event.data =
|
|
// trackVerticalOffset.floorEntry(event.y).getValue().getFullName();
|
|
event.doit = true;
|
|
LocalSelectionTransfer.getTransfer().setSelection(getSelection());
|
|
// System.out.println("dragStart at location "+new
|
|
// Point(event.x, event.y));
|
|
}
|
|
}
|
|
|
|
public void dragSetData(DragSourceEvent event) {
|
|
event.data =getSelection();
|
|
// System.out.println("dragSetData with data " + event.data);
|
|
}
|
|
|
|
public void dragFinished(DragSourceEvent event) {
|
|
// do nothing
|
|
}
|
|
});
|
|
}
|
|
|
|
private void createDropTarget(final Canvas targetText) {
|
|
Transfer[] types = new Transfer[] { LocalSelectionTransfer.getTransfer() };
|
|
DropTarget dropTarget = new DropTarget(targetText, DND.DROP_MOVE);
|
|
dropTarget.setTransfer(types);
|
|
|
|
dropTarget.addDropListener(new DropTargetListener() {
|
|
|
|
public void dragEnter(DropTargetEvent event) {
|
|
}
|
|
|
|
public void dragLeave(DropTargetEvent event) {
|
|
}
|
|
|
|
public void dragOperationChanged(DropTargetEvent event) {
|
|
}
|
|
|
|
public void dragOver(DropTargetEvent event) {
|
|
}
|
|
|
|
public void drop(DropTargetEvent event) {
|
|
if (LocalSelectionTransfer.getTransfer().isSupportedType(event.currentDataType)){
|
|
ISelection sel = LocalSelectionTransfer.getTransfer().getSelection();
|
|
if(sel!=null && sel instanceof IStructuredSelection){
|
|
Object source = ((IStructuredSelection)sel).getFirstElement();
|
|
DropTarget tgt = (DropTarget) event.widget;
|
|
Point dropPoint = ((Canvas) tgt.getControl()).toControl(event.x, event.y);
|
|
Object target = trackVerticalOffset.floorEntry(dropPoint.y).getValue();
|
|
if(source instanceof IWaveform<?> && target instanceof IWaveform<?>){
|
|
// int srcIdx=streams.indexOf(source);
|
|
// int tgtIdx=streams.indexOf(target);
|
|
// if(srcIdx<tgtIdx){
|
|
// streams.rotate(srcIdx, tgtIdx, -1);
|
|
// } else {
|
|
// streams.rotate(tgtIdx, srcIdx+1, 1);
|
|
// }
|
|
streams.remove(source);
|
|
int tgtIdx=streams.indexOf(target);
|
|
streams.add(tgtIdx, (IWaveform<? extends IWaveformEvent>) source);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public void dropAccept(DropTargetEvent event) {
|
|
if (event.detail != DND.DROP_MOVE || event.y > trackVerticalOffset.lastKey() + trackList.getTrackHeight()) {
|
|
event.detail = DND.DROP_NONE;
|
|
}
|
|
}
|
|
});
|
|
}
|
|
|
|
}
|