org.eclipse.linuxtools.tmf.ui/src/org/eclipse/linuxtools/tmf/ui/widgets/timegraph/widgets/TimeGraphControl.java

   1 /*****************************************************************************
   2  * Copyright (c) 2007, 2008 Intel Corporation, 2009, 2010, 2011, 2012 Ericsson.
   3  * All rights reserved. This program and the accompanying materials
   4  * are made available under the terms of the Eclipse Public License v1.0
   5  * which accompanies this distribution, and is available at
   6  * http://www.eclipse.org/legal/epl-v10.html
   7  *
   8  * Contributors:
   9  *   Intel Corporation - Initial API and implementation
  10  *   Ruslan A. Scherbakov, Intel - Initial API and implementation
  11  *   Alvaro Sanchez-Leon - Updated for TMF
  12  *   Patrick Tasse - Refactoring
  13  *
  14  *****************************************************************************/
  15
  16 package org.eclipse.linuxtools.tmf.ui.widgets.timegraph.widgets;
  17
  18 import java.util.ArrayList;
  19 import java.util.Iterator;
  20 import java.util.List;
  21 import java.util.Vector;
  22
  23 import org.eclipse.jface.resource.JFaceResources;
  24 import org.eclipse.jface.resource.LocalResourceManager;
  25 import org.eclipse.jface.viewers.ISelection;
  26 import org.eclipse.jface.viewers.ISelectionChangedListener;
  27 import org.eclipse.jface.viewers.ISelectionProvider;
  28 import org.eclipse.linuxtools.tmf.ui.widgets.timegraph.ITimeGraphPresentationProvider;
  29 import org.eclipse.linuxtools.tmf.ui.widgets.timegraph.ITimeGraphTreeListener;
  30 import org.eclipse.linuxtools.tmf.ui.widgets.timegraph.StateItem;
  31 import org.eclipse.linuxtools.tmf.ui.widgets.timegraph.TimeGraphTreeExpansionEvent;
  32 import org.eclipse.linuxtools.tmf.ui.widgets.timegraph.model.ITimeEvent;
  33 import org.eclipse.linuxtools.tmf.ui.widgets.timegraph.model.ITimeGraphEntry;
  34 import org.eclipse.swt.SWT;
  35 import org.eclipse.swt.events.ControlEvent;
  36 import org.eclipse.swt.events.ControlListener;
  37 import org.eclipse.swt.events.FocusEvent;
  38 import org.eclipse.swt.events.FocusListener;
  39 import org.eclipse.swt.events.KeyEvent;
  40 import org.eclipse.swt.events.KeyListener;
  41 import org.eclipse.swt.events.MouseEvent;
  42 import org.eclipse.swt.events.MouseListener;
  43 import org.eclipse.swt.events.MouseMoveListener;
  44 import org.eclipse.swt.events.MouseTrackListener;
  45 import org.eclipse.swt.events.MouseWheelListener;
  46 import org.eclipse.swt.events.PaintEvent;
  47 import org.eclipse.swt.events.SelectionEvent;
  48 import org.eclipse.swt.events.SelectionListener;
  49 import org.eclipse.swt.events.TraverseEvent;
  50 import org.eclipse.swt.events.TraverseListener;
  51 import org.eclipse.swt.graphics.Color;
  52 import org.eclipse.swt.graphics.Cursor;
  53 import org.eclipse.swt.graphics.GC;
  54 import org.eclipse.swt.graphics.Image;
  55 import org.eclipse.swt.graphics.Point;
  56 import org.eclipse.swt.graphics.Rectangle;
  57 import org.eclipse.swt.widgets.Composite;
  58 import org.eclipse.swt.widgets.Display;
  59 import org.eclipse.swt.widgets.Event;
  60 import org.eclipse.swt.widgets.Listener;
  61 import org.eclipse.swt.widgets.ScrollBar;
  62
  63 /**
  64  * Time graph control implementation
  65  *
  66  * @version 1.0
  67  * @author Alvaro Sanchez-Leon
  68  * @author Patrick Tasse
  69  */
  70 public class TimeGraphControl extends TimeGraphBaseControl implements FocusListener, KeyListener, MouseMoveListener, MouseListener, MouseWheelListener, ControlListener, SelectionListener, MouseTrackListener, TraverseListener, ISelectionProvider {
  71
  72     private static final int DRAG_NONE = 0;
  73     private static final int DRAG_TRACE_ITEM = 1;
  74     private static final int DRAG_SPLIT_LINE = 2;
  75     public static final boolean DEFAULT_DRAW_THREAD_JOIN = true;
  76     public static final boolean DEFAULT_DRAW_THREAD_WAIT = true;
  77     public static final boolean DEFAULT_DRAW_THREAD_RELEASE = true;
  78     public static final int H_SCROLLBAR_MAX = Integer.MAX_VALUE - 1;
  79     private static final int CUSTOM_ITEM_HEIGHT = -1; // get item height from provider
  80
  81     private static final double zoomCoeff = 1.5;
  82
  83     private ITimeDataProvider _timeProvider;
  84     private boolean _isInFocus = false;
  85     private boolean _isDragCursor3 = false;
  86     private boolean _isWaitCursor = true;
  87     private boolean _mouseOverSplitLine = false;
  88     private int _itemHeight = CUSTOM_ITEM_HEIGHT;
  89     private int _minimumItemWidth = 0;
  90     private int _topIndex = 0;
  91     private int _dragState = DRAG_NONE;
  92     private int _dragX0 = 0;
  93     private int _dragX = 0;
  94     private int _idealNameSpace = 0;
  95     // private double _timeStep = 10000000;
  96     private long _time0bak;
  97     private long _time1bak;
  98     private ITimeGraphPresentationProvider fTimeGraphProvider = null;
  99     private ItemData _data = null;
 100     private List<SelectionListener> _selectionListeners;
 101     private final List<ISelectionChangedListener> _selectionChangedListeners = new ArrayList<ISelectionChangedListener>();
 102     private final List<ITimeGraphTreeListener> _treeListeners = new ArrayList<ITimeGraphTreeListener>();
 103     private final Cursor _dragCursor3;
 104     private final Cursor _WaitCursor;
 105
 106     // Vertical formatting formatting for the state control view
 107     private final boolean _visibleVerticalScroll = true;
 108     private int _borderWidth = 0;
 109     private int _headerHeight = 0;
 110
 111     private Listener mouseScrollFilterListener;
 112
 113     protected LocalResourceManager fResourceManager = new LocalResourceManager(JFaceResources.getResources());
 114     protected Color[] fEventColorMap = null;
 115
 116     private MouseScrollNotifier fMouseScrollNotifier;
 117     private final Object fMouseScrollNotifierLock = new Object();
 118     private class MouseScrollNotifier extends Thread {
 119         private final static long DELAY = 400L;
 120         private final static long POLLING_INTERVAL = 10L;
 121         private long fLastScrollTime = Long.MAX_VALUE;
 122
 123         @Override
 124         public void run() {
 125             while ((System.currentTimeMillis() - fLastScrollTime) < DELAY) {
 126                 try {
 127                     Thread.sleep(POLLING_INTERVAL);
 128                 } catch (Exception e) {
 129                     return;
 130                 }
 131             }
 132             if (!isInterrupted()) {
 133                 Display.getDefault().asyncExec(new Runnable() {
 134                     @Override
 135                     public void run() {
 136                         if (isDisposed()) {
 137                             return;
 138                         }
 139                         _timeProvider.notifyStartFinishTime();
 140                     }
 141                 });
 142             }
 143             synchronized (fMouseScrollNotifierLock) {
 144                 fMouseScrollNotifier = null;
 145             }
 146         }
 147
 148         public void mouseScrolled() {
 149             fLastScrollTime = System.currentTimeMillis();
 150         }
 151     }
 152
 153     /**
 154      * Standard constructor
 155      *
 156      * @param parent
 157      *            The parent composite object
 158      * @param colors
 159      *            The color scheme to use
 160      */
 161     public TimeGraphControl(Composite parent, TimeGraphColorScheme colors) {
 162
 163         super(parent, colors, SWT.NO_BACKGROUND | SWT.H_SCROLL | SWT.DOUBLE_BUFFERED);
 164
 165         _data = new ItemData();
 166
 167         addFocusListener(this);
 168         addMouseListener(this);
 169         addMouseMoveListener(this);
 170         addMouseTrackListener(this);
 171         addMouseWheelListener(this);
 172         addTraverseListener(this);
 173         addKeyListener(this);
 174         addControlListener(this);
 175         ScrollBar scrollHor = getHorizontalBar();
 176
 177         if (scrollHor != null) {
 178             scrollHor.addSelectionListener(this);
 179         }
 180
 181         _dragCursor3 = new Cursor(super.getDisplay(), SWT.CURSOR_SIZEWE);
 182         _WaitCursor = new Cursor(super.getDisplay(), SWT.CURSOR_WAIT);
 183     }
 184
 185     @Override
 186     public void dispose() {
 187         super.dispose();
 188         _dragCursor3.dispose();
 189         _WaitCursor.dispose();
 190         fResourceManager.dispose();
 191     }
 192
 193     /**
 194      * Sets the timegraph provider used by this timegraph viewer.
 195      *
 196      * @param timeGraphProvider the timegraph provider
 197      */
 198     public void setTimeGraphProvider(ITimeGraphPresentationProvider timeGraphProvider) {
 199         fTimeGraphProvider = timeGraphProvider;
 200         _data.provider = timeGraphProvider;
 201
 202         if (fEventColorMap != null) {
 203             for (Color color : fEventColorMap) {
 204                 fResourceManager.destroyColor(color.getRGB());
 205             }
 206         }
 207         StateItem[] stateItems = fTimeGraphProvider.getStateTable();
 208         if (stateItems != null) {
 209             fEventColorMap = new Color[stateItems.length];
 210             for (int i = 0; i < stateItems.length; i++) {
 211                 fEventColorMap[i] = fResourceManager.createColor(stateItems[i].getStateColor());
 212             }
 213         } else {
 214             fEventColorMap = new Color[] { };
 215         }
 216     }
 217
 218     /**
 219      * Assign the given time provider
 220      *
 221      * @param timeProvider
 222      *            The time provider
 223      */
 224     public void setTimeProvider(ITimeDataProvider timeProvider) {
 225         _timeProvider = timeProvider;
 226         adjustScrolls();
 227         redraw();
 228     }
 229
 230     /**
 231      * Add a selection listener
 232      *
 233      * @param listener
 234      *            The listener to add
 235      */
 236     public void addSelectionListener(SelectionListener listener) {
 237         if (listener == null) {
 238             SWT.error(SWT.ERROR_NULL_ARGUMENT);
 239         }
 240         if (null == _selectionListeners) {
 241             _selectionListeners = new ArrayList<SelectionListener>();
 242         }
 243         _selectionListeners.add(listener);
 244     }
 245
 246     /**
 247      * Remove a selection listener
 248      *
 249      * @param listener
 250      *            The listener to remove
 251      */
 252     public void removeSelectionListener(SelectionListener listener) {
 253         if (null != _selectionListeners) {
 254             _selectionListeners.remove(listener);
 255         }
 256     }
 257
 258     /**
 259      * Selection changed callback
 260      */
 261     public void fireSelectionChanged() {
 262         if (null != _selectionListeners) {
 263             Iterator<SelectionListener> it = _selectionListeners.iterator();
 264             while (it.hasNext()) {
 265                 SelectionListener listener = it.next();
 266                 listener.widgetSelected(null);
 267             }
 268         }
 269     }
 270
 271     /**
 272      * Default selection callback
 273      */
 274     public void fireDefaultSelection() {
 275         if (null != _selectionListeners) {
 276             Iterator<SelectionListener> it = _selectionListeners.iterator();
 277             while (it.hasNext()) {
 278                 SelectionListener listener = it.next();
 279                 listener.widgetDefaultSelected(null);
 280             }
 281         }
 282     }
 283
 284     /**
 285      * Get the traces in the model
 286      *
 287      * @return The array of traces
 288      */
 289     public ITimeGraphEntry[] getTraces() {
 290         return _data.getTraces();
 291     }
 292
 293     /**
 294      * Get the on/off trace filters
 295      *
 296      * @return The array of filters
 297      */
 298     public boolean[] getTraceFilter() {
 299         return _data.getTraceFilter();
 300     }
 301
 302     /**
 303      * Refresh the data for the thing
 304      */
 305     public void refreshData() {
 306         _data.refreshData();
 307         adjustScrolls();
 308         redraw();
 309     }
 310
 311     /**
 312      * Refresh data for the given traces
 313      *
 314      * @param traces
 315      *            The traces to refresh
 316      */
 317     public void refreshData(ITimeGraphEntry[] traces) {
 318         _data.refreshData(traces);
 319         adjustScrolls();
 320         redraw();
 321     }
 322
 323     /**
 324      * Adjust the scoll bars
 325      */
 326     public void adjustScrolls() {
 327         if (null == _timeProvider) {
 328             getHorizontalBar().setValues(0, 1, 1, 1, 1, 1);
 329             return;
 330         }
 331
 332         // HORIZONTAL BAR
 333         // Visible window
 334         long time0 = _timeProvider.getTime0();
 335         long time1 = _timeProvider.getTime1();
 336         // Time boundaries
 337         long timeMin = _timeProvider.getMinTime();
 338         long timeMax = _timeProvider.getMaxTime();
 339
 340         long delta = timeMax - timeMin;
 341
 342         int timePos = 0;
 343         int thumb = H_SCROLLBAR_MAX;
 344
 345         if (delta != 0) {
 346             // Thumb size (page size)
 347             thumb = Math.max(1, (int) (H_SCROLLBAR_MAX * ((double) (time1 - time0) / delta)));
 348             // At the beginning of visible window
 349             timePos = (int) (H_SCROLLBAR_MAX * ((double) (time0 - timeMin) / delta));
 350         }
 351
 352         // position, minimum, maximum, thumb size, increment (half page)t, page
 353         // increment size (full page)
 354         getHorizontalBar().setValues(timePos, 0, H_SCROLLBAR_MAX, thumb, Math.max(1, thumb / 2), Math.max(2, thumb));
 355     }
 356
 357     boolean ensureVisibleItem(int idx, boolean redraw) {
 358         boolean changed = false;
 359         if (idx < 0) {
 360             for (idx = 0; idx < _data._expandedItems.length; idx++) {
 361                 if (_data._expandedItems[idx]._selected) {
 362                     break;
 363                 }
 364             }
 365         }
 366         if (idx >= _data._expandedItems.length) {
 367             return changed;
 368         }
 369         if (idx < _topIndex) {
 370             setTopIndex(idx);
 371             //FIXME:getVerticalBar().setSelection(_topItem);
 372             if (redraw) {
 373                 redraw();
 374             }
 375             changed = true;
 376         } else {
 377             int page = countPerPage();
 378             if (idx >= _topIndex + page) {
 379                 setTopIndex(idx - page + 1);
 380                 //FIXME:getVerticalBar().setSelection(_topItem);
 381                 if (redraw) {
 382                     redraw();
 383                 }
 384                 changed = true;
 385             }
 386         }
 387         return changed;
 388     }
 389
 390     /**
 391      * Assign the given index as the top one
 392      *
 393      * @param idx
 394      *            The index
 395      */
 396     public void setTopIndex(int idx) {
 397         idx = Math.min(idx, _data._expandedItems.length - countPerPage());
 398         idx = Math.max(0,  idx);
 399         _topIndex = idx;
 400         redraw();
 401     }
 402
 403     /**
 404      * Set the expanded state of a given entry
 405      *
 406      * @param entry
 407      *            The entry
 408      * @param expanded
 409      *            True if expanded, false if collapsed
 410      */
 411     public void setExpandedState(ITimeGraphEntry entry, boolean expanded) {
 412         Item item = _data.findItem(entry);
 413         if (item != null && item._expanded != expanded) {
 414             item._expanded = expanded;
 415             _data.updateExpandedItems();
 416             redraw();
 417         }
 418     }
 419
 420     /**
 421      * Add a tree listener
 422      *
 423      * @param listener
 424      *            The listener to add
 425      */
 426     public void addTreeListener(ITimeGraphTreeListener listener) {
 427         if (!_treeListeners.contains(listener)) {
 428             _treeListeners.add(listener);
 429         }
 430     }
 431
 432     /**
 433      * Remove a tree listener
 434      *
 435      * @param listener
 436      *            The listener to remove
 437      */
 438     public void removeTreeListener(ITimeGraphTreeListener listener) {
 439         if (_treeListeners.contains(listener)) {
 440             _treeListeners.remove(listener);
 441         }
 442     }
 443
 444     /**
 445      * Tree event callback
 446      *
 447      * @param entry
 448      *            The affected entry
 449      * @param expanded
 450      *            The expanded state (true for expanded, false for collapsed)
 451      */
 452     public void fireTreeEvent(ITimeGraphEntry entry, boolean expanded) {
 453         TimeGraphTreeExpansionEvent event = new TimeGraphTreeExpansionEvent(this, entry);
 454         for (ITimeGraphTreeListener listener : _treeListeners) {
 455             if (expanded) {
 456                 listener.treeExpanded(event);
 457             } else {
 458                 listener.treeCollapsed(event);
 459             }
 460         }
 461     }
 462
 463     @Override
 464     public ISelection getSelection() {
 465         TimeGraphSelection sel = new TimeGraphSelection();
 466         ITimeGraphEntry trace = getSelectedTrace();
 467         if (null != trace && null != _timeProvider) {
 468             long selectedTime = _timeProvider.getSelectedTime();
 469             ITimeEvent event = Utils.findEvent(trace, selectedTime, 0);
 470             if (event != null) {
 471                 sel.add(event);
 472             } else {
 473                 sel.add(trace);
 474             }
 475         }
 476         return sel;
 477     }
 478
 479     /**
 480      * Get the selection object
 481      *
 482      * @return The selection
 483      */
 484     public ISelection getSelectionTrace() {
 485         TimeGraphSelection sel = new TimeGraphSelection();
 486         ITimeGraphEntry trace = getSelectedTrace();
 487         if (null != trace) {
 488             sel.add(trace);
 489         }
 490         return sel;
 491     }
 492
 493     /**
 494      * Enable/disable one of the traces in the model
 495      *
 496      * @param n
 497      *            1 to enable it, -1 to disable. The method returns immediately
 498      *            if another value is used.
 499      */
 500     public void selectTrace(int n) {
 501         if ((n != 1) && (n != -1)) {
 502             return;
 503         }
 504
 505         boolean changed = false;
 506         int lastSelection = -1;
 507         for (int i = 0; i < _data._expandedItems.length; i++) {
 508             Item item = _data._expandedItems[i];
 509             if (item._selected) {
 510                 lastSelection = i;
 511                 if ((1 == n) && (i < _data._expandedItems.length - 1)) {
 512                     item._selected = false;
 513                     item = _data._expandedItems[i + 1];
 514                     item._selected = true;
 515                     changed = true;
 516                 } else if ((-1 == n) && (i > 0)) {
 517                     item._selected = false;
 518                     item = _data._expandedItems[i - 1];
 519                     item._selected = true;
 520                     changed = true;
 521                 }
 522                 break;
 523             }
 524         }
 525
 526         if (lastSelection < 0 && _data._expandedItems.length > 0) {
 527             Item item = _data._expandedItems[0];
 528             item._selected = true;
 529             changed = true;
 530         }
 531
 532         if (changed) {
 533             ensureVisibleItem(-1, false);
 534             redraw();
 535             fireSelectionChanged();
 536         }
 537     }
 538
 539     /**
 540      * Select an event
 541      *
 542      * @param n
 543      *            1 to enable, -1 to disable
 544      */
 545     public void selectEvent(int n) {
 546         if (null == _timeProvider) {
 547             return;
 548         }
 549         ITimeGraphEntry trace = getSelectedTrace();
 550         if (trace == null) {
 551             return;
 552         }
 553         long selectedTime = _timeProvider.getSelectedTime();
 554         long endTime = _timeProvider.getEndTime();
 555         ITimeEvent nextEvent;
 556         if (-1 == n && selectedTime > endTime) {
 557             nextEvent = Utils.findEvent(trace, selectedTime, 0);
 558         } else {
 559             nextEvent = Utils.findEvent(trace, selectedTime, n);
 560         }
 561         if (null == nextEvent && -1 == n) {
 562             nextEvent = Utils.getFirstEvent(trace);
 563         }
 564         if (null != nextEvent) {
 565             long nextTime = nextEvent.getTime();
 566             // If last event detected e.g. going back or not moving to a next
 567             // event
 568             if (nextTime <= selectedTime && n == 1) {
 569                 // Select to the end of this last event
 570                 nextTime = nextEvent.getTime() + nextEvent.getDuration();
 571                 // but not beyond the end of the trace
 572                 if (nextTime > endTime) {
 573                     nextTime = endTime;
 574                 }
 575             }
 576             _timeProvider.setSelectedTimeNotify(nextTime, true);
 577             fireSelectionChanged();
 578         } else if (1 == n) {
 579             _timeProvider.setSelectedTimeNotify(endTime, true);
 580             fireSelectionChanged();
 581         }
 582     }
 583
 584     /**
 585      * Select the next event
 586      */
 587     public void selectNextEvent() {
 588         selectEvent(1);
 589         // Notify if visible time window has been adjusted
 590         _timeProvider.setStartFinishTimeNotify(_timeProvider.getTime0(), _timeProvider.getTime1());
 591     }
 592
 593     /**
 594      * Select the previous event
 595      */
 596     public void selectPrevEvent() {
 597         selectEvent(-1);
 598         // Notify if visible time window has been adjusted
 599         _timeProvider.setStartFinishTimeNotify(_timeProvider.getTime0(), _timeProvider.getTime1());
 600     }
 601
 602     /**
 603      * Select the next trace
 604      */
 605     public void selectNextTrace() {
 606         selectTrace(1);
 607     }
 608
 609     /**
 610      * Select the previous trace
 611      */
 612     public void selectPrevTrace() {
 613         selectTrace(-1);
 614     }
 615
 616     /**
 617      * Zoom based on mouse cursor location with mouse scrolling
 618      *
 619      * @param zoomIn true to zoom in, false to zoom out
 620      */
 621     public void zoom(boolean zoomIn) {
 622         int globalX = getDisplay().getCursorLocation().x;
 623         Point p = toControl(globalX, 0);
 624         int nameSpace = _timeProvider.getNameSpace();
 625         int timeSpace = _timeProvider.getTimeSpace();
 626         int xPos = Math.max(nameSpace, Math.min(nameSpace + timeSpace, p.x));
 627         long time0 = _timeProvider.getTime0();
 628         long time1 = _timeProvider.getTime1();
 629         long interval = time1 - time0;
 630         if (interval == 0) {
 631             interval = 1;
 632         } // to allow getting out of single point interval
 633         long newInterval;
 634         if (zoomIn) {
 635             newInterval = Math.max(Math.round(interval * 0.8), _timeProvider.getMinTimeInterval());
 636         } else {
 637             newInterval = (long) Math.ceil(interval * 1.25);
 638         }
 639         long center = time0 + Math.round(((double) (xPos - nameSpace) / timeSpace * interval));
 640         long newTime0 = center - Math.round((double) newInterval * (center - time0) / interval);
 641         long newTime1 = newTime0 + newInterval;
 642         _timeProvider.setStartFinishTime(newTime0, newTime1);
 643         synchronized (fMouseScrollNotifierLock) {
 644             if (fMouseScrollNotifier == null) {
 645                 fMouseScrollNotifier = new MouseScrollNotifier();
 646                 fMouseScrollNotifier.start();
 647             }
 648             fMouseScrollNotifier.mouseScrolled();
 649         }
 650     }
 651
 652     /**
 653      * zoom in using single click
 654      */
 655     public void zoomIn() {
 656         long _time0 = _timeProvider.getTime0();
 657         long _time1 = _timeProvider.getTime1();
 658         long _range = _time1 - _time0;
 659         long selTime = _timeProvider.getSelectedTime();
 660         if (selTime <= _time0 || selTime >= _time1) {
 661             selTime = (_time0 + _time1) / 2;
 662         }
 663         long time0 = selTime - (long) ((selTime - _time0) / zoomCoeff);
 664         long time1 = selTime + (long) ((_time1 - selTime) / zoomCoeff);
 665
 666         long inaccuracy = (_timeProvider.getMaxTime() - _timeProvider.getMinTime()) - (time1 - time0);
 667
 668         // Trace.debug("selTime:" + selTime + " time0:" + time0 + " time1:"
 669         // + time1 + " inaccuracy:" + inaccuracy);
 670
 671         if (inaccuracy > 0 && inaccuracy < 100) {
 672             _timeProvider.setStartFinishTimeNotify(_timeProvider.getMinTime(), _timeProvider.getMaxTime());
 673             return;
 674         }
 675
 676         long m = _timeProvider.getMinTimeInterval();
 677         if ((time1 - time0) < m) {
 678             time0 = selTime - (selTime - _time0) * m / _range;
 679             time1 = time0 + m;
 680         }
 681
 682         _timeProvider.setStartFinishTimeNotify(time0, time1);
 683     }
 684
 685     /**
 686      * zoom out using single click
 687      */
 688     public void zoomOut() {
 689         long _time0 = _timeProvider.getTime0();
 690         long _time1 = _timeProvider.getTime1();
 691         long selTime = _timeProvider.getSelectedTime();
 692         if (selTime <= _time0 || selTime >= _time1) {
 693             selTime = (_time0 + _time1) / 2;
 694         }
 695         long time0 = (long) (selTime - (selTime - _time0) * zoomCoeff);
 696         long time1 = (long) (selTime + (_time1 - selTime) * zoomCoeff);
 697
 698         long inaccuracy = (_timeProvider.getMaxTime() - _timeProvider.getMinTime()) - (time1 - time0);
 699         if (inaccuracy > 0 && inaccuracy < 100) {
 700             _timeProvider.setStartFinishTimeNotify(_timeProvider.getMinTime(), _timeProvider.getMaxTime());
 701             return;
 702         }
 703
 704         _timeProvider.setStartFinishTimeNotify(time0, time1);
 705     }
 706
 707     /**
 708      * Return the currently selected trace
 709      *
 710      * @return The entry matching the trace
 711      */
 712     public ITimeGraphEntry getSelectedTrace() {
 713         ITimeGraphEntry trace = null;
 714         int idx = getSelectedIndex();
 715         if (idx >= 0) {
 716             trace = _data._expandedItems[idx]._trace;
 717         }
 718         return trace;
 719     }
 720
 721     /**
 722      * Retrieve the index of the currently selected item
 723      *
 724      * @return The index
 725      */
 726     public int getSelectedIndex() {
 727         int idx = -1;
 728         for (int i = 0; i < _data._expandedItems.length; i++) {
 729             Item item = _data._expandedItems[i];
 730             if (item._selected) {
 731                 idx = i;
 732                 break;
 733             }
 734         }
 735         return idx;
 736     }
 737
 738     boolean toggle(int idx) {
 739         boolean toggled = false;
 740         if (idx >= 0 && idx < _data._expandedItems.length) {
 741             Item item = _data._expandedItems[idx];
 742             if (item._hasChildren) {
 743                 item._expanded = !item._expanded;
 744                 _data.updateExpandedItems();
 745                 adjustScrolls();
 746                 redraw();
 747                 toggled = true;
 748                 fireTreeEvent(item._trace, item._expanded);
 749             }
 750         }
 751         return toggled;
 752     }
 753
 754     int getItemIndexAtY(int y) {
 755         if (y < 0) {
 756             return -1;
 757         }
 758         if (_itemHeight == CUSTOM_ITEM_HEIGHT) {
 759             int ySum = 0;
 760             for (int idx = _topIndex; idx < _data._expandedItems.length; idx++) {
 761                 ySum += _data._expandedItems[idx].itemHeight;
 762                 if (y < ySum) {
 763                     return idx;
 764                 }
 765             }
 766             return -1;
 767         }
 768         int idx = y / _itemHeight;
 769         idx += _topIndex;
 770         if (idx < _data._expandedItems.length) {
 771             return idx;
 772         }
 773         return -1;
 774     }
 775
 776     boolean isOverSplitLine(int x) {
 777         if (x < 0 || null == _timeProvider) {
 778             return false;
 779         }
 780         int w = 4;
 781         int nameWidth = _timeProvider.getNameSpace();
 782         if (x > nameWidth - w && x < nameWidth + w) {
 783             return true;
 784         }
 785         return false;
 786     }
 787
 788     ITimeGraphEntry getEntry(Point pt) {
 789         int idx = getItemIndexAtY(pt.y);
 790         return idx >= 0 ? _data._expandedItems[idx]._trace : null;
 791     }
 792
 793     long getTimeAtX(int x) {
 794         if (null == _timeProvider) {
 795             return -1;
 796         }
 797         long hitTime = -1;
 798         Point size = getCtrlSize();
 799         long time0 = _timeProvider.getTime0();
 800         long time1 = _timeProvider.getTime1();
 801         int nameWidth = _timeProvider.getNameSpace();
 802         x -= nameWidth;
 803         int timeWidth = size.x - nameWidth - RIGHT_MARGIN;
 804         if (x >= 0 && size.x >= nameWidth) {
 805             if (time1 - time0 > timeWidth) {
 806                 // nanosecond smaller than one pixel: use the first integer nanosecond of this pixel's time range
 807                 hitTime = time0 + (long) Math.ceil((time1 - time0) * ((double) x / timeWidth));
 808             } else {
 809                 // nanosecond greater than one pixel: use the nanosecond that covers this pixel start position
 810                 hitTime = time0 + (long) Math.floor((time1 - time0) * ((double) x / timeWidth));
 811             }
 812         }
 813         return hitTime;
 814     }
 815
 816     void selectItem(int idx, boolean addSelection) {
 817         boolean changed = false;
 818         if (addSelection) {
 819             if (idx >= 0 && idx < _data._expandedItems.length) {
 820                 Item item = _data._expandedItems[idx];
 821                 changed = (item._selected == false);
 822                 item._selected = true;
 823             }
 824         } else {
 825             for (int i = 0; i < _data._expandedItems.length; i++) {
 826                 Item item = _data._expandedItems[i];
 827                 if ((i == idx && !item._selected) || (idx == -1 && item._selected)) {
 828                     changed = true;
 829                 }
 830                 item._selected = i == idx;
 831             }
 832         }
 833         changed |= ensureVisibleItem(idx, true);
 834         if (changed) {
 835             redraw();
 836         }
 837     }
 838
 839     /**
 840      * Callback for item selection
 841      *
 842      * @param trace
 843      *            The entry matching the trace
 844      * @param addSelection
 845      *            If the selection is added or removed
 846      */
 847     public void selectItem(ITimeGraphEntry trace, boolean addSelection) {
 848         int idx = _data.findItemIndex(trace);
 849         selectItem(idx, addSelection);
 850     }
 851
 852     /**
 853      * Retrieve the number of entries shown per page.
 854      *
 855      * @return The count
 856      */
 857     public int countPerPage() {
 858         int height = getCtrlSize().y;
 859         int count = 0;
 860         if (_itemHeight == CUSTOM_ITEM_HEIGHT) {
 861             int ySum = 0;
 862             for (int idx = _topIndex; idx < _data._expandedItems.length; idx++) {
 863                 ySum += _data._expandedItems[idx].itemHeight;
 864                 if (ySum >= height) {
 865                     return count;
 866                 }
 867                 count++;
 868             }
 869             for (int idx = _topIndex - 1; idx >= 0; idx--) {
 870                 ySum += _data._expandedItems[idx].itemHeight;
 871                 if (ySum >= height) {
 872                     return count;
 873                 }
 874                 count++;
 875             }
 876             return count;
 877         }
 878         if (height > 0) {
 879             count = height / _itemHeight;
 880         }
 881         return count;
 882     }
 883
 884     /**
 885      * Get the index of the top element
 886      *
 887      * @return The index
 888      */
 889     public int getTopIndex() {
 890         return _topIndex;
 891     }
 892
 893     /**
 894      * Get the number of expanded items
 895      *
 896      * @return The count of expanded items
 897      */
 898     public int getExpandedElementCount() {
 899         return _data._expandedItems.length;
 900     }
 901
 902     /**
 903      * Get an array of all expanded elements
 904      *
 905      * @return The expanded elements
 906      */
 907     public ITimeGraphEntry[] getExpandedElements() {
 908         ArrayList<ITimeGraphEntry> elements = new ArrayList<ITimeGraphEntry>();
 909         for (Item item : _data._expandedItems) {
 910             elements.add(item._trace);
 911         }
 912         return elements.toArray(new ITimeGraphEntry[0]);
 913     }
 914
 915     Point getCtrlSize() {
 916         Point size = getSize();
 917         if (getHorizontalBar().isVisible()) {
 918             size.y -= getHorizontalBar().getSize().y;
 919         }
 920         return size;
 921     }
 922
 923     Rectangle getNameRect(Rectangle bound, int idx, int nameWidth) {
 924         int x = bound.x;
 925         int y = bound.y + (idx - _topIndex) * _itemHeight;
 926         int width = nameWidth;
 927         int height = _itemHeight;
 928         if (_itemHeight == CUSTOM_ITEM_HEIGHT) {
 929             int ySum = 0;
 930             for (int i = _topIndex; i < idx; i++) {
 931                 ySum += _data._expandedItems[i].itemHeight;
 932             }
 933             y = bound.y + ySum;
 934             height = _data._expandedItems[idx].itemHeight;
 935         }
 936         return new Rectangle(x, y, width, height);
 937     }
 938
 939     Rectangle getStatesRect(Rectangle bound, int idx, int nameWidth) {
 940         int x = bound.x + nameWidth;
 941         int y = bound.y + (idx - _topIndex) * _itemHeight;
 942         int width = bound.width - x;
 943         int height = _itemHeight;
 944         if (_itemHeight == CUSTOM_ITEM_HEIGHT) {
 945             int ySum = 0;
 946             for (int i = _topIndex; i < idx; i++) {
 947                 ySum += _data._expandedItems[i].itemHeight;
 948             }
 949             y = bound.y + ySum;
 950             height = _data._expandedItems[idx].itemHeight;
 951         }
 952         return new Rectangle(x, y, width, height);
 953     }
 954
 955     @Override
 956     void paint(Rectangle bounds, PaintEvent e) {
 957         GC gc = e.gc;
 958         gc.setBackground(_colors.getColor(TimeGraphColorScheme.BACKGROUND));
 959         drawBackground(gc, bounds.x, bounds.y, bounds.width, bounds.height);
 960
 961         if (bounds.width < 2 || bounds.height < 2 || null == _timeProvider) {
 962             return;
 963         }
 964
 965         _idealNameSpace = 0;
 966         int nameSpace = _timeProvider.getNameSpace();
 967
 968         // draw empty name space background
 969         gc.setBackground(_colors.getBkColor(false, false, true));
 970         drawBackground(gc, bounds.x, bounds.y, nameSpace, bounds.height);
 971
 972         drawItems(bounds, _timeProvider, _data._expandedItems, _topIndex, nameSpace, gc);
 973
 974         // draw selected time
 975         long time0 = _timeProvider.getTime0();
 976         long time1 = _timeProvider.getTime1();
 977         long selectedTime = _timeProvider.getSelectedTime();
 978         double pixelsPerNanoSec = (bounds.width - nameSpace <= RIGHT_MARGIN) ? 0 : (double) (bounds.width - nameSpace - RIGHT_MARGIN) / (time1 - time0);
 979         int x = bounds.x + nameSpace + (int) ((selectedTime - time0) * pixelsPerNanoSec);
 980         if (x >= nameSpace && x < bounds.x + bounds.width) {
 981             gc.setForeground(_colors.getColor(TimeGraphColorScheme.SELECTED_TIME));
 982             gc.drawLine(x, bounds.y, x, bounds.y + bounds.height);
 983         }
 984
 985         // draw drag line, no line if name space is 0.
 986         if (DRAG_SPLIT_LINE == _dragState) {
 987             gc.setForeground(_colors.getColor(TimeGraphColorScheme.BLACK));
 988             gc.drawLine(bounds.x + nameSpace, bounds.y, bounds.x + nameSpace, bounds.y + bounds.height - 1);
 989         } else if (DRAG_NONE == _dragState && _mouseOverSplitLine && _timeProvider.getNameSpace() > 0) {
 990             gc.setForeground(_colors.getColor(TimeGraphColorScheme.RED));
 991             gc.drawLine(bounds.x + nameSpace, bounds.y, bounds.x + nameSpace, bounds.y + bounds.height - 1);
 992         }
 993     }
 994
 995     /**
 996      * Draw many items at once
 997      *
 998      * @param bounds
 999      *            The rectangle of the area
1000      * @param timeProvider
1001      *            The time provider
1002      * @param items
1003      *            The array items to draw
1004      * @param topIndex
1005      *            The index of the first element to draw
1006      * @param nameSpace
1007      *            The width reserved for the names
1008      * @param gc
1009      *            Reference to the SWT GC object
1010      */
1011     public void drawItems(Rectangle bounds, ITimeDataProvider timeProvider,
1012             Item[] items, int topIndex, int nameSpace, GC gc) {
1013         for (int i = topIndex; i < items.length; i++) {
1014             Item item = items[i];
1015             drawItem(item, bounds, timeProvider, i, nameSpace, gc);
1016         }
1017         fTimeGraphProvider.postDrawControl(bounds, gc);
1018     }
1019
1020     /**
1021      * Draws the item
1022      *
1023      * @param item the item to draw
1024      * @param bounds the container rectangle
1025      * @param i the item index
1026      * @param nameSpace the name space
1027      * @param gc
1028      */
1029     protected void drawItem(Item item, Rectangle bounds, ITimeDataProvider timeProvider, int i, int nameSpace, GC gc) {
1030         ITimeGraphEntry entry = item._trace;
1031         long time0 = timeProvider.getTime0();
1032         long time1 = timeProvider.getTime1();
1033         long selectedTime = timeProvider.getSelectedTime();
1034
1035         Rectangle nameRect = getNameRect(bounds, i, nameSpace);
1036         if (nameRect.y >= bounds.y + bounds.height) {
1037             return;
1038         }
1039
1040         if (! item._trace.hasTimeEvents()) {
1041             Rectangle statesRect = getStatesRect(bounds, i, nameSpace);
1042             nameRect.width += statesRect.width;
1043             drawName(item, nameRect, gc);
1044         } else {
1045             drawName(item, nameRect, gc);
1046         }
1047         Rectangle rect = getStatesRect(bounds, i, nameSpace);
1048         if (rect.isEmpty()) {
1049             fTimeGraphProvider.postDrawEntry(entry, rect, gc);
1050             return;
1051         }
1052         if (time1 <= time0) {
1053             gc.setBackground(_colors.getBkColor(false, false, false));
1054             gc.fillRectangle(rect);
1055             fTimeGraphProvider.postDrawEntry(entry, rect, gc);
1056             return;
1057         }
1058
1059         // Initialize _rect1 to same values as enclosing rectangle rect
1060         Rectangle stateRect = Utils.clone(rect);
1061         boolean selected = item._selected;
1062         // K pixels per second
1063         double pixelsPerNanoSec = (rect.width <= RIGHT_MARGIN) ? 0 : (double) (rect.width - RIGHT_MARGIN) / (time1 - time0);
1064
1065         if (item._trace.hasTimeEvents()) {
1066             fillSpace(rect, gc, selected);
1067             // Drawing rectangle is smaller than reserved space
1068             stateRect.y += 3;
1069             stateRect.height -= 6;
1070
1071             long maxDuration = (timeProvider.getTimeSpace() == 0) ? Long.MAX_VALUE : 1 * (time1 - time0) / timeProvider.getTimeSpace();
1072             Iterator<ITimeEvent> iterator = entry.getTimeEventsIterator(time0, time1, maxDuration);
1073
1074             int lastX = -1;
1075             while (iterator.hasNext()) {
1076                 ITimeEvent event = iterator.next();
1077                 int x = rect.x + (int) ((event.getTime() - time0) * pixelsPerNanoSec);
1078                 int xEnd = rect.x + (int) ((event.getTime() + event.getDuration() - time0) * pixelsPerNanoSec);
1079                 if (x >= rect.x + rect.width || xEnd < rect.x) {
1080                     // event is out of bounds
1081                     continue;
1082                 }
1083                 xEnd = Math.min(rect.x + rect.width, xEnd);
1084                 stateRect.x = Math.max(rect.x, x);
1085                 stateRect.width = Math.max(0, xEnd - stateRect.x + 1);
1086                 if (stateRect.x == lastX) {
1087                     stateRect.width -= 1;
1088                     if (stateRect.width > 0) {
1089                         gc.setForeground(Display.getDefault().getSystemColor(SWT.COLOR_BLACK));
1090                         gc.drawPoint(stateRect.x, stateRect.y - 2);
1091                         stateRect.x += 1;
1092                     }
1093                 } else {
1094                     lastX = x;
1095                 }
1096                 boolean timeSelected = selectedTime >= event.getTime() && selectedTime < event.getTime() + event.getDuration();
1097                 drawState(_colors, event, stateRect, gc, selected, timeSelected);
1098             }
1099         }
1100         fTimeGraphProvider.postDrawEntry(entry, rect, gc);
1101     }
1102
1103     protected void drawName(Item item, Rectangle bounds, GC gc) {
1104         boolean hasTimeEvents = item._trace.hasTimeEvents();
1105         if (! hasTimeEvents) {
1106             gc.setBackground(_colors.getBkColorGroup(item._selected, _isInFocus));
1107             gc.fillRectangle(bounds);
1108             if (item._selected && _isInFocus) {
1109                 gc.setForeground(_colors.getBkColor(item._selected, _isInFocus, false));
1110                 gc.drawRectangle(bounds.x, bounds.y, bounds.width - 1, bounds.height - 1);
1111             }
1112         } else {
1113             gc.setBackground(_colors.getBkColor(item._selected, _isInFocus, true));
1114             gc.setForeground(_colors.getFgColor(item._selected, _isInFocus));
1115             gc.fillRectangle(bounds);
1116         }
1117
1118         // No name to be drawn
1119         if (_timeProvider.getNameSpace() == 0) {
1120             return;
1121         }
1122
1123         int leftMargin = MARGIN + item.level * EXPAND_SIZE;
1124         if (item._hasChildren) {
1125             gc.setForeground(_colors.getFgColorGroup(false, false));
1126             gc.setBackground(_colors.getBkColor(false, false, false));
1127             Rectangle rect = Utils.clone(bounds);
1128             rect.x += leftMargin;
1129             rect.y += (bounds.height - EXPAND_SIZE) / 2;
1130             rect.width = EXPAND_SIZE;
1131             rect.height = EXPAND_SIZE;
1132             gc.fillRectangle(rect);
1133             gc.drawRectangle(rect.x, rect.y, rect.width - 1, rect.height - 1);
1134             int midy = rect.y + rect.height / 2;
1135             gc.drawLine(rect.x + 2, midy, rect.x + rect.width - 3, midy);
1136             if (!item._expanded) {
1137                 int midx = rect.x + rect.width / 2;
1138                 gc.drawLine(midx, rect.y + 2, midx, rect.y + rect.height - 3);
1139             }
1140         }
1141         leftMargin += EXPAND_SIZE + MARGIN;
1142
1143         Image img = fTimeGraphProvider.getItemImage(item._trace);
1144         if (img != null) {
1145             // draw icon
1146             int imgHeight = img.getImageData().height;
1147             int imgWidth = img.getImageData().width;
1148             int x = leftMargin;
1149             int y = bounds.y + (bounds.height - imgHeight) / 2;
1150             gc.drawImage(img, x, y);
1151             leftMargin += imgWidth + MARGIN;
1152         }
1153         String name = item._name;
1154         Point size = gc.stringExtent(name);
1155         if (_idealNameSpace < leftMargin + size.x + MARGIN) {
1156             _idealNameSpace = leftMargin + size.x + MARGIN;
1157         }
1158         if (hasTimeEvents) {
1159             // cut long string with "..."
1160             int width = bounds.width - leftMargin;
1161             int cuts = 0;
1162             while (size.x > width && name.length() > 1) {
1163                 cuts++;
1164                 name = name.substring(0, name.length() - 1);
1165                 size = gc.stringExtent(name + "..."); //$NON-NLS-1$
1166             }
1167             if (cuts > 0) {
1168                 name += "..."; //$NON-NLS-1$
1169             }
1170         }
1171         Rectangle rect = Utils.clone(bounds);
1172         rect.x += leftMargin;
1173         rect.width -= leftMargin;
1174         // draw text
1175         if (rect.width > 0) {
1176             rect.y += (bounds.height - gc.stringExtent(name).y) / 2;
1177             gc.setForeground(_colors.getFgColor(item._selected, _isInFocus));
1178             int textWidth = Utils.drawText(gc, name, rect, true);
1179             leftMargin += textWidth + MARGIN;
1180             rect.y -= 2;
1181
1182             if (hasTimeEvents) {
1183                 // draw middle line
1184                 int x = bounds.x + leftMargin;
1185                 int width = bounds.width - x;
1186                 int midy = bounds.y + bounds.height / 2;
1187                 gc.setForeground(_colors.getColor(TimeGraphColorScheme.MID_LINE));
1188                 gc.drawLine(x, midy, x + width, midy);
1189             }
1190         }
1191     }
1192
1193     protected void drawState(TimeGraphColorScheme colors, ITimeEvent event,
1194             Rectangle rect, GC gc, boolean selected, boolean timeSelected) {
1195
1196         int colorIdx = fTimeGraphProvider.getStateTableIndex(event);
1197         if (colorIdx < 0) {
1198             return;
1199         }
1200         boolean visible = rect.width == 0 ? false : true;
1201
1202         if (visible) {
1203             Color stateColor = null;
1204             if (colorIdx < fEventColorMap.length) {
1205                 stateColor = fEventColorMap[colorIdx];
1206             } else {
1207                 stateColor = Display.getDefault().getSystemColor(SWT.COLOR_BLACK);
1208             }
1209
1210             timeSelected = timeSelected && selected;
1211             if (timeSelected) {
1212                 // modify the color?
1213             }
1214             // fill all rect area
1215             gc.setBackground(stateColor);
1216             gc.fillRectangle(rect);
1217             // get the border color?
1218             gc.setForeground(Display.getDefault().getSystemColor(SWT.COLOR_BLACK));
1219
1220             // draw bounds
1221             if (!timeSelected) {
1222                 // Draw the top and bottom borders i.e. no side borders
1223                 // top
1224                 gc.drawLine(rect.x, rect.y, rect.x + rect.width - 1, rect.y);
1225                 // bottom
1226                 gc.drawLine(rect.x, rect.y + rect.height - 1, rect.x + rect.width - 1, rect.y + rect.height - 1);
1227             }
1228         } else {
1229             gc.setForeground(Display.getDefault().getSystemColor(SWT.COLOR_BLACK));
1230             gc.drawPoint(rect.x, rect.y - 2);
1231             /*
1232             // selected rectangle area is not visible but can be represented
1233             // with a broken vertical line of specified width.
1234             int width = 1;
1235             rect.width = width;
1236             gc.setForeground(stateColor);
1237             int s = gc.getLineStyle();
1238             int w = gc.getLineWidth();
1239             gc.setLineStyle(SWT.LINE_DOT);
1240             gc.setLineWidth(width);
1241             // Trace.debug("Rectangle not visible, drawing vertical line with: "
1242             // + rect.x + "," + rect.y + "," + rect.x + "," + rect.y
1243             // + rect.height);
1244             gc.drawLine(rect.x, rect.y, rect.x, rect.y + rect.height - 1);
1245             gc.setLineStyle(s);
1246             gc.setLineWidth(w);
1247             if (!timeSelected) {
1248                 gc.setForeground(Display.getDefault().getSystemColor(SWT.COLOR_BLACK));
1249                 gc.drawPoint(rect.x, rect.y);
1250                 gc.drawPoint(rect.x, rect.y + rect.height - 1);
1251             }
1252             */
1253         }
1254         fTimeGraphProvider.postDrawEvent(event, rect, gc);
1255     }
1256
1257     protected void fillSpace(Rectangle rect, GC gc, boolean selected) {
1258         gc.setBackground(_colors.getBkColor(selected, _isInFocus, false));
1259         gc.fillRectangle(rect);
1260         // draw middle line
1261         gc.setForeground(_colors.getColor(TimeGraphColorScheme.MID_LINE));
1262         int midy = rect.y + rect.height / 2;
1263         gc.drawLine(rect.x, midy, rect.x + rect.width, midy);
1264     }
1265
1266     @Override
1267     public void keyTraversed(TraverseEvent e) {
1268         if ((e.detail == SWT.TRAVERSE_TAB_NEXT) || (e.detail == SWT.TRAVERSE_TAB_PREVIOUS)) {
1269             e.doit = true;
1270         }
1271     }
1272
1273     @Override
1274     public void keyPressed(KeyEvent e) {
1275         int idx = -1;
1276         if (_data._expandedItems.length == 0) {
1277             return;
1278         }
1279         if (SWT.HOME == e.keyCode) {
1280             idx = 0;
1281         } else if (SWT.END == e.keyCode) {
1282             idx = _data._expandedItems.length - 1;
1283         } else if (SWT.ARROW_DOWN == e.keyCode) {
1284             idx = getSelectedIndex();
1285             if (idx < 0) {
1286                 idx = 0;
1287             } else if (idx < _data._expandedItems.length - 1) {
1288                 idx++;
1289             }
1290         } else if (SWT.ARROW_UP == e.keyCode) {
1291             idx = getSelectedIndex();
1292             if (idx < 0) {
1293                 idx = 0;
1294             } else if (idx > 0) {
1295                 idx--;
1296             }
1297         } else if (SWT.ARROW_LEFT == e.keyCode) {
1298             selectPrevEvent();
1299         } else if (SWT.ARROW_RIGHT == e.keyCode) {
1300             selectNextEvent();
1301         } else if (SWT.PAGE_DOWN == e.keyCode) {
1302             int page = countPerPage();
1303             idx = getSelectedIndex();
1304             if (idx < 0) {
1305                 idx = 0;
1306             }
1307             idx += page;
1308             if (idx >= _data._expandedItems.length) {
1309                 idx = _data._expandedItems.length - 1;
1310             }
1311         } else if (SWT.PAGE_UP == e.keyCode) {
1312             int page = countPerPage();
1313             idx = getSelectedIndex();
1314             if (idx < 0) {
1315                 idx = 0;
1316             }
1317             idx -= page;
1318             if (idx < 0) {
1319                 idx = 0;
1320             }
1321         } else if (SWT.CR == e.keyCode) {
1322             idx = getSelectedIndex();
1323             if (idx >= 0) {
1324                 if (_data._expandedItems[idx]._hasChildren) {
1325                     toggle(idx);
1326                 } else {
1327                     fireDefaultSelection();
1328                 }
1329             }
1330             idx = -1;
1331         }
1332         if (idx >= 0) {
1333             selectItem(idx, false);
1334             fireSelectionChanged();
1335         }
1336     }
1337
1338     @Override
1339     public void keyReleased(KeyEvent e) {
1340     }
1341
1342     @Override
1343     public void focusGained(FocusEvent e) {
1344         _isInFocus = true;
1345         if (mouseScrollFilterListener == null) {
1346             mouseScrollFilterListener = new Listener() {
1347                 // This filter is used to prevent horizontal scrolling of the view
1348                 // when the mouse wheel is used to zoom
1349                 @Override
1350                 public void handleEvent(Event event) {
1351                     event.doit = false;
1352                 }
1353             };
1354             getDisplay().addFilter(SWT.MouseWheel, mouseScrollFilterListener);
1355         }
1356         redraw();
1357     }
1358
1359     @Override
1360     public void focusLost(FocusEvent e) {
1361         _isInFocus = false;
1362         if (mouseScrollFilterListener != null) {
1363             getDisplay().removeFilter(SWT.MouseWheel, mouseScrollFilterListener);
1364             mouseScrollFilterListener = null;
1365         }
1366         if (DRAG_NONE != _dragState) {
1367             setCapture(false);
1368             _dragState = DRAG_NONE;
1369         }
1370         redraw();
1371     }
1372
1373     /**
1374      * @return If the current view is focused
1375      */
1376     public boolean isInFocus() {
1377         return _isInFocus;
1378     }
1379
1380     /**
1381      * Provide the possibility to control the wait cursor externally e.g. data
1382      * requests in progress
1383      *
1384      * @param waitInd Should we wait indefinitely?
1385      */
1386     public void waitCursor(boolean waitInd) {
1387         // Update cursor as indicated
1388         if (waitInd) {
1389             setCursor(_WaitCursor);
1390             _isWaitCursor = true;
1391         } else {
1392             setCursor(null);
1393             _isWaitCursor = false;
1394         }
1395
1396         // Get ready for next mouse move
1397         _isDragCursor3 = false;
1398     }
1399
1400     /**
1401      * <p>
1402      * If the x, y position is over the vertical split line (name to time
1403      * ranges), then change the cursor to a drag cursor to indicate the user the
1404      * possibility of resizing
1405      * </p>
1406      *
1407      * @param x
1408      * @param y
1409      */
1410     void updateCursor(int x, int y) {
1411         // if Wait cursor not active, check for the need to change to a drag
1412         // cursor
1413         if (_isWaitCursor == false) {
1414             boolean isSplitLine = isOverSplitLine(x);
1415             // No dragcursor is name space is fixed to zero
1416             if (isSplitLine && !_isDragCursor3 && _timeProvider.getNameSpace() > 0) {
1417                 setCursor(_dragCursor3);
1418                 _isDragCursor3 = true;
1419             } else if (!isSplitLine && _isDragCursor3) {
1420                 setCursor(null);
1421                 _isDragCursor3 = false;
1422             }
1423         }
1424     }
1425
1426     @Override
1427     public void mouseMove(MouseEvent e) {
1428         if (null == _timeProvider) {
1429             return;
1430         }
1431         Point size = getCtrlSize();
1432         if (DRAG_TRACE_ITEM == _dragState) {
1433             int nameWidth = _timeProvider.getNameSpace();
1434             int x = e.x - nameWidth;
1435             if (x > 0 && size.x > nameWidth && _dragX != x) {
1436                 _dragX = x;
1437                 double pixelsPerNanoSec = (size.x - nameWidth <= RIGHT_MARGIN) ? 0 : (double) (size.x - nameWidth - RIGHT_MARGIN) / (_time1bak - _time0bak);
1438                 long timeDelta = (long) ((pixelsPerNanoSec == 0) ? 0 : ((_dragX - _dragX0) / pixelsPerNanoSec));
1439                 long time1 = _time1bak - timeDelta;
1440                 long maxTime = _timeProvider.getMaxTime();
1441                 if (time1 > maxTime) {
1442                     time1 = maxTime;
1443                 }
1444                 long time0 = time1 - (_time1bak - _time0bak);
1445                 if (time0 < _timeProvider.getMinTime()) {
1446                     time0 = _timeProvider.getMinTime();
1447                     time1 = time0 + (_time1bak - _time0bak);
1448                 }
1449                 _timeProvider.setStartFinishTime(time0, time1);
1450             }
1451         } else if (DRAG_SPLIT_LINE == _dragState) {
1452             _dragX = e.x;
1453             _timeProvider.setNameSpace(e.x);
1454         } else if (DRAG_NONE == _dragState) {
1455             boolean mouseOverSplitLine = isOverSplitLine(e.x);
1456             if (_mouseOverSplitLine != mouseOverSplitLine) {
1457                 redraw();
1458             }
1459             _mouseOverSplitLine = mouseOverSplitLine;
1460         }
1461         updateCursor(e.x, e.y);
1462     }
1463
1464     @Override
1465     public void mouseDoubleClick(MouseEvent e) {
1466         if (null == _timeProvider) {
1467             return;
1468         }
1469         if (1 == e.button) {
1470             if (isOverSplitLine(e.x) && _timeProvider.getNameSpace() != 0) {
1471                 _timeProvider.setNameSpace(_idealNameSpace);
1472                 boolean mouseOverSplitLine = isOverSplitLine(e.x);
1473                 if (_mouseOverSplitLine != mouseOverSplitLine) {
1474                     redraw();
1475                 }
1476                 _mouseOverSplitLine = mouseOverSplitLine;
1477                 return;
1478             }
1479             int idx = getItemIndexAtY(e.y);
1480             if (idx >= 0) {
1481                 selectItem(idx, false);
1482                 fireDefaultSelection();
1483             }
1484         }
1485     }
1486
1487     @Override
1488     public void mouseDown(MouseEvent e) {
1489         if (null == _timeProvider) {
1490             return;
1491         }
1492         int idx;
1493         if (1 == e.button) {
1494             int nameSpace = _timeProvider.getNameSpace();
1495             if (nameSpace != 0) {
1496                 if (isOverSplitLine(e.x)) {
1497                     _dragState = DRAG_SPLIT_LINE;
1498                     _dragX = _dragX0 = e.x;
1499                     _time0bak = _timeProvider.getTime0();
1500                     _time1bak = _timeProvider.getTime1();
1501                     redraw();
1502                     return;
1503                 }
1504             }
1505
1506             idx = getItemIndexAtY(e.y);
1507             if (idx >= 0) {
1508                 Item item = _data._expandedItems[idx];
1509                 if (item._hasChildren && e.x < nameSpace && e.x < MARGIN + (item.level + 1) * EXPAND_SIZE) {
1510                     toggle(idx);
1511                 } else {
1512                     long hitTime = getTimeAtX(e.x);
1513                     if (hitTime >= 0) {
1514                         // _timeProvider.setSelectedTimeInt(hitTime, false);
1515                         setCapture(true);
1516                         _dragState = DRAG_TRACE_ITEM;
1517                         _dragX = _dragX0 = e.x - nameSpace;
1518                         _time0bak = _timeProvider.getTime0();
1519                         _time1bak = _timeProvider.getTime1();
1520                     }
1521                 }
1522                 selectItem(idx, false);
1523                 fireSelectionChanged();
1524             } else {
1525                 selectItem(idx, false); // clear selection
1526                 redraw();
1527                 fireSelectionChanged();
1528             }
1529         }
1530     }
1531
1532     @Override
1533     public void mouseUp(MouseEvent e) {
1534         if (DRAG_NONE != _dragState) {
1535             setCapture(false);
1536             if (DRAG_TRACE_ITEM == _dragState) {
1537                 // Notify time provider to check the need for listener
1538                 // notification
1539                 _timeProvider.notifyStartFinishTime();
1540                 if (_dragX == _dragX0) { // click without drag
1541                     long time = getTimeAtX(e.x);
1542                     _timeProvider.setSelectedTimeNotify(time, false);
1543                 }
1544             } else if (DRAG_SPLIT_LINE == _dragState) {
1545                 redraw();
1546             }
1547             _dragState = DRAG_NONE;
1548         }
1549     }
1550
1551     @Override
1552     public void mouseEnter(MouseEvent e) {
1553     }
1554
1555     @Override
1556     public void mouseExit(MouseEvent e) {
1557         if (_mouseOverSplitLine) {
1558             _mouseOverSplitLine = false;
1559             redraw();
1560         }
1561     }
1562
1563     @Override
1564     public void mouseHover(MouseEvent e) {
1565     }
1566
1567     @Override
1568     public void mouseScrolled(MouseEvent e) {
1569         if ((mouseScrollFilterListener == null) || _dragState != DRAG_NONE) {
1570             return;
1571         }
1572         boolean zoomScroll = false;
1573         Point p = getParent().toControl(getDisplay().getCursorLocation());
1574         Point parentSize = getParent().getSize();
1575         if (p.x >= 0 && p.x < parentSize.x && p.y >= 0 && p.y < parentSize.y) {
1576             // over the parent control
1577             if (e.x > getCtrlSize().x) {
1578                 // over the horizontal scroll bar
1579                 zoomScroll = false;
1580             } else if (e.y >= 0 && e.y < getCtrlSize().y && e.x < _timeProvider.getNameSpace()) {
1581                 // over the name space
1582                 zoomScroll = false;
1583             } else {
1584                 zoomScroll = true;
1585             }
1586         }
1587         if (zoomScroll && _timeProvider.getTime0() != _timeProvider.getTime1()) {
1588             if (e.count > 0) {
1589                 zoom(true);
1590             } else if (e.count < 0) {
1591                 zoom(false);
1592             }
1593         } else {
1594             setTopIndex(getTopIndex() - e.count);
1595         }
1596     }
1597
1598     @Override
1599     public void controlMoved(ControlEvent e) {
1600     }
1601
1602     @Override
1603     public void controlResized(ControlEvent e) {
1604         adjustScrolls();
1605     }
1606
1607     @Override
1608     public void widgetDefaultSelected(SelectionEvent e) {
1609     }
1610
1611     @Override
1612     public void widgetSelected(SelectionEvent e) {
1613         if (e.widget == getVerticalBar()) {
1614             setTopIndex(getVerticalBar().getSelection());
1615         } else if (e.widget == getHorizontalBar() && null != _timeProvider) {
1616             int start = getHorizontalBar().getSelection();
1617             long time0 = _timeProvider.getTime0();
1618             long time1 = _timeProvider.getTime1();
1619             long timeMin = _timeProvider.getMinTime();
1620             long timeMax = _timeProvider.getMaxTime();
1621             long delta = timeMax - timeMin;
1622
1623             long range = time1 - time0;
1624             // _timeRangeFixed = true;
1625             time0 = timeMin + Math.round(delta * ((double) start / H_SCROLLBAR_MAX));
1626             time1 = time0 + range;
1627
1628             // TODO: Follow-up with Bug 310310
1629             // In Linux SWT.DRAG is the only value received
1630             // https://bugs.eclipse.org/bugs/show_bug.cgi?id=310310
1631             if (e.detail == SWT.DRAG) {
1632                 _timeProvider.setStartFinishTime(time0, time1);
1633             } else {
1634                 _timeProvider.setStartFinishTimeNotify(time0, time1);
1635             }
1636         }
1637     }
1638
1639     /**
1640      * @return The current visibility of the vertical scroll bar
1641      */
1642     public boolean isVisibleVerticalScroll() {
1643         return _visibleVerticalScroll;
1644     }
1645
1646     @Override
1647     public int getBorderWidth() {
1648         return _borderWidth;
1649     }
1650
1651     /**
1652      * Set the border width
1653      *
1654      * @param borderWidth
1655      *            The width
1656      */
1657     public void setBorderWidth(int borderWidth) {
1658         this._borderWidth = borderWidth;
1659     }
1660
1661     /**
1662      * @return The current height of the header row
1663      */
1664     public int getHeaderHeight() {
1665         return _headerHeight;
1666     }
1667
1668     /**
1669      * Set the height of the header row
1670      *
1671      * @param headerHeight
1672      *            The height
1673      */
1674     public void setHeaderHeight(int headerHeight) {
1675         this._headerHeight = headerHeight;
1676     }
1677
1678     /**
1679      * @return The height of regular item rows
1680      */
1681     public int getItemHeight() {
1682         return _itemHeight;
1683     }
1684
1685     /**
1686      * Set the height of regular itew rows
1687      *
1688      * @param rowHeight
1689      *            The height
1690      */
1691     public void setItemHeight(int rowHeight) {
1692         this._itemHeight = rowHeight;
1693     }
1694
1695     /**
1696      * Set the minimum item width
1697      *
1698      * @param width The minimum width
1699      */
1700     public void setMinimumItemWidth(int width) {
1701         this._minimumItemWidth = width;
1702     }
1703
1704     /**
1705      * @return The minimum item width
1706      */
1707     public int getMinimumItemWidth() {
1708         return _minimumItemWidth;
1709     }
1710
1711     /**
1712      * @return The entries that are currently filtered out
1713      */
1714     public Vector<ITimeGraphEntry> getFilteredOut() {
1715         return _data.getFilteredOut();
1716     }
1717
1718     // @Override
1719     @Override
1720     public void addSelectionChangedListener(ISelectionChangedListener listener) {
1721         if (listener != null) {
1722             if (!_selectionChangedListeners.contains(listener)) {
1723                 _selectionChangedListeners.add(listener);
1724             }
1725         }
1726     }
1727
1728     // @Override
1729     @Override
1730     public void removeSelectionChangedListener(ISelectionChangedListener listener) {
1731         if (listener != null) {
1732             _selectionChangedListeners.remove(listener);
1733         }
1734     }
1735
1736     // @Override
1737     @Override
1738     public void setSelection(ISelection selection) {
1739         if (selection instanceof TimeGraphSelection) {
1740             TimeGraphSelection sel = (TimeGraphSelection) selection;
1741             Object ob = sel.getFirstElement();
1742             if (ob instanceof ITimeGraphEntry) {
1743                 ITimeGraphEntry trace = (ITimeGraphEntry) ob;
1744                 selectItem(trace, false);
1745             }
1746         }
1747
1748     }
1749
1750     private class ItemData {
1751         public Item[] _expandedItems = new Item[0];
1752         public Item[] _items = new Item[0];
1753         private ITimeGraphEntry _traces[] = new ITimeGraphEntry[0];
1754         private boolean traceFilter[] = new boolean[0];
1755         private final Vector<ITimeGraphEntry> filteredOut = new Vector<ITimeGraphEntry>();
1756         public ITimeGraphPresentationProvider provider;
1757
1758         public ItemData() {
1759         }
1760
1761         Item findItem(ITimeGraphEntry entry) {
1762             if (entry == null) {
1763                 return null;
1764             }
1765
1766             for (int i = 0; i < _items.length; i++) {
1767                 Item item = _items[i];
1768                 if (item._trace == entry) {
1769                     return item;
1770                 }
1771             }
1772
1773             return null;
1774         }
1775
1776         int findItemIndex(ITimeGraphEntry trace) {
1777             if (trace == null) {
1778                 return -1;
1779             }
1780
1781             for (int i = 0; i < _expandedItems.length; i++) {
1782                 Item item = _expandedItems[i];
1783                 if (item._trace == trace) {
1784                     return i;
1785                 }
1786             }
1787
1788             return -1;
1789         }
1790
1791         public void refreshData() {
1792             List<Item> itemList = new ArrayList<Item>();
1793             filteredOut.clear();
1794             for (int i = 0; i < _traces.length; i++) {
1795                 ITimeGraphEntry entry = _traces[i];
1796                 refreshData(itemList, null, 0, entry);
1797             }
1798             _items = itemList.toArray(new Item[0]);
1799             updateExpandedItems();
1800         }
1801
1802         private void refreshData(List<Item> itemList, Item parent, int level, ITimeGraphEntry entry) {
1803             Item item = new Item(entry, entry.getName(), level);
1804             if (parent != null) {
1805                 parent.children.add(item);
1806             }
1807             item.itemHeight = provider.getItemHeight(entry);
1808             itemList.add(item);
1809             if (entry.hasChildren()) {
1810                 item._expanded = true;
1811                 item._hasChildren = true;
1812                 for (ITimeGraphEntry child : entry.getChildren()) {
1813                     refreshData(itemList, item, level + 1, child);
1814                 }
1815             }
1816         }
1817
1818         public void updateExpandedItems() {
1819             List<Item> expandedItemList = new ArrayList<Item>();
1820             for (int i = 0; i < _traces.length; i++) {
1821                 ITimeGraphEntry entry = _traces[i];
1822                 Item item = findItem(entry);
1823                 refreshExpanded(expandedItemList, item);
1824             }
1825             _expandedItems = expandedItemList.toArray(new Item[0]);
1826         }
1827
1828         private void refreshExpanded(List<Item> expandedItemList, Item item) {
1829             expandedItemList.add(item);
1830             if (item._hasChildren && item._expanded) {
1831                 for (Item child : item.children) {
1832                     refreshExpanded(expandedItemList, child);
1833                 }
1834             }
1835         }
1836
1837         public void refreshData(ITimeGraphEntry traces[]) {
1838             if (traces == null || traces.length == 0) {
1839                 traceFilter = null;
1840             } else if (traceFilter == null || traces.length != traceFilter.length) {
1841                 traceFilter = new boolean[traces.length];
1842                 java.util.Arrays.fill(traceFilter, true);
1843             }
1844
1845             _traces = traces;
1846             refreshData();
1847         }
1848
1849         public ITimeGraphEntry[] getTraces() {
1850             return _traces;
1851         }
1852
1853         public boolean[] getTraceFilter() {
1854             return traceFilter;
1855         }
1856
1857         public Vector<ITimeGraphEntry> getFilteredOut() {
1858             return filteredOut;
1859         }
1860     }
1861
1862     private class Item {
1863         public boolean _expanded;
1864         public boolean _selected;
1865         public boolean _hasChildren;
1866         public int itemHeight;
1867         public int level;
1868         public List<Item> children;
1869         public String _name;
1870         public ITimeGraphEntry _trace;
1871
1872         public Item(ITimeGraphEntry trace, String name, int level) {
1873             this._trace = trace;
1874             this._name = name;
1875             this.level = level;
1876             this.children = new ArrayList<Item>();
1877         }
1878
1879         @Override
1880         public String toString() {
1881             return _name;
1882         }
1883     }
1884
1885 }
1886