1354 lines
47 KiB
Java
1354 lines
47 KiB
Java
/*******************************************************************************
|
|
* Copyright (c) 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.internal;
|
|
|
|
import java.awt.Color;
|
|
import java.beans.PropertyChangeEvent;
|
|
import java.beans.PropertyChangeListener;
|
|
import java.beans.PropertyChangeSupport;
|
|
import java.text.DecimalFormat;
|
|
import java.util.ArrayList;
|
|
import java.util.Collection;
|
|
import java.util.Collections;
|
|
import java.util.HashMap;
|
|
import java.util.LinkedList;
|
|
import java.util.List;
|
|
import java.util.Map.Entry;
|
|
import java.util.NavigableMap;
|
|
import java.util.NoSuchElementException;
|
|
import java.util.TreeMap;
|
|
import java.util.stream.Collectors;
|
|
|
|
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.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.DragSourceAdapter;
|
|
import org.eclipse.swt.dnd.DragSourceEvent;
|
|
import org.eclipse.swt.dnd.DropTarget;
|
|
import org.eclipse.swt.dnd.DropTargetAdapter;
|
|
import org.eclipse.swt.dnd.DropTargetEvent;
|
|
import org.eclipse.swt.dnd.Transfer;
|
|
import org.eclipse.swt.events.ControlAdapter;
|
|
import org.eclipse.swt.events.ControlEvent;
|
|
import org.eclipse.swt.events.DisposeListener;
|
|
import org.eclipse.swt.events.MouseAdapter;
|
|
import org.eclipse.swt.events.MouseEvent;
|
|
import org.eclipse.swt.events.MouseListener;
|
|
import org.eclipse.swt.events.MouseMoveListener;
|
|
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.graphics.Font;
|
|
import org.eclipse.swt.graphics.GC;
|
|
import org.eclipse.swt.graphics.Point;
|
|
import org.eclipse.swt.graphics.RGB;
|
|
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.Menu;
|
|
import org.eclipse.swt.widgets.ScrollBar;
|
|
import org.eclipse.swt.widgets.Widget;
|
|
import org.eclipse.wb.swt.SWTResourceManager;
|
|
|
|
import com.google.common.collect.Lists;
|
|
import com.minres.scviewer.database.BitVector;
|
|
import com.minres.scviewer.database.ISignal;
|
|
import com.minres.scviewer.database.ITx;
|
|
import com.minres.scviewer.database.ITxEvent;
|
|
import com.minres.scviewer.database.ITxRelation;
|
|
import com.minres.scviewer.database.ITxStream;
|
|
import com.minres.scviewer.database.IWaveform;
|
|
import com.minres.scviewer.database.RelationType;
|
|
import com.minres.scviewer.database.swt.Constants;
|
|
import com.minres.scviewer.database.ui.GotoDirection;
|
|
import com.minres.scviewer.database.ui.ICursor;
|
|
import com.minres.scviewer.database.ui.IWaveformView;
|
|
import com.minres.scviewer.database.ui.TrackEntry;
|
|
import com.minres.scviewer.database.ui.WaveformColors;
|
|
|
|
public class WaveformView implements IWaveformView {
|
|
|
|
private ListenerList<ISelectionChangedListener> selectionChangedListeners = new ListenerList<ISelectionChangedListener>();
|
|
|
|
private PropertyChangeSupport pcs;
|
|
|
|
static final DecimalFormat df = new DecimalFormat("#0.00####");
|
|
|
|
private ITx currentTxSelection;
|
|
|
|
private TrackEntry currentWaveformSelection;
|
|
|
|
private ScrolledComposite nameListScrolled;
|
|
|
|
private ScrolledComposite valueListScrolled;
|
|
|
|
private Control namePaneHeader;
|
|
|
|
final private Canvas nameList;
|
|
|
|
final private Canvas valueList;
|
|
|
|
final WaveformCanvas waveformCanvas;
|
|
|
|
final ToolTipHandler toolTipHandler;
|
|
|
|
private boolean revealSelected=false;
|
|
|
|
private Composite top;
|
|
|
|
protected ObservableList<TrackEntry> streams;
|
|
|
|
int selectedMarker = 0;
|
|
|
|
private int trackVerticalHeight;
|
|
|
|
private TreeMap<Integer, TrackEntry> trackVerticalOffset;
|
|
|
|
private Font nameFont, nameFontB;
|
|
|
|
protected MouseListener nameValueMouseListener = new MouseAdapter() {
|
|
@Override
|
|
public void mouseDown(MouseEvent e) {
|
|
if (e.button == 1) {
|
|
Entry<Integer, TrackEntry> entry = trackVerticalOffset.floorEntry(e.y);
|
|
if (entry != null)
|
|
setSelection(new StructuredSelection(entry.getValue()));
|
|
} else if (e.button == 3) {
|
|
Menu topMenu= top.getMenu();
|
|
if(topMenu!=null) topMenu.setVisible(true);
|
|
}
|
|
}
|
|
};
|
|
|
|
class WaveformMouseListener implements MouseMoveListener, MouseListener, PaintListener {
|
|
Point start, end;
|
|
List<Object> initialSelected;
|
|
boolean down=false;
|
|
|
|
@Override
|
|
public void mouseDoubleClick(MouseEvent e) {
|
|
}
|
|
|
|
@Override
|
|
public void mouseDown(MouseEvent e) {
|
|
start=new Point(e.x, e.y);
|
|
end=new Point(e.x, e.y);
|
|
down=true;
|
|
if((e.stateMask&SWT.MODIFIER_MASK)!=0) return; //don't react on modifier
|
|
if (e.button == 1) {
|
|
initialSelected = waveformCanvas.getElementsAt(start);
|
|
} else if (e.button == 3) {
|
|
Menu topMenu= top.getMenu();
|
|
if(topMenu!=null) topMenu.setVisible(true);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void mouseMove(MouseEvent e) {
|
|
if(down) {
|
|
end=new Point(e.x, e.y);
|
|
asyncUpdate(e.widget);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void paintControl(PaintEvent e) {
|
|
if(down) {
|
|
GC gc = e.gc;
|
|
gc.setAlpha(128);
|
|
int minX = Math.min(start.x, end.x);
|
|
int width = Math.max(start.x, end.x) - minX;
|
|
int y_top = waveformCanvas.getRulerHeight();
|
|
int y_bottom = waveformCanvas.getSize().y;
|
|
gc.fillRectangle(minX, y_top, width,y_bottom);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void mouseUp(MouseEvent e) {
|
|
down=false;
|
|
if(start==null) return;
|
|
if((e.stateMask&SWT.MODIFIER_MASK&~SWT.SHIFT)!=0) return; //don't react on modifier except shift
|
|
if(!start.equals(end)){
|
|
asyncUpdate(e.widget);
|
|
long startTime = waveformCanvas.getTimeForOffset(start.x);
|
|
long endTime = waveformCanvas.getTimeForOffset(end.x);
|
|
long targetTimeRange = endTime-startTime;
|
|
long currentTimeRange = waveformCanvas.getMaxVisibleTime()-waveformCanvas.getMinVisibleTime();
|
|
if(targetTimeRange==0) return;
|
|
long relation = currentTimeRange/targetTimeRange;
|
|
long i = 1;
|
|
int level=0;//relation>0?0:0;
|
|
do {
|
|
if(relation<0 ) {
|
|
if(-relation<i) {
|
|
break;
|
|
}
|
|
level--;
|
|
if(-relation<i*3) {
|
|
break;
|
|
}
|
|
level--;
|
|
} else {
|
|
if(relation<i) {
|
|
break;
|
|
}
|
|
level++;
|
|
if(relation<i*3) {
|
|
break;
|
|
}
|
|
level++;
|
|
}
|
|
i=i*10;
|
|
} while(i<10000);
|
|
if(i<10000) {
|
|
int curLevel = waveformCanvas.getZoomLevel();
|
|
waveformCanvas.setZoomLevel(curLevel-level, (startTime+endTime)/2);
|
|
}
|
|
} else if (e.button == 1 && ((e.stateMask&SWT.SHIFT)==0)) {
|
|
// set cursor (button 1 and no shift)
|
|
if(Math.abs(e.x-start.x)<3 && Math.abs(e.y-start.y)<3){
|
|
// first set cursor time
|
|
setCursorTime(snapOffsetToEvent(start));
|
|
// then set selection and reveal
|
|
setSelection(new StructuredSelection(initialSelected));
|
|
asyncUpdate(e.widget);
|
|
}
|
|
}else if (e.button == 2 ||(e.button==1 && (e.stateMask&SWT.SHIFT)!=0)) {
|
|
// set marker (button 1 and shift)
|
|
setMarkerTime(snapOffsetToEvent(start), selectedMarker);
|
|
asyncUpdate(e.widget);
|
|
}
|
|
}
|
|
|
|
protected long snapOffsetToEvent(Point p) {
|
|
long time= waveformCanvas.getTimeForOffset(p.x);
|
|
long scaling=5*waveformCanvas.getScaleFactor();
|
|
for(Object o:waveformCanvas.getElementsAt(p)){
|
|
Entry<Long, ?> floorEntry=null, ceilEntry=null;
|
|
if(o instanceof TrackEntry){
|
|
TrackEntry entry = (TrackEntry) o;
|
|
if(entry.waveform instanceof ISignal<?>){
|
|
NavigableMap<Long, ?> map = ((ISignal<?>)entry.waveform).getEvents();
|
|
floorEntry = map.floorEntry(time);
|
|
ceilEntry = map.ceilingEntry(time);
|
|
} else if (entry.waveform instanceof ITxStream<?>){
|
|
NavigableMap<Long, ?> map = ((ITxStream<?>)entry.waveform).getEvents();
|
|
floorEntry = map.floorEntry(time);
|
|
ceilEntry = map.ceilingEntry(time);
|
|
}
|
|
} else if(o instanceof ITx){
|
|
NavigableMap<Long, ?> map = ((ITx)o).getStream().getEvents();
|
|
floorEntry = map.floorEntry(time);
|
|
ceilEntry = map.ceilingEntry(time);
|
|
}
|
|
if(floorEntry!=null && time-floorEntry.getKey()>scaling)
|
|
floorEntry=null;
|
|
if(ceilEntry!=null && ceilEntry.getKey()-time>scaling)
|
|
ceilEntry=null;
|
|
if(ceilEntry==null && floorEntry!=null){
|
|
time=floorEntry.getKey();
|
|
}else if(ceilEntry!=null && floorEntry==null){
|
|
time=ceilEntry.getKey();
|
|
}else if(ceilEntry!=null && floorEntry!=null){
|
|
time=time-floorEntry.getKey()<ceilEntry.getKey()-time?floorEntry.getKey(): ceilEntry.getKey();
|
|
}
|
|
}
|
|
return time;
|
|
}
|
|
|
|
};
|
|
protected WaveformMouseListener waveformMouseListener = new WaveformMouseListener();
|
|
|
|
public WaveformView(Composite parent) {
|
|
pcs=new PropertyChangeSupport(this);
|
|
|
|
trackVerticalOffset = new TreeMap<Integer, TrackEntry>();
|
|
trackVerticalHeight=0;
|
|
|
|
nameFont = parent.getDisplay().getSystemFont();
|
|
nameFontB = SWTResourceManager.getBoldFont(nameFont);
|
|
|
|
streams = new ObservableList<>();
|
|
streams.addPropertyChangeListener("content", 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));
|
|
|
|
waveformCanvas = new WaveformCanvas(topSash, SWT.NONE);
|
|
|
|
SashForm leftSash = new SashForm(composite, SWT.SMOOTH);
|
|
leftSash.setBackground(SWTResourceManager.getColor(SWT.COLOR_GRAY));
|
|
|
|
Composite namePane = createTextPane(leftSash, "Name");
|
|
namePaneHeader= namePane.getChildren()[0];
|
|
namePane.setBackground(SWTResourceManager.getColor(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) {
|
|
if(!trackVerticalOffset.isEmpty()) {
|
|
GC gc = event.gc;
|
|
Rectangle rect = ((Canvas) event.widget).getClientArea();
|
|
paintNames(gc, rect);
|
|
}
|
|
}
|
|
});
|
|
nameList.addMouseListener(nameValueMouseListener);
|
|
nameListScrolled.setContent(nameList);
|
|
|
|
Composite valuePane = createTextPane(leftSash, "Value");
|
|
valuePane.setBackground(SWTResourceManager.getColor(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) {
|
|
if(!trackVerticalOffset.isEmpty()) {
|
|
GC gc = event.gc;
|
|
Rectangle rect = ((Canvas) event.widget).getClientArea();
|
|
paintValues(gc, rect);
|
|
}
|
|
}
|
|
});
|
|
valueList.addMouseListener(nameValueMouseListener);
|
|
valueListScrolled.setContent(valueList);
|
|
|
|
waveformCanvas.setMaxTime(1);
|
|
waveformCanvas.addMouseListener(waveformMouseListener);
|
|
waveformCanvas.addMouseMoveListener(waveformMouseListener);
|
|
waveformCanvas.addPaintListener(waveformMouseListener);
|
|
|
|
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 = waveformCanvas.getOrigin();
|
|
waveformCanvas.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);
|
|
waveformCanvas.setOrigin(waveformCanvas.getOrigin().x, -y);
|
|
}
|
|
});
|
|
waveformCanvas.addSelectionListener(new SelectionAdapter() {
|
|
public void widgetSelected(SelectionEvent e) {
|
|
int y = waveformCanvas.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 });
|
|
|
|
createStreamDragSource(nameList);
|
|
createStreamDragSource(valueList);
|
|
createStreamDropTarget(nameList);
|
|
createStreamDropTarget(valueList);
|
|
createWaveformDragSource(waveformCanvas);
|
|
createWaveformDropTarget(waveformCanvas);
|
|
|
|
toolTipHandler = new ToolTipHandler(parent.getShell());
|
|
toolTipHandler.activateHoverHelp(waveformCanvas);
|
|
}
|
|
|
|
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 = waveformCanvas.getRulerHeight() - 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())) {
|
|
if(revealSelected) {
|
|
waveformCanvas.getDisplay().asyncExec(new Runnable() {
|
|
@Override
|
|
public void run() {
|
|
update();
|
|
waveformCanvas.reveal(currentWaveformSelection.waveform);
|
|
valueList.redraw();
|
|
nameList.redraw();
|
|
}
|
|
});
|
|
revealSelected=false;
|
|
} else
|
|
waveformCanvas.getDisplay().asyncExec(new Runnable() {
|
|
@Override
|
|
public void run() {
|
|
update();
|
|
}
|
|
});
|
|
}
|
|
}
|
|
|
|
public void update() {
|
|
trackVerticalHeight = 0;
|
|
int nameMaxWidth = 0;
|
|
IWaveformPainter painter = null;
|
|
trackVerticalOffset.clear();
|
|
waveformCanvas.clearAllWaveformPainter(false);
|
|
boolean even = true;
|
|
boolean clearSelection = true;
|
|
TextLayout tl = new TextLayout(waveformCanvas.getDisplay());
|
|
tl.setFont(nameFontB);
|
|
for (TrackEntry streamEntry : streams) {
|
|
streamEntry.height = waveformCanvas.getTrackHeight();
|
|
streamEntry.vOffset=trackVerticalHeight;
|
|
clearSelection &= currentWaveformSelection!=null && (streamEntry.waveform != currentWaveformSelection.waveform);
|
|
if (streamEntry.isStream()) {
|
|
streamEntry.currentValue="";
|
|
streamEntry.height *= streamEntry.getStream().getMaxConcurrency();
|
|
painter = new StreamPainter(waveformCanvas, even, streamEntry);
|
|
} else if (streamEntry.isSignal()) {
|
|
streamEntry.currentValue="---";
|
|
painter = new SignalPainter(waveformCanvas, even, streamEntry);
|
|
}
|
|
waveformCanvas.addWaveformPainter(painter, false);
|
|
trackVerticalOffset.put(trackVerticalHeight, streamEntry);
|
|
tl.setText(streamEntry.waveform.getFullName());
|
|
nameMaxWidth = Math.max(nameMaxWidth, tl.getBounds().width);
|
|
trackVerticalHeight += streamEntry.height;
|
|
even = !even;
|
|
}
|
|
waveformCanvas.syncScrollBars();
|
|
nameList.setSize(nameMaxWidth + 15, trackVerticalHeight);
|
|
nameListScrolled.setMinSize(nameMaxWidth + 15, trackVerticalHeight);
|
|
nameList.redraw();
|
|
updateValueList();
|
|
waveformCanvas.redraw();
|
|
top.layout(new Control[] { valueList, nameList, waveformCanvas });
|
|
if (trackVerticalOffset.isEmpty()){
|
|
waveformCanvas.setOrigin(0, 0);
|
|
}
|
|
if(clearSelection) setSelection(new StructuredSelection());
|
|
}
|
|
|
|
private int calculateValueWidth() {
|
|
TextLayout tl = new TextLayout(waveformCanvas.getDisplay());
|
|
tl.setFont(nameFontB);
|
|
int valueMaxWidth = 0;
|
|
for (TrackEntry v : streams) {
|
|
tl.setText(v.currentValue);
|
|
valueMaxWidth = Math.max(valueMaxWidth, tl.getBounds().width);
|
|
}
|
|
return valueMaxWidth + 15;
|
|
}
|
|
|
|
private void updateValueList(){
|
|
final Long time = getCursorTime();
|
|
for(TrackEntry entry:streams){
|
|
if(entry.isSignal()){
|
|
ISignal<?> signal = (ISignal<?>) entry.waveform;
|
|
Object value = signal.getWaveformValueBeforeTime(time);
|
|
if(value instanceof BitVector){
|
|
BitVector bv = (BitVector) value;
|
|
if(bv.getWidth()==1)
|
|
entry.currentValue="b'"+bv;
|
|
else {
|
|
// TODO: same code resides in SignalPainter, fix it
|
|
switch(entry.valueDisplay) {
|
|
case SIGNED:
|
|
entry.currentValue=Long.toString(bv.toSignedValue());
|
|
break;
|
|
case UNSIGNED:
|
|
entry.currentValue=Long.toString(bv.toUnsignedValue());
|
|
break;
|
|
default:
|
|
entry.currentValue="h'"+bv.toHexString();
|
|
}
|
|
}
|
|
} else if(value instanceof Double){
|
|
Double val = (Double) value;
|
|
if(val>0.001)
|
|
entry.currentValue=String.format("%1$,.3f", val);
|
|
else
|
|
entry.currentValue=Double.toString(val);
|
|
}
|
|
} else if(entry.isStream()){
|
|
ITxStream<?> stream = (ITxStream<?>) entry.waveform;
|
|
ITx[] resultsList = new ITx[stream.getMaxConcurrency()];
|
|
Entry<Long, List<ITxEvent>> firstTx=stream.getEvents().floorEntry(time);
|
|
if(firstTx!=null){
|
|
do {
|
|
for(ITxEvent evt:firstTx.getValue()){
|
|
ITx tx=evt.getTransaction();
|
|
if(evt.getType()==ITxEvent.Type.BEGIN && tx.getBeginTime()<=time && tx.getEndTime()>=time){
|
|
if(resultsList[tx.getConcurrencyIndex()]==null)
|
|
resultsList[tx.getConcurrencyIndex()]= evt.getTransaction();
|
|
}
|
|
}
|
|
firstTx=stream.getEvents().lowerEntry(firstTx.getKey());
|
|
}while(firstTx!=null && !isArrayFull(resultsList));
|
|
entry.currentValue="";
|
|
boolean separator=false;
|
|
|
|
for(ITx o:resultsList){
|
|
if(separator) entry.currentValue+="|";
|
|
if(o!=null) entry.currentValue+=((ITx)o).getGenerator().getName();
|
|
|
|
separator=true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
int width = calculateValueWidth();
|
|
valueList.setSize(width, trackVerticalHeight);
|
|
valueListScrolled.setMinSize(width, trackVerticalHeight);
|
|
valueListScrolled.redraw();
|
|
}
|
|
|
|
|
|
private boolean isArrayFull(Object[] array){
|
|
for(Object o:array){
|
|
if(o==null) return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/* (non-Javadoc)
|
|
* @see com.minres.scviewer.database.swt.IWaveformPanel#addSelectionChangedListener(org.eclipse.jface.viewers.ISelectionChangedListener)
|
|
*/
|
|
@Override
|
|
public void addSelectionChangedListener(ISelectionChangedListener listener) {
|
|
selectionChangedListeners.add(listener);
|
|
}
|
|
|
|
/* (non-Javadoc)
|
|
* @see com.minres.scviewer.database.swt.IWaveformPanel#removeSelectionChangedListener(org.eclipse.jface.viewers.ISelectionChangedListener)
|
|
*/
|
|
@Override
|
|
public void removeSelectionChangedListener(ISelectionChangedListener listener) {
|
|
selectionChangedListeners.remove(listener);
|
|
}
|
|
|
|
/* (non-Javadoc)
|
|
* @see com.minres.scviewer.database.swt.IWaveformPanel#getControl()
|
|
*/
|
|
@Override
|
|
public Control getControl() {
|
|
return top;
|
|
}
|
|
|
|
/* (non-Javadoc)
|
|
* @see com.minres.scviewer.database.swt.IWaveformPanel#getNameControl()
|
|
*/
|
|
@Override
|
|
public Control getNameControl() {
|
|
return nameList;
|
|
}
|
|
|
|
/* (non-Javadoc)
|
|
* @see com.minres.scviewer.database.swt.IWaveformPanel#getValueControl()
|
|
*/
|
|
@Override
|
|
public Control getValueControl() {
|
|
return valueList;
|
|
}
|
|
|
|
/* (non-Javadoc)
|
|
* @see com.minres.scviewer.database.swt.IWaveformPanel#getWaveformControl()
|
|
*/
|
|
@Override
|
|
public Control getWaveformControl() {
|
|
return waveformCanvas;
|
|
}
|
|
|
|
/* (non-Javadoc)
|
|
* @see com.minres.scviewer.database.swt.IWaveformPanel#getSelection()
|
|
*/
|
|
@Override
|
|
public ISelection getSelection() {
|
|
if (currentTxSelection != null) {
|
|
Object[] elem = {currentTxSelection, currentWaveformSelection};
|
|
return new StructuredSelection(elem);
|
|
} else if (currentWaveformSelection != null) {
|
|
Object[] elem = {currentWaveformSelection.waveform, currentWaveformSelection};
|
|
return new StructuredSelection(elem);
|
|
} else
|
|
return new StructuredSelection();
|
|
}
|
|
|
|
/* (non-Javadoc)
|
|
* @see com.minres.scviewer.database.swt.IWaveformPanel#setSelection(org.eclipse.jface.viewers.ISelection)
|
|
*/
|
|
@Override
|
|
public void setSelection(ISelection selection) {
|
|
setSelection(selection, false);
|
|
}
|
|
|
|
/* (non-Javadoc)
|
|
* @see com.minres.scviewer.database.swt.IWaveformPanel#setSelection(org.eclipse.jface.viewers.ISelection, boolean)
|
|
*/
|
|
@Override
|
|
public void setSelection(ISelection selection, boolean addIfNeeded) {
|
|
boolean selectionChanged = false;
|
|
if(currentWaveformSelection!=null) currentWaveformSelection.selected=false;
|
|
if (selection instanceof IStructuredSelection) {
|
|
if(((IStructuredSelection) selection).size()==0){
|
|
selectionChanged = currentTxSelection!=null||currentWaveformSelection!=null;
|
|
currentTxSelection = null;
|
|
currentWaveformSelection = null;
|
|
} else {
|
|
for(Object sel:((IStructuredSelection) selection).toArray()){
|
|
if (sel instanceof ITx && currentTxSelection != sel){
|
|
ITx txSel = (ITx) sel;
|
|
TrackEntry trackEntry = getEntryForStream(txSel.getStream());
|
|
if(trackEntry==null && addIfNeeded){
|
|
trackEntry=new TrackEntry(txSel.getStream());
|
|
// compute fallback colors
|
|
Color fallbackColors[] = TrackEntry.computeColor(txSel.getStream().getName(), TrackEntry.fallbackColor, TrackEntry.highlightedFallbackColor);
|
|
trackEntry.setColor(fallbackColors[0], fallbackColors[1]);
|
|
streams.add(trackEntry);
|
|
}
|
|
currentTxSelection = txSel;
|
|
if(trackEntry!=null) currentWaveformSelection = trackEntry;
|
|
selectionChanged = true;
|
|
} else if (sel instanceof TrackEntry && currentWaveformSelection != sel) {
|
|
currentWaveformSelection = (TrackEntry) sel;
|
|
if(currentTxSelection!=null && currentTxSelection.getStream()!=currentWaveformSelection)
|
|
currentTxSelection=null;
|
|
|
|
selectionChanged = true;
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
if (currentTxSelection != null || currentWaveformSelection != null)
|
|
selectionChanged = true;
|
|
currentTxSelection = null;
|
|
currentWaveformSelection = null;
|
|
}
|
|
if(currentWaveformSelection!=null) currentWaveformSelection.selected=true;
|
|
if (selectionChanged) {
|
|
if(currentWaveformSelection!=null) waveformCanvas.reveal(currentWaveformSelection.waveform);
|
|
waveformCanvas.setSelected(currentTxSelection);
|
|
valueList.redraw();
|
|
nameList.redraw();
|
|
fireSelectionChanged();
|
|
}
|
|
}
|
|
|
|
protected void fireSelectionChanged() {
|
|
if(currentWaveformSelection==null) return;
|
|
IStructuredSelection selection=currentTxSelection!=null?
|
|
new StructuredSelection(new Object[]{currentTxSelection, currentWaveformSelection.waveform}):
|
|
new StructuredSelection(currentWaveformSelection.waveform);
|
|
Object[] list = selectionChangedListeners.getListeners();
|
|
for (int i = 0; i < list.length; i++) {
|
|
((ISelectionChangedListener) list[i]).selectionChanged(new SelectionChangedEvent(this, selection));
|
|
}
|
|
}
|
|
|
|
/* (non-Javadoc)
|
|
* @see com.minres.scviewer.database.swt.IWaveformPanel#moveSelection(com.minres.scviewer.database.swt.GotoDirection)
|
|
*/
|
|
@Override
|
|
public void moveSelection(GotoDirection direction) {
|
|
if(direction==GotoDirection.NEXT || direction==GotoDirection.PREV)
|
|
moveSelection(direction, NEXT_PREV_IN_STREAM) ;
|
|
else {
|
|
int idx = streams.indexOf(currentWaveformSelection);
|
|
if(direction==GotoDirection.UP && idx>0) {
|
|
setSelection(new StructuredSelection(streams.get(idx-1)));
|
|
} else if(direction==GotoDirection.DOWN && idx<(streams.size()-1)) {
|
|
setSelection(new StructuredSelection(streams.get(idx+1)));
|
|
}
|
|
}
|
|
}
|
|
|
|
/* (non-Javadoc)
|
|
* @see com.minres.scviewer.database.swt.IWaveformPanel#moveSelection(com.minres.scviewer.database.swt.GotoDirection, com.minres.scviewer.database.RelationType)
|
|
*/
|
|
@Override
|
|
public void moveSelection(GotoDirection direction, RelationType relationType) {
|
|
if (currentWaveformSelection!=null && currentWaveformSelection.isStream() && currentTxSelection!=null) {
|
|
if(relationType.equals(IWaveformView.NEXT_PREV_IN_STREAM)){
|
|
ITxStream<? extends ITxEvent> stream = currentWaveformSelection.getStream();
|
|
ITx transaction = null;
|
|
if (direction == GotoDirection.NEXT) {
|
|
List<ITxEvent> thisEntryList = stream.getEvents().get(currentTxSelection.getBeginTime());
|
|
boolean meFound=false;
|
|
for (ITxEvent evt : thisEntryList) {
|
|
if (evt.getType() == ITxEvent.Type.BEGIN) {
|
|
if(meFound){
|
|
transaction = evt.getTransaction();
|
|
break;
|
|
}
|
|
meFound|= evt.getTransaction().equals(currentTxSelection);
|
|
}
|
|
}
|
|
if (transaction == null){
|
|
Entry<Long, List<ITxEvent>> entry = stream.getEvents().higherEntry(currentTxSelection.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(currentTxSelection.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().equals(currentTxSelection);
|
|
}
|
|
}
|
|
if (transaction == null){
|
|
Entry<Long, List<ITxEvent>> entry = stream.getEvents().lowerEntry(currentTxSelection.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));
|
|
}
|
|
} else {
|
|
if (direction == GotoDirection.NEXT) {
|
|
Collection<ITxRelation> outRel=currentTxSelection.getOutgoingRelations();
|
|
ITxRelation tx = selectTxToNavigateTo(outRel, relationType, true);
|
|
if(tx!=null) setSelection(new StructuredSelection(tx.getTarget()), true);
|
|
} else if (direction == GotoDirection.PREV) {
|
|
Collection<ITxRelation> inRel=currentTxSelection.getIncomingRelations();
|
|
ITxRelation tx = selectTxToNavigateTo(inRel, relationType, false);
|
|
if(tx!=null) setSelection(new StructuredSelection(tx.getSource()), true);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private ITxRelation selectTxToNavigateTo(Collection<ITxRelation> rel, RelationType relationType, boolean target) {
|
|
ArrayList<ITxRelation> candidates = rel.stream().filter(r -> relationType.equals(r.getRelationType())).collect(Collectors.toCollection(ArrayList::new));
|
|
//new RelSelectionDialog(waveformCanvas.getShell(), candidates, target).open();
|
|
switch (candidates.size()) {
|
|
case 0: return null;
|
|
case 1: return candidates.get(0);
|
|
default:
|
|
ArrayList<ITxRelation> visibleCandidates = candidates.stream().filter(r -> streamsVisible(r)).collect(Collectors.toCollection(ArrayList::new));
|
|
if(visibleCandidates.size()==0) {
|
|
return new RelSelectionDialog(waveformCanvas.getShell(), candidates, target).open();
|
|
} else if(visibleCandidates.size()==1) {
|
|
return visibleCandidates.size()==1?visibleCandidates.get(0):null;
|
|
} else {
|
|
return new RelSelectionDialog(waveformCanvas.getShell(), visibleCandidates, target).open();
|
|
}
|
|
}
|
|
}
|
|
|
|
private boolean streamsVisible(ITxRelation relation) {
|
|
final ITxStream<ITxEvent> src = relation.getSource().getStream();
|
|
final ITxStream<ITxEvent> tgt = relation.getTarget().getStream();
|
|
return streams.stream().anyMatch(x -> x.waveform == src) && streams.stream().anyMatch(x -> x.waveform == tgt);
|
|
}
|
|
|
|
/* (non-Javadoc)
|
|
* @see com.minres.scviewer.database.swt.IWaveformPanel#moveCursor(com.minres.scviewer.database.swt.GotoDirection)
|
|
*/
|
|
@Override
|
|
public void moveCursor(GotoDirection direction) {
|
|
long time = getCursorTime();
|
|
NavigableMap<Long, ?> map=null;
|
|
if(currentWaveformSelection!=null) {
|
|
if(currentWaveformSelection.isStream()){
|
|
map=currentWaveformSelection.getStream().getEvents();
|
|
} else if(currentWaveformSelection.isSignal()){
|
|
map=currentWaveformSelection.getSignal().getEvents();
|
|
}
|
|
}
|
|
if(map!=null){
|
|
Entry<Long, ?> entry=direction==GotoDirection.PREV?map.lowerEntry(time):map.higherEntry(time);
|
|
if(entry!=null) {
|
|
time=entry.getKey();
|
|
setCursorTime(time);
|
|
waveformCanvas.reveal(time);
|
|
waveformCanvas.redraw();
|
|
updateValueList();
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
/* (non-Javadoc)
|
|
* @see com.minres.scviewer.database.swt.IWaveformPanel#getStreamList()
|
|
*/
|
|
@Override
|
|
public List<TrackEntry> getStreamList() {
|
|
return streams;
|
|
}
|
|
|
|
/* (non-Javadoc)
|
|
* @see com.minres.scviewer.database.swt.IWaveformPanel#moveSelected(int)
|
|
*/
|
|
@Override
|
|
public void moveSelectedTrack(int i) {
|
|
if(currentWaveformSelection!=null){
|
|
int idx = streams.indexOf(currentWaveformSelection);
|
|
int newIdx=idx+i;
|
|
if(newIdx>=0 && newIdx<streams.size()){
|
|
Collections.swap(streams,idx,newIdx);
|
|
revealSelected=true;
|
|
// update();
|
|
// ITx selectedTx=currentTxSelection;
|
|
// if(selectedTx!=null){
|
|
// setSelection(new StructuredSelection(new Object[]{selectedTx, currentWaveformSelection.waveform}));
|
|
// } else {
|
|
// setSelection(new StructuredSelection(currentWaveformSelection.waveform));
|
|
// }
|
|
// waveformCanvas.reveal(currentWaveformSelection.waveform);
|
|
// valueList.redraw();
|
|
// nameList.redraw();
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
protected void paintNames(GC gc, Rectangle rect) {
|
|
if (streams.size() > 0) {
|
|
try {
|
|
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, waveformCanvas.getTrackHeight());
|
|
if (lastKey == firstKey) {
|
|
TrackEntry trackEntry=trackVerticalOffset.get(firstKey);
|
|
IWaveform w = trackEntry.waveform;
|
|
if (w instanceof ITxStream<?>)
|
|
subArea.height *= ((ITxStream<?>) w).getMaxConcurrency();
|
|
drawTextFormat(gc, subArea, firstKey, w.getFullName(), trackEntry.selected);
|
|
} else {
|
|
for (Entry<Integer, TrackEntry> entry : trackVerticalOffset.subMap(firstKey, true, lastKey, true).entrySet()) {
|
|
IWaveform w = entry.getValue().waveform;
|
|
subArea.height = waveformCanvas.getTrackHeight();
|
|
if (w instanceof ITxStream<?>)
|
|
subArea.height *= ((ITxStream<?>) w).getMaxConcurrency();
|
|
drawTextFormat(gc, subArea, entry.getKey(), w.getFullName(), entry.getValue().selected);
|
|
}
|
|
}
|
|
}catch(NoSuchElementException e){}
|
|
}
|
|
}
|
|
|
|
protected void paintValues(GC gc, Rectangle rect) {
|
|
if (streams.size() > 0) {
|
|
try {
|
|
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, waveformCanvas.getTrackHeight());
|
|
if (lastKey == firstKey) {
|
|
TrackEntry trackEntry=trackVerticalOffset.get(firstKey);
|
|
IWaveform w = trackEntry.waveform;
|
|
if (w instanceof ITxStream<?>)
|
|
subArea.height *= ((ITxStream<?>) w).getMaxConcurrency();
|
|
drawValue(gc, subArea, firstKey, trackEntry.currentValue, trackEntry.selected);
|
|
} else {
|
|
for (Entry<Integer, TrackEntry> entry : trackVerticalOffset.subMap(firstKey, true, lastKey, true)
|
|
.entrySet()) {
|
|
IWaveform w = entry.getValue().waveform;
|
|
subArea.height = waveformCanvas.getTrackHeight();
|
|
if (w instanceof ITxStream<?>)
|
|
subArea.height *= ((ITxStream<?>) w).getMaxConcurrency();
|
|
drawValue(gc, subArea, entry.getKey(), entry.getValue().currentValue, entry.getValue().selected);
|
|
}
|
|
}
|
|
}catch(NoSuchElementException e){}
|
|
}
|
|
}
|
|
|
|
protected void drawValue(GC gc, Rectangle subArea, Integer yOffset, String value, boolean highlite) {
|
|
int beginIndex=0;
|
|
for(int offset=0; offset<subArea.height; offset+=waveformCanvas.getTrackHeight()){
|
|
int endIndex=value.indexOf('|', beginIndex);
|
|
String str = endIndex<0?value.substring(beginIndex):value.substring(beginIndex, endIndex);
|
|
drawTextFormat(gc, new Rectangle(subArea.x, subArea.y, subArea.width, waveformCanvas.getTrackHeight()), yOffset+offset, str, highlite);
|
|
beginIndex=endIndex<0?beginIndex:endIndex+1;
|
|
}
|
|
}
|
|
|
|
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(namePaneHeader.getBackground());
|
|
gc.setForeground(namePaneHeader.getForeground());
|
|
gc.setFont(nameFont);
|
|
}
|
|
gc.drawText(value, subArea.x + 5, subArea.y + yOffset + (waveformCanvas.getTrackHeight() - size.y) / 2, true);
|
|
}
|
|
|
|
|
|
public void setHighliteRelation(RelationType relationType){
|
|
this.waveformCanvas.setHighliteRelation(relationType);
|
|
}
|
|
|
|
/* (non-Javadoc)
|
|
* @see com.minres.scviewer.database.swt.IWaveformPanel#getMaxTime()
|
|
*/
|
|
@Override
|
|
public long getMaxTime() {
|
|
return waveformCanvas.getMaxTime();
|
|
}
|
|
|
|
/* (non-Javadoc)
|
|
* @see com.minres.scviewer.database.swt.IWaveformPanel#setMaxTime(long)
|
|
*/
|
|
@Override
|
|
public void setMaxTime(long maxTime) {
|
|
this.waveformCanvas.setMaxTime(maxTime);
|
|
}
|
|
|
|
/* (non-Javadoc)
|
|
* @see com.minres.scviewer.database.swt.IWaveformPanel#setZoomLevel(int)
|
|
*/
|
|
@Override
|
|
public void setZoomLevel(int scale) {
|
|
waveformCanvas.setZoomLevel(scale);
|
|
waveformCanvas.reveal(getCursorTime());
|
|
}
|
|
|
|
/* (non-Javadoc)
|
|
* @see com.minres.scviewer.database.swt.IWaveformPanel#getZoomLevel()
|
|
*/
|
|
@Override
|
|
public int getZoomLevel() {
|
|
return waveformCanvas.getZoomLevel();
|
|
}
|
|
|
|
/* (non-Javadoc)
|
|
* @see com.minres.scviewer.database.swt.IWaveformPanel#setCursorTime(long)
|
|
*/
|
|
@Override
|
|
public void setCursorTime(long time){
|
|
final Long oldVal= waveformCanvas.getCursorPainters().get(0).getTime();
|
|
waveformCanvas.getCursorPainters().get(0).setTime(time);
|
|
pcs.firePropertyChange(CURSOR_PROPERTY, oldVal, time);
|
|
}
|
|
|
|
/* (non-Javadoc)
|
|
* @see com.minres.scviewer.database.swt.IWaveformPanel#setMarkerTime(long, int)
|
|
*/
|
|
@Override
|
|
public void setMarkerTime(long time, int index){
|
|
if(waveformCanvas.getCursorPainters().size()>index+1){
|
|
final Long oldVal= waveformCanvas.getCursorPainters().get(1+index).getTime();
|
|
waveformCanvas.getCursorPainters().get(1+index).setTime(time);
|
|
pcs.firePropertyChange(MARKER_PROPERTY, oldVal, time);
|
|
}
|
|
}
|
|
|
|
/* (non-Javadoc)
|
|
* @see com.minres.scviewer.database.swt.IWaveformPanel#getCursorTime()
|
|
*/
|
|
@Override
|
|
public long getCursorTime(){
|
|
return waveformCanvas.getCursorPainters().get(0).getTime();
|
|
}
|
|
|
|
/* (non-Javadoc)
|
|
* @see com.minres.scviewer.database.swt.IWaveformPanel#getActMarkerTime()
|
|
*/
|
|
@Override
|
|
public int getSelectedMarkerId(){
|
|
return selectedMarker;
|
|
}
|
|
|
|
@Override
|
|
public List<ICursor> getCursorList(){
|
|
List<ICursor> cursors = new LinkedList<>();
|
|
for(CursorPainter painter:waveformCanvas.getCursorPainters()) cursors.add(painter);
|
|
return Collections.unmodifiableList(cursors);
|
|
}
|
|
|
|
/* (non-Javadoc)
|
|
* @see com.minres.scviewer.database.swt.IWaveformPanel#getMarkerTime(int)
|
|
*/
|
|
@Override
|
|
public long getMarkerTime(int index){
|
|
return waveformCanvas.getCursorPainters().get(index+1).getTime();
|
|
}
|
|
|
|
private void createStreamDragSource(final Canvas canvas) {
|
|
Transfer[] types = new Transfer[] { LocalSelectionTransfer.getTransfer() };
|
|
DragSource dragSource = new DragSource(canvas, DND.DROP_MOVE);
|
|
dragSource.setTransfer(types);
|
|
dragSource.addDragListener(new DragSourceAdapter() {
|
|
public void dragStart(DragSourceEvent event) {
|
|
if (event.y < trackVerticalHeight) {
|
|
event.doit = true;
|
|
LocalSelectionTransfer.getTransfer().setSelection(new StructuredSelection(currentWaveformSelection));
|
|
}
|
|
}
|
|
|
|
public void dragSetData(DragSourceEvent event) {
|
|
if (LocalSelectionTransfer.getTransfer().isSupportedType(event.dataType)) {
|
|
event.data =getSelection();
|
|
}
|
|
}
|
|
});
|
|
}
|
|
|
|
private void createStreamDropTarget(final Canvas canvas) {
|
|
Transfer[] types = new Transfer[] { LocalSelectionTransfer.getTransfer() };
|
|
DropTarget dropTarget = new DropTarget(canvas, DND.DROP_MOVE);
|
|
dropTarget.setTransfer(types);
|
|
|
|
dropTarget.addDropListener(new DropTargetAdapter() {
|
|
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 TrackEntry && target instanceof TrackEntry){
|
|
TrackEntry srcWave=(TrackEntry) source;
|
|
int srcIdx=streams.indexOf(srcWave);
|
|
streams.remove(srcWave);
|
|
int tgtIdx=streams.indexOf(target);
|
|
if(srcIdx<=tgtIdx) tgtIdx++;
|
|
if(tgtIdx>=streams.size())
|
|
streams.add(srcWave);
|
|
else
|
|
streams.add(tgtIdx, srcWave);
|
|
currentWaveformSelection=srcWave;
|
|
update();
|
|
} else if(source instanceof CursorPainter){
|
|
((CursorPainter)source).setTime(0);
|
|
updateValueList();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
public void dropAccept(DropTargetEvent event) {
|
|
Point offset = canvas.toControl(event.x, event.y);
|
|
if (event.detail != DND.DROP_MOVE || offset.y > trackVerticalOffset.lastKey() + waveformCanvas.getTrackHeight()) {
|
|
event.detail = DND.DROP_NONE;
|
|
}
|
|
}
|
|
});
|
|
}
|
|
|
|
public TrackEntry getEntryForStream(IWaveform source) {
|
|
for(TrackEntry trackEntry:streams)
|
|
if(trackEntry.waveform.equals(source)) return trackEntry;
|
|
return null;
|
|
}
|
|
|
|
public List<Object> getElementsAt(Point pt){
|
|
return waveformCanvas.getElementsAt(pt);
|
|
}
|
|
|
|
private void createWaveformDragSource(final Canvas canvas) {
|
|
Transfer[] types = new Transfer[] { LocalSelectionTransfer.getTransfer() };
|
|
DragSource dragSource = new DragSource(canvas, DND.DROP_MOVE);
|
|
dragSource.setTransfer(types);
|
|
dragSource.addDragListener(new DragSourceAdapter() {
|
|
public void dragStart(DragSourceEvent event) {
|
|
event.doit = false;
|
|
List<Object> clicked = waveformCanvas.getElementsAt(new Point(event.x, event.y));
|
|
for(Object o:clicked){
|
|
if(o instanceof CursorPainter){
|
|
LocalSelectionTransfer.getTransfer().setSelection(new StructuredSelection(o));
|
|
((CursorPainter)o).setDragging(true);
|
|
event.doit = true;
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
public void dragSetData(DragSourceEvent event) {
|
|
if (LocalSelectionTransfer.getTransfer().isSupportedType(event.dataType)) {
|
|
event.data=waveformCanvas.getElementsAt(new Point(event.x, event.y));
|
|
}
|
|
}
|
|
});
|
|
}
|
|
|
|
private void createWaveformDropTarget(final Canvas canvas) {
|
|
Transfer[] types = new Transfer[] { LocalSelectionTransfer.getTransfer() };
|
|
DropTarget dropTarget = new DropTarget(canvas, DND.DROP_MOVE);
|
|
dropTarget.setTransfer(types);
|
|
dropTarget.addDropListener(new DropTargetAdapter() {
|
|
public void drop(DropTargetEvent event) {
|
|
if (LocalSelectionTransfer.getTransfer().isSupportedType(event.currentDataType)){
|
|
ISelection sel = LocalSelectionTransfer.getTransfer().getSelection();
|
|
if(sel!=null && sel instanceof IStructuredSelection &&
|
|
((IStructuredSelection)sel).getFirstElement() instanceof CursorPainter){
|
|
CursorPainter painter = (CursorPainter)((IStructuredSelection)sel).getFirstElement();
|
|
painter.setDragging(false);
|
|
updateWaveform(canvas, event, painter);
|
|
}
|
|
}
|
|
}
|
|
|
|
public void dropAccept(DropTargetEvent event) {
|
|
Point offset = canvas.toControl(event.x, event.y);
|
|
if (event.detail != DND.DROP_MOVE || offset.y > trackVerticalOffset.lastKey() + waveformCanvas.getTrackHeight()) {
|
|
event.detail = DND.DROP_NONE;
|
|
}
|
|
}
|
|
|
|
public void dragOver(DropTargetEvent event){
|
|
ISelection sel = LocalSelectionTransfer.getTransfer().getSelection();
|
|
if(sel!=null && sel instanceof IStructuredSelection &&
|
|
((IStructuredSelection)sel).getFirstElement() instanceof CursorPainter){
|
|
updateWaveform(canvas, event, (CursorPainter) ((IStructuredSelection)sel).getFirstElement());
|
|
}
|
|
}
|
|
|
|
protected void updateWaveform(final Canvas canvas, DropTargetEvent event, CursorPainter painter) {
|
|
Point dropPoint = canvas.toControl(event.x, event.y);
|
|
long time = waveformCanvas.getTimeForOffset(dropPoint.x);
|
|
final Long oldVal= painter.getTime();
|
|
painter.setTime(time);
|
|
if(painter.id<0){
|
|
pcs.firePropertyChange(CURSOR_PROPERTY, oldVal, time);
|
|
}else{
|
|
pcs.firePropertyChange(MARKER_PROPERTY, oldVal, time);
|
|
pcs.firePropertyChange(MARKER_PROPERTY+painter.id, oldVal, time);
|
|
}
|
|
canvas.getDisplay().asyncExec(new Runnable() {
|
|
@Override
|
|
public void run() {
|
|
if(!canvas.isDisposed()){
|
|
canvas.redraw();
|
|
updateValueList();
|
|
}
|
|
}
|
|
});
|
|
}
|
|
});
|
|
|
|
}
|
|
|
|
/* (non-Javadoc)
|
|
* @see com.minres.scviewer.database.swt.IWaveformPanel#addPropertyChangeListener(java.beans.PropertyChangeListener)
|
|
*/
|
|
@Override
|
|
public void addPropertyChangeListener(PropertyChangeListener listener) {
|
|
this.pcs.addPropertyChangeListener(listener);
|
|
}
|
|
|
|
/* (non-Javadoc)
|
|
* @see com.minres.scviewer.database.swt.IWaveformPanel#addPropertyChangeListener(java.lang.String, java.beans.PropertyChangeListener)
|
|
*/
|
|
@Override
|
|
public void addPropertyChangeListener(String propertyName, PropertyChangeListener listener) {
|
|
this.pcs.addPropertyChangeListener(propertyName, listener);
|
|
}
|
|
|
|
public PropertyChangeListener[] getPropertyChangeListeners() {
|
|
return this.pcs.getPropertyChangeListeners();
|
|
}
|
|
|
|
public PropertyChangeListener[] getPropertyChangeListeners(String propertyName) {
|
|
return this.pcs.getPropertyChangeListeners(propertyName);
|
|
}
|
|
|
|
/* (non-Javadoc)
|
|
* @see com.minres.scviewer.database.swt.IWaveformPanel#removePropertyChangeListener(java.beans.PropertyChangeListener)
|
|
*/
|
|
@Override
|
|
public void removePropertyChangeListener(PropertyChangeListener listener) {
|
|
this.pcs.removePropertyChangeListener(listener);
|
|
}
|
|
|
|
/* (non-Javadoc)
|
|
* @see com.minres.scviewer.database.swt.IWaveformPanel#removePropertyChangeListener(java.lang.String, java.beans.PropertyChangeListener)
|
|
*/
|
|
@Override
|
|
public void removePropertyChangeListener(String propertyName, PropertyChangeListener listener) {
|
|
this.pcs.removePropertyChangeListener(propertyName, listener);
|
|
}
|
|
|
|
public boolean hasListeners(String propertyName) {
|
|
return this.pcs.hasListeners(propertyName);
|
|
}
|
|
|
|
/* (non-Javadoc)
|
|
* @see com.minres.scviewer.database.swt.IWaveformPanel#getScaledTime(long)
|
|
*/
|
|
@Override
|
|
public String getScaledTime(long time) {
|
|
StringBuilder sb = new StringBuilder();
|
|
Double dTime=new Double(time);
|
|
Double scaledTime = dTime/waveformCanvas.getScaleFactorPow10();
|
|
return sb.append(df.format(scaledTime)).append(waveformCanvas.getUnitStr()).toString();
|
|
}
|
|
|
|
/* (non-Javadoc)
|
|
* @see com.minres.scviewer.database.swt.IWaveformPanel#getZoomLevels()
|
|
*/
|
|
@Override
|
|
public String[] getZoomLevels(){
|
|
String[] res = new String[Constants.unitMultiplier.length*Constants.unitString.length];
|
|
int index=0;
|
|
for(String unit:Constants.unitString){
|
|
for(int factor:Constants.unitMultiplier){
|
|
res[index++]= new Integer(factor).toString()+unit;
|
|
}
|
|
}
|
|
return res;
|
|
}
|
|
|
|
@Override
|
|
public void setColors(HashMap<WaveformColors, RGB> colourMap) {
|
|
waveformCanvas.initColors(colourMap);
|
|
}
|
|
|
|
@Override
|
|
public long getBaselineTime() {
|
|
return -waveformCanvas.getScaleFactorPow10()*waveformCanvas.getOrigin().x;
|
|
}
|
|
|
|
@Override
|
|
public void setBaselineTime(Long time) {
|
|
Point origin = waveformCanvas.getOrigin();
|
|
origin.x=(int) (-time/waveformCanvas.getScaleFactorPow10());
|
|
waveformCanvas.setOrigin(origin);
|
|
}
|
|
|
|
@Override
|
|
public void scrollHorizontal(int percent) {
|
|
if(percent<-100) percent=-100;
|
|
if(percent>100) percent=100;
|
|
int diff = (waveformCanvas.getWidth()*percent)/100;
|
|
Point o = waveformCanvas.getOrigin();
|
|
waveformCanvas.setOrigin(o.x-diff, o.y);
|
|
waveformCanvas.redraw();
|
|
}
|
|
|
|
public void asyncUpdate(Widget widget) {
|
|
widget.getDisplay().asyncExec(new Runnable() {
|
|
@Override
|
|
public void run() {
|
|
waveformCanvas.redraw();
|
|
updateValueList();
|
|
}
|
|
});
|
|
}
|
|
|
|
/// probably not the way it should be done
|
|
public void addDisposeListener( DisposeListener listener ) {
|
|
waveformCanvas.addDisposeListener(listener);
|
|
}
|
|
}
|