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