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                     ResourcesEntry entry = (ResourcesEntry) child;
 231                     if (fZoomStartTime <= entry.getStartTime() && fZoomEndTime >= entry.getEndTime()) {
 232                         entry.setZoomedEventList(null);
 233                         return;
 234                     }
 235                     if (fMonitor.isCanceled()) {
 236                         break;
 237                     }
 238                     List<ITimeEvent> zoomedEventList = getEventList(entry, fZoomStartTime, fZoomEndTime, resolution, true, fMonitor);
 239                     if (fMonitor.isCanceled()) {
 240                         break;
 241                     }
 242                     entry.setZoomedEventList(zoomedEventList);
 243                     redraw();
 244                 }
 245             }
 246         }
 247
 248         public void cancel() {
 249             fMonitor.setCanceled(true);
 250         }
 251     }
 252
 253     // ------------------------------------------------------------------------
 254     // Constructors
 255     // ------------------------------------------------------------------------
 256
 257     public ResourcesView() {
 258         super(ID);
 259         fDisplayWidth = Display.getDefault().getBounds().width;
 260     }
 261
 262     // ------------------------------------------------------------------------
 263     // ViewPart
 264     // ------------------------------------------------------------------------
 265
 266     /* (non-Javadoc)
 267      * @see org.eclipse.linuxtools.tmf.ui.views.TmfView#createPartControl(org.eclipse.swt.widgets.Composite)
 268      */
 269     @Override
 270     public void createPartControl(Composite parent) {
 271         fTimeGraphViewer = new TimeGraphViewer(parent, SWT.NONE);
 272
 273         fTimeGraphViewer.setTimeGraphProvider(new ResourcesPresentationProvider());
 274
 275         fTimeGraphViewer.setTimeCalendarFormat(true);
 276
 277         fTimeGraphViewer.addRangeListener(new ITimeGraphRangeListener() {
 278             @Override
 279             public void timeRangeUpdated(TimeGraphRangeUpdateEvent event) {
 280                 long startTime = event.getStartTime();
 281                 long endTime = event.getEndTime();
 282                 TmfTimeRange range = new TmfTimeRange(new CtfTmfTimestamp(startTime), new CtfTmfTimestamp(endTime));
 283                 TmfTimestamp time = new CtfTmfTimestamp(fTimeGraphViewer.getSelectedTime());
 284                 broadcast(new TmfRangeSynchSignal(ResourcesView.this, range, time));
 285                 startZoomThread(startTime, endTime);
 286             }
 287         });
 288
 289         fTimeGraphViewer.addTimeListener(new ITimeGraphTimeListener() {
 290             @Override
 291             public void timeSelected(TimeGraphTimeEvent event) {
 292                 long time = event.getTime();
 293                 broadcast(new TmfTimeSynchSignal(ResourcesView.this, new CtfTmfTimestamp(time)));
 294             }
 295         });
 296
 297         final Thread thread = new Thread("ResourcesView build") { //$NON-NLS-1$
 298             @Override
 299             public void run() {
 300                 if (TmfExperiment.getCurrentExperiment() != null) {
 301                     selectExperiment(TmfExperiment.getCurrentExperiment());
 302                 }
 303             }
 304         };
 305         thread.start();
 306
 307         // View Action Handling
 308         makeActions();
 309         contributeToActionBars();
 310     }
 311
 312     /* (non-Javadoc)
 313      * @see org.eclipse.ui.part.WorkbenchPart#setFocus()
 314      */
 315     @Override
 316     public void setFocus() {
 317         fTimeGraphViewer.setFocus();
 318     }
 319
 320     // ------------------------------------------------------------------------
 321     // Signal handlers
 322     // ------------------------------------------------------------------------
 323
 324     @TmfSignalHandler
 325     public void experimentSelected(final TmfExperimentSelectedSignal<? extends TmfEvent> signal) {
 326         if (signal.getExperiment().equals(fSelectedExperiment)) {
 327             return;
 328         }
 329
 330         final Thread thread = new Thread("ResourcesView build") { //$NON-NLS-1$
 331             @Override
 332             public void run() {
 333                 selectExperiment(signal.getExperiment());
 334             }
 335         };
 336         thread.start();
 337     }
 338
 339     @TmfSignalHandler
 340     public void synchToTime(final TmfTimeSynchSignal signal) {
 341         if (signal.getSource() == this) {
 342             return;
 343         }
 344         final long time = signal.getCurrentTime().normalize(0, -9).getValue();
 345         Display.getDefault().asyncExec(new Runnable() {
 346             @Override
 347             public void run() {
 348                 if (fTimeGraphViewer.getControl().isDisposed()) {
 349                     return;
 350                 }
 351                 fTimeGraphViewer.setSelectedTime(time, true);
 352                 startZoomThread(fTimeGraphViewer.getTime0(), fTimeGraphViewer.getTime1());
 353             }
 354         });
 355     }
 356
 357     @TmfSignalHandler
 358     public void synchToRange(final TmfRangeSynchSignal signal) {
 359         if (signal.getSource() == this) {
 360             return;
 361         }
 362         final long startTime = signal.getCurrentRange().getStartTime().normalize(0, -9).getValue();
 363         final long endTime = signal.getCurrentRange().getEndTime().normalize(0, -9).getValue();
 364         final long time = signal.getCurrentTime().normalize(0, -9).getValue();
 365         Display.getDefault().asyncExec(new Runnable() {
 366             @Override
 367             public void run() {
 368                 if (fTimeGraphViewer.getControl().isDisposed()) {
 369                     return;
 370                 }
 371                 fTimeGraphViewer.setStartFinishTime(startTime, endTime);
 372                 fTimeGraphViewer.setSelectedTime(time, false);
 373                 startZoomThread(startTime, endTime);
 374             }
 375         });
 376     }
 377
 378     @TmfSignalHandler
 379     public void stateSystemBuildCompleted (final TmfStateSystemBuildCompleted signal) {
 380         final TmfExperiment<?> selectedExperiment = fSelectedExperiment;
 381         if (selectedExperiment == null) {
 382             return;
 383         }
 384         for (ITmfTrace<?> trace : selectedExperiment.getTraces()) {
 385             if (trace == signal.getTrace() && trace instanceof CtfKernelTrace) {
 386                 final Thread thread = new Thread("ResourcesView build") { //$NON-NLS-1$
 387                     @Override
 388                     public void run() {
 389                         // rebuild the model
 390                         selectExperiment(selectedExperiment);
 391                     }
 392                 };
 393                 thread.start();
 394             }
 395         }
 396     }
 397
 398     // ------------------------------------------------------------------------
 399     // Internal
 400     // ------------------------------------------------------------------------
 401
 402     @SuppressWarnings("unchecked")
 403     private void selectExperiment(TmfExperiment<?> experiment) {
 404         fStartTime = Long.MAX_VALUE;
 405         fEndTime = Long.MIN_VALUE;
 406         fSelectedExperiment = (TmfExperiment<ITmfEvent>) experiment;
 407         ArrayList<TraceEntry> entryList = new ArrayList<TraceEntry>();
 408         for (ITmfTrace<?> trace : experiment.getTraces()) {
 409             if (trace instanceof CtfKernelTrace) {
 410                 CtfKernelTrace ctfKernelTrace = (CtfKernelTrace) trace;
 411                 IStateSystemQuerier ssq = ctfKernelTrace.getStateSystem();
 412                 long startTime = ssq.getStartTime();
 413                 long endTime = ssq.getCurrentEndTime() + 1;
 414                 TraceEntry groupEntry = new TraceEntry(ctfKernelTrace, trace.getName(), startTime, endTime);
 415                 entryList.add(groupEntry);
 416                 fStartTime = Math.min(fStartTime, startTime);
 417                 fEndTime = Math.max(fEndTime, endTime);
 418                 List<Integer> cpuQuarks = ssq.getQuarks(Attributes.CPUS, "*"); //$NON-NLS-1$
 419                 ResourcesEntry[] cpuEntries = new ResourcesEntry[cpuQuarks.size()];
 420                 for (int i = 0; i < cpuQuarks.size(); i++) {
 421                     int cpuQuark = cpuQuarks.get(i);
 422                     int cpu = Integer.parseInt(ssq.getAttributeName(cpuQuark));
 423                     ResourcesEntry entry = new ResourcesEntry(cpuQuark, ctfKernelTrace, Type.CPU, cpu);
 424                     groupEntry.addChild(entry);
 425                     cpuEntries[i] = entry;
 426                 }
 427                 List<Integer> irqQuarks = ssq.getQuarks(Attributes.RESOURCES, Attributes.IRQS, "*"); //$NON-NLS-1$
 428                 ResourcesEntry[] irqEntries = new ResourcesEntry[irqQuarks.size()];
 429                 for (int i = 0; i < irqQuarks.size(); i++) {
 430                     int irqQuark = irqQuarks.get(i);
 431                     int irq = Integer.parseInt(ssq.getAttributeName(irqQuark));
 432                     ResourcesEntry entry = new ResourcesEntry(irqQuark, ctfKernelTrace, Type.IRQ, irq);
 433                     groupEntry.addChild(entry);
 434                     irqEntries[i] = entry;
 435                 }
 436                 List<Integer> softIrqQuarks = ssq.getQuarks(Attributes.RESOURCES, Attributes.SOFT_IRQS, "*"); //$NON-NLS-1$
 437                 ResourcesEntry[] softIrqEntries = new ResourcesEntry[softIrqQuarks.size()];
 438                 for (int i = 0; i < softIrqQuarks.size(); i++) {
 439                     int softIrqQuark = softIrqQuarks.get(i);
 440                     int softIrq = Integer.parseInt(ssq.getAttributeName(softIrqQuark));
 441                     ResourcesEntry entry = new ResourcesEntry(softIrqQuark, ctfKernelTrace, Type.SOFT_IRQ, softIrq);
 442                     groupEntry.addChild(entry);
 443                     softIrqEntries[i] = entry;
 444                 }
 445             }
 446         }
 447         fEntryList = entryList;
 448         refresh(INITIAL_WINDOW_OFFSET);
 449         for (TraceEntry traceEntry : fEntryList) {
 450             CtfKernelTrace ctfKernelTrace = ((TraceEntry) traceEntry).getTrace();
 451             IStateSystemQuerier ssq = ctfKernelTrace.getStateSystem();
 452             long startTime = ssq.getStartTime();
 453             long endTime = ssq.getCurrentEndTime() + 1;
 454             long resolution = (endTime - startTime) / fDisplayWidth;
 455             for (ResourcesEntry entry : traceEntry.getChildren()) {
 456                 List<ITimeEvent> eventList = getEventList(entry, startTime, endTime, resolution, false, new NullProgressMonitor());
 457                 entry.setEventList(eventList);
 458                 redraw();
 459             }
 460         }
 461     }
 462
 463     private List<ITimeEvent> getEventList(ResourcesEntry entry, long startTime, long endTime, long resolution, boolean includeNull, IProgressMonitor monitor) {
 464         IStateSystemQuerier ssq = entry.getTrace().getStateSystem();
 465         startTime = Math.max(startTime, ssq.getStartTime());
 466         endTime = Math.min(endTime, ssq.getCurrentEndTime() + 1);
 467         if (endTime <= startTime) {
 468             return null;
 469         }
 470         List<ITimeEvent> eventList = null;
 471         int quark = entry.getQuark();
 472         try {
 473             if (entry.getType().equals(Type.CPU)) {
 474                 int statusQuark = ssq.getQuarkRelative(quark, Attributes.STATUS);
 475                 List<ITmfStateInterval> statusIntervals = ssq.queryHistoryRange(statusQuark, startTime, endTime - 1, resolution);
 476                 eventList = new ArrayList<ITimeEvent>(statusIntervals.size());
 477                 long lastEndTime = -1;
 478                 for (ITmfStateInterval statusInterval : statusIntervals) {
 479                     if (monitor.isCanceled()) {
 480                         return null;
 481                     }
 482                     int status = statusInterval.getStateValue().unboxInt();
 483                     long time = statusInterval.getStartTime();
 484                     long duration = statusInterval.getEndTime() - time + 1;
 485                     if (!statusInterval.getStateValue().isNull()) {
 486                         if (lastEndTime != time && lastEndTime != -1) {
 487                             eventList.add(new TimeEvent(entry, lastEndTime, time - lastEndTime));
 488                         }
 489                         eventList.add(new ResourcesEvent(entry, time, duration, status));
 490                         lastEndTime = time + duration;
 491                     } else {
 492                         if (includeNull) {
 493                             eventList.add(new ResourcesEvent(entry, time, duration));
 494                         }
 495                     }
 496                 }
 497             } else if (entry.getType().equals(Type.IRQ)) {
 498                 List<ITmfStateInterval> irqIntervals = ssq.queryHistoryRange(quark, startTime, endTime - 1, resolution);
 499                 eventList = new ArrayList<ITimeEvent>(irqIntervals.size());
 500                 long lastEndTime = -1;
 501                 boolean lastIsNull = true;
 502                 for (ITmfStateInterval irqInterval : irqIntervals) {
 503                     if (monitor.isCanceled()) {
 504                         return null;
 505                     }
 506                     long time = irqInterval.getStartTime();
 507                     long duration = irqInterval.getEndTime() - time + 1;
 508                     if (!irqInterval.getStateValue().isNull()) {
 509                         int cpu = irqInterval.getStateValue().unboxInt();
 510                         eventList.add(new ResourcesEvent(entry, time, duration, cpu));
 511                         lastIsNull = false;
 512                     } else {
 513                         if (lastEndTime != time && lastEndTime != -1 && lastIsNull) {
 514                             eventList.add(new ResourcesEvent(entry, lastEndTime, time - lastEndTime, -1));
 515                         }
 516                         if (includeNull) {
 517                             eventList.add(new ResourcesEvent(entry, time, duration));
 518                         }
 519                         lastIsNull = true;
 520                     }
 521                     lastEndTime = time + duration;
 522                 }
 523             } else if (entry.getType().equals(Type.SOFT_IRQ)) {
 524                 List<ITmfStateInterval> softIrqIntervals = ssq.queryHistoryRange(quark, startTime, endTime - 1, resolution);
 525                 eventList = new ArrayList<ITimeEvent>(softIrqIntervals.size());
 526                 long lastEndTime = -1;
 527                 boolean lastIsNull = true;
 528                 for (ITmfStateInterval softIrqInterval : softIrqIntervals) {
 529                     if (monitor.isCanceled()) {
 530                         return null;
 531                     }
 532                     long time = softIrqInterval.getStartTime();
 533                     long duration = softIrqInterval.getEndTime() - time + 1;
 534                     if (!softIrqInterval.getStateValue().isNull()) {
 535                         int cpu = softIrqInterval.getStateValue().unboxInt();
 536                         eventList.add(new ResourcesEvent(entry, time, duration, cpu));
 537                     } else {
 538                         if (lastEndTime != time && lastEndTime != -1 && lastIsNull) {
 539                             eventList.add(new ResourcesEvent(entry, lastEndTime, time - lastEndTime, -1));
 540                         }
 541                         if (includeNull) {
 542                             eventList.add(new ResourcesEvent(entry, time, duration));
 543                         }
 544                         lastIsNull = true;
 545                     }
 546                     lastEndTime = time + duration;
 547                 }
 548             }
 549         } catch (AttributeNotFoundException e) {
 550             e.printStackTrace();
 551         } catch (TimeRangeException e) {
 552             e.printStackTrace();
 553         } catch (StateValueTypeException e) {
 554             e.printStackTrace();
 555         }
 556         return eventList;
 557     }
 558
 559     private void refresh(final long windowRange) {
 560         Display.getDefault().asyncExec(new Runnable() {
 561             @Override
 562             public void run() {
 563                 if (fTimeGraphViewer.getControl().isDisposed()) {
 564                     return;
 565                 }
 566                 ITimeGraphEntry[] entries = fEntryList.toArray(new ITimeGraphEntry[0]);
 567                 Arrays.sort(entries, new TraceEntryComparator());
 568                 fTimeGraphViewer.setInput(entries);
 569                 fTimeGraphViewer.setTimeBounds(fStartTime, fEndTime);
 570
 571                 long endTime = fStartTime + windowRange;
 572
 573                 if (fEndTime < endTime) {
 574                     endTime = fEndTime;
 575                 }
 576                 fTimeGraphViewer.setStartFinishTime(fStartTime, endTime);
 577
 578                 startZoomThread(fStartTime, endTime);
 579             }
 580         });
 581     }
 582
 583
 584     private void redraw() {
 585         Display.getDefault().asyncExec(new Runnable() {
 586             @Override
 587             public void run() {
 588                 if (fTimeGraphViewer.getControl().isDisposed()) {
 589                     return;
 590                 }
 591                 fTimeGraphViewer.getControl().redraw();
 592                 fTimeGraphViewer.getControl().update();
 593             }
 594         });
 595     }
 596
 597     private void startZoomThread(long startTime, long endTime) {
 598         if (fZoomThread != null) {
 599             fZoomThread.cancel();
 600         }
 601         fZoomThread = new ZoomThread(startTime, endTime);
 602         fZoomThread.start();
 603     }
 604
 605     private void makeActions() {
 606         fPreviousResourceAction = fTimeGraphViewer.getPreviousItemAction();
 607         fPreviousResourceAction.setText(Messages.ResourcesView_previousResourceActionNameText);
 608         fPreviousResourceAction.setToolTipText(Messages.ResourcesView_previousResourceActionToolTipText);
 609         fNextResourceAction = fTimeGraphViewer.getNextItemAction();
 610         fNextResourceAction.setText(Messages.ResourcesView_nextResourceActionNameText);
 611         fNextResourceAction.setToolTipText(Messages.ResourcesView_previousResourceActionToolTipText);
 612     }
 613
 614     private void contributeToActionBars() {
 615         IActionBars bars = getViewSite().getActionBars();
 616         fillLocalToolBar(bars.getToolBarManager());
 617     }
 618
 619     private void fillLocalToolBar(IToolBarManager manager) {
 620         manager.add(fTimeGraphViewer.getShowLegendAction());
 621         manager.add(new Separator());
 622         manager.add(fTimeGraphViewer.getResetScaleAction());
 623         manager.add(fTimeGraphViewer.getPreviousEventAction());
 624         manager.add(fTimeGraphViewer.getNextEventAction());
 625         manager.add(fPreviousResourceAction);
 626         manager.add(fNextResourceAction);
 627         manager.add(fTimeGraphViewer.getZoomInAction());
 628         manager.add(fTimeGraphViewer.getZoomOutAction());
 629         manager.add(new Separator());
 630     }
 631 }