/*******************************************************************************
 * 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;

import java.beans.PropertyChangeEvent;
import java.beans.PropertyChangeListener;
import java.beans.PropertyChangeSupport;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map.Entry;
import java.util.NavigableMap;
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.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.MouseAdapter;
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.Menu;
import org.eclipse.swt.widgets.ScrollBar;
import org.eclipse.wb.swt.SWTResourceManager;

import com.google.common.collect.Lists;
import com.minres.scviewer.database.ISignal;
import com.minres.scviewer.database.ISignalChange;
import com.minres.scviewer.database.ISignalChangeMulti;
import com.minres.scviewer.database.ISignalChangeSingle;
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.RulerPainter;
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;
import com.minres.scviewer.database.ui.GotoDirection;
import com.minres.scviewer.database.ui.IWaveformPanel;

public class TxDisplay implements IWaveformPanel  {
	
	private ListenerList selectionChangedListeners = new ListenerList();
	
	private PropertyChangeSupport pcs;

	private static final String SELECTION = "selection";
	
	private ITx currentTxSelection;
	
	private IWaveform<? extends IWaveformEvent> currentWaveformSelection;

	private ScrolledComposite nameListScrolled;
	
	private ScrolledComposite valueListScrolled;

	private Canvas nameList;
	
	private Canvas valueList;
	
	WaveformCanvas waveformCanvas;

	private Composite top;

	protected ObservableList<IWaveform<? extends IWaveformEvent>> streams;
	
	Vector<CursorPainter> cursorPainters;

	int selectedMarker = 0;
	
	private int trackVerticalHeight;
	
	private TreeMap<Integer, IWaveform<? extends IWaveformEvent>> trackVerticalOffset;
	
	private HashMap<IWaveform<? extends IWaveformEvent>, String> actualValues;
	
	private Font nameFont, nameFontB;

	protected MouseListener nameValueMouseListener = new MouseAdapter() {
		@Override
		public void mouseDown(MouseEvent e) {
			if ((e.button == 1 || e.button == 3)) {
				Entry<Integer, IWaveform<? extends IWaveformEvent>> entry = trackVerticalOffset.floorEntry(e.y);
				if (entry != null)
					setSelection(new StructuredSelection(entry.getValue()));
			} 
			if (e.button == 3) {
				Menu topMenu= top.getMenu();
				if(topMenu!=null) topMenu.setVisible(true);
			}
		}
	};

	protected MouseListener waveformMouseListener = new MouseAdapter(){
		Point start;
		List<Object> initialSelected;
		
		@Override
		public void mouseDown(MouseEvent e) {
			start=new Point(e.x, e.y);
			if (e.button ==  1) {	
				initialSelected = waveformCanvas.getClicked(start);
			} else if (e.button == 3) {
				List<Object> hitted = waveformCanvas.getClicked(start);
				for(Object entry:hitted){
					if(entry instanceof IWaveform<?>){
						setSelection(new StructuredSelection(entry));
						break;
					}else if(entry instanceof ITx){
						setSelection(new StructuredSelection(((ITx)entry).getStream()));
						break;
					}
				}
				Menu topMenu= top.getMenu();
				if(topMenu!=null) topMenu.setVisible(true);
			}
		}

		@Override
		public void mouseUp(MouseEvent e) {
			if (e.button ==  1) {
				if(Math.abs(e.x-start.x)<3 && Math.abs(e.y-start.y)<3){				
					// first set time
					setCursorTime(snapOffsetToEvent(e));
					// then set selection and reveal
					setSelection(new StructuredSelection(initialSelected));
					e.widget.getDisplay().asyncExec(new Runnable() {
						@Override
						public void run() {
							waveformCanvas.redraw();
							updateValueList();
						}
					});
				}
			}else	if (e.button ==  2) {
				setMarkerTime(snapOffsetToEvent(e), selectedMarker);
				e.widget.getDisplay().asyncExec(new Runnable() {
					@Override
					public void run() {
						waveformCanvas.redraw();
						updateValueList();
					}
				});
			}        
		}

		protected long snapOffsetToEvent(MouseEvent e) {
			long time= waveformCanvas.getTimeForOffset(e.x);
			long scaling=5*waveformCanvas.getScaleFactor();
			for(Object o:waveformCanvas.getClicked(start)){
				Entry<Long, ?> floorEntry=null, ceilEntry=null;
				if(o instanceof ISignal<?>){
					NavigableMap<Long, ?> map = ((ISignal<?>)o).getEvents();
					floorEntry = map.floorEntry(time);
					ceilEntry = map.ceilingEntry(time);
				} else if (o instanceof ITxStream<?>){
					NavigableMap<Long, ?> map = ((ITxStream<?>)o).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;
		}
	};

	public TxDisplay(Composite parent) {
		pcs=new PropertyChangeSupport(this);

		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));

		waveformCanvas = new WaveformCanvas(topSash, SWT.NONE);

		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(nameValueMouseListener);
		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(nameValueMouseListener);
		valueListScrolled.setContent(valueList);

		waveformCanvas.setStreams(streams);
		// order is important: it is bottom to top
		waveformCanvas.addPainter(new TrackPainter(waveformCanvas));
		waveformCanvas.addPainter(new RulerPainter(
				waveformCanvas, waveformCanvas.getDisplay().getSystemColor(SWT.COLOR_BLACK), waveformCanvas.getDisplay().getSystemColor(SWT.COLOR_WHITE)));
		CursorPainter cp = new CursorPainter(waveformCanvas, waveformCanvas.getScaleFactor() * 10, cursorPainters.size()-1);
		waveformCanvas.addPainter(cp);
		cursorPainters.add(cp);
		CursorPainter marker = new CursorPainter(waveformCanvas, waveformCanvas.getScaleFactor() * 100, cursorPainters.size()-1);
		waveformCanvas.addPainter(marker);
		cursorPainters.add(marker);
		waveformCanvas.setMaxTime(1);
		waveformCanvas.addMouseListener(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);
	}

	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())) {
			updateTracklist();
		}
	}

	@SuppressWarnings("unchecked")
	protected void updateTracklist() {
		trackVerticalHeight = 0;
		int nameMaxWidth = 0;
		int previousHeight = trackVerticalOffset.size() == 0 ? 0 : trackVerticalOffset.lastKey();
		IWaveformPainter painter = null;
		trackVerticalOffset.clear();
		actualValues.clear();
		waveformCanvas.clearAllWavefromPainter();
		boolean even = true;
		boolean clearSelection = true;
		TextLayout tl = new TextLayout(waveformCanvas.getDisplay());
		tl.setFont(nameFontB);
		for (IWaveform<? extends IWaveformEvent> waveform : streams) {
			int height = waveformCanvas.getTrackHeight();
			clearSelection &= (waveform != currentWaveformSelection);
			if (waveform instanceof ITxStream<?>) {
				ITxStream<? extends ITxEvent> stream = (ITxStream<? extends ITxEvent>) waveform;
				height *= stream.getMaxConcurrency();
				painter = new StreamPainter(waveformCanvas, even, height, (ITxStream<? extends ITxEvent>) waveform);
				actualValues.put(stream, "");
			} else if (waveform instanceof ISignal<?>) {
				painter = new SignalPainter(waveformCanvas, even, height, (ISignal<?>) waveform);
				actualValues.put(waveform, "---");
			}
			waveformCanvas.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();
		updateValueList();
		waveformCanvas.redraw();
		top.layout(new Control[] { valueList, nameList, waveformCanvas });
		if (trackVerticalOffset.isEmpty() || previousHeight > trackVerticalOffset.lastKey()) {
			Point o = waveformCanvas.getOrigin();
			waveformCanvas.setOrigin(o.x, o.y - (previousHeight - trackVerticalOffset.lastKey()));
		}
		if(clearSelection) setSelection(new StructuredSelection());
		/*        System.out.println("updateTracklist() state:");
        for(Entry<Integer, IWaveform<? extends IWaveformEvent>> entry: trackVerticalOffset.entrySet()){
        	System.out.println("    "+entry.getKey()+": " +entry.getValue().getFullName());
        }
		 */    }

	private int calculateValueWidth() {
		TextLayout tl = new TextLayout(waveformCanvas.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;
	}

	private void updateValueList(){
		final Long time = getCursorTime();
		for(Entry<IWaveform<? extends IWaveformEvent>, String> entry:actualValues.entrySet()){
			if(entry.getKey() instanceof ISignal){    
				ISignalChange event = ((ISignal<?>)entry.getKey()).getWaveformEventsBeforeTime(time);
				if(event instanceof ISignalChangeSingle){
					entry.setValue("b'"+((ISignalChangeSingle)event).getValue());
				} else if(event instanceof ISignalChangeMulti){
					entry.setValue("h'"+((ISignalChangeMulti)event).getValue().toHexString());
				}
			} else if(entry.getKey() instanceof ITxStream<?>){
				ITxStream<?> stream = (ITxStream<?>) entry.getKey();
				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));
					String value=null;
					for(ITx o:resultsList){
						if(value==null)
							value=new String();
						else
							value+="|";
						if(o!=null) value+=((ITx)o).getGenerator().getName();
					}
					entry.setValue(value);
				}
            }
		}
		valueList.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)
			return new StructuredSelection(currentTxSelection);
		else if (currentWaveformSelection != null)
			return new StructuredSelection(currentWaveformSelection);
		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
	@SuppressWarnings("unchecked")
	public void setSelection(ISelection selection, boolean addIfNeeded) {
		boolean selectionChanged = 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;
						if (streams.contains(((ITx)sel).getStream())) {
							currentTxSelection = txSel;
							currentWaveformSelection = txSel.getStream();
							selectionChanged = true;
						} else if(addIfNeeded){
							streams.add(txSel.getStream());
							currentTxSelection = txSel;
							currentWaveformSelection = txSel.getStream();
							selectionChanged = true;
						}
					} else if (sel instanceof IWaveform<?> && currentWaveformSelection != sel&& streams.contains(sel)) {
						currentTxSelection = null;
						currentWaveformSelection = (IWaveform<? extends IWaveformEvent>) sel;
						selectionChanged = true;
					}            		
				}
			}
		} else {
			if (currentTxSelection != null || currentWaveformSelection != null)
				selectionChanged = true;
			currentTxSelection = null;
			currentWaveformSelection = null;
		}
		if (selectionChanged) {
			waveformCanvas.setSelected(currentTxSelection, currentWaveformSelection);
			nameList.setData(SELECTION, currentWaveformSelection);
			valueList.redraw();
			nameList.redraw();
			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
	@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(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));
			}
		}
	}

	/* (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 instanceof ITxStream<?>){
			map=((ITxStream<?>) currentWaveformSelection).getEvents();
		} else if(currentWaveformSelection instanceof ISignal<?>){
			map=((ISignal<?>) currentWaveformSelection).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();
			}
		}
	
	}

	/* (non-Javadoc)
	 * @see com.minres.scviewer.database.swt.IWaveformPanel#getStreamList()
	 */
	@Override
	public List<IWaveform<? extends IWaveformEvent>> getStreamList() {
		return streams;
	}

	/* (non-Javadoc)
	 * @see com.minres.scviewer.database.swt.IWaveformPanel#moveSelected(int)
	 */
	@Override
	public void moveSelected(int i) {
		if(currentWaveformSelection!=null){
			ITx selectedTx=currentTxSelection;
			IWaveform<? extends IWaveformEvent> selectedWaveform=currentWaveformSelection;
			int idx = streams.indexOf(currentWaveformSelection);
			int newIdx=idx+i;
			if(newIdx>=0 && newIdx<streams.size()){
				Collections.swap(streams,idx,newIdx);
				updateTracklist();
				if(selectedTx!=null){
					setSelection(new StructuredSelection(new Object[]{selectedTx, selectedWaveform}));
				} else
					setSelection(new StructuredSelection(selectedWaveform));
			}
		}	
	}


	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, waveformCanvas.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(), w.equals(wave));
			} else {
				for (Entry<Integer, IWaveform<? extends IWaveformEvent>> entry : trackVerticalOffset.subMap(firstKey, true, lastKey, true)
						.entrySet()) {
					IWaveform<? extends IWaveformEvent> w = entry.getValue();
					subArea.height = waveformCanvas.getTrackHeight();
					if (w instanceof ITxStream<?>)
						subArea.height *= ((ITxStream<?>) w).getMaxConcurrency();
					drawTextFormat(gc, subArea, entry.getKey(), w.getFullName(), w.equals(wave));
				}
			}
		}
	}

	@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, waveformCanvas.getTrackHeight());
			if (lastKey == firstKey) {
				IWaveform<? extends IWaveformEvent> w = trackVerticalOffset.get(firstKey);
				if (w instanceof ITxStream<?>)
					subArea.height *= ((ITxStream<?>) w).getMaxConcurrency();
				drawValue(gc, subArea, firstKey, actualValues.get(w), w.equals(wave));
			} else {
				for (Entry<Integer, IWaveform<? extends IWaveformEvent>> entry : trackVerticalOffset.subMap(firstKey, true, lastKey, true)
						.entrySet()) {
					IWaveform<? extends IWaveformEvent> w = entry.getValue();
					subArea.height = waveformCanvas.getTrackHeight();
					if (w instanceof ITxStream<?>)
						subArea.height *= ((ITxStream<?>) w).getMaxConcurrency();
					drawValue(gc, subArea, entry.getKey(), actualValues.get(w), w.equals(wave));
				}
			}
		}
	}

	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(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 + (waveformCanvas.getTrackHeight() - size.y) / 2, true);
	}

	/* (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= cursorPainters.get(0).getTime();
		cursorPainters.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(cursorPainters.size()>index+1){
			final Long oldVal= cursorPainters.get(1+index).getTime();
			cursorPainters.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 cursorPainters.get(0).getTime();   
	}

	/* (non-Javadoc)
	 * @see com.minres.scviewer.database.swt.IWaveformPanel#getActMarkerTime()
	 */
	@Override
	public long getActMarkerTime(){
		return getMarkerTime(selectedMarker);
	}

	/* (non-Javadoc)
	 * @see com.minres.scviewer.database.swt.IWaveformPanel#getMarkerTime(int)
	 */
	@Override
	public long getMarkerTime(int index){
		return cursorPainters.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.data =
					// trackVerticalOffset.floorEntry(event.y).getValue().getFullName();
					event.doit = true;
					LocalSelectionTransfer.getTransfer().setSelection(new StructuredSelection(currentWaveformSelection));
					// System.out.println("dragStart at location "+new
					// Point(event.x, event.y));
				}
			}

			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() {
			@SuppressWarnings("unchecked")
			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<?>){
							IWaveform<? extends IWaveformEvent> srcWave=(IWaveform<? extends IWaveformEvent>) source;
							int srcIdx=streams.indexOf(srcWave);
							streams.remove(source);
							int tgtIdx=streams.indexOf(target);
							if(srcIdx<=tgtIdx) tgtIdx++;
							if(tgtIdx>=streams.size())
								streams.add(srcWave);
							else
								streams.add(tgtIdx, srcWave);
							currentWaveformSelection=srcWave;
							updateTracklist();
						} 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;
				}
			}
		});
	}

	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) {
				System.out.println("dragStart");
				event.doit = false;
				List<Object> clicked = waveformCanvas.getClicked(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.getClicked(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);
		return sb.append(dTime/waveformCanvas.getScaleFactorPow10()).append(waveformCanvas.getUnitStr()).toString();
	}

	/* (non-Javadoc)
	 * @see com.minres.scviewer.database.swt.IWaveformPanel#getZoomLevels()
	 */
	@Override
	public String[] getZoomLevels(){
		String[] res = new String[WaveformCanvas.unitMultiplier.length*WaveformCanvas.unitString.length];
		int index=0;
		for(String unit:WaveformCanvas.unitString){
			for(int factor:WaveformCanvas.unitMultiplier){
				res[index++]= new Integer(factor).toString()+unit;
			}
		}
		return res;
	}
}