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

   1 /*****************************************************************************
   2  * Copyright (c) 2007, 2014 Intel Corporation and others
   3  *
   4  * All rights reserved. This program and the accompanying materials
   5  * are made available under the terms of the Eclipse Public License v1.0
   6  * which accompanies this distribution, and is available at
   7  * http://www.eclipse.org/legal/epl-v10.html
   8  *
   9  * Contributors:
  10  *   Intel Corporation - Initial API and implementation
  11  *   Ruslan A. Scherbakov, Intel - Initial API and implementation
  12  *   Alvaro Sanchez-Leon, Ericsson - Updated for TMF
  13  *   Patrick Tasse, Ericsson - Refactoring
  14  *   Geneviève Bastien, École Polytechnique de Montréal - Move code to
  15  *                            provide base classes for time graph view
  16  *                            Add display of links between items
  17  *   Xavier Raynaud, Kalray - Code optimization
  18  *****************************************************************************/
  19
  20 package org.eclipse.linuxtools.tmf.ui.widgets.timegraph.widgets;
  21
  22 import java.util.ArrayList;
  23 import java.util.Arrays;
  24 import java.util.Iterator;
  25 import java.util.LinkedHashMap;
  26 import java.util.List;
  27 import java.util.Map;
  28
  29 import org.eclipse.jface.action.IStatusLineManager;
  30 import org.eclipse.jface.resource.JFaceResources;
  31 import org.eclipse.jface.resource.LocalResourceManager;
  32 import org.eclipse.jface.viewers.ISelection;
  33 import org.eclipse.jface.viewers.ISelectionChangedListener;
  34 import org.eclipse.jface.viewers.ISelectionProvider;
  35 import org.eclipse.jface.viewers.ViewerFilter;
  36 import org.eclipse.linuxtools.tmf.core.timestamp.ITmfTimestamp;
  37 import org.eclipse.linuxtools.tmf.core.timestamp.TmfNanoTimestamp;
  38 import org.eclipse.linuxtools.tmf.core.timestamp.TmfTimestampDelta;
  39 import org.eclipse.linuxtools.tmf.ui.widgets.timegraph.ITimeGraphColorListener;
  40 import org.eclipse.linuxtools.tmf.ui.widgets.timegraph.ITimeGraphPresentationProvider;
  41 import org.eclipse.linuxtools.tmf.ui.widgets.timegraph.ITimeGraphPresentationProvider2;
  42 import org.eclipse.linuxtools.tmf.ui.widgets.timegraph.ITimeGraphTreeListener;
  43 import org.eclipse.linuxtools.tmf.ui.widgets.timegraph.StateItem;
  44 import org.eclipse.linuxtools.tmf.ui.widgets.timegraph.TimeGraphTreeExpansionEvent;
  45 import org.eclipse.linuxtools.tmf.ui.widgets.timegraph.model.ILinkEvent;
  46 import org.eclipse.linuxtools.tmf.ui.widgets.timegraph.model.ITimeEvent;
  47 import org.eclipse.linuxtools.tmf.ui.widgets.timegraph.model.ITimeGraphEntry;
  48 import org.eclipse.swt.SWT;
  49 import org.eclipse.swt.events.ControlEvent;
  50 import org.eclipse.swt.events.ControlListener;
  51 import org.eclipse.swt.events.FocusEvent;
  52 import org.eclipse.swt.events.FocusListener;
  53 import org.eclipse.swt.events.KeyEvent;
  54 import org.eclipse.swt.events.KeyListener;
  55 import org.eclipse.swt.events.MenuDetectEvent;
  56 import org.eclipse.swt.events.MenuDetectListener;
  57 import org.eclipse.swt.events.MouseEvent;
  58 import org.eclipse.swt.events.MouseListener;
  59 import org.eclipse.swt.events.MouseMoveListener;
  60 import org.eclipse.swt.events.MouseTrackListener;
  61 import org.eclipse.swt.events.MouseWheelListener;
  62 import org.eclipse.swt.events.PaintEvent;
  63 import org.eclipse.swt.events.SelectionEvent;
  64 import org.eclipse.swt.events.SelectionListener;
  65 import org.eclipse.swt.events.TraverseEvent;
  66 import org.eclipse.swt.events.TraverseListener;
  67 import org.eclipse.swt.events.TypedEvent;
  68 import org.eclipse.swt.graphics.Color;
  69 import org.eclipse.swt.graphics.Cursor;
  70 import org.eclipse.swt.graphics.GC;
  71 import org.eclipse.swt.graphics.Image;
  72 import org.eclipse.swt.graphics.Point;
  73 import org.eclipse.swt.graphics.Rectangle;
  74 import org.eclipse.swt.widgets.Composite;
  75 import org.eclipse.swt.widgets.Display;
  76 import org.eclipse.swt.widgets.Event;
  77 import org.eclipse.swt.widgets.Listener;
  78 import org.eclipse.swt.widgets.ScrollBar;
  79
  80 /**
  81  * Time graph control implementation
  82  *
  83  * @version 1.0
  84  * @author Alvaro Sanchez-Leon
  85  * @author Patrick Tasse
  86  */
  87 public class TimeGraphControl extends TimeGraphBaseControl
  88         implements FocusListener, KeyListener, MouseMoveListener, MouseListener, MouseWheelListener,
  89         ControlListener, SelectionListener, MouseTrackListener, TraverseListener, ISelectionProvider,
  90         MenuDetectListener, ITmfTimeGraphDrawingHelper, ITimeGraphColorListener {
  91
  92     /** Max scrollbar size */
  93     public static final int H_SCROLLBAR_MAX = Integer.MAX_VALUE - 1;
  94
  95     private static final int DRAG_NONE = 0;
  96     private static final int DRAG_TRACE_ITEM = 1;
  97     private static final int DRAG_SPLIT_LINE = 2;
  98     private static final int DRAG_ZOOM = 3;
  99     private static final int DRAG_SELECTION = 4;
 100
 101     private static final int CUSTOM_ITEM_HEIGHT = -1; // get item height from provider
 102
 103     private static final double ZOOM_FACTOR = 1.5;
 104     private static final double ZOOM_IN_FACTOR = 0.8;
 105     private static final double ZOOM_OUT_FACTOR = 1.25;
 106
 107     private static final int SNAP_WIDTH = 2;
 108
 109     private static final int NO_STATUS = -1;
 110
 111     /** Resource manager */
 112     private LocalResourceManager fResourceManager = new LocalResourceManager(JFaceResources.getResources());
 113
 114     /** Color map for event types */
 115     private Color[] fEventColorMap = null;
 116
 117     private ITimeDataProvider fTimeProvider;
 118     private IStatusLineManager fStatusLineManager = null;
 119     private TimeGraphScale fTimeGraphScale = null;
 120
 121     private boolean fIsInFocus = false;
 122     private boolean fMouseOverSplitLine = false;
 123     private int fGlobalItemHeight = CUSTOM_ITEM_HEIGHT;
 124     private int fMinimumItemWidth = 0;
 125     private int fTopIndex = 0;
 126     private int fDragState = DRAG_NONE;
 127     private int fDragButton;
 128     private int fDragX0 = 0;
 129     private int fDragX = 0;
 130     private long fDragTime0 = 0; // used to preserve accuracy of modified selection
 131     private int fIdealNameSpace = 0;
 132     private long fTime0bak;
 133     private long fTime1bak;
 134     private ITimeGraphPresentationProvider fTimeGraphProvider = null;
 135     private ItemData fItemData = null;
 136     private List<SelectionListener> fSelectionListeners;
 137     private final List<ISelectionChangedListener> fSelectionChangedListeners = new ArrayList<>();
 138     private final List<ITimeGraphTreeListener> fTreeListeners = new ArrayList<>();
 139     private final List<MenuDetectListener> fTimeGraphEntryMenuListeners = new ArrayList<>();
 140     private final List<MenuDetectListener> fTimeEventMenuListeners = new ArrayList<>();
 141     private final Cursor fDragCursor = Display.getDefault().getSystemCursor(SWT.CURSOR_HAND);
 142     private final Cursor fResizeCursor = Display.getDefault().getSystemCursor(SWT.CURSOR_IBEAM);
 143     private final Cursor fWaitCursor = Display.getDefault().getSystemCursor(SWT.CURSOR_WAIT);
 144     private final Cursor fZoomCursor = Display.getDefault().getSystemCursor(SWT.CURSOR_SIZEWE);
 145     private final List<ViewerFilter> fFilters = new ArrayList<>();
 146     private MenuDetectEvent fPendingMenuDetectEvent = null;
 147     private boolean fHideArrows = false;
 148
 149     private int fBorderWidth = 0;
 150     private int fHeaderHeight = 0;
 151
 152     private Listener fMouseScrollFilterListener;
 153
 154     private MouseScrollNotifier fMouseScrollNotifier;
 155     private final Object fMouseScrollNotifierLock = new Object();
 156
 157     private class MouseScrollNotifier extends Thread {
 158         private static final long DELAY = 400L;
 159         private static final long POLLING_INTERVAL = 10L;
 160         private long fLastScrollTime = Long.MAX_VALUE;
 161
 162         @Override
 163         public void run() {
 164             while ((System.currentTimeMillis() - fLastScrollTime) < DELAY) {
 165                 try {
 166                     Thread.sleep(POLLING_INTERVAL);
 167                 } catch (Exception e) {
 168                     return;
 169                 }
 170             }
 171             if (!isInterrupted()) {
 172                 Display.getDefault().asyncExec(new Runnable() {
 173                     @Override
 174                     public void run() {
 175                         if (isDisposed()) {
 176                             return;
 177                         }
 178                         fTimeProvider.notifyStartFinishTime();
 179                     }
 180                 });
 181             }
 182             synchronized (fMouseScrollNotifierLock) {
 183                 fMouseScrollNotifier = null;
 184             }
 185         }
 186
 187         public void mouseScrolled() {
 188             fLastScrollTime = System.currentTimeMillis();
 189         }
 190     }
 191
 192     /**
 193      * Standard constructor
 194      *
 195      * @param parent
 196      *            The parent composite object
 197      * @param colors
 198      *            The color scheme to use
 199      */
 200     public TimeGraphControl(Composite parent, TimeGraphColorScheme colors) {
 201
 202         super(parent, colors, SWT.NO_BACKGROUND | SWT.H_SCROLL | SWT.DOUBLE_BUFFERED);
 203
 204         fItemData = new ItemData();
 205
 206         addFocusListener(this);
 207         addMouseListener(this);
 208         addMouseMoveListener(this);
 209         addMouseTrackListener(this);
 210         addMouseWheelListener(this);
 211         addTraverseListener(this);
 212         addKeyListener(this);
 213         addControlListener(this);
 214         addMenuDetectListener(this);
 215         ScrollBar scrollHor = getHorizontalBar();
 216
 217         if (scrollHor != null) {
 218             scrollHor.addSelectionListener(this);
 219         }
 220     }
 221
 222     @Override
 223     public void dispose() {
 224         super.dispose();
 225         fResourceManager.dispose();
 226     }
 227
 228     /**
 229      * Sets the timegraph provider used by this timegraph viewer.
 230      *
 231      * @param timeGraphProvider the timegraph provider
 232      */
 233     public void setTimeGraphProvider(ITimeGraphPresentationProvider timeGraphProvider) {
 234         fTimeGraphProvider = timeGraphProvider;
 235
 236         if (timeGraphProvider instanceof ITimeGraphPresentationProvider2) {
 237             ((ITimeGraphPresentationProvider2) timeGraphProvider).setDrawingHelper(this);
 238             ((ITimeGraphPresentationProvider2) timeGraphProvider).addColorListener(this);
 239         }
 240
 241         StateItem[] stateItems = fTimeGraphProvider.getStateTable();
 242         colorSettingsChanged(stateItems);
 243     }
 244
 245     /**
 246      * Gets the timegraph provider used by this timegraph viewer.
 247      *
 248      * @return the timegraph provider, or <code>null</code> if not set.
 249      * @since 3.0
 250      */
 251     public ITimeGraphPresentationProvider getTimeGraphProvider() {
 252         return fTimeGraphProvider;
 253     }
 254
 255     /**
 256      * Gets the color map used by this timegraph viewer.
 257      *
 258      * @return a color map, or <code>null</code> if not set.
 259      * @since 3.0
 260      */
 261     public Color[] getEventColorMap() {
 262         return fEventColorMap;
 263     }
 264
 265     /**
 266      * Assign the given time provider
 267      *
 268      * @param timeProvider
 269      *            The time provider
 270      */
 271     public void setTimeProvider(ITimeDataProvider timeProvider) {
 272         fTimeProvider = timeProvider;
 273         adjustScrolls();
 274         redraw();
 275     }
 276
 277     /**
 278      * Assign the status line manager
 279      *
 280      * @param statusLineManager
 281      *            The status line manager, or null to disable status line messages
 282      * @since 2.1
 283      */
 284     public void setStatusLineManager(IStatusLineManager statusLineManager) {
 285         if (fStatusLineManager != null && statusLineManager == null) {
 286             fStatusLineManager.setMessage(""); //$NON-NLS-1$
 287         }
 288         fStatusLineManager = statusLineManager;
 289     }
 290
 291     /**
 292      * Assign the time graph scale
 293      *
 294      * @param timeGraphScale
 295      *            The time graph scale
 296      * @since 2.1
 297      */
 298     public void setTimeGraphScale(TimeGraphScale timeGraphScale) {
 299         fTimeGraphScale = timeGraphScale;
 300     }
 301
 302     /**
 303      * Add a selection listener
 304      *
 305      * @param listener
 306      *            The listener to add
 307      */
 308     public void addSelectionListener(SelectionListener listener) {
 309         if (listener == null) {
 310             SWT.error(SWT.ERROR_NULL_ARGUMENT);
 311         }
 312         if (null == fSelectionListeners) {
 313             fSelectionListeners = new ArrayList<>();
 314         }
 315         fSelectionListeners.add(listener);
 316     }
 317
 318     /**
 319      * Remove a selection listener
 320      *
 321      * @param listener
 322      *            The listener to remove
 323      */
 324     public void removeSelectionListener(SelectionListener listener) {
 325         if (null != fSelectionListeners) {
 326             fSelectionListeners.remove(listener);
 327         }
 328     }
 329
 330     /**
 331      * Selection changed callback
 332      */
 333     public void fireSelectionChanged() {
 334         if (null != fSelectionListeners) {
 335             Iterator<SelectionListener> it = fSelectionListeners.iterator();
 336             while (it.hasNext()) {
 337                 SelectionListener listener = it.next();
 338                 listener.widgetSelected(null);
 339             }
 340         }
 341     }
 342
 343     /**
 344      * Default selection callback
 345      */
 346     public void fireDefaultSelection() {
 347         if (null != fSelectionListeners) {
 348             Iterator<SelectionListener> it = fSelectionListeners.iterator();
 349             while (it.hasNext()) {
 350                 SelectionListener listener = it.next();
 351                 listener.widgetDefaultSelected(null);
 352             }
 353         }
 354     }
 355
 356     /**
 357      * Get the traces in the model
 358      *
 359      * @return The array of traces
 360      */
 361     public ITimeGraphEntry[] getTraces() {
 362         return fItemData.getEntries();
 363     }
 364
 365     /**
 366      * Get the on/off trace filters
 367      *
 368      * @return The array of filters
 369      */
 370     public boolean[] getTraceFilter() {
 371         return fItemData.getEntryFilter();
 372     }
 373
 374     /**
 375      * Refresh the data for the thing
 376      */
 377     public void refreshData() {
 378         fItemData.refreshData();
 379         adjustScrolls();
 380         redraw();
 381     }
 382
 383     /**
 384      * Refresh data for the given traces
 385      *
 386      * @param traces
 387      *            The traces to refresh
 388      */
 389     public void refreshData(ITimeGraphEntry[] traces) {
 390         fItemData.refreshData(traces);
 391         adjustScrolls();
 392         redraw();
 393     }
 394
 395     /**
 396      * Refresh the links (arrows) of this widget
 397      *
 398      * @param events The link events to refresh
 399      * @since 2.1
 400      */
 401     public void refreshArrows(List<ILinkEvent> events) {
 402         fItemData.refreshArrows(events);
 403     }
 404
 405     /**
 406      * Adjust the scoll bars
 407      */
 408     public void adjustScrolls() {
 409         if (null == fTimeProvider) {
 410             getHorizontalBar().setValues(0, 1, 1, 1, 1, 1);
 411             return;
 412         }
 413
 414         // HORIZONTAL BAR
 415         // Visible window
 416         long time0 = fTimeProvider.getTime0();
 417         long time1 = fTimeProvider.getTime1();
 418         // Time boundaries
 419         long timeMin = fTimeProvider.getMinTime();
 420         long timeMax = fTimeProvider.getMaxTime();
 421
 422         long delta = timeMax - timeMin;
 423
 424         int timePos = 0;
 425         int thumb = H_SCROLLBAR_MAX;
 426
 427         if (delta != 0) {
 428             // Thumb size (page size)
 429             thumb = Math.max(1, (int) (H_SCROLLBAR_MAX * ((double) (time1 - time0) / delta)));
 430             // At the beginning of visible window
 431             timePos = (int) (H_SCROLLBAR_MAX * ((double) (time0 - timeMin) / delta));
 432         }
 433
 434         // position, minimum, maximum, thumb size, increment (half page)t, page
 435         // increment size (full page)
 436         getHorizontalBar().setValues(timePos, 0, H_SCROLLBAR_MAX, thumb, Math.max(1, thumb / 2), Math.max(2, thumb));
 437     }
 438
 439     boolean ensureVisibleItem(int idx, boolean redraw) {
 440         boolean changed = false;
 441         int index = idx;
 442         if (index < 0) {
 443             for (index = 0; index < fItemData.fExpandedItems.length; index++) {
 444                 if (fItemData.fExpandedItems[index].fSelected) {
 445                     break;
 446                 }
 447             }
 448         }
 449         if (index >= fItemData.fExpandedItems.length) {
 450             return changed;
 451         }
 452         if (index < fTopIndex) {
 453             setTopIndex(index);
 454             if (redraw) {
 455                 redraw();
 456             }
 457             changed = true;
 458         } else {
 459             int page = countPerPage();
 460             if (index >= fTopIndex + page) {
 461                 setTopIndex(index - page + 1);
 462                 if (redraw) {
 463                     redraw();
 464                 }
 465                 changed = true;
 466             }
 467         }
 468         return changed;
 469     }
 470
 471     /**
 472      * Assign the given index as the top one
 473      *
 474      * @param idx
 475      *            The index
 476      */
 477     public void setTopIndex(int idx) {
 478         int index = Math.min(idx, fItemData.fExpandedItems.length - countPerPage());
 479         index = Math.max(0,  index);
 480         fTopIndex = index;
 481         redraw();
 482     }
 483
 484     /**
 485      * Set the expanded state of a given entry
 486      *
 487      * @param entry
 488      *            The entry
 489      * @param expanded
 490      *            True if expanded, false if collapsed
 491      */
 492     public void setExpandedState(ITimeGraphEntry entry, boolean expanded) {
 493         Item item = fItemData.findItem(entry);
 494         if (item != null && item.fExpanded != expanded) {
 495             item.fExpanded = expanded;
 496             fItemData.updateExpandedItems();
 497             redraw();
 498         }
 499     }
 500
 501     /**
 502      * Collapses all nodes of the viewer's tree, starting with the root.
 503      *
 504      * @since 2.0
 505      */
 506     public void collapseAll() {
 507         for (Item item : fItemData.fItems) {
 508             item.fExpanded = false;
 509         }
 510         fItemData.updateExpandedItems();
 511         redraw();
 512     }
 513
 514     /**
 515      * Expands all nodes of the viewer's tree, starting with the root.
 516      *
 517      * @since 2.0
 518      */
 519     public void expandAll() {
 520         for (Item item : fItemData.fItems) {
 521             item.fExpanded = true;
 522         }
 523         fItemData.updateExpandedItems();
 524         redraw();
 525     }
 526
 527     /**
 528      * Add a tree listener
 529      *
 530      * @param listener
 531      *            The listener to add
 532      */
 533     public void addTreeListener(ITimeGraphTreeListener listener) {
 534         if (!fTreeListeners.contains(listener)) {
 535             fTreeListeners.add(listener);
 536         }
 537     }
 538
 539     /**
 540      * Remove a tree listener
 541      *
 542      * @param listener
 543      *            The listener to remove
 544      */
 545     public void removeTreeListener(ITimeGraphTreeListener listener) {
 546         if (fTreeListeners.contains(listener)) {
 547             fTreeListeners.remove(listener);
 548         }
 549     }
 550
 551     /**
 552      * Tree event callback
 553      *
 554      * @param entry
 555      *            The affected entry
 556      * @param expanded
 557      *            The expanded state (true for expanded, false for collapsed)
 558      */
 559     public void fireTreeEvent(ITimeGraphEntry entry, boolean expanded) {
 560         TimeGraphTreeExpansionEvent event = new TimeGraphTreeExpansionEvent(this, entry);
 561         for (ITimeGraphTreeListener listener : fTreeListeners) {
 562             if (expanded) {
 563                 listener.treeExpanded(event);
 564             } else {
 565                 listener.treeCollapsed(event);
 566             }
 567         }
 568     }
 569
 570     /**
 571      * Add a menu listener on {@link ITimeGraphEntry}s
 572      * @param listener
 573      *            The listener to add
 574      * @since 1.2
 575      */
 576     public void addTimeGraphEntryMenuListener(MenuDetectListener listener) {
 577         if (!fTimeGraphEntryMenuListeners.contains(listener)) {
 578             fTimeGraphEntryMenuListeners.add(listener);
 579         }
 580     }
 581
 582     /**
 583      * Remove a menu listener on {@link ITimeGraphEntry}s
 584      *
 585      * @param listener
 586      *            The listener to remove
 587      * @since 1.2
 588      */
 589     public void removeTimeGraphEntryMenuListener(MenuDetectListener listener) {
 590         if (fTimeGraphEntryMenuListeners.contains(listener)) {
 591             fTimeGraphEntryMenuListeners.remove(listener);
 592         }
 593     }
 594
 595     /**
 596      * Menu event callback on {@link ITimeGraphEntry}s
 597      *
 598      * @param event
 599      *            The MenuDetectEvent, with field {@link TypedEvent#data} set to the selected {@link ITimeGraphEntry}
 600      */
 601     private void fireMenuEventOnTimeGraphEntry(MenuDetectEvent event) {
 602         for (MenuDetectListener listener : fTimeGraphEntryMenuListeners) {
 603             listener.menuDetected(event);
 604         }
 605     }
 606
 607     /**
 608      * Add a menu listener on {@link ITimeEvent}s
 609      *
 610      * @param listener
 611      *            The listener to add
 612      * @since 1.2
 613      */
 614     public void addTimeEventMenuListener(MenuDetectListener listener) {
 615         if (!fTimeEventMenuListeners.contains(listener)) {
 616             fTimeEventMenuListeners.add(listener);
 617         }
 618     }
 619
 620     /**
 621      * Remove a menu listener on {@link ITimeEvent}s
 622      *
 623      * @param listener
 624      *            The listener to remove
 625      * @since 1.2
 626      */
 627     public void removeTimeEventMenuListener(MenuDetectListener listener) {
 628         if (fTimeEventMenuListeners.contains(listener)) {
 629             fTimeEventMenuListeners.remove(listener);
 630         }
 631     }
 632
 633     /**
 634      * Menu event callback on {@link ITimeEvent}s
 635      *
 636      * @param event
 637      *            The MenuDetectEvent, with field {@link TypedEvent#data} set to the selected {@link ITimeEvent}
 638      */
 639     private void fireMenuEventOnTimeEvent(MenuDetectEvent event) {
 640         for (MenuDetectListener listener : fTimeEventMenuListeners) {
 641             listener.menuDetected(event);
 642         }
 643     }
 644
 645     @Override
 646     public ISelection getSelection() {
 647         TimeGraphSelection sel = new TimeGraphSelection();
 648         ITimeGraphEntry trace = getSelectedTrace();
 649         if (null != trace && null != fTimeProvider) {
 650             long selectedTime = fTimeProvider.getSelectionBegin();
 651             ITimeEvent event = Utils.findEvent(trace, selectedTime, 0);
 652             if (event != null) {
 653                 sel.add(event);
 654             } else {
 655                 sel.add(trace);
 656             }
 657         }
 658         return sel;
 659     }
 660
 661     /**
 662      * Get the selection object
 663      *
 664      * @return The selection
 665      */
 666     public ISelection getSelectionTrace() {
 667         TimeGraphSelection sel = new TimeGraphSelection();
 668         ITimeGraphEntry trace = getSelectedTrace();
 669         if (null != trace) {
 670             sel.add(trace);
 671         }
 672         return sel;
 673     }
 674
 675     /**
 676      * Enable/disable one of the traces in the model
 677      *
 678      * @param n
 679      *            1 to enable it, -1 to disable. The method returns immediately
 680      *            if another value is used.
 681      */
 682     public void selectTrace(int n) {
 683         if ((n != 1) && (n != -1)) {
 684             return;
 685         }
 686
 687         boolean changed = false;
 688         int lastSelection = -1;
 689         for (int i = 0; i < fItemData.fExpandedItems.length; i++) {
 690             Item item = fItemData.fExpandedItems[i];
 691             if (item.fSelected) {
 692                 lastSelection = i;
 693                 if ((1 == n) && (i < fItemData.fExpandedItems.length - 1)) {
 694                     item.fSelected = false;
 695                     item = fItemData.fExpandedItems[i + 1];
 696                     item.fSelected = true;
 697                     changed = true;
 698                 } else if ((-1 == n) && (i > 0)) {
 699                     item.fSelected = false;
 700                     item = fItemData.fExpandedItems[i - 1];
 701                     item.fSelected = true;
 702                     changed = true;
 703                 }
 704                 break;
 705             }
 706         }
 707
 708         if (lastSelection < 0 && fItemData.fExpandedItems.length > 0) {
 709             Item item = fItemData.fExpandedItems[0];
 710             item.fSelected = true;
 711             changed = true;
 712         }
 713
 714         if (changed) {
 715             ensureVisibleItem(-1, false);
 716             redraw();
 717             fireSelectionChanged();
 718         }
 719     }
 720
 721     /**
 722      * Select an event
 723      *
 724      * @param n
 725      *            1 for next event, -1 for previous event
 726      */
 727     public void selectEvent(int n) {
 728         if (null == fTimeProvider) {
 729             return;
 730         }
 731         ITimeGraphEntry trace = getSelectedTrace();
 732         if (trace == null) {
 733             return;
 734         }
 735         long selectedTime = fTimeProvider.getSelectionBegin();
 736         long endTime = fTimeProvider.getEndTime();
 737         ITimeEvent nextEvent;
 738         if (-1 == n && selectedTime > endTime) {
 739             nextEvent = Utils.findEvent(trace, selectedTime, 0);
 740         } else {
 741             nextEvent = Utils.findEvent(trace, selectedTime, n);
 742         }
 743         if (null == nextEvent && -1 == n) {
 744             nextEvent = Utils.getFirstEvent(trace);
 745         }
 746         if (null != nextEvent) {
 747             long nextTime = nextEvent.getTime();
 748             // If last event detected e.g. going back or not moving to a next
 749             // event
 750             if (nextTime <= selectedTime && n == 1) {
 751                 // Select to the end of this last event
 752                 nextTime = nextEvent.getTime() + nextEvent.getDuration();
 753                 // but not beyond the end of the trace
 754                 if (nextTime > endTime) {
 755                     nextTime = endTime;
 756                 }
 757             } else if (n == -1 && nextEvent.getTime() + nextEvent.getDuration() < selectedTime) {
 758                 // for previous event go to its end time unless we were already there
 759                 nextTime = nextEvent.getTime() + nextEvent.getDuration();
 760             }
 761             fTimeProvider.setSelectedTimeNotify(nextTime, true);
 762             fireSelectionChanged();
 763         } else if (1 == n) {
 764             fTimeProvider.setSelectedTimeNotify(endTime, true);
 765             fireSelectionChanged();
 766         }
 767     }
 768
 769     /**
 770      * Select the next event
 771      */
 772     public void selectNextEvent() {
 773         selectEvent(1);
 774         // Notify if visible time window has been adjusted
 775         fTimeProvider.setStartFinishTimeNotify(fTimeProvider.getTime0(), fTimeProvider.getTime1());
 776     }
 777
 778     /**
 779      * Select the previous event
 780      */
 781     public void selectPrevEvent() {
 782         selectEvent(-1);
 783         // Notify if visible time window has been adjusted
 784         fTimeProvider.setStartFinishTimeNotify(fTimeProvider.getTime0(), fTimeProvider.getTime1());
 785     }
 786
 787     /**
 788      * Select the next trace
 789      */
 790     public void selectNextTrace() {
 791         selectTrace(1);
 792     }
 793
 794     /**
 795      * Select the previous trace
 796      */
 797     public void selectPrevTrace() {
 798         selectTrace(-1);
 799     }
 800
 801     /**
 802      * Zoom based on mouse cursor location with mouse scrolling
 803      *
 804      * @param zoomIn true to zoom in, false to zoom out
 805      */
 806     public void zoom(boolean zoomIn) {
 807         int globalX = getDisplay().getCursorLocation().x;
 808         Point p = toControl(globalX, 0);
 809         int nameSpace = fTimeProvider.getNameSpace();
 810         int timeSpace = fTimeProvider.getTimeSpace();
 811         int xPos = Math.max(nameSpace, Math.min(nameSpace + timeSpace, p.x));
 812         long time0 = fTimeProvider.getTime0();
 813         long time1 = fTimeProvider.getTime1();
 814         long interval = time1 - time0;
 815         if (interval == 0) {
 816             interval = 1;
 817         } // to allow getting out of single point interval
 818         long newInterval;
 819         if (zoomIn) {
 820             newInterval = Math.max(Math.round(interval * ZOOM_IN_FACTOR), fTimeProvider.getMinTimeInterval());
 821         } else {
 822             newInterval = (long) Math.ceil(interval * ZOOM_OUT_FACTOR);
 823         }
 824         long center = time0 + Math.round(((double) (xPos - nameSpace) / timeSpace * interval));
 825         long newTime0 = center - Math.round((double) newInterval * (center - time0) / interval);
 826         long newTime1 = newTime0 + newInterval;
 827         fTimeProvider.setStartFinishTime(newTime0, newTime1);
 828         synchronized (fMouseScrollNotifierLock) {
 829             if (fMouseScrollNotifier == null) {
 830                 fMouseScrollNotifier = new MouseScrollNotifier();
 831                 fMouseScrollNotifier.start();
 832             }
 833             fMouseScrollNotifier.mouseScrolled();
 834         }
 835     }
 836
 837     /**
 838      * zoom in using single click
 839      */
 840     public void zoomIn() {
 841         long prevTime0 = fTimeProvider.getTime0();
 842         long prevTime1 = fTimeProvider.getTime1();
 843         long prevRange = prevTime1 - prevTime0;
 844         if (prevRange == 0) {
 845             return;
 846         }
 847         ITimeDataProvider provider = fTimeProvider;
 848         long selTime = (provider.getSelectionEnd() + provider.getSelectionBegin()) / 2;
 849         if (selTime <= prevTime0 || selTime >= prevTime1) {
 850             selTime = (prevTime0 + prevTime1) / 2;
 851         }
 852         long time0 = selTime - (long) ((selTime - prevTime0) / ZOOM_FACTOR);
 853         long time1 = selTime + (long) ((prevTime1 - selTime) / ZOOM_FACTOR);
 854
 855         long inaccuracy = (fTimeProvider.getMaxTime() - fTimeProvider.getMinTime()) - (time1 - time0);
 856
 857         if (inaccuracy > 0 && inaccuracy < 100) {
 858             fTimeProvider.setStartFinishTimeNotify(fTimeProvider.getMinTime(), fTimeProvider.getMaxTime());
 859             return;
 860         }
 861
 862         long min = fTimeProvider.getMinTimeInterval();
 863         if ((time1 - time0) < min) {
 864             time0 = selTime - (selTime - prevTime0) * min / prevRange;
 865             time1 = time0 + min;
 866         }
 867
 868         fTimeProvider.setStartFinishTimeNotify(time0, time1);
 869     }
 870
 871     /**
 872      * zoom out using single click
 873      */
 874     public void zoomOut() {
 875         long prevTime0 = fTimeProvider.getTime0();
 876         long prevTime1 = fTimeProvider.getTime1();
 877         ITimeDataProvider provider = fTimeProvider;
 878         long selTime = (provider.getSelectionEnd() + provider.getSelectionBegin()) / 2;
 879         if (selTime <= prevTime0 || selTime >= prevTime1) {
 880             selTime = (prevTime0 + prevTime1) / 2;
 881         }
 882         long time0 = (long) (selTime - (selTime - prevTime0) * ZOOM_FACTOR);
 883         long time1 = (long) (selTime + (prevTime1 - selTime) * ZOOM_FACTOR);
 884
 885         long inaccuracy = (fTimeProvider.getMaxTime() - fTimeProvider.getMinTime()) - (time1 - time0);
 886         if (inaccuracy > 0 && inaccuracy < 100) {
 887             fTimeProvider.setStartFinishTimeNotify(fTimeProvider.getMinTime(), fTimeProvider.getMaxTime());
 888             return;
 889         }
 890
 891         fTimeProvider.setStartFinishTimeNotify(time0, time1);
 892     }
 893
 894     /**
 895      * Hide arrows
 896      *
 897      * @param hideArrows true to hide arrows
 898      *
 899      * @since 2.1
 900      */
 901     public void hideArrows(boolean hideArrows) {
 902         fHideArrows = hideArrows;
 903     }
 904
 905     /**
 906      * Follow the arrow forward
 907      *
 908      * @since 2.1
 909      */
 910     public void followArrowFwd() {
 911         ITimeGraphEntry trace = getSelectedTrace();
 912         if (trace == null) {
 913             return;
 914         }
 915         long selectedTime = fTimeProvider.getSelectionBegin();
 916         for (ILinkEvent link : fItemData.fLinks) {
 917             if (link.getEntry() == trace && link.getTime() == selectedTime) {
 918                 selectItem(link.getDestinationEntry(), false);
 919                 if (link.getDuration() != 0) {
 920                     fTimeProvider.setSelectedTimeNotify(link.getTime() + link.getDuration(), true);
 921                     // Notify if visible time window has been adjusted
 922                     fTimeProvider.setStartFinishTimeNotify(fTimeProvider.getTime0(), fTimeProvider.getTime1());
 923                 }
 924                 fireSelectionChanged();
 925                 return;
 926             }
 927         }
 928         selectNextEvent();
 929     }
 930
 931     /**
 932      * Follow the arrow backward
 933      *
 934      * @since 2.1
 935      */
 936     public void followArrowBwd() {
 937         ITimeGraphEntry trace = getSelectedTrace();
 938         if (trace == null) {
 939             return;
 940         }
 941         long selectedTime = fTimeProvider.getSelectionBegin();
 942         for (ILinkEvent link : fItemData.fLinks) {
 943             if (link.getDestinationEntry() == trace && link.getTime() + link.getDuration() == selectedTime) {
 944                 selectItem(link.getEntry(), false);
 945                 if (link.getDuration() != 0) {
 946                     fTimeProvider.setSelectedTimeNotify(link.getTime(), true);
 947                     // Notify if visible time window has been adjusted
 948                     fTimeProvider.setStartFinishTimeNotify(fTimeProvider.getTime0(), fTimeProvider.getTime1());
 949                 }
 950                 fireSelectionChanged();
 951                 return;
 952             }
 953         }
 954         selectPrevEvent();
 955     }
 956
 957     /**
 958      * Return the currently selected trace
 959      *
 960      * @return The entry matching the trace
 961      */
 962     public ITimeGraphEntry getSelectedTrace() {
 963         ITimeGraphEntry trace = null;
 964         int idx = getSelectedIndex();
 965         if (idx >= 0) {
 966             trace = fItemData.fExpandedItems[idx].fEntry;
 967         }
 968         return trace;
 969     }
 970
 971     /**
 972      * Retrieve the index of the currently selected item
 973      *
 974      * @return The index
 975      */
 976     public int getSelectedIndex() {
 977         int idx = -1;
 978         for (int i = 0; i < fItemData.fExpandedItems.length; i++) {
 979             Item item = fItemData.fExpandedItems[i];
 980             if (item.fSelected) {
 981                 idx = i;
 982                 break;
 983             }
 984         }
 985         return idx;
 986     }
 987
 988     boolean toggle(int idx) {
 989         boolean toggled = false;
 990         if (idx >= 0 && idx < fItemData.fExpandedItems.length) {
 991             Item item = fItemData.fExpandedItems[idx];
 992             if (item.fHasChildren) {
 993                 item.fExpanded = !item.fExpanded;
 994                 fItemData.updateExpandedItems();
 995                 adjustScrolls();
 996                 redraw();
 997                 toggled = true;
 998                 fireTreeEvent(item.fEntry, item.fExpanded);
 999             }
1000         }
1001         return toggled;
1002     }
1003
1004     /**
1005      * Gets the index of the item at the given location.
1006      *
1007      * @param y
1008      *            the y coordinate
1009      * @return the index of the item at the given location, of -1 if none.
1010      * @since 3.0
1011      */
1012     protected int getItemIndexAtY(int y) {
1013         if (y < 0) {
1014             return -1;
1015         }
1016         int ySum = 0;
1017         for (int idx = fTopIndex; idx < fItemData.fExpandedItems.length; idx++) {
1018             ySum += fItemData.fExpandedItems[idx].fItemHeight;
1019             if (y < ySum) {
1020                 return idx;
1021             }
1022         }
1023         return -1;
1024     }
1025
1026     boolean isOverSplitLine(int x) {
1027         if (x < 0 || null == fTimeProvider) {
1028             return false;
1029         }
1030         int nameWidth = fTimeProvider.getNameSpace();
1031         return Math.abs(x - nameWidth) < SNAP_WIDTH;
1032     }
1033
1034     /**
1035      * Gets the {@link ITimeGraphEntry} at the given location.
1036      *
1037      * @param pt
1038      *            a point in the widget
1039      * @return the {@link ITimeGraphEntry} at this point, or <code>null</code>
1040      *         if none.
1041      * @since 3.0
1042      */
1043     protected ITimeGraphEntry getEntry(Point pt) {
1044         int idx = getItemIndexAtY(pt.y);
1045         return idx >= 0 ? fItemData.fExpandedItems[idx].fEntry : null;
1046     }
1047
1048     /**
1049      * @since 2.0
1050      */
1051     @Override
1052     public int getXForTime(long time) {
1053         if (null == fTimeProvider) {
1054             return -1;
1055         }
1056         long time0 = fTimeProvider.getTime0();
1057         long time1 = fTimeProvider.getTime1();
1058         int width = getCtrlSize().x;
1059         int nameSpace = fTimeProvider.getNameSpace();
1060         double pixelsPerNanoSec = (width - nameSpace <= RIGHT_MARGIN) ? 0 : (double) (width - nameSpace - RIGHT_MARGIN) / (time1 - time0);
1061         int x = getBounds().x + nameSpace + (int) ((time - time0) * pixelsPerNanoSec);
1062         return x;
1063     }
1064
1065     /**
1066      * @since 2.0
1067      */
1068     @Override
1069     public long getTimeAtX(int coord) {
1070         if (null == fTimeProvider) {
1071             return -1;
1072         }
1073         long hitTime = -1;
1074         Point size = getCtrlSize();
1075         long time0 = fTimeProvider.getTime0();
1076         long time1 = fTimeProvider.getTime1();
1077         int nameWidth = fTimeProvider.getNameSpace();
1078         final int x = coord - nameWidth;
1079         int timeWidth = size.x - nameWidth - RIGHT_MARGIN;
1080         if (x >= 0 && size.x >= nameWidth) {
1081             if (time1 - time0 > timeWidth) {
1082                 // nanosecond smaller than one pixel: use the first integer nanosecond of this pixel's time range
1083                 hitTime = time0 + (long) Math.ceil((time1 - time0) * ((double) x / timeWidth));
1084             } else {
1085                 // nanosecond greater than one pixel: use the nanosecond that covers this pixel start position
1086                 hitTime = time0 + (long) Math.floor((time1 - time0) * ((double) x / timeWidth));
1087             }
1088         }
1089         return hitTime;
1090     }
1091
1092     void selectItem(int idx, boolean addSelection) {
1093         boolean changed = false;
1094         if (addSelection) {
1095             if (idx >= 0 && idx < fItemData.fExpandedItems.length) {
1096                 Item item = fItemData.fExpandedItems[idx];
1097                 changed = !item.fSelected;
1098                 item.fSelected = true;
1099             }
1100         } else {
1101             for (int i = 0; i < fItemData.fExpandedItems.length; i++) {
1102                 Item item = fItemData.fExpandedItems[i];
1103                 if ((i == idx && !item.fSelected) || (idx == -1 && item.fSelected)) {
1104                     changed = true;
1105                 }
1106                 item.fSelected = i == idx;
1107             }
1108         }
1109         changed |= ensureVisibleItem(idx, true);
1110         if (changed) {
1111             redraw();
1112         }
1113     }
1114
1115     /**
1116      * Callback for item selection
1117      *
1118      * @param trace
1119      *            The entry matching the trace
1120      * @param addSelection
1121      *            If the selection is added or removed
1122      */
1123     public void selectItem(ITimeGraphEntry trace, boolean addSelection) {
1124         int idx = fItemData.findItemIndex(trace);
1125         selectItem(idx, addSelection);
1126     }
1127
1128     /**
1129      * Retrieve the number of entries shown per page.
1130      *
1131      * @return The count
1132      */
1133     public int countPerPage() {
1134         int height = getCtrlSize().y;
1135         int count = 0;
1136         int ySum = 0;
1137         for (int idx = fTopIndex; idx < fItemData.fExpandedItems.length; idx++) {
1138             ySum += fItemData.fExpandedItems[idx].fItemHeight;
1139             if (ySum >= height) {
1140                 return count;
1141             }
1142             count++;
1143         }
1144         for (int idx = fTopIndex - 1; idx >= 0; idx--) {
1145             ySum += fItemData.fExpandedItems[idx].fItemHeight;
1146             if (ySum >= height) {
1147                 return count;
1148             }
1149             count++;
1150         }
1151         return count;
1152     }
1153
1154     /**
1155      * Get the index of the top element
1156      *
1157      * @return The index
1158      */
1159     public int getTopIndex() {
1160         return fTopIndex;
1161     }
1162
1163     /**
1164      * Get the number of expanded items
1165      *
1166      * @return The count of expanded items
1167      */
1168     public int getExpandedElementCount() {
1169         return fItemData.fExpandedItems.length;
1170     }
1171
1172     /**
1173      * Get an array of all expanded elements
1174      *
1175      * @return The expanded elements
1176      */
1177     public ITimeGraphEntry[] getExpandedElements() {
1178         ArrayList<ITimeGraphEntry> elements = new ArrayList<>();
1179         for (Item item : fItemData.fExpandedItems) {
1180             elements.add(item.fEntry);
1181         }
1182         return elements.toArray(new ITimeGraphEntry[0]);
1183     }
1184
1185     Point getCtrlSize() {
1186         Point size = getSize();
1187         if (getHorizontalBar().isVisible()) {
1188             size.y -= getHorizontalBar().getSize().y;
1189         }
1190         return size;
1191     }
1192
1193     Rectangle getNameRect(Rectangle bound, int idx, int nameWidth) {
1194         Rectangle rect = getStatesRect(bound, idx, nameWidth);
1195         rect.x = bound.x;
1196         rect.width = nameWidth;
1197         return rect;
1198     }
1199
1200     Rectangle getStatesRect(Rectangle bound, int idx, int nameWidth) {
1201         int x = bound.x + nameWidth;
1202         int width = bound.width - x;
1203         int ySum = 0;
1204         if (idx >= fTopIndex) {
1205             for (int i = fTopIndex; i < idx; i++) {
1206                 ySum += fItemData.fExpandedItems[i].fItemHeight;
1207             }
1208         } else {
1209             for (int i = fTopIndex - 1; i >= idx; i--) {
1210                 ySum -= fItemData.fExpandedItems[i].fItemHeight;
1211             }
1212         }
1213         int y = bound.y + ySum;
1214         int height = fItemData.fExpandedItems[idx].fItemHeight;
1215         return new Rectangle(x, y, width, height);
1216     }
1217
1218     @Override
1219     void paint(Rectangle bounds, PaintEvent e) {
1220         GC gc = e.gc;
1221         gc.setBackground(getColorScheme().getColor(TimeGraphColorScheme.BACKGROUND));
1222         drawBackground(gc, bounds.x, bounds.y, bounds.width, bounds.height);
1223
1224         if (bounds.width < 2 || bounds.height < 2 || null == fTimeProvider) {
1225             return;
1226         }
1227
1228         fIdealNameSpace = 0;
1229         int nameSpace = fTimeProvider.getNameSpace();
1230
1231         // draw empty name space background
1232         gc.setBackground(getColorScheme().getBkColor(false, false, true));
1233         drawBackground(gc, bounds.x, bounds.y, nameSpace, bounds.height);
1234
1235         // draw items
1236         drawItems(bounds, fTimeProvider, fItemData.fExpandedItems, fTopIndex, nameSpace, gc);
1237         drawLinks(bounds, fTimeProvider, fItemData.fLinks, nameSpace, gc);
1238         fTimeGraphProvider.postDrawControl(bounds, gc);
1239
1240         int alpha = gc.getAlpha();
1241         gc.setAlpha(100);
1242
1243         long time0 = fTimeProvider.getTime0();
1244         long time1 = fTimeProvider.getTime1();
1245         long selectionBegin = fTimeProvider.getSelectionBegin();
1246         long selectionEnd = fTimeProvider.getSelectionEnd();
1247         double pixelsPerNanoSec = (bounds.width - nameSpace <= RIGHT_MARGIN) ? 0 : (double) (bounds.width - nameSpace - RIGHT_MARGIN) / (time1 - time0);
1248         int x0 = bounds.x + nameSpace + (int) ((selectionBegin - time0) * pixelsPerNanoSec);
1249         int x1 = bounds.x + nameSpace + (int) ((selectionEnd - time0) * pixelsPerNanoSec);
1250
1251         // draw selection lines
1252         if (fDragState != DRAG_SELECTION) {
1253             gc.setForeground(getColorScheme().getColor(TimeGraphColorScheme.SELECTED_TIME));
1254             if (x0 >= nameSpace && x0 < bounds.x + bounds.width) {
1255                 gc.drawLine(x0, bounds.y, x0, bounds.y + bounds.height);
1256             }
1257             if (x1 != x0) {
1258                 if (x1 >= nameSpace && x1 < bounds.x + bounds.width) {
1259                     gc.drawLine(x1, bounds.y, x1, bounds.y + bounds.height);
1260                 }
1261             }
1262         }
1263
1264         // draw selection background
1265         if (selectionBegin != 0 && selectionEnd != 0 && fDragState != DRAG_SELECTION) {
1266             x0 = Math.max(nameSpace, Math.min(bounds.x + bounds.width, x0));
1267             x1 = Math.max(nameSpace, Math.min(bounds.x + bounds.width, x1));
1268             gc.setBackground(getColorScheme().getBkColor(false, false, true));
1269             if (x1 - x0 > 1) {
1270                 gc.fillRectangle(new Rectangle(x0 + 1, bounds.y, x1 - x0 - 1, bounds.height));
1271             } else if (x0 - x1 > 1) {
1272                 gc.fillRectangle(new Rectangle(x1 + 1, bounds.y, x0 - x1 - 1, bounds.height));
1273             }
1274         }
1275
1276         // draw drag selection background
1277         if (fDragState == DRAG_ZOOM || fDragState == DRAG_SELECTION) {
1278             gc.setBackground(getColorScheme().getBkColor(false, false, true));
1279             if (fDragX0 < fDragX) {
1280                 gc.fillRectangle(new Rectangle(fDragX0, bounds.y, fDragX - fDragX0, bounds.height));
1281             } else if (fDragX0 > fDragX) {
1282                 gc.fillRectangle(new Rectangle(fDragX, bounds.y, fDragX0 - fDragX, bounds.height));
1283             }
1284         }
1285
1286         // draw drag line
1287         if (DRAG_SPLIT_LINE == fDragState) {
1288             gc.setForeground(getColorScheme().getColor(TimeGraphColorScheme.BLACK));
1289             gc.drawLine(bounds.x + nameSpace, bounds.y, bounds.x + nameSpace, bounds.y + bounds.height - 1);
1290         } else if (DRAG_ZOOM == fDragState && Math.max(fDragX, fDragX0) > nameSpace) {
1291             gc.setForeground(getColorScheme().getColor(TimeGraphColorScheme.TOOL_FOREGROUND));
1292             gc.drawLine(fDragX0, bounds.y, fDragX0, bounds.y + bounds.height - 1);
1293             if (fDragX != fDragX0) {
1294                 gc.drawLine(fDragX, bounds.y, fDragX, bounds.y + bounds.height - 1);
1295             }
1296         } else if (DRAG_SELECTION == fDragState && Math.max(fDragX, fDragX0) > nameSpace) {
1297             gc.setForeground(getColorScheme().getColor(TimeGraphColorScheme.SELECTED_TIME));
1298             gc.drawLine(fDragX0, bounds.y, fDragX0, bounds.y + bounds.height - 1);
1299             if (fDragX != fDragX0) {
1300                 gc.drawLine(fDragX, bounds.y, fDragX, bounds.y + bounds.height - 1);
1301             }
1302         } else if (DRAG_NONE == fDragState && fMouseOverSplitLine && fTimeProvider.getNameSpace() > 0) {
1303             gc.setForeground(getColorScheme().getColor(TimeGraphColorScheme.RED));
1304             gc.drawLine(bounds.x + nameSpace, bounds.y, bounds.x + nameSpace, bounds.y + bounds.height - 1);
1305         }
1306
1307         gc.setAlpha(alpha);
1308     }
1309
1310     /**
1311      * Draw many items at once
1312      *
1313      * @param bounds
1314      *            The rectangle of the area
1315      * @param timeProvider
1316      *            The time provider
1317      * @param items
1318      *            The array items to draw
1319      * @param topIndex
1320      *            The index of the first element to draw
1321      * @param nameSpace
1322      *            The width reserved for the names
1323      * @param gc
1324      *            Reference to the SWT GC object
1325      */
1326     public void drawItems(Rectangle bounds, ITimeDataProvider timeProvider,
1327             Item[] items, int topIndex, int nameSpace, GC gc) {
1328         for (int i = topIndex; i < items.length; i++) {
1329             Item item = items[i];
1330             drawItem(item, bounds, timeProvider, i, nameSpace, gc);
1331         }
1332     }
1333
1334     /**
1335      * Draws the item
1336      *
1337      * @param item the item to draw
1338      * @param bounds the container rectangle
1339      * @param timeProvider Time provider
1340      * @param i the item index
1341      * @param nameSpace the name space
1342      * @param gc Graphics context
1343      */
1344     protected void drawItem(Item item, Rectangle bounds, ITimeDataProvider timeProvider, int i, int nameSpace, GC gc) {
1345         ITimeGraphEntry entry = item.fEntry;
1346         long time0 = timeProvider.getTime0();
1347         long time1 = timeProvider.getTime1();
1348         long selectedTime = fTimeProvider.getSelectionBegin();
1349
1350         Rectangle nameRect = getNameRect(bounds, i, nameSpace);
1351         if (nameRect.y >= bounds.y + bounds.height) {
1352             return;
1353         }
1354
1355         if (! item.fEntry.hasTimeEvents()) {
1356             Rectangle statesRect = getStatesRect(bounds, i, nameSpace);
1357             nameRect.width += statesRect.width;
1358             drawName(item, nameRect, gc);
1359         } else {
1360             drawName(item, nameRect, gc);
1361         }
1362         Rectangle rect = getStatesRect(bounds, i, nameSpace);
1363         if (rect.isEmpty()) {
1364             fTimeGraphProvider.postDrawEntry(entry, rect, gc);
1365             return;
1366         }
1367         if (time1 <= time0) {
1368             gc.setBackground(getColorScheme().getBkColor(false, false, false));
1369             gc.fillRectangle(rect);
1370             fTimeGraphProvider.postDrawEntry(entry, rect, gc);
1371             return;
1372         }
1373
1374         // Initialize _rect1 to same values as enclosing rectangle rect
1375         Rectangle stateRect = Utils.clone(rect);
1376         boolean selected = item.fSelected;
1377         // K pixels per second
1378         double pixelsPerNanoSec = (rect.width <= RIGHT_MARGIN) ? 0 : (double) (rect.width - RIGHT_MARGIN) / (time1 - time0);
1379
1380         if (item.fEntry.hasTimeEvents()) {
1381             fillSpace(rect, gc, selected);
1382             // Drawing rectangle is smaller than reserved space
1383             stateRect.y += 3;
1384             stateRect.height -= 6;
1385
1386             long maxDuration = (timeProvider.getTimeSpace() == 0) ? Long.MAX_VALUE : 1 * (time1 - time0) / timeProvider.getTimeSpace();
1387             Iterator<ITimeEvent> iterator = entry.getTimeEventsIterator(time0, time1, maxDuration);
1388
1389             int lastX = -1;
1390             while (iterator.hasNext()) {
1391                 ITimeEvent event = iterator.next();
1392                 int x = rect.x + (int) ((event.getTime() - time0) * pixelsPerNanoSec);
1393                 int xEnd = rect.x + (int) ((event.getTime() + event.getDuration() - time0) * pixelsPerNanoSec);
1394                 if (x >= rect.x + rect.width || xEnd < rect.x) {
1395                     // event is out of bounds
1396                     continue;
1397                 }
1398                 xEnd = Math.min(rect.x + rect.width, xEnd);
1399                 stateRect.x = Math.max(rect.x, x);
1400                 stateRect.width = Math.max(0, xEnd - stateRect.x + 1);
1401                 if (stateRect.x == lastX) {
1402                     stateRect.width -= 1;
1403                     if (stateRect.width > 0) {
1404                         gc.setForeground(Display.getDefault().getSystemColor(SWT.COLOR_BLACK));
1405                         gc.drawPoint(stateRect.x, stateRect.y - 2);
1406                         stateRect.x += 1;
1407                     }
1408                 }
1409                 boolean timeSelected = selectedTime >= event.getTime() && selectedTime < event.getTime() + event.getDuration();
1410                 if (drawState(getColorScheme(), event, stateRect, gc, selected, timeSelected)) {
1411                     lastX = x;
1412                 }
1413             }
1414         }
1415         fTimeGraphProvider.postDrawEntry(entry, rect, gc);
1416     }
1417
1418     /**
1419      * Draw the links
1420      *
1421      * @param bounds
1422      *            The rectangle of the area
1423      * @param timeProvider
1424      *            The time provider
1425      * @param links
1426      *            The array items to draw
1427      * @param nameSpace
1428      *            The width reserved for the names
1429      * @param gc
1430      *            Reference to the SWT GC object
1431      * @since 2.1
1432      */
1433     public void drawLinks(Rectangle bounds, ITimeDataProvider timeProvider,
1434             List<ILinkEvent> links, int nameSpace, GC gc) {
1435         if (fHideArrows) {
1436             return;
1437         }
1438         for (ILinkEvent event : links) {
1439             drawLink(event, bounds, timeProvider, nameSpace, gc);
1440         }
1441     }
1442
1443     /**
1444      * Draws the link type events of this item
1445      *
1446      * @param event
1447      *            the item to draw
1448      * @param bounds
1449      *            the container rectangle
1450      * @param timeProvider
1451      *            Time provider
1452      * @param nameSpace
1453      *            the name space
1454      * @param gc
1455      *            Graphics context
1456      * @since 2.1
1457      */
1458     protected void drawLink(ILinkEvent event, Rectangle bounds, ITimeDataProvider timeProvider, int nameSpace, GC gc) {
1459         int srcIndex = fItemData.findItemIndex(event.getEntry());
1460         int destIndex = fItemData.findItemIndex(event.getDestinationEntry());
1461
1462         if ((srcIndex == -1) || (destIndex == -1)) {
1463             return;
1464         }
1465
1466         Rectangle src = getStatesRect(bounds, srcIndex, nameSpace);
1467         Rectangle dst = getStatesRect(bounds, destIndex, nameSpace);
1468
1469         int x0 = getXForTime(event.getTime());
1470         int x1 = getXForTime(event.getTime() + event.getDuration());
1471
1472         // limit the x-coordinates to prevent integer overflow in calculations
1473         // and also GC.drawLine doesn't draw properly with large coordinates
1474         final int limit = Integer.MAX_VALUE / 1024;
1475         x0 = Math.max(-limit, Math.min(x0, limit));
1476         x1 = Math.max(-limit, Math.min(x1, limit));
1477
1478         int y0 = src.y + src.height / 2;
1479         int y1 = dst.y + dst.height / 2;
1480         drawArrow(getColorScheme(), event, new Rectangle(x0, y0, x1 - x0, y1 - y0), gc);
1481     }
1482
1483     /**
1484      * Draw the state (color fill)
1485      *
1486      * @param colors
1487      *            Color scheme
1488      * @param event
1489      *            Time event for which we're drawing the state
1490      * @param rect
1491      *            Where to draw
1492      * @param gc
1493      *            Graphics context
1494      * @return true if the state was drawn
1495      * @since 2.1
1496      */
1497     protected boolean drawArrow(TimeGraphColorScheme colors, ITimeEvent event,
1498             Rectangle rect, GC gc) {
1499
1500         int colorIdx = fTimeGraphProvider.getStateTableIndex(event);
1501         if (colorIdx < 0) {
1502             return false;
1503         }
1504         boolean visible = ((rect.height == 0) && (rect.width == 0)) ? false : true;
1505
1506         if (visible) {
1507             Color stateColor = null;
1508             if (colorIdx < fEventColorMap.length) {
1509                 stateColor = fEventColorMap[colorIdx];
1510             } else {
1511                 stateColor = Display.getDefault().getSystemColor(SWT.COLOR_BLACK);
1512             }
1513
1514             gc.setForeground(stateColor);
1515             gc.setBackground(stateColor);
1516
1517             /* Draw the arrow */
1518             gc.drawLine(rect.x, rect.y, rect.x + rect.width, rect.y + rect.height);
1519             drawArrowHead(rect.x, rect.y, rect.x + rect.width, rect.y + rect.height, gc);
1520
1521         }
1522         fTimeGraphProvider.postDrawEvent(event, rect, gc);
1523         return visible;
1524     }
1525
1526     /*
1527      * @author Francis Giraldeau
1528      *
1529      * Inspiration:
1530      * http://stackoverflow.com/questions/3010803/draw-arrow-on-line-algorithm
1531      *
1532      * The algorithm was taken from this site, not the code itself
1533      */
1534     private static void drawArrowHead(int x0, int y0, int x1, int y1, GC gc)
1535     {
1536         int factor = 10;
1537         double cos = 0.9510;
1538         double sin = 0.3090;
1539         long lenx = x1 - x0;
1540         long leny = y1 - y0;
1541         double len = Math.sqrt(lenx * lenx + leny * leny);
1542
1543         double dx = factor * lenx / len;
1544         double dy = factor * leny / len;
1545         int end1X = (int) Math.round((x1 - (dx * cos + dy * -sin)));
1546         int end1Y = (int) Math.round((y1 - (dx * sin + dy * cos)));
1547         int end2X = (int) Math.round((x1 - (dx * cos + dy * sin)));
1548         int end2Y = (int) Math.round((y1 - (dx * -sin + dy * cos)));
1549         int[] arrow = new int[] { x1, y1, end1X, end1Y, end2X, end2Y, x1, y1 };
1550         gc.fillPolygon(arrow);
1551     }
1552
1553     /**
1554      * Draw the name of an item.
1555      *
1556      * @param item
1557      *            Item object
1558      * @param bounds
1559      *            Where to draw the name
1560      * @param gc
1561      *            Graphics context
1562      */
1563     protected void drawName(Item item, Rectangle bounds, GC gc) {
1564         boolean hasTimeEvents = item.fEntry.hasTimeEvents();
1565         if (! hasTimeEvents) {
1566             gc.setBackground(getColorScheme().getBkColorGroup(item.fSelected, fIsInFocus));
1567             gc.fillRectangle(bounds);
1568             if (item.fSelected && fIsInFocus) {
1569                 gc.setForeground(getColorScheme().getBkColor(item.fSelected, fIsInFocus, false));
1570                 gc.drawRectangle(bounds.x, bounds.y, bounds.width - 1, bounds.height - 1);
1571             }
1572         } else {
1573             gc.setBackground(getColorScheme().getBkColor(item.fSelected, fIsInFocus, true));
1574             gc.setForeground(getColorScheme().getFgColor(item.fSelected, fIsInFocus));
1575             gc.fillRectangle(bounds);
1576         }
1577
1578         // No name to be drawn
1579         if (fTimeProvider.getNameSpace() == 0) {
1580             return;
1581         }
1582
1583         int leftMargin = MARGIN + item.fLevel * EXPAND_SIZE;
1584         if (item.fHasChildren) {
1585             gc.setForeground(getColorScheme().getFgColorGroup(false, false));
1586             gc.setBackground(getColorScheme().getBkColor(false, false, false));
1587             Rectangle rect = Utils.clone(bounds);
1588             rect.x += leftMargin;
1589             rect.y += (bounds.height - EXPAND_SIZE) / 2;
1590             rect.width = EXPAND_SIZE;
1591             rect.height = EXPAND_SIZE;
1592             gc.fillRectangle(rect);
1593             gc.drawRectangle(rect.x, rect.y, rect.width - 1, rect.height - 1);
1594             int midy = rect.y + rect.height / 2;
1595             gc.drawLine(rect.x + 2, midy, rect.x + rect.width - 3, midy);
1596             if (!item.fExpanded) {
1597                 int midx = rect.x + rect.width / 2;
1598                 gc.drawLine(midx, rect.y + 2, midx, rect.y + rect.height - 3);
1599             }
1600         }
1601         leftMargin += EXPAND_SIZE + MARGIN;
1602
1603         Image img = fTimeGraphProvider.getItemImage(item.fEntry);
1604         if (img != null) {
1605             // draw icon
1606             int imgHeight = img.getImageData().height;
1607             int imgWidth = img.getImageData().width;
1608             int x = leftMargin;
1609             int y = bounds.y + (bounds.height - imgHeight) / 2;
1610             gc.drawImage(img, x, y);
1611             leftMargin += imgWidth + MARGIN;
1612         }
1613         String name = item.fName;
1614         Point size = gc.stringExtent(name);
1615         if (fIdealNameSpace < leftMargin + size.x + MARGIN) {
1616             fIdealNameSpace = leftMargin + size.x + MARGIN;
1617         }
1618         if (hasTimeEvents) {
1619             // cut long string with "..."
1620             int width = bounds.width - leftMargin;
1621             int cuts = 0;
1622             while (size.x > width && name.length() > 1) {
1623                 cuts++;
1624                 name = name.substring(0, name.length() - 1);
1625                 size = gc.stringExtent(name + "..."); //$NON-NLS-1$
1626             }
1627             if (cuts > 0) {
1628                 name += "..."; //$NON-NLS-1$
1629             }
1630         }
1631         Rectangle rect = Utils.clone(bounds);
1632         rect.x += leftMargin;
1633         rect.width -= leftMargin;
1634         // draw text
1635         if (rect.width > 0) {
1636             rect.y += (bounds.height - gc.stringExtent(name).y) / 2;
1637             gc.setForeground(getColorScheme().getFgColor(item.fSelected, fIsInFocus));
1638             int textWidth = Utils.drawText(gc, name, rect, true);
1639             leftMargin += textWidth + MARGIN;
1640             rect.y -= 2;
1641
1642             if (hasTimeEvents) {
1643                 // draw middle line
1644                 int x = bounds.x + leftMargin;
1645                 int width = bounds.width - x;
1646                 int midy = bounds.y + bounds.height / 2;
1647                 gc.setForeground(getColorScheme().getColor(TimeGraphColorScheme.MID_LINE));
1648                 gc.drawLine(x, midy, x + width, midy);
1649             }
1650         }
1651     }
1652
1653     /**
1654      * Draw the state (color fill)
1655      *
1656      * @param colors
1657      *            Color scheme
1658      * @param event
1659      *            Time event for which we're drawing the state
1660      * @param rect
1661      *            Where to draw
1662      * @param gc
1663      *            Graphics context
1664      * @param selected
1665      *            Is this time event currently selected (so it appears
1666      *            highlighted)
1667      * @param timeSelected
1668      *            Is the timestamp currently selected
1669      * @return true if the state was drawn
1670      * @since 2.0
1671      */
1672     protected boolean drawState(TimeGraphColorScheme colors, ITimeEvent event,
1673             Rectangle rect, GC gc, boolean selected, boolean timeSelected) {
1674
1675         int colorIdx = fTimeGraphProvider.getStateTableIndex(event);
1676         if (colorIdx < 0 && colorIdx != ITimeGraphPresentationProvider.TRANSPARENT) {
1677             return false;
1678         }
1679         boolean visible = rect.width == 0 ? false : true;
1680         Color black =  Display.getDefault().getSystemColor(SWT.COLOR_BLACK);
1681         gc.setForeground(black);
1682
1683         if (visible) {
1684             if (colorIdx == ITimeGraphPresentationProvider.TRANSPARENT) {
1685                 // Only draw the top and bottom borders
1686                 gc.drawLine(rect.x, rect.y, rect.x + rect.width - 1, rect.y);
1687                 gc.drawLine(rect.x, rect.y + rect.height - 1, rect.x + rect.width - 1, rect.y + rect.height - 1);
1688                 if (rect.width == 1) {
1689                     gc.drawPoint(rect.x, rect.y - 2);
1690                 }
1691                 return false;
1692             }
1693             Color stateColor = null;
1694             if (colorIdx < fEventColorMap.length) {
1695                 stateColor = fEventColorMap[colorIdx];
1696             } else {
1697                 stateColor = black;
1698             }
1699
1700             boolean reallySelected = timeSelected && selected;
1701             // fill all rect area
1702             gc.setBackground(stateColor);
1703             gc.fillRectangle(rect);
1704
1705             if (reallySelected) {
1706                 gc.drawLine(rect.x, rect.y - 1, rect.x + rect.width - 1, rect.y - 1);
1707                 gc.drawLine(rect.x, rect.y + rect.height, rect.x + rect.width - 1, rect.y + rect.height);
1708             }
1709         } else {
1710             gc.drawPoint(rect.x, rect.y - 2);
1711         }
1712         fTimeGraphProvider.postDrawEvent(event, rect, gc);
1713         return visible;
1714     }
1715
1716     /**
1717      * Fill the space between two contiguous time events
1718      *
1719      * @param rect
1720      *            Rectangle to fill
1721      * @param gc
1722      *            Graphics context
1723      * @param selected
1724      *            Is this time event selected or not
1725      */
1726     protected void fillSpace(Rectangle rect, GC gc, boolean selected) {
1727         gc.setBackground(getColorScheme().getBkColor(selected, fIsInFocus, false));
1728         gc.fillRectangle(rect);
1729         if (fDragState == DRAG_ZOOM) {
1730             gc.setBackground(getColorScheme().getBkColor(selected, fIsInFocus, true));
1731             if (fDragX0 < fDragX) {
1732                 gc.fillRectangle(new Rectangle(fDragX0, rect.y, fDragX - fDragX0, rect.height));
1733             } else if (fDragX0 > fDragX) {
1734                 gc.fillRectangle(new Rectangle(fDragX, rect.y, fDragX0 - fDragX, rect.height));
1735             }
1736         }
1737         // draw middle line
1738         gc.setForeground(getColorScheme().getColor(TimeGraphColorScheme.MID_LINE));
1739         int midy = rect.y + rect.height / 2;
1740         gc.drawLine(rect.x, midy, rect.x + rect.width, midy);
1741     }
1742
1743     @Override
1744     public void keyTraversed(TraverseEvent e) {
1745         if ((e.detail == SWT.TRAVERSE_TAB_NEXT) || (e.detail == SWT.TRAVERSE_TAB_PREVIOUS)) {
1746             e.doit = true;
1747         }
1748     }
1749
1750     @Override
1751     public void keyPressed(KeyEvent e) {
1752         int idx = -1;
1753         if (fItemData.fExpandedItems.length == 0) {
1754             return;
1755         }
1756         if (SWT.HOME == e.keyCode) {
1757             idx = 0;
1758         } else if (SWT.END == e.keyCode) {
1759             idx = fItemData.fExpandedItems.length - 1;
1760         } else if (SWT.ARROW_DOWN == e.keyCode) {
1761             idx = getSelectedIndex();
1762             if (idx < 0) {
1763                 idx = 0;
1764             } else if (idx < fItemData.fExpandedItems.length - 1) {
1765                 idx++;
1766             }
1767         } else if (SWT.ARROW_UP == e.keyCode) {
1768             idx = getSelectedIndex();
1769             if (idx < 0) {
1770                 idx = 0;
1771             } else if (idx > 0) {
1772                 idx--;
1773             }
1774         } else if (SWT.ARROW_LEFT == e.keyCode) {
1775             selectPrevEvent();
1776         } else if (SWT.ARROW_RIGHT == e.keyCode) {
1777             selectNextEvent();
1778         } else if (SWT.PAGE_DOWN == e.keyCode) {
1779             int page = countPerPage();
1780             idx = getSelectedIndex();
1781             if (idx < 0) {
1782                 idx = 0;
1783             }
1784             idx += page;
1785             if (idx >= fItemData.fExpandedItems.length) {
1786                 idx = fItemData.fExpandedItems.length - 1;
1787             }
1788         } else if (SWT.PAGE_UP == e.keyCode) {
1789             int page = countPerPage();
1790             idx = getSelectedIndex();
1791             if (idx < 0) {
1792                 idx = 0;
1793             }
1794             idx -= page;
1795             if (idx < 0) {
1796                 idx = 0;
1797             }
1798         } else if (SWT.CR == e.keyCode) {
1799             idx = getSelectedIndex();
1800             if (idx >= 0) {
1801                 if (fItemData.fExpandedItems[idx].fHasChildren) {
1802                     toggle(idx);
1803                 } else {
1804                     fireDefaultSelection();
1805                 }
1806             }
1807             idx = -1;
1808         }
1809         if (idx >= 0) {
1810             selectItem(idx, false);
1811             fireSelectionChanged();
1812         }
1813         int x = toControl(e.display.getCursorLocation()).x;
1814         updateCursor(x, e.stateMask | e.keyCode);
1815     }
1816
1817     @Override
1818     public void keyReleased(KeyEvent e) {
1819         int x = toControl(e.display.getCursorLocation()).x;
1820         updateCursor(x, e.stateMask & ~e.keyCode);
1821     }
1822
1823     @Override
1824     public void focusGained(FocusEvent e) {
1825         fIsInFocus = true;
1826         if (fMouseScrollFilterListener == null) {
1827             fMouseScrollFilterListener = new Listener() {
1828                 // This filter is used to prevent horizontal scrolling of the view
1829                 // when the mouse wheel is used to zoom
1830                 @Override
1831                 public void handleEvent(Event event) {
1832                     event.doit = false;
1833                 }
1834             };
1835             getDisplay().addFilter(SWT.MouseWheel, fMouseScrollFilterListener);
1836         }
1837         redraw();
1838         updateStatusLine(NO_STATUS);
1839     }
1840
1841     @Override
1842     public void focusLost(FocusEvent e) {
1843         fIsInFocus = false;
1844         if (fMouseScrollFilterListener != null) {
1845             getDisplay().removeFilter(SWT.MouseWheel, fMouseScrollFilterListener);
1846             fMouseScrollFilterListener = null;
1847         }
1848         if (DRAG_NONE != fDragState) {
1849             setCapture(false);
1850             fDragState = DRAG_NONE;
1851         }
1852         redraw();
1853         updateStatusLine(NO_STATUS);
1854     }
1855
1856     /**
1857      * @return If the current view is focused
1858      */
1859     public boolean isInFocus() {
1860         return fIsInFocus;
1861     }
1862
1863     /**
1864      * Provide the possibility to control the wait cursor externally e.g. data
1865      * requests in progress
1866      *
1867      * @param waitInd Should we wait indefinitely?
1868      */
1869     public void waitCursor(boolean waitInd) {
1870         // Update cursor as indicated
1871         if (waitInd) {
1872             setCursor(fWaitCursor);
1873         } else {
1874             setCursor(null);
1875         }
1876     }
1877
1878     private void updateCursor(int x, int stateMask) {
1879         // if Wait cursor not active, check for the need to change the cursor
1880         if (getCursor() == fWaitCursor) {
1881             return;
1882         }
1883         Cursor cursor = null;
1884         if (fDragState == DRAG_SPLIT_LINE) {
1885         } else if (fDragState == DRAG_SELECTION) {
1886             cursor = fResizeCursor;
1887         } else if (fDragState == DRAG_TRACE_ITEM) {
1888             cursor = fDragCursor;
1889         } else if (fDragState == DRAG_ZOOM) {
1890             cursor = fZoomCursor;
1891         } else if ((stateMask & SWT.MODIFIER_MASK) == SWT.CTRL) {
1892             cursor = fDragCursor;
1893         } else if ((stateMask & SWT.MODIFIER_MASK) == SWT.SHIFT) {
1894             cursor = fResizeCursor;
1895         } else if (!isOverSplitLine(x)) {
1896             long selectionBegin = fTimeProvider.getSelectionBegin();
1897             long selectionEnd = fTimeProvider.getSelectionEnd();
1898             int xBegin = getXForTime(selectionBegin);
1899             int xEnd = getXForTime(selectionEnd);
1900             if (Math.abs(x - xBegin) < SNAP_WIDTH || Math.abs(x - xEnd) < SNAP_WIDTH) {
1901                 cursor = fResizeCursor;
1902             }
1903         }
1904         if (getCursor() != cursor) {
1905             setCursor(cursor);
1906         }
1907     }
1908
1909     private void updateStatusLine(int x) {
1910         if (fStatusLineManager == null || null == fTimeProvider ||
1911                 fTimeProvider.getTime0() == fTimeProvider.getTime1()) {
1912             return;
1913         }
1914         StringBuilder message = new StringBuilder();
1915         if (x >= 0 && fDragState == DRAG_NONE) {
1916             long time = getTimeAtX(x);
1917             if (time >= 0) {
1918                 message.append("T: "); //$NON-NLS-1$
1919                 message.append(new TmfNanoTimestamp(time).toString());
1920                 message.append("     T1: "); //$NON-NLS-1$
1921                 long selectionBegin = fTimeProvider.getSelectionBegin();
1922                 long selectionEnd = fTimeProvider.getSelectionEnd();
1923                 message.append(new TmfNanoTimestamp(Math.min(selectionBegin, selectionEnd)).toString());
1924                 if (selectionBegin != selectionEnd) {
1925                     message.append("     T2: "); //$NON-NLS-1$
1926                     message.append(new TmfNanoTimestamp(Math.max(selectionBegin, selectionEnd)).toString());
1927                     message.append("     \u0394: "); //$NON-NLS-1$
1928                     message.append(new TmfTimestampDelta(Math.abs(selectionBegin - selectionEnd), ITmfTimestamp.NANOSECOND_SCALE));
1929                 }
1930             }
1931         } else if (fDragState == DRAG_SELECTION || fDragState == DRAG_ZOOM) {
1932             long time0 = fDragTime0;
1933             long time = getTimeAtX(fDragX);
1934             message.append("T1: "); //$NON-NLS-1$
1935             message.append(new TmfNanoTimestamp(Math.min(time, time0)).toString());
1936             if (time != time0) {
1937                 message.append("     T2: "); //$NON-NLS-1$
1938                 message.append(new TmfNanoTimestamp(Math.max(time, time0)).toString());
1939                 message.append("     \u0394: "); //$NON-NLS-1$
1940                 message.append(new TmfTimestampDelta(Math.abs(time - time0), ITmfTimestamp.NANOSECOND_SCALE));
1941             }
1942         }
1943         fStatusLineManager.setMessage(message.toString());
1944     }
1945
1946     @Override
1947     public void mouseMove(MouseEvent e) {
1948         if (null == fTimeProvider) {
1949             return;
1950         }
1951         Point size = getCtrlSize();
1952         if (DRAG_TRACE_ITEM == fDragState) {
1953             int nameWidth = fTimeProvider.getNameSpace();
1954             if (e.x > nameWidth && size.x > nameWidth && fDragX != e.x) {
1955                 fDragX = e.x;
1956                 double pixelsPerNanoSec = (size.x - nameWidth <= RIGHT_MARGIN) ? 0 : (double) (size.x - nameWidth - RIGHT_MARGIN) / (fTime1bak - fTime0bak);
1957                 long timeDelta = (long) ((pixelsPerNanoSec == 0) ? 0 : ((fDragX - fDragX0) / pixelsPerNanoSec));
1958                 long time1 = fTime1bak - timeDelta;
1959                 long maxTime = fTimeProvider.getMaxTime();
1960                 if (time1 > maxTime) {
1961                     time1 = maxTime;
1962                 }
1963                 long time0 = time1 - (fTime1bak - fTime0bak);
1964                 if (time0 < fTimeProvider.getMinTime()) {
1965                     time0 = fTimeProvider.getMinTime();
1966                     time1 = time0 + (fTime1bak - fTime0bak);
1967                 }
1968                 fTimeProvider.setStartFinishTime(time0, time1);
1969             }
1970         } else if (DRAG_SPLIT_LINE == fDragState) {
1971             fDragX = e.x;
1972             fTimeProvider.setNameSpace(e.x);
1973         } else if (DRAG_SELECTION == fDragState) {
1974             fDragX = Math.min(Math.max(e.x, fTimeProvider.getNameSpace()), size.x - RIGHT_MARGIN);
1975             redraw();
1976             fTimeGraphScale.setDragRange(fDragX0, fDragX);
1977         } else if (DRAG_ZOOM == fDragState) {
1978             fDragX = Math.min(Math.max(e.x, fTimeProvider.getNameSpace()), size.x - RIGHT_MARGIN);
1979             redraw();
1980             fTimeGraphScale.setDragRange(fDragX0, fDragX);
1981         } else if (DRAG_NONE == fDragState) {
1982             boolean mouseOverSplitLine = isOverSplitLine(e.x);
1983             if (fMouseOverSplitLine != mouseOverSplitLine) {
1984                 redraw();
1985             }
1986             fMouseOverSplitLine = mouseOverSplitLine;
1987         }
1988         updateCursor(e.x, e.stateMask);
1989         updateStatusLine(e.x);
1990     }
1991
1992     @Override
1993     public void mouseDoubleClick(MouseEvent e) {
1994         if (null == fTimeProvider) {
1995             return;
1996         }
1997         if (1 == e.button && (e.stateMask & SWT.BUTTON_MASK) == 0) {
1998             if (isOverSplitLine(e.x) && fTimeProvider.getNameSpace() != 0) {
1999                 fTimeProvider.setNameSpace(fIdealNameSpace);
2000                 boolean mouseOverSplitLine = isOverSplitLine(e.x);
2001                 if (fMouseOverSplitLine != mouseOverSplitLine) {
2002                     redraw();
2003                 }
2004                 fMouseOverSplitLine = mouseOverSplitLine;
2005                 return;
2006             }
2007             int idx = getItemIndexAtY(e.y);
2008             if (idx >= 0) {
2009                 selectItem(idx, false);
2010                 fireDefaultSelection();
2011             }
2012         }
2013     }
2014
2015     @Override
2016     public void mouseDown(MouseEvent e) {
2017         if (fDragState != DRAG_NONE || null == fTimeProvider ||
2018                 fTimeProvider.getTime0() == fTimeProvider.getTime1() ||
2019                 getCtrlSize().x - fTimeProvider.getNameSpace() <= 0) {
2020             return;
2021         }
2022         int idx;
2023         if (1 == e.button && (e.stateMask & SWT.MODIFIER_MASK) == 0) {
2024             int nameSpace = fTimeProvider.getNameSpace();
2025             if (nameSpace != 0 && isOverSplitLine(e.x)) {
2026                 fDragState = DRAG_SPLIT_LINE;
2027                 fDragButton = e.button;
2028                 fDragX = e.x;
2029                 fDragX0 = fDragX;
2030                 fTime0bak = fTimeProvider.getTime0();
2031                 fTime1bak = fTimeProvider.getTime1();
2032                 redraw();
2033                 updateCursor(e.x, e.stateMask);
2034                 return;
2035             }
2036         }
2037         if (1 == e.button && ((e.stateMask & SWT.MODIFIER_MASK) == 0 || (e.stateMask & SWT.MODIFIER_MASK) == SWT.SHIFT)) {
2038             int nameSpace = fTimeProvider.getNameSpace();
2039             idx = getItemIndexAtY(e.y);
2040             if (idx >= 0) {
2041                 Item item = fItemData.fExpandedItems[idx];
2042                 if (item.fHasChildren && e.x < nameSpace && e.x < MARGIN + (item.fLevel + 1) * EXPAND_SIZE) {
2043                     toggle(idx);
2044                     return;
2045                 }
2046                 selectItem(idx, false);
2047                 fireSelectionChanged();
2048             } else {
2049                 selectItem(idx, false); // clear selection
2050                 fireSelectionChanged();
2051             }
2052             long hitTime = getTimeAtX(e.x);
2053             if (hitTime >= 0) {
2054                 setCapture(true);
2055
2056                 fDragState = DRAG_SELECTION;
2057                 fDragButton = e.button;
2058                 fDragX = e.x;
2059                 fDragX0 = fDragX;
2060                 fDragTime0 = getTimeAtX(fDragX0);
2061                 long selectionBegin = fTimeProvider.getSelectionBegin();
2062                 long selectionEnd = fTimeProvider.getSelectionEnd();
2063                 int xBegin = getXForTime(selectionBegin);
2064                 int xEnd = getXForTime(selectionEnd);
2065                 if ((e.stateMask & SWT.MODIFIER_MASK) == SWT.SHIFT) {
2066                     long time = getTimeAtX(e.x);
2067                     if (Math.abs(time - selectionBegin) < Math.abs(time - selectionEnd)) {
2068                         fDragX0 = xEnd;
2069                         fDragTime0 = selectionEnd;
2070                     } else {
2071                         fDragX0 = xBegin;
2072                         fDragTime0 = selectionBegin;
2073                     }
2074                 } else {
2075                     long time = getTimeAtX(e.x);
2076                     if (Math.abs(e.x - xBegin) < SNAP_WIDTH && Math.abs(time - selectionBegin) <= Math.abs(time - selectionEnd)) {
2077                         fDragX0 = xEnd;
2078                         fDragTime0 = selectionEnd;
2079                     } else if (Math.abs(e.x - xEnd) < SNAP_WIDTH && Math.abs(time - selectionEnd) <= Math.abs(time - selectionBegin)) {
2080                         fDragX0 = xBegin;
2081                         fDragTime0 = selectionBegin;
2082                     }
2083                 }
2084                 fTime0bak = fTimeProvider.getTime0();
2085                 fTime1bak = fTimeProvider.getTime1();
2086                 redraw();
2087                 updateCursor(e.x, e.stateMask);
2088                 fTimeGraphScale.setDragRange(fDragX0, fDragX);
2089             }
2090         } else if (2 == e.button || (1 == e.button && (e.stateMask & SWT.MODIFIER_MASK) == SWT.CTRL)) {
2091             long hitTime = getTimeAtX(e.x);
2092             if (hitTime > 0) {
2093                 setCapture(true);
2094                 fDragState = DRAG_TRACE_ITEM;
2095                 fDragButton = e.button;
2096                 fDragX = e.x;
2097                 fDragX0 = fDragX;
2098                 fTime0bak = fTimeProvider.getTime0();
2099                 fTime1bak = fTimeProvider.getTime1();
2100                 updateCursor(e.x, e.stateMask);
2101             }
2102         } else if (3 == e.button) {
2103             setCapture(true);
2104             fDragX = Math.min(Math.max(e.x, fTimeProvider.getNameSpace()), getCtrlSize().x - RIGHT_MARGIN);
2105             fDragX0 = fDragX;
2106             fDragState = DRAG_ZOOM;
2107             fDragButton = e.button;
2108             redraw();
2109             updateCursor(e.x, e.stateMask);
2110             fTimeGraphScale.setDragRange(fDragX0, fDragX);
2111         }
2112     }
2113
2114     @Override
2115     public void mouseUp(MouseEvent e) {
2116         if (fPendingMenuDetectEvent != null && e.button == 3) {
2117             menuDetected(fPendingMenuDetectEvent);
2118         }
2119         if (DRAG_NONE != fDragState) {
2120             setCapture(false);
2121             if (e.button == fDragButton && DRAG_TRACE_ITEM == fDragState) {
2122                 if (fDragX != fDragX0) {
2123                     fTimeProvider.notifyStartFinishTime();
2124                 }
2125                 fDragState = DRAG_NONE;
2126             } else if (e.button == fDragButton && DRAG_SPLIT_LINE == fDragState) {
2127                 fDragState = DRAG_NONE;
2128                 redraw();
2129             }  else if (e.button == fDragButton && DRAG_SELECTION == fDragState) {
2130                 if (fDragX == fDragX0) { // click without selecting anything
2131                     long time = getTimeAtX(e.x);
2132                     fTimeProvider.setSelectedTimeNotify(time, false);
2133                 } else {
2134                     long time0 = fDragTime0;
2135                     long time1 = getTimeAtX(fDragX);
2136                     if (time0 <= time1) {
2137                         fTimeProvider.setSelectionRangeNotify(time0, time1);
2138                     } else {
2139                         fTimeProvider.setSelectionRangeNotify(time1, time0);
2140                     }
2141                 }
2142                 fDragState = DRAG_NONE;
2143                 redraw();
2144                 fTimeGraphScale.setDragRange(-1, -1);
2145             } else if (e.button == fDragButton && DRAG_ZOOM == fDragState) {
2146                 int nameWidth = fTimeProvider.getNameSpace();
2147                 if (Math.max(fDragX, fDragX0) > nameWidth && fDragX != fDragX0) {
2148                     long time0 = getTimeAtX(fDragX0);
2149                     long time1 = getTimeAtX(fDragX);
2150                     if (time0 < time1) {
2151                         fTimeProvider.setStartFinishTimeNotify(time0, time1);
2152                     } else {
2153                         fTimeProvider.setStartFinishTimeNotify(time1, time0);
2154                     }
2155                 } else {
2156                     redraw();
2157                 }
2158                 fDragState = DRAG_NONE;
2159                 fTimeGraphScale.setDragRange(-1, -1);
2160             }
2161         }
2162         updateCursor(e.x, e.stateMask);
2163         updateStatusLine(e.x);
2164     }
2165
2166     @Override
2167     public void mouseEnter(MouseEvent e) {
2168     }
2169
2170     @Override
2171     public void mouseExit(MouseEvent e) {
2172         if (fMouseOverSplitLine) {
2173             fMouseOverSplitLine = false;
2174             redraw();
2175         }
2176         updateStatusLine(NO_STATUS);
2177     }
2178
2179     @Override
2180     public void mouseHover(MouseEvent e) {
2181     }
2182
2183     @Override
2184     public void mouseScrolled(MouseEvent e) {
2185         if ((fMouseScrollFilterListener == null) || fDragState != DRAG_NONE) {
2186             return;
2187         }
2188         boolean zoomScroll = false;
2189         Point p = getParent().toControl(getDisplay().getCursorLocation());
2190         Point parentSize = getParent().getSize();
2191         if (p.x >= 0 && p.x < parentSize.x && p.y >= 0 && p.y < parentSize.y) {
2192             // over the parent control
2193             if (e.x > getCtrlSize().x) {
2194                 // over the horizontal scroll bar
2195                 zoomScroll = false;
2196             } else if (e.y >= 0 && e.y < getCtrlSize().y && e.x < fTimeProvider.getNameSpace()) {
2197                 // over the name space
2198                 zoomScroll = false;
2199             } else {
2200                 zoomScroll = true;
2201             }
2202         }
2203         if (zoomScroll && fTimeProvider.getTime0() != fTimeProvider.getTime1()) {
2204             if (e.count > 0) {
2205                 zoom(true);
2206             } else if (e.count < 0) {
2207                 zoom(false);
2208             }
2209         } else {
2210             setTopIndex(getTopIndex() - e.count);
2211         }
2212     }
2213
2214     @Override
2215     public void controlMoved(ControlEvent e) {
2216     }
2217
2218     @Override
2219     public void controlResized(ControlEvent e) {
2220         adjustScrolls();
2221     }
2222
2223     @Override
2224     public void widgetDefaultSelected(SelectionEvent e) {
2225     }
2226
2227     @Override
2228     public void widgetSelected(SelectionEvent e) {
2229         if (e.widget == getVerticalBar()) {
2230             setTopIndex(getVerticalBar().getSelection());
2231         } else if (e.widget == getHorizontalBar() && null != fTimeProvider) {
2232             int start = getHorizontalBar().getSelection();
2233             long time0 = fTimeProvider.getTime0();
2234             long time1 = fTimeProvider.getTime1();
2235             long timeMin = fTimeProvider.getMinTime();
2236             long timeMax = fTimeProvider.getMaxTime();
2237             long delta = timeMax - timeMin;
2238
2239             long range = time1 - time0;
2240             time0 = timeMin + Math.round(delta * ((double) start / H_SCROLLBAR_MAX));
2241             time1 = time0 + range;
2242
2243             // TODO: Follow-up with Bug 310310
2244             // In Linux SWT.DRAG is the only value received
2245             // https://bugs.eclipse.org/bugs/show_bug.cgi?id=310310
2246             if (e.detail == SWT.DRAG) {
2247                 fTimeProvider.setStartFinishTime(time0, time1);
2248             } else {
2249                 fTimeProvider.setStartFinishTimeNotify(time0, time1);
2250             }
2251         }
2252     }
2253
2254     @Override
2255     public int getBorderWidth() {
2256         return fBorderWidth;
2257     }
2258
2259     /**
2260      * Set the border width
2261      *
2262      * @param borderWidth
2263      *            The width
2264      */
2265     public void setBorderWidth(int borderWidth) {
2266         this.fBorderWidth = borderWidth;
2267     }
2268
2269     /**
2270      * @return The current height of the header row
2271      */
2272     public int getHeaderHeight() {
2273         return fHeaderHeight;
2274     }
2275
2276     /**
2277      * Set the height of the header row
2278      *
2279      * @param headerHeight
2280      *            The height
2281      */
2282     public void setHeaderHeight(int headerHeight) {
2283         this.fHeaderHeight = headerHeight;
2284     }
2285
2286     /**
2287      * @return The default height of regular item rows
2288      */
2289     public int getItemHeight() {
2290         return fGlobalItemHeight;
2291     }
2292
2293     /**
2294      * Set the default height of regular item rows.
2295      *
2296      * @param rowHeight
2297      *            The height
2298      */
2299     public void setItemHeight(int rowHeight) {
2300         this.fGlobalItemHeight = rowHeight;
2301     }
2302
2303     /**
2304      * Set the height of a specific item. Overrides the default item height.
2305      *
2306      * @param entry
2307      *            A time graph entry
2308      * @param rowHeight
2309      *            The height
2310      * @return true if the height is successfully stored, false otherwise
2311      *
2312      * @since 2.1
2313      */
2314     public boolean setItemHeight(ITimeGraphEntry entry, int rowHeight) {
2315         Item item = fItemData.findItem(entry);
2316         if (item != null) {
2317             item.fItemHeight = rowHeight;
2318             return true;
2319         }
2320         return false;
2321     }
2322
2323     /**
2324      * Set the minimum item width
2325      *
2326      * @param width The minimum width
2327      */
2328     public void setMinimumItemWidth(int width) {
2329         this.fMinimumItemWidth = width;
2330     }
2331
2332     /**
2333      * @return The minimum item width
2334      */
2335     public int getMinimumItemWidth() {
2336         return fMinimumItemWidth;
2337     }
2338
2339     /**
2340      * @return The entries that are currently filtered out
2341      *
2342      * @since 2.0
2343      */
2344     public List<ITimeGraphEntry> getFilteredOut() {
2345         return fItemData.getFilteredOut();
2346     }
2347
2348     @Override
2349     public void addSelectionChangedListener(ISelectionChangedListener listener) {
2350         if (listener != null && !fSelectionChangedListeners.contains(listener)) {
2351             fSelectionChangedListeners.add(listener);
2352         }
2353     }
2354
2355     @Override
2356     public void removeSelectionChangedListener(ISelectionChangedListener listener) {
2357         if (listener != null) {
2358             fSelectionChangedListeners.remove(listener);
2359         }
2360     }
2361
2362     @Override
2363     public void setSelection(ISelection selection) {
2364         if (selection instanceof TimeGraphSelection) {
2365             TimeGraphSelection sel = (TimeGraphSelection) selection;
2366             Object ob = sel.getFirstElement();
2367             if (ob instanceof ITimeGraphEntry) {
2368                 ITimeGraphEntry trace = (ITimeGraphEntry) ob;
2369                 selectItem(trace, false);
2370             }
2371         }
2372
2373     }
2374
2375     /**
2376      * @param filter The filter object to be attached to the view
2377      * @since 2.0
2378      */
2379     public void addFilter(ViewerFilter filter) {
2380         if (!fFilters.contains(filter)) {
2381             fFilters.add(filter);
2382         }
2383     }
2384
2385     /**
2386      * @param filter The filter object to be attached to the view
2387      * @since 2.0
2388      */
2389     public void removeFilter(ViewerFilter filter) {
2390         fFilters.remove(filter);
2391     }
2392
2393     /**
2394      * @since 3.0
2395      */
2396     @Override
2397     public void colorSettingsChanged(StateItem[] stateItems) {
2398         /* Destroy previous colors from the resource manager */
2399         if (fEventColorMap != null) {
2400             for (Color color : fEventColorMap) {
2401                 fResourceManager.destroyColor(color.getRGB());
2402             }
2403         }
2404         if (stateItems != null) {
2405             fEventColorMap = new Color[stateItems.length];
2406             for (int i = 0; i < stateItems.length; i++) {
2407                 fEventColorMap[i] = fResourceManager.createColor(stateItems[i].getStateColor());
2408             }
2409         } else {
2410             fEventColorMap = new Color[] { };
2411         }
2412         redraw();
2413     }
2414
2415     private class ItemData {
2416         private final Map<ITimeGraphEntry, Item> fItemMap = new LinkedHashMap<>();
2417         private Item[] fExpandedItems = new Item[0];
2418         private Item[] fItems = new Item[0];
2419         private ITimeGraphEntry fRootEntries[] = new ITimeGraphEntry[0];
2420         private List<ILinkEvent> fLinks = new ArrayList<>();
2421         private boolean fEntryFilter[] = new boolean[0];
2422         private final ArrayList<ITimeGraphEntry> fFilteredOut = new ArrayList<>();
2423
2424         public ItemData() {
2425         }
2426
2427         public Item findItem(ITimeGraphEntry entry) {
2428             return fItemMap.get(entry);
2429         }
2430
2431         public int findItemIndex(ITimeGraphEntry entry) {
2432             Item item = fItemMap.get(entry);
2433             if (item == null) {
2434                 return -1;
2435             }
2436             return item.fExpandedIndex;
2437         }
2438
2439         public void refreshData() {
2440             fItemMap.clear();
2441             fFilteredOut.clear();
2442             ITimeGraphEntry selection = getSelectedTrace();
2443             for (int i = 0; i < fRootEntries.length; i++) {
2444                 ITimeGraphEntry entry = fRootEntries[i];
2445                 refreshData(fItemMap, null, 0, entry);
2446             }
2447             fItems = fItemMap.values().toArray(new Item[0]);
2448             updateExpandedItems();
2449             if (selection != null) {
2450                 for (Item item : fExpandedItems) {
2451                     if (item.fEntry == selection) {
2452                         item.fSelected = true;
2453                         break;
2454                     }
2455                 }
2456             }
2457         }
2458
2459         private void refreshData(Map<ITimeGraphEntry, Item> itemMap, Item parent, int level, ITimeGraphEntry entry) {
2460             Item item = new Item(entry, entry.getName(), level);
2461             if (parent != null) {
2462                 parent.fChildren.add(item);
2463             }
2464             if (fGlobalItemHeight == CUSTOM_ITEM_HEIGHT) {
2465                 item.fItemHeight = fTimeGraphProvider.getItemHeight(entry);
2466             } else {
2467                 item.fItemHeight = fGlobalItemHeight;
2468             }
2469             itemMap.put(entry, item);
2470             if (entry.hasChildren()) {
2471                 item.fExpanded = true;
2472                 item.fHasChildren = true;
2473                 for (ITimeGraphEntry child : entry.getChildren()) {
2474                     refreshData(itemMap, item, level + 1, child);
2475                 }
2476             }
2477         }
2478
2479         public void updateExpandedItems() {
2480             for (Item item : fItems) {
2481                 item.fExpandedIndex = -1;
2482             }
2483             List<Item> expandedItemList = new ArrayList<>();
2484             for (int i = 0; i < fRootEntries.length; i++) {
2485                 ITimeGraphEntry entry = fRootEntries[i];
2486                 Item item = findItem(entry);
2487                 refreshExpanded(expandedItemList, item);
2488             }
2489             fExpandedItems = expandedItemList.toArray(new Item[0]);
2490             fTopIndex = Math.min(fTopIndex, Math.max(0, fExpandedItems.length - 1));
2491         }
2492
2493         private void refreshExpanded(List<Item> expandedItemList, Item item) {
2494             // Check for filters
2495             boolean display = true;
2496             for (ViewerFilter filter : fFilters) {
2497                 if (!filter.select(null, item.fEntry.getParent(), item.fEntry)) {
2498                     display = false;
2499                     break;
2500                 }
2501             }
2502             if (display) {
2503                 item.fExpandedIndex = expandedItemList.size();
2504                 expandedItemList.add(item);
2505                 if (item.fHasChildren && item.fExpanded) {
2506                     for (Item child : item.fChildren) {
2507                         refreshExpanded(expandedItemList, child);
2508                     }
2509                 }
2510             }
2511         }
2512
2513         public void refreshData(ITimeGraphEntry[] entries) {
2514             if (entries == null) {
2515                 fEntryFilter = null;
2516                 fRootEntries = null;
2517             } else {
2518                 if (entries.length == 0) {
2519                     fEntryFilter = null;
2520                 } else if (fEntryFilter == null || entries.length != fEntryFilter.length) {
2521                     fEntryFilter = new boolean[entries.length];
2522                     java.util.Arrays.fill(fEntryFilter, true);
2523                 }
2524                 fRootEntries = Arrays.copyOf(entries, entries.length);
2525             }
2526
2527             refreshData();
2528         }
2529
2530         public void refreshArrows(List<ILinkEvent> events) {
2531             /* If links are null, reset the list */
2532             if (events != null) {
2533                 fLinks = events;
2534             } else {
2535                 fLinks = new ArrayList<>();
2536             }
2537         }
2538
2539         public ITimeGraphEntry[] getEntries() {
2540             return fRootEntries;
2541         }
2542
2543         public boolean[] getEntryFilter() {
2544             return fEntryFilter;
2545         }
2546
2547         public List<ITimeGraphEntry> getFilteredOut() {
2548             return fFilteredOut;
2549         }
2550     }
2551
2552     private class Item {
2553         private boolean fExpanded;
2554         private int fExpandedIndex;
2555         private boolean fSelected;
2556         private boolean fHasChildren;
2557         private int fItemHeight;
2558         private final int fLevel;
2559         private final List<Item> fChildren;
2560         private final String fName;
2561         private final ITimeGraphEntry fEntry;
2562
2563         public Item(ITimeGraphEntry entry, String name, int level) {
2564             this.fEntry = entry;
2565             this.fName = name;
2566             this.fLevel = level;
2567             this.fChildren = new ArrayList<>();
2568         }
2569
2570         @Override
2571         public String toString() {
2572             return fName;
2573         }
2574     }
2575
2576     /**
2577      * @since 1.2
2578      */
2579     @Override
2580     public void menuDetected(MenuDetectEvent e) {
2581         if (null == fTimeProvider) {
2582             return;
2583         }
2584         if (e.detail == SWT.MENU_MOUSE) {
2585             if (fPendingMenuDetectEvent == null) {
2586                 /* Feature in Linux. The MenuDetectEvent is received before mouseDown.
2587                  * Store the event and trigger it later just before handling mouseUp.
2588                  * This allows for the method to detect if mouse is used to drag zoom.
2589                  */
2590                 fPendingMenuDetectEvent = e;
2591                 return;
2592             }
2593             fPendingMenuDetectEvent = null;
2594             if (fDragState != DRAG_ZOOM || fDragX != fDragX0) {
2595                 return;
2596             }
2597         } else {
2598             if (fDragState != DRAG_NONE) {
2599                 return;
2600             }
2601         }
2602         Point p = toControl(e.x, e.y);
2603         int idx = getItemIndexAtY(p.y);
2604         if (idx >= 0 && idx < fItemData.fExpandedItems.length) {
2605             Item item = fItemData.fExpandedItems[idx];
2606             ITimeGraphEntry entry = item.fEntry;
2607             if (entry.hasTimeEvents()) {
2608                 ITimeEvent event = Utils.findEvent(entry, getTimeAtX(p.x), 2);
2609                 if (event != null) {
2610                     e.data = event;
2611                     fireMenuEventOnTimeEvent(e);
2612                     return;
2613                 }
2614             }
2615             e.data = entry;
2616             fireMenuEventOnTimeGraphEntry(e);
2617         }
2618     }
2619
2620 }
2621
2622