1 /*******************************************************************************
2 * Copyright (c) 2012 Ericsson
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
10 * Patrick Tasse - Initial API and implementation
11 *******************************************************************************/
13 package org
.eclipse
.linuxtools
.internal
.lttng2
.kernel
.ui
.views
.resources
;
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
;
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
.TmfTimeRange
;
32 import org
.eclipse
.linuxtools
.tmf
.core
.event
.TmfTimestamp
;
33 import org
.eclipse
.linuxtools
.tmf
.core
.exceptions
.AttributeNotFoundException
;
34 import org
.eclipse
.linuxtools
.tmf
.core
.exceptions
.StateValueTypeException
;
35 import org
.eclipse
.linuxtools
.tmf
.core
.exceptions
.TimeRangeException
;
36 import org
.eclipse
.linuxtools
.tmf
.core
.interval
.ITmfStateInterval
;
37 import org
.eclipse
.linuxtools
.tmf
.core
.signal
.TmfExperimentDisposedSignal
;
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
.TmfStateSystemBuildCompleted
;
42 import org
.eclipse
.linuxtools
.tmf
.core
.signal
.TmfTimeSynchSignal
;
43 import org
.eclipse
.linuxtools
.tmf
.core
.statesystem
.IStateSystemQuerier
;
44 import org
.eclipse
.linuxtools
.tmf
.core
.trace
.ITmfTrace
;
45 import org
.eclipse
.linuxtools
.tmf
.core
.trace
.TmfExperiment
;
46 import org
.eclipse
.linuxtools
.tmf
.ui
.views
.TmfView
;
47 import org
.eclipse
.linuxtools
.tmf
.ui
.widgets
.timegraph
.ITimeGraphRangeListener
;
48 import org
.eclipse
.linuxtools
.tmf
.ui
.widgets
.timegraph
.ITimeGraphTimeListener
;
49 import org
.eclipse
.linuxtools
.tmf
.ui
.widgets
.timegraph
.TimeGraphRangeUpdateEvent
;
50 import org
.eclipse
.linuxtools
.tmf
.ui
.widgets
.timegraph
.TimeGraphTimeEvent
;
51 import org
.eclipse
.linuxtools
.tmf
.ui
.widgets
.timegraph
.TimeGraphViewer
;
52 import org
.eclipse
.linuxtools
.tmf
.ui
.widgets
.timegraph
.model
.ITimeEvent
;
53 import org
.eclipse
.linuxtools
.tmf
.ui
.widgets
.timegraph
.model
.ITimeGraphEntry
;
54 import org
.eclipse
.linuxtools
.tmf
.ui
.widgets
.timegraph
.model
.TimeEvent
;
55 import org
.eclipse
.swt
.SWT
;
56 import org
.eclipse
.swt
.widgets
.Composite
;
57 import org
.eclipse
.swt
.widgets
.Display
;
58 import org
.eclipse
.ui
.IActionBars
;
61 * Main implementation for the LTTng 2.0 kernel Resource view
63 * @author Patrick Tasse
65 public class ResourcesView
extends TmfView
{
67 // ------------------------------------------------------------------------
69 // ------------------------------------------------------------------------
72 public static final String ID
= "org.eclipse.linuxtools.lttng2.kernel.ui.views.resources"; //$NON-NLS-1$
74 /** Initial time range */
75 private static final long INITIAL_WINDOW_OFFSET
= (1L * 100 * 1000 * 1000); // .1sec
80 private enum State
{ IDLE
, BUSY
, PENDING
}
82 // ------------------------------------------------------------------------
84 // ------------------------------------------------------------------------
86 // The time graph viewer
87 TimeGraphViewer fTimeGraphViewer
;
89 // The selected experiment
90 private TmfExperiment fSelectedExperiment
;
92 // The time graph entry list
93 private ArrayList
<TraceEntry
> fEntryList
;
95 // The time graph entry list synchronization object
96 final private Object fEntryListSyncObj
= new Object();
99 private long fStartTime
;
102 private long fEndTime
;
105 private final int fDisplayWidth
;
107 // The next resource action
108 private Action fNextResourceAction
;
110 // The previous resource action
111 private Action fPreviousResourceAction
;
114 private ZoomThread fZoomThread
;
116 // The redraw state used to prevent unnecessary queuing of display runnables
117 private State fRedrawState
= State
.IDLE
;
119 // The redraw synchronization object
120 final private Object fSyncObj
= new Object();
122 // ------------------------------------------------------------------------
124 // ------------------------------------------------------------------------
126 private class TraceEntry
implements ITimeGraphEntry
{
128 private final CtfKernelTrace fTrace
;
130 private final long fTraceStartTime
;
132 private final long fTraceEndTime
;
133 // The children of the entry
134 private final ArrayList
<ResourcesEntry
> fChildren
;
136 private final String fName
;
138 public TraceEntry(CtfKernelTrace trace
, String name
, long startTime
, long endTime
) {
140 fChildren
= new ArrayList
<ResourcesEntry
>();
142 fTraceStartTime
= startTime
;
143 fTraceEndTime
= endTime
;
147 public ITimeGraphEntry
getParent() {
152 public boolean hasChildren() {
153 return fChildren
!= null && fChildren
.size() > 0;
157 public ResourcesEntry
[] getChildren() {
158 return fChildren
.toArray(new ResourcesEntry
[0]);
162 public String
getName() {
167 public long getStartTime() {
168 return fTraceStartTime
;
172 public long getEndTime() {
173 return fTraceEndTime
;
177 public boolean hasTimeEvents() {
182 public Iterator
<ITimeEvent
> getTimeEventsIterator() {
187 public <T
extends ITimeEvent
> Iterator
<T
> getTimeEventsIterator(long startTime
, long stopTime
, long visibleDuration
) {
191 public CtfKernelTrace
getTrace() {
195 public void addChild(ResourcesEntry entry
) {
197 for (index
= 0; index
< fChildren
.size(); index
++) {
198 ResourcesEntry other
= fChildren
.get(index
);
199 if (entry
.getType().compareTo(other
.getType()) < 0) {
201 } else if (entry
.getType().equals(other
.getType())) {
202 if (entry
.getId() < other
.getId()) {
207 entry
.setParent(this);
208 fChildren
.add(index
, entry
);
212 private static class TraceEntryComparator
implements Comparator
<ITimeGraphEntry
> {
214 public int compare(ITimeGraphEntry o1
, ITimeGraphEntry o2
) {
215 int result
= o1
.getStartTime() < o2
.getStartTime() ?
-1 : o1
.getStartTime() > o2
.getStartTime() ?
1 : 0;
217 result
= o1
.getName().compareTo(o2
.getName());
223 private class ZoomThread
extends Thread
{
224 private final long fZoomStartTime
;
225 private final long fZoomEndTime
;
226 private final IProgressMonitor fMonitor
;
228 public ZoomThread(long startTime
, long endTime
) {
229 super("ResourcesView zoom"); //$NON-NLS-1$
230 fZoomStartTime
= startTime
;
231 fZoomEndTime
= endTime
;
232 fMonitor
= new NullProgressMonitor();
237 ArrayList
<TraceEntry
> entryList
= null;
238 synchronized (fEntryListSyncObj
) {
239 entryList
= (ArrayList
<TraceEntry
>) fEntryList
.clone();
241 if (entryList
== null) {
244 long resolution
= Math
.max(1, (fZoomEndTime
- fZoomStartTime
) / fDisplayWidth
);
245 for (TraceEntry traceEntry
: entryList
) {
246 for (ITimeGraphEntry child
: traceEntry
.getChildren()) {
247 if (fMonitor
.isCanceled()) {
250 ResourcesEntry entry
= (ResourcesEntry
) child
;
251 if (fZoomStartTime
<= fStartTime
&& fZoomEndTime
>= fEndTime
) {
252 entry
.setZoomedEventList(null);
254 List
<ITimeEvent
> zoomedEventList
= getEventList(entry
, fZoomStartTime
, fZoomEndTime
, resolution
, true, fMonitor
);
255 if (zoomedEventList
!= null) {
256 entry
.setZoomedEventList(zoomedEventList
);
264 public void cancel() {
265 fMonitor
.setCanceled(true);
269 // ------------------------------------------------------------------------
271 // ------------------------------------------------------------------------
274 * Default constructor
276 public ResourcesView() {
278 fDisplayWidth
= Display
.getDefault().getBounds().width
;
281 // ------------------------------------------------------------------------
283 // ------------------------------------------------------------------------
286 * @see org.eclipse.linuxtools.tmf.ui.views.TmfView#createPartControl(org.eclipse.swt.widgets.Composite)
289 public void createPartControl(Composite parent
) {
290 fTimeGraphViewer
= new TimeGraphViewer(parent
, SWT
.NONE
);
292 fTimeGraphViewer
.setTimeGraphProvider(new ResourcesPresentationProvider());
294 fTimeGraphViewer
.setTimeCalendarFormat(true);
296 fTimeGraphViewer
.addRangeListener(new ITimeGraphRangeListener() {
298 public void timeRangeUpdated(TimeGraphRangeUpdateEvent event
) {
299 long startTime
= event
.getStartTime();
300 long endTime
= event
.getEndTime();
301 TmfTimeRange range
= new TmfTimeRange(new CtfTmfTimestamp(startTime
), new CtfTmfTimestamp(endTime
));
302 TmfTimestamp time
= new CtfTmfTimestamp(fTimeGraphViewer
.getSelectedTime());
303 broadcast(new TmfRangeSynchSignal(ResourcesView
.this, range
, time
));
304 startZoomThread(startTime
, endTime
);
308 fTimeGraphViewer
.addTimeListener(new ITimeGraphTimeListener() {
310 public void timeSelected(TimeGraphTimeEvent event
) {
311 long time
= event
.getTime();
312 broadcast(new TmfTimeSynchSignal(ResourcesView
.this, new CtfTmfTimestamp(time
)));
316 final Thread thread
= new Thread("ResourcesView build") { //$NON-NLS-1$
319 if (TmfExperiment
.getCurrentExperiment() != null) {
320 selectExperiment(TmfExperiment
.getCurrentExperiment());
326 // View Action Handling
328 contributeToActionBars();
332 * @see org.eclipse.ui.part.WorkbenchPart#setFocus()
335 public void setFocus() {
336 refresh(INITIAL_WINDOW_OFFSET
);
337 fTimeGraphViewer
.setFocus();
340 // ------------------------------------------------------------------------
342 // ------------------------------------------------------------------------
345 * Handler for the ExperimentSelected signal
348 * The incoming signal
351 public void experimentSelected(final TmfExperimentSelectedSignal signal
) {
352 if (signal
.getExperiment().equals(fSelectedExperiment
)) {
356 final Thread thread
= new Thread("ResourcesView build") { //$NON-NLS-1$
359 selectExperiment(signal
.getExperiment());
366 * Experiment is disposed: clear the data structures and the view
368 * @param signal the signal received
371 public void experimentDisposed(final TmfExperimentDisposedSignal signal
) {
372 if (signal
.getExperiment().equals(fSelectedExperiment
)) {
373 fSelectedExperiment
= null;
376 fZoomThread
.cancel();
377 synchronized(fEntryListSyncObj
) {
380 refresh(INITIAL_WINDOW_OFFSET
);
385 * Handler for the TimeSynch signal
388 * The incoming signal
391 public void synchToTime(final TmfTimeSynchSignal signal
) {
392 if (signal
.getSource() == this || fSelectedExperiment
== null) {
395 final long time
= signal
.getCurrentTime().normalize(0, -9).getValue();
396 Display
.getDefault().asyncExec(new Runnable() {
399 if (fTimeGraphViewer
.getControl().isDisposed()) {
402 fTimeGraphViewer
.setSelectedTime(time
, true);
403 startZoomThread(fTimeGraphViewer
.getTime0(), fTimeGraphViewer
.getTime1());
409 * Handler for the RangeSynch signal
412 * The incoming signal
415 public void synchToRange(final TmfRangeSynchSignal signal
) {
416 if (signal
.getSource() == this || fSelectedExperiment
== null) {
419 final long startTime
= signal
.getCurrentRange().getStartTime().normalize(0, -9).getValue();
420 final long endTime
= signal
.getCurrentRange().getEndTime().normalize(0, -9).getValue();
421 final long time
= signal
.getCurrentTime().normalize(0, -9).getValue();
422 Display
.getDefault().asyncExec(new Runnable() {
425 if (fTimeGraphViewer
.getControl().isDisposed()) {
428 fTimeGraphViewer
.setStartFinishTime(startTime
, endTime
);
429 fTimeGraphViewer
.setSelectedTime(time
, false);
430 startZoomThread(startTime
, endTime
);
436 * Handler for the StatesystemBuildCompleted signal
439 * The incoming signal
442 public void stateSystemBuildCompleted (final TmfStateSystemBuildCompleted signal
) {
443 final TmfExperiment selectedExperiment
= fSelectedExperiment
;
444 if (selectedExperiment
== null || selectedExperiment
.getTraces() == null) {
447 for (ITmfTrace trace
: selectedExperiment
.getTraces()) {
448 if (trace
== signal
.getTrace() && trace
instanceof CtfKernelTrace
) {
449 final Thread thread
= new Thread("ResourcesView build") { //$NON-NLS-1$
453 selectExperiment(selectedExperiment
);
461 // ------------------------------------------------------------------------
463 // ------------------------------------------------------------------------
465 private void selectExperiment(TmfExperiment experiment
) {
466 fStartTime
= Long
.MAX_VALUE
;
467 fEndTime
= Long
.MIN_VALUE
;
468 fSelectedExperiment
= experiment
;
469 ArrayList
<TraceEntry
> entryList
= new ArrayList
<TraceEntry
>();
470 for (ITmfTrace trace
: experiment
.getTraces()) {
471 if (trace
instanceof CtfKernelTrace
) {
472 CtfKernelTrace ctfKernelTrace
= (CtfKernelTrace
) trace
;
473 IStateSystemQuerier ssq
= ctfKernelTrace
.getStateSystem();
474 long startTime
= ssq
.getStartTime();
475 long endTime
= ssq
.getCurrentEndTime() + 1;
476 TraceEntry groupEntry
= new TraceEntry(ctfKernelTrace
, trace
.getName(), startTime
, endTime
);
477 entryList
.add(groupEntry
);
478 fStartTime
= Math
.min(fStartTime
, startTime
);
479 fEndTime
= Math
.max(fEndTime
, endTime
);
480 List
<Integer
> cpuQuarks
= ssq
.getQuarks(Attributes
.CPUS
, "*"); //$NON-NLS-1$
481 ResourcesEntry
[] cpuEntries
= new ResourcesEntry
[cpuQuarks
.size()];
482 for (int i
= 0; i
< cpuQuarks
.size(); i
++) {
483 int cpuQuark
= cpuQuarks
.get(i
);
484 int cpu
= Integer
.parseInt(ssq
.getAttributeName(cpuQuark
));
485 ResourcesEntry entry
= new ResourcesEntry(cpuQuark
, ctfKernelTrace
, Type
.CPU
, cpu
);
486 groupEntry
.addChild(entry
);
487 cpuEntries
[i
] = entry
;
489 List
<Integer
> irqQuarks
= ssq
.getQuarks(Attributes
.RESOURCES
, Attributes
.IRQS
, "*"); //$NON-NLS-1$
490 ResourcesEntry
[] irqEntries
= new ResourcesEntry
[irqQuarks
.size()];
491 for (int i
= 0; i
< irqQuarks
.size(); i
++) {
492 int irqQuark
= irqQuarks
.get(i
);
493 int irq
= Integer
.parseInt(ssq
.getAttributeName(irqQuark
));
494 ResourcesEntry entry
= new ResourcesEntry(irqQuark
, ctfKernelTrace
, Type
.IRQ
, irq
);
495 groupEntry
.addChild(entry
);
496 irqEntries
[i
] = entry
;
498 List
<Integer
> softIrqQuarks
= ssq
.getQuarks(Attributes
.RESOURCES
, Attributes
.SOFT_IRQS
, "*"); //$NON-NLS-1$
499 ResourcesEntry
[] softIrqEntries
= new ResourcesEntry
[softIrqQuarks
.size()];
500 for (int i
= 0; i
< softIrqQuarks
.size(); i
++) {
501 int softIrqQuark
= softIrqQuarks
.get(i
);
502 int softIrq
= Integer
.parseInt(ssq
.getAttributeName(softIrqQuark
));
503 ResourcesEntry entry
= new ResourcesEntry(softIrqQuark
, ctfKernelTrace
, Type
.SOFT_IRQ
, softIrq
);
504 groupEntry
.addChild(entry
);
505 softIrqEntries
[i
] = entry
;
509 synchronized (fEntryListSyncObj
) {
510 fEntryList
= (ArrayList
<TraceEntry
>) entryList
.clone();
512 refresh(INITIAL_WINDOW_OFFSET
);
513 for (TraceEntry traceEntry
: entryList
) {
514 CtfKernelTrace ctfKernelTrace
= traceEntry
.getTrace();
515 IStateSystemQuerier ssq
= ctfKernelTrace
.getStateSystem();
516 long startTime
= ssq
.getStartTime();
517 long endTime
= ssq
.getCurrentEndTime() + 1;
518 long resolution
= (endTime
- startTime
) / fDisplayWidth
;
519 for (ResourcesEntry entry
: traceEntry
.getChildren()) {
520 List
<ITimeEvent
> eventList
= getEventList(entry
, startTime
, endTime
, resolution
, false, new NullProgressMonitor());
521 entry
.setEventList(eventList
);
527 private static List
<ITimeEvent
> getEventList(ResourcesEntry entry
,
528 long startTime
, long endTime
, long resolution
, boolean includeNull
,
529 IProgressMonitor monitor
) {
530 IStateSystemQuerier ssq
= entry
.getTrace().getStateSystem();
531 startTime
= Math
.max(startTime
, ssq
.getStartTime());
532 endTime
= Math
.min(endTime
, ssq
.getCurrentEndTime() + 1);
533 if (endTime
<= startTime
) {
536 List
<ITimeEvent
> eventList
= null;
537 int quark
= entry
.getQuark();
539 if (entry
.getType().equals(Type
.CPU
)) {
540 int statusQuark
= ssq
.getQuarkRelative(quark
, Attributes
.STATUS
);
541 List
<ITmfStateInterval
> statusIntervals
= ssq
.queryHistoryRange(statusQuark
, startTime
, endTime
- 1, resolution
, monitor
);
542 eventList
= new ArrayList
<ITimeEvent
>(statusIntervals
.size());
543 long lastEndTime
= -1;
544 for (ITmfStateInterval statusInterval
: statusIntervals
) {
545 if (monitor
.isCanceled()) {
548 int status
= statusInterval
.getStateValue().unboxInt();
549 long time
= statusInterval
.getStartTime();
550 long duration
= statusInterval
.getEndTime() - time
+ 1;
551 if (!statusInterval
.getStateValue().isNull()) {
552 if (lastEndTime
!= time
&& lastEndTime
!= -1) {
553 eventList
.add(new TimeEvent(entry
, lastEndTime
, time
- lastEndTime
));
555 eventList
.add(new ResourcesEvent(entry
, time
, duration
, status
));
556 lastEndTime
= time
+ duration
;
559 eventList
.add(new ResourcesEvent(entry
, time
, duration
));
563 } else if (entry
.getType().equals(Type
.IRQ
)) {
564 List
<ITmfStateInterval
> irqIntervals
= ssq
.queryHistoryRange(quark
, startTime
, endTime
- 1, resolution
, monitor
);
565 eventList
= new ArrayList
<ITimeEvent
>(irqIntervals
.size());
566 long lastEndTime
= -1;
567 boolean lastIsNull
= true;
568 for (ITmfStateInterval irqInterval
: irqIntervals
) {
569 if (monitor
.isCanceled()) {
572 long time
= irqInterval
.getStartTime();
573 long duration
= irqInterval
.getEndTime() - time
+ 1;
574 if (!irqInterval
.getStateValue().isNull()) {
575 int cpu
= irqInterval
.getStateValue().unboxInt();
576 eventList
.add(new ResourcesEvent(entry
, time
, duration
, cpu
));
579 if (lastEndTime
!= time
&& lastEndTime
!= -1 && lastIsNull
) {
580 eventList
.add(new ResourcesEvent(entry
, lastEndTime
, time
- lastEndTime
, -1));
583 eventList
.add(new ResourcesEvent(entry
, time
, duration
));
587 lastEndTime
= time
+ duration
;
589 } else if (entry
.getType().equals(Type
.SOFT_IRQ
)) {
590 List
<ITmfStateInterval
> softIrqIntervals
= ssq
.queryHistoryRange(quark
, startTime
, endTime
- 1, resolution
, monitor
);
591 eventList
= new ArrayList
<ITimeEvent
>(softIrqIntervals
.size());
592 long lastEndTime
= -1;
593 boolean lastIsNull
= true;
594 for (ITmfStateInterval softIrqInterval
: softIrqIntervals
) {
595 if (monitor
.isCanceled()) {
598 long time
= softIrqInterval
.getStartTime();
599 long duration
= softIrqInterval
.getEndTime() - time
+ 1;
600 if (!softIrqInterval
.getStateValue().isNull()) {
601 int cpu
= softIrqInterval
.getStateValue().unboxInt();
602 eventList
.add(new ResourcesEvent(entry
, time
, duration
, cpu
));
604 if (lastEndTime
!= time
&& lastEndTime
!= -1 && lastIsNull
) {
605 eventList
.add(new ResourcesEvent(entry
, lastEndTime
, time
- lastEndTime
, -1));
608 eventList
.add(new ResourcesEvent(entry
, time
, duration
));
612 lastEndTime
= time
+ duration
;
615 } catch (AttributeNotFoundException e
) {
617 } catch (TimeRangeException e
) {
619 } catch (StateValueTypeException e
) {
625 private void refresh(final long windowRange
) {
626 Display
.getDefault().asyncExec(new Runnable() {
629 if (fTimeGraphViewer
.getControl().isDisposed()) {
632 ITimeGraphEntry
[] entries
= null;
633 synchronized (fEntryListSyncObj
) {
634 if (fEntryList
!= null) {
635 entries
= fEntryList
.toArray(new ITimeGraphEntry
[0]);
638 if (entries
!= null) {
639 Arrays
.sort(entries
, new TraceEntryComparator());
640 fTimeGraphViewer
.setInput(entries
);
641 fTimeGraphViewer
.setTimeBounds(fStartTime
, fEndTime
);
643 long endTime
= fStartTime
+ windowRange
;
645 if (fEndTime
< endTime
) {
648 fTimeGraphViewer
.setStartFinishTime(fStartTime
, endTime
);
650 startZoomThread(fStartTime
, endTime
);
656 private void redraw() {
657 synchronized (fSyncObj
) {
658 if (fRedrawState
== State
.IDLE
) {
659 fRedrawState
= State
.BUSY
;
661 fRedrawState
= State
.PENDING
;
665 Display
.getDefault().asyncExec(new Runnable() {
668 if (fTimeGraphViewer
.getControl().isDisposed()) {
671 fTimeGraphViewer
.getControl().redraw();
672 fTimeGraphViewer
.getControl().update();
673 synchronized (fSyncObj
) {
674 if (fRedrawState
== State
.PENDING
) {
675 fRedrawState
= State
.IDLE
;
678 fRedrawState
= State
.IDLE
;
685 private void startZoomThread(long startTime
, long endTime
) {
686 if (fZoomThread
!= null) {
687 fZoomThread
.cancel();
689 fZoomThread
= new ZoomThread(startTime
, endTime
);
693 private void makeActions() {
694 fPreviousResourceAction
= fTimeGraphViewer
.getPreviousItemAction();
695 fPreviousResourceAction
.setText(Messages
.ResourcesView_previousResourceActionNameText
);
696 fPreviousResourceAction
.setToolTipText(Messages
.ResourcesView_previousResourceActionToolTipText
);
697 fNextResourceAction
= fTimeGraphViewer
.getNextItemAction();
698 fNextResourceAction
.setText(Messages
.ResourcesView_nextResourceActionNameText
);
699 fNextResourceAction
.setToolTipText(Messages
.ResourcesView_previousResourceActionToolTipText
);
702 private void contributeToActionBars() {
703 IActionBars bars
= getViewSite().getActionBars();
704 fillLocalToolBar(bars
.getToolBarManager());
707 private void fillLocalToolBar(IToolBarManager manager
) {
708 manager
.add(fTimeGraphViewer
.getShowLegendAction());
709 manager
.add(new Separator());
710 manager
.add(fTimeGraphViewer
.getResetScaleAction());
711 manager
.add(fTimeGraphViewer
.getPreviousEventAction());
712 manager
.add(fTimeGraphViewer
.getNextEventAction());
713 manager
.add(fPreviousResourceAction
);
714 manager
.add(fNextResourceAction
);
715 manager
.add(fTimeGraphViewer
.getZoomInAction());
716 manager
.add(fTimeGraphViewer
.getZoomOutAction());
717 manager
.add(new Separator());