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