org.eclipse.linuxtools.lttng2.kernel.ui/src/org/eclipse/linuxtools/internal/lttng2/kernel/ui/views/resources/ResourcesView.java

   1 /*******************************************************************************
   2  * Copyright (c) 2012 Ericsson
   3  *
   4  * All rights reserved. This program and the accompanying materials are
   5  * made available under the terms of the Eclipse Public License v1.0 which
   6  * accompanies this distribution, and is available at
   7  * http://www.eclipse.org/legal/epl-v10.html
   8  *
   9  * Contributors:
  10  *   Patrick Tasse - Initial API and implementation
  11  *******************************************************************************/
  12
  13 package org.eclipse.linuxtools.internal.lttng2.kernel.ui.views.resources;
  14
  15 import java.util.ArrayList;
  16 import java.util.Arrays;
  17 import java.util.Comparator;
  18 import java.util.Iterator;
  19 import java.util.List;
  20
  21 import org.eclipse.core.runtime.IProgressMonitor;
  22 import org.eclipse.core.runtime.NullProgressMonitor;
  23 import org.eclipse.jface.action.Action;
  24 import org.eclipse.jface.action.IToolBarManager;
  25 import org.eclipse.jface.action.Separator;
  26 import org.eclipse.linuxtools.internal.lttng2.kernel.core.Attributes;
  27 import org.eclipse.linuxtools.internal.lttng2.kernel.ui.Messages;
  28 import org.eclipse.linuxtools.internal.lttng2.kernel.ui.views.resources.ResourcesEntry.Type;
  29 import org.eclipse.linuxtools.lttng2.kernel.core.trace.CtfKernelTrace;
  30 import org.eclipse.linuxtools.tmf.core.ctfadaptor.CtfTmfTimestamp;
  31 import org.eclipse.linuxtools.tmf.core.event.ITmfEvent;
  32 import org.eclipse.linuxtools.tmf.core.event.TmfEvent;
  33 import org.eclipse.linuxtools.tmf.core.event.TmfTimeRange;
  34 import org.eclipse.linuxtools.tmf.core.event.TmfTimestamp;
  35 import org.eclipse.linuxtools.tmf.core.exceptions.AttributeNotFoundException;
  36 import org.eclipse.linuxtools.tmf.core.exceptions.StateValueTypeException;
  37 import org.eclipse.linuxtools.tmf.core.exceptions.TimeRangeException;
  38 import org.eclipse.linuxtools.tmf.core.interval.ITmfStateInterval;
  39 import org.eclipse.linuxtools.tmf.core.signal.TmfExperimentSelectedSignal;
  40 import org.eclipse.linuxtools.tmf.core.signal.TmfRangeSynchSignal;
  41 import org.eclipse.linuxtools.tmf.core.signal.TmfSignalHandler;
  42 import org.eclipse.linuxtools.tmf.core.signal.TmfStateSystemBuildCompleted;
  43 import org.eclipse.linuxtools.tmf.core.signal.TmfTimeSynchSignal;
  44 import org.eclipse.linuxtools.tmf.core.statesystem.IStateSystemQuerier;
  45 import org.eclipse.linuxtools.tmf.core.trace.ITmfTrace;
  46 import org.eclipse.linuxtools.tmf.core.trace.TmfExperiment;
  47 import org.eclipse.linuxtools.tmf.ui.views.TmfView;
  48 import org.eclipse.linuxtools.tmf.ui.widgets.timegraph.ITimeGraphRangeListener;
  49 import org.eclipse.linuxtools.tmf.ui.widgets.timegraph.ITimeGraphTimeListener;
  50 import org.eclipse.linuxtools.tmf.ui.widgets.timegraph.TimeGraphRangeUpdateEvent;
  51 import org.eclipse.linuxtools.tmf.ui.widgets.timegraph.TimeGraphTimeEvent;
  52 import org.eclipse.linuxtools.tmf.ui.widgets.timegraph.TimeGraphViewer;
  53 import org.eclipse.linuxtools.tmf.ui.widgets.timegraph.model.ITimeEvent;
  54 import org.eclipse.linuxtools.tmf.ui.widgets.timegraph.model.ITimeGraphEntry;
  55 import org.eclipse.linuxtools.tmf.ui.widgets.timegraph.model.TimeEvent;
  56 import org.eclipse.swt.SWT;
  57 import org.eclipse.swt.widgets.Composite;
  58 import org.eclipse.swt.widgets.Display;
  59 import org.eclipse.ui.IActionBars;
  60
  61 public class ResourcesView extends TmfView {
  62
  63     // ------------------------------------------------------------------------
  64     // Constants
  65     // ------------------------------------------------------------------------
  66
  67     /**
  68      * View ID.
  69      */
  70     public static final String ID = "org.eclipse.linuxtools.lttng2.kernel.ui.views.resources"; //$NON-NLS-1$
  71
  72     /**
  73      * Initial time range
  74      */
  75     private static final long INITIAL_WINDOW_OFFSET = (1L * 100  * 1000 * 1000); // .1sec
  76
  77     // ------------------------------------------------------------------------
  78     // Fields
  79     // ------------------------------------------------------------------------
  80
  81     // The time graph viewer
  82     TimeGraphViewer fTimeGraphViewer;
  83
  84     // The selected experiment
  85     private TmfExperiment<ITmfEvent> fSelectedExperiment;
  86
  87     // The time graph entry list
  88     private ArrayList<TraceEntry> fEntryList;
  89
  90     // The start time
  91     private long fStartTime;
  92
  93     // The end time
  94     private long fEndTime;
  95
  96     // The display width
  97     private int fDisplayWidth;
  98
  99     // The next resource action
 100     private Action fNextResourceAction;
 101
 102     // The previous resource action
 103     private Action fPreviousResourceAction;
 104
 105     // The zoom thread
 106     private ZoomThread fZoomThread;
 107
 108     // ------------------------------------------------------------------------
 109     // Classes
 110     // ------------------------------------------------------------------------
 111
 112     private class TraceEntry implements ITimeGraphEntry {
 113         // The Trace
 114         private CtfKernelTrace fTrace;
 115         // The start time
 116         private long fTraceStartTime;
 117         // The end time
 118         private long fTraceEndTime;
 119         // The children of the entry
 120         private ArrayList<ResourcesEntry> fChildren;
 121         // The name of entry
 122         private String fName;
 123
 124         public TraceEntry(CtfKernelTrace trace, String name, long startTime, long endTime) {
 125             fTrace = trace;
 126             fChildren = new ArrayList<ResourcesEntry>();
 127             fName = name;
 128             fTraceStartTime = startTime;
 129             fTraceEndTime = endTime;
 130         }
 131
 132         @Override
 133         public ITimeGraphEntry getParent() {
 134             return null;
 135         }
 136
 137         @Override
 138         public boolean hasChildren() {
 139             return fChildren != null && fChildren.size() > 0;
 140         }
 141
 142         @Override
 143         public ResourcesEntry[] getChildren() {
 144             return fChildren.toArray(new ResourcesEntry[0]);
 145         }
 146
 147         @Override
 148         public String getName() {
 149             return fName;
 150         }
 151
 152         @Override
 153         public long getStartTime() {
 154             return fTraceStartTime;
 155         }
 156
 157         @Override
 158         public long getEndTime() {
 159             return fTraceEndTime;
 160         }
 161
 162         @Override
 163         public boolean hasTimeEvents() {
 164             return false;
 165         }
 166
 167         @Override
 168         public Iterator<ITimeEvent> getTimeEventsIterator() {
 169             return null;
 170         }
 171
 172         @Override
 173         public <T extends ITimeEvent> Iterator<T> getTimeEventsIterator(long startTime, long stopTime, long visibleDuration) {
 174             return null;
 175         }
 176
 177         public CtfKernelTrace getTrace() {
 178             return fTrace;
 179         }
 180
 181         public void addChild(ResourcesEntry entry) {
 182             int index;
 183             for (index = 0; index < fChildren.size(); index++) {
 184                 ResourcesEntry other = fChildren.get(index);
 185                 if (entry.getType().compareTo(other.getType()) < 0) {
 186                     break;
 187                 } else if (entry.getType().equals(other.getType())) {
 188                     if (entry.getId() < other.getId()) {
 189                         break;
 190                     }
 191                 }
 192             }
 193             entry.setParent(this);
 194             fChildren.add(index, entry);
 195         }
 196     }
 197
 198     private static class TraceEntryComparator implements Comparator<ITimeGraphEntry> {
 199         @Override
 200         public int compare(ITimeGraphEntry o1, ITimeGraphEntry o2) {
 201             int result = o1.getStartTime() < o2.getStartTime() ? -1 : o1.getStartTime() > o2.getStartTime() ? 1 : 0;
 202             if (result == 0) {
 203                 result = o1.getName().compareTo(o2.getName());
 204             }
 205             return result;
 206         }
 207     }
 208
 209     private class ZoomThread extends Thread {
 210         private long fZoomStartTime;
 211         private long fZoomEndTime;
 212         private IProgressMonitor fMonitor;
 213
 214         public ZoomThread(long startTime, long endTime) {
 215             super("ResourcesView zoom"); //$NON-NLS-1$
 216             fZoomStartTime = startTime;
 217             fZoomEndTime = endTime;
 218             fMonitor = new NullProgressMonitor();
 219         }
 220
 221         @Override
 222         public void run() {
 223             ArrayList<TraceEntry> entryList = fEntryList;
 224             if (entryList == null) {
 225                 return;
 226             }
 227             long resolution = Math.max(1, (fZoomEndTime - fZoomStartTime) / fDisplayWidth);
 228             for (TraceEntry traceEntry : entryList) {
 229                 for (ITimeGraphEntry child : traceEntry.getChildren()) {
 230                     if (fMonitor.isCanceled()) {
 231                         break;
 232                     }
 233                     ResourcesEntry entry = (ResourcesEntry) child;
 234                     if (fZoomStartTime <= fStartTime && fZoomEndTime >= fEndTime) {
 235                         entry.setZoomedEventList(null);
 236                     } else {
 237                         List<ITimeEvent> zoomedEventList = getEventList(entry, fZoomStartTime, fZoomEndTime, resolution, true, fMonitor);
 238                         if (zoomedEventList != null) {
 239                             entry.setZoomedEventList(zoomedEventList);
 240                         }
 241                     }
 242                 }
 243             }
 244             redraw();
 245         }
 246
 247         public void cancel() {
 248             fMonitor.setCanceled(true);
 249         }
 250     }
 251
 252     // ------------------------------------------------------------------------
 253     // Constructors
 254     // ------------------------------------------------------------------------
 255
 256     public ResourcesView() {
 257         super(ID);
 258         fDisplayWidth = Display.getDefault().getBounds().width;
 259     }
 260
 261     // ------------------------------------------------------------------------
 262     // ViewPart
 263     // ------------------------------------------------------------------------
 264
 265     /* (non-Javadoc)
 266      * @see org.eclipse.linuxtools.tmf.ui.views.TmfView#createPartControl(org.eclipse.swt.widgets.Composite)
 267      */
 268     @Override
 269     public void createPartControl(Composite parent) {
 270         fTimeGraphViewer = new TimeGraphViewer(parent, SWT.NONE);
 271
 272         fTimeGraphViewer.setTimeGraphProvider(new ResourcesPresentationProvider());
 273
 274         fTimeGraphViewer.setTimeCalendarFormat(true);
 275
 276         fTimeGraphViewer.addRangeListener(new ITimeGraphRangeListener() {
 277             @Override
 278             public void timeRangeUpdated(TimeGraphRangeUpdateEvent event) {
 279                 long startTime = event.getStartTime();
 280                 long endTime = event.getEndTime();
 281                 TmfTimeRange range = new TmfTimeRange(new CtfTmfTimestamp(startTime), new CtfTmfTimestamp(endTime));
 282                 TmfTimestamp time = new CtfTmfTimestamp(fTimeGraphViewer.getSelectedTime());
 283                 broadcast(new TmfRangeSynchSignal(ResourcesView.this, range, time));
 284                 startZoomThread(startTime, endTime);
 285             }
 286         });
 287
 288         fTimeGraphViewer.addTimeListener(new ITimeGraphTimeListener() {
 289             @Override
 290             public void timeSelected(TimeGraphTimeEvent event) {
 291                 long time = event.getTime();
 292                 broadcast(new TmfTimeSynchSignal(ResourcesView.this, new CtfTmfTimestamp(time)));
 293             }
 294         });
 295
 296         final Thread thread = new Thread("ResourcesView build") { //$NON-NLS-1$
 297             @Override
 298             public void run() {
 299                 if (TmfExperiment.getCurrentExperiment() != null) {
 300                     selectExperiment(TmfExperiment.getCurrentExperiment());
 301                 }
 302             }
 303         };
 304         thread.start();
 305
 306         // View Action Handling
 307         makeActions();
 308         contributeToActionBars();
 309     }
 310
 311     /* (non-Javadoc)
 312      * @see org.eclipse.ui.part.WorkbenchPart#setFocus()
 313      */
 314     @Override
 315     public void setFocus() {
 316         fTimeGraphViewer.setFocus();
 317     }
 318
 319     // ------------------------------------------------------------------------
 320     // Signal handlers
 321     // ------------------------------------------------------------------------
 322
 323     @TmfSignalHandler
 324     public void experimentSelected(final TmfExperimentSelectedSignal<? extends TmfEvent> signal) {
 325         if (signal.getExperiment().equals(fSelectedExperiment)) {
 326             return;
 327         }
 328
 329         final Thread thread = new Thread("ResourcesView build") { //$NON-NLS-1$
 330             @Override
 331             public void run() {
 332                 selectExperiment(signal.getExperiment());
 333             }
 334         };
 335         thread.start();
 336     }
 337
 338     @TmfSignalHandler
 339     public void synchToTime(final TmfTimeSynchSignal signal) {
 340         if (signal.getSource() == this || fSelectedExperiment == null) {
 341             return;
 342         }
 343         final long time = signal.getCurrentTime().normalize(0, -9).getValue();
 344         Display.getDefault().asyncExec(new Runnable() {
 345             @Override
 346             public void run() {
 347                 if (fTimeGraphViewer.getControl().isDisposed()) {
 348                     return;
 349                 }
 350                 fTimeGraphViewer.setSelectedTime(time, true);
 351                 startZoomThread(fTimeGraphViewer.getTime0(), fTimeGraphViewer.getTime1());
 352             }
 353         });
 354     }
 355
 356     @TmfSignalHandler
 357     public void synchToRange(final TmfRangeSynchSignal signal) {
 358         if (signal.getSource() == this || fSelectedExperiment == null) {
 359             return;
 360         }
 361         final long startTime = signal.getCurrentRange().getStartTime().normalize(0, -9).getValue();
 362         final long endTime = signal.getCurrentRange().getEndTime().normalize(0, -9).getValue();
 363         final long time = signal.getCurrentTime().normalize(0, -9).getValue();
 364         Display.getDefault().asyncExec(new Runnable() {
 365             @Override
 366             public void run() {
 367                 if (fTimeGraphViewer.getControl().isDisposed()) {
 368                     return;
 369                 }
 370                 fTimeGraphViewer.setStartFinishTime(startTime, endTime);
 371                 fTimeGraphViewer.setSelectedTime(time, false);
 372                 startZoomThread(startTime, endTime);
 373             }
 374         });
 375     }
 376
 377     @TmfSignalHandler
 378     public void stateSystemBuildCompleted (final TmfStateSystemBuildCompleted signal) {
 379         final TmfExperiment<?> selectedExperiment = fSelectedExperiment;
 380         if (selectedExperiment == null) {
 381             return;
 382         }
 383         for (ITmfTrace<?> trace : selectedExperiment.getTraces()) {
 384             if (trace == signal.getTrace() && trace instanceof CtfKernelTrace) {
 385                 final Thread thread = new Thread("ResourcesView build") { //$NON-NLS-1$
 386                     @Override
 387                     public void run() {
 388                         // rebuild the model
 389                         selectExperiment(selectedExperiment);
 390                     }
 391                 };
 392                 thread.start();
 393             }
 394         }
 395     }
 396
 397     // ------------------------------------------------------------------------
 398     // Internal
 399     // ------------------------------------------------------------------------
 400
 401     @SuppressWarnings("unchecked")
 402     private void selectExperiment(TmfExperiment<?> experiment) {
 403         fStartTime = Long.MAX_VALUE;
 404         fEndTime = Long.MIN_VALUE;
 405         fSelectedExperiment = (TmfExperiment<ITmfEvent>) experiment;
 406         ArrayList<TraceEntry> entryList = new ArrayList<TraceEntry>();
 407         for (ITmfTrace<?> trace : experiment.getTraces()) {
 408             if (trace instanceof CtfKernelTrace) {
 409                 CtfKernelTrace ctfKernelTrace = (CtfKernelTrace) trace;
 410                 IStateSystemQuerier ssq = ctfKernelTrace.getStateSystem();
 411                 long startTime = ssq.getStartTime();
 412                 long endTime = ssq.getCurrentEndTime() + 1;
 413                 TraceEntry groupEntry = new TraceEntry(ctfKernelTrace, trace.getName(), startTime, endTime);
 414                 entryList.add(groupEntry);
 415                 fStartTime = Math.min(fStartTime, startTime);
 416                 fEndTime = Math.max(fEndTime, endTime);
 417                 List<Integer> cpuQuarks = ssq.getQuarks(Attributes.CPUS, "*"); //$NON-NLS-1$
 418                 ResourcesEntry[] cpuEntries = new ResourcesEntry[cpuQuarks.size()];
 419                 for (int i = 0; i < cpuQuarks.size(); i++) {
 420                     int cpuQuark = cpuQuarks.get(i);
 421                     int cpu = Integer.parseInt(ssq.getAttributeName(cpuQuark));
 422                     ResourcesEntry entry = new ResourcesEntry(cpuQuark, ctfKernelTrace, Type.CPU, cpu);
 423                     groupEntry.addChild(entry);
 424                     cpuEntries[i] = entry;
 425                 }
 426                 List<Integer> irqQuarks = ssq.getQuarks(Attributes.RESOURCES, Attributes.IRQS, "*"); //$NON-NLS-1$
 427                 ResourcesEntry[] irqEntries = new ResourcesEntry[irqQuarks.size()];
 428                 for (int i = 0; i < irqQuarks.size(); i++) {
 429                     int irqQuark = irqQuarks.get(i);
 430                     int irq = Integer.parseInt(ssq.getAttributeName(irqQuark));
 431                     ResourcesEntry entry = new ResourcesEntry(irqQuark, ctfKernelTrace, Type.IRQ, irq);
 432                     groupEntry.addChild(entry);
 433                     irqEntries[i] = entry;
 434                 }
 435                 List<Integer> softIrqQuarks = ssq.getQuarks(Attributes.RESOURCES, Attributes.SOFT_IRQS, "*"); //$NON-NLS-1$
 436                 ResourcesEntry[] softIrqEntries = new ResourcesEntry[softIrqQuarks.size()];
 437                 for (int i = 0; i < softIrqQuarks.size(); i++) {
 438                     int softIrqQuark = softIrqQuarks.get(i);
 439                     int softIrq = Integer.parseInt(ssq.getAttributeName(softIrqQuark));
 440                     ResourcesEntry entry = new ResourcesEntry(softIrqQuark, ctfKernelTrace, Type.SOFT_IRQ, softIrq);
 441                     groupEntry.addChild(entry);
 442                     softIrqEntries[i] = entry;
 443                 }
 444             }
 445         }
 446         fEntryList = entryList;
 447         refresh(INITIAL_WINDOW_OFFSET);
 448         for (TraceEntry traceEntry : fEntryList) {
 449             CtfKernelTrace ctfKernelTrace = ((TraceEntry) traceEntry).getTrace();
 450             IStateSystemQuerier ssq = ctfKernelTrace.getStateSystem();
 451             long startTime = ssq.getStartTime();
 452             long endTime = ssq.getCurrentEndTime() + 1;
 453             long resolution = (endTime - startTime) / fDisplayWidth;
 454             for (ResourcesEntry entry : traceEntry.getChildren()) {
 455                 List<ITimeEvent> eventList = getEventList(entry, startTime, endTime, resolution, false, new NullProgressMonitor());
 456                 entry.setEventList(eventList);
 457                 redraw();
 458             }
 459         }
 460     }
 461
 462     private List<ITimeEvent> getEventList(ResourcesEntry entry, long startTime, long endTime, long resolution, boolean includeNull, IProgressMonitor monitor) {
 463         IStateSystemQuerier ssq = entry.getTrace().getStateSystem();
 464         startTime = Math.max(startTime, ssq.getStartTime());
 465         endTime = Math.min(endTime, ssq.getCurrentEndTime() + 1);
 466         if (endTime <= startTime) {
 467             return null;
 468         }
 469         List<ITimeEvent> eventList = null;
 470         int quark = entry.getQuark();
 471         try {
 472             if (entry.getType().equals(Type.CPU)) {
 473                 int statusQuark = ssq.getQuarkRelative(quark, Attributes.STATUS);
 474                 List<ITmfStateInterval> statusIntervals = ssq.queryHistoryRange(statusQuark, startTime, endTime - 1, resolution);
 475                 eventList = new ArrayList<ITimeEvent>(statusIntervals.size());
 476                 long lastEndTime = -1;
 477                 for (ITmfStateInterval statusInterval : statusIntervals) {
 478                     if (monitor.isCanceled()) {
 479                         return null;
 480                     }
 481                     int status = statusInterval.getStateValue().unboxInt();
 482                     long time = statusInterval.getStartTime();
 483                     long duration = statusInterval.getEndTime() - time + 1;
 484                     if (!statusInterval.getStateValue().isNull()) {
 485                         if (lastEndTime != time && lastEndTime != -1) {
 486                             eventList.add(new TimeEvent(entry, lastEndTime, time - lastEndTime));
 487                         }
 488                         eventList.add(new ResourcesEvent(entry, time, duration, status));
 489                         lastEndTime = time + duration;
 490                     } else {
 491                         if (includeNull) {
 492                             eventList.add(new ResourcesEvent(entry, time, duration));
 493                         }
 494                     }
 495                 }
 496             } else if (entry.getType().equals(Type.IRQ)) {
 497                 List<ITmfStateInterval> irqIntervals = ssq.queryHistoryRange(quark, startTime, endTime - 1, resolution);
 498                 eventList = new ArrayList<ITimeEvent>(irqIntervals.size());
 499                 long lastEndTime = -1;
 500                 boolean lastIsNull = true;
 501                 for (ITmfStateInterval irqInterval : irqIntervals) {
 502                     if (monitor.isCanceled()) {
 503                         return null;
 504                     }
 505                     long time = irqInterval.getStartTime();
 506                     long duration = irqInterval.getEndTime() - time + 1;
 507                     if (!irqInterval.getStateValue().isNull()) {
 508                         int cpu = irqInterval.getStateValue().unboxInt();
 509                         eventList.add(new ResourcesEvent(entry, time, duration, cpu));
 510                         lastIsNull = false;
 511                     } else {
 512                         if (lastEndTime != time && lastEndTime != -1 && lastIsNull) {
 513                             eventList.add(new ResourcesEvent(entry, lastEndTime, time - lastEndTime, -1));
 514                         }
 515                         if (includeNull) {
 516                             eventList.add(new ResourcesEvent(entry, time, duration));
 517                         }
 518                         lastIsNull = true;
 519                     }
 520                     lastEndTime = time + duration;
 521                 }
 522             } else if (entry.getType().equals(Type.SOFT_IRQ)) {
 523                 List<ITmfStateInterval> softIrqIntervals = ssq.queryHistoryRange(quark, startTime, endTime - 1, resolution);
 524                 eventList = new ArrayList<ITimeEvent>(softIrqIntervals.size());
 525                 long lastEndTime = -1;
 526                 boolean lastIsNull = true;
 527                 for (ITmfStateInterval softIrqInterval : softIrqIntervals) {
 528                     if (monitor.isCanceled()) {
 529                         return null;
 530                     }
 531                     long time = softIrqInterval.getStartTime();
 532                     long duration = softIrqInterval.getEndTime() - time + 1;
 533                     if (!softIrqInterval.getStateValue().isNull()) {
 534                         int cpu = softIrqInterval.getStateValue().unboxInt();
 535                         eventList.add(new ResourcesEvent(entry, time, duration, cpu));
 536                     } else {
 537                         if (lastEndTime != time && lastEndTime != -1 && lastIsNull) {
 538                             eventList.add(new ResourcesEvent(entry, lastEndTime, time - lastEndTime, -1));
 539                         }
 540                         if (includeNull) {
 541                             eventList.add(new ResourcesEvent(entry, time, duration));
 542                         }
 543                         lastIsNull = true;
 544                     }
 545                     lastEndTime = time + duration;
 546                 }
 547             }
 548         } catch (AttributeNotFoundException e) {
 549             e.printStackTrace();
 550         } catch (TimeRangeException e) {
 551             e.printStackTrace();
 552         } catch (StateValueTypeException e) {
 553             e.printStackTrace();
 554         }
 555         return eventList;
 556     }
 557
 558     private void refresh(final long windowRange) {
 559         Display.getDefault().asyncExec(new Runnable() {
 560             @Override
 561             public void run() {
 562                 if (fTimeGraphViewer.getControl().isDisposed()) {
 563                     return;
 564                 }
 565                 ITimeGraphEntry[] entries = fEntryList.toArray(new ITimeGraphEntry[0]);
 566                 Arrays.sort(entries, new TraceEntryComparator());
 567                 fTimeGraphViewer.setInput(entries);
 568                 fTimeGraphViewer.setTimeBounds(fStartTime, fEndTime);
 569
 570                 long endTime = fStartTime + windowRange;
 571
 572                 if (fEndTime < endTime) {
 573                     endTime = fEndTime;
 574                 }
 575                 fTimeGraphViewer.setStartFinishTime(fStartTime, endTime);
 576
 577                 startZoomThread(fStartTime, endTime);
 578             }
 579         });
 580     }
 581
 582
 583     private void redraw() {
 584         Display.getDefault().asyncExec(new Runnable() {
 585             @Override
 586             public void run() {
 587                 if (fTimeGraphViewer.getControl().isDisposed()) {
 588                     return;
 589                 }
 590                 fTimeGraphViewer.getControl().redraw();
 591                 fTimeGraphViewer.getControl().update();
 592             }
 593         });
 594     }
 595
 596     private void startZoomThread(long startTime, long endTime) {
 597         if (fZoomThread != null) {
 598             fZoomThread.cancel();
 599         }
 600         fZoomThread = new ZoomThread(startTime, endTime);
 601         fZoomThread.start();
 602     }
 603
 604     private void makeActions() {
 605         fPreviousResourceAction = fTimeGraphViewer.getPreviousItemAction();
 606         fPreviousResourceAction.setText(Messages.ResourcesView_previousResourceActionNameText);
 607         fPreviousResourceAction.setToolTipText(Messages.ResourcesView_previousResourceActionToolTipText);
 608         fNextResourceAction = fTimeGraphViewer.getNextItemAction();
 609         fNextResourceAction.setText(Messages.ResourcesView_nextResourceActionNameText);
 610         fNextResourceAction.setToolTipText(Messages.ResourcesView_previousResourceActionToolTipText);
 611     }
 612
 613     private void contributeToActionBars() {
 614         IActionBars bars = getViewSite().getActionBars();
 615         fillLocalToolBar(bars.getToolBarManager());
 616     }
 617
 618     private void fillLocalToolBar(IToolBarManager manager) {
 619         manager.add(fTimeGraphViewer.getShowLegendAction());
 620         manager.add(new Separator());
 621         manager.add(fTimeGraphViewer.getResetScaleAction());
 622         manager.add(fTimeGraphViewer.getPreviousEventAction());
 623         manager.add(fTimeGraphViewer.getNextEventAction());
 624         manager.add(fPreviousResourceAction);
 625         manager.add(fNextResourceAction);
 626         manager.add(fTimeGraphViewer.getZoomInAction());
 627         manager.add(fTimeGraphViewer.getZoomOutAction());
 628         manager.add(new Separator());
 629     }
 630 }