org.eclipse.linuxtools.lttng.ui/src/org/eclipse/linuxtools/internal/lttng/ui/views/timeframe/TimeFrameView.java

   1 /*******************************************************************************
   2  * Copyright (c) 2009 2010 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  *   Francois Chouinard - Initial API and implementation
  11  *******************************************************************************/
  12
  13 package org.eclipse.linuxtools.internal.lttng.ui.views.timeframe;
  14
  15 import org.eclipse.linuxtools.tmf.core.event.ITmfTimestamp;
  16 import org.eclipse.linuxtools.tmf.core.event.TmfTimeRange;
  17 import org.eclipse.linuxtools.tmf.core.event.TmfTimestamp;
  18 import org.eclipse.linuxtools.tmf.core.signal.TmfExperimentSelectedSignal;
  19 import org.eclipse.linuxtools.tmf.core.signal.TmfExperimentUpdatedSignal;
  20 import org.eclipse.linuxtools.tmf.core.signal.TmfRangeSynchSignal;
  21 import org.eclipse.linuxtools.tmf.core.signal.TmfSignalHandler;
  22 import org.eclipse.linuxtools.tmf.core.signal.TmfTimeSynchSignal;
  23 import org.eclipse.linuxtools.tmf.core.trace.TmfExperiment;
  24 import org.eclipse.linuxtools.tmf.ui.views.TmfView;
  25 import org.eclipse.swt.SWT;
  26 import org.eclipse.swt.layout.GridData;
  27 import org.eclipse.swt.layout.GridLayout;
  28 import org.eclipse.swt.widgets.Composite;
  29 import org.eclipse.swt.widgets.Event;
  30 import org.eclipse.swt.widgets.Listener;
  31 import org.eclipse.swt.widgets.Slider;
  32
  33 /**
  34  * <b><u>TimeFrameView</u></b>
  35  * <p>
  36  * The TimeFrameView provides a set of spinners to monitor and set the start time, end time, the current time interval
  37  * and current time of the trace set at the nanosecond level.
  38  * <p>
  39  * It ensures that the following relations are always true:
  40  * <p>
  41  * <li>[ startTime >= start time of the trace ]
  42  * <li>[ endTime <= end time of the trace ]
  43  * <li>[ startTime <= currentTime <= endTime ]
  44  * <li>[ interval == (endTime - startTime) ]</li>
  45  * <p>
  46  * It provides a slider to rapidly set the current time within the time range (i.e. between startTime and endTime).
  47  * <p>
  48  * Finally, it allows modification of the time range and the current time. This triggers notifications to the other
  49  * LTTng views.
  50  * <p>
  51  * FIXME: The slider is very jumpy due to the large number of async updates FIXME: Revisit the control flow between
  52  * View, Spinners and Slider
  53  */
  54 @Deprecated
  55 public class TimeFrameView extends TmfView {
  56
  57     public static final String ID = "org.eclipse.linuxtools.lttng.ui.views.timeframe"; //$NON-NLS-1$
  58
  59     // ------------------------------------------------------------------------
  60     // TimeFrameView
  61     // ------------------------------------------------------------------------
  62
  63     // The event log timestamp characteristics
  64     private ITmfTimestamp fTraceStartTime = new TmfTimestamp();
  65     private ITmfTimestamp fTraceEndTime = new TmfTimestamp();
  66
  67     private ITmfTimestamp fCurrentTime = new TmfTimestamp();
  68
  69     private TmfTimeRange fTraceTimeRange = new TmfTimeRange(fTraceStartTime, fTraceEndTime);
  70     private TmfTimeRange fTraceSpan = new TmfTimeRange(fTraceStartTime, fTraceEndTime);
  71     private int fScale = 0;
  72
  73     // Labels
  74     private static final String START_TIME_LABEL = Messages.TimeFrameView_WindowStartTime;
  75     private static final String END_TIME_LABEL = Messages.TimeFrameView_WindowEndTime;
  76     private static final String TIME_RANGE_LABEL = Messages.TimeFrameView_WindowRange;
  77     private static final String CURRENT_TIME_LABEL = Messages.TimeFrameView_CurrentTime;
  78
  79     private static final int SLIDER_RANGE = 10000;
  80
  81     private SpinnerGroup fStartGroup;
  82     private SpinnerGroup fEndGroup;
  83     private SpinnerGroup fRangeGroup;
  84     private SpinnerGroup fCurrentGroup;
  85
  86     // The slider
  87     private Slider fSlider;
  88
  89     // The current experiment
  90     TmfExperiment fExperiment = null;
  91
  92     // notify external listeners may not be needed if the update originated externally
  93     private boolean fupdateExternalListeners = true;
  94
  95     // ------------------------------------------------------------------------
  96     // Constructor
  97     // ------------------------------------------------------------------------
  98
  99     /**
 100      * Constructor
 101      */
 102     public TimeFrameView() {
 103         super("TimeFrameView"); //$NON-NLS-1$
 104     }
 105
 106     /*
 107      * (non-Javadoc)
 108      *
 109      * @see org.eclipse.ui.part.WorkbenchPart#createPartControl(org.eclipse.swt.widgets .Composite)
 110      */
 111     @Override
 112     public void createPartControl(Composite parent) {
 113
 114         // Set the view layout
 115         GridLayout layout = new GridLayout(4, true);
 116         parent.setLayout(layout);
 117
 118         fStartGroup = new SpinnerGroup(this, parent, START_TIME_LABEL, fTraceTimeRange, fTraceStartTime);
 119         fEndGroup = new SpinnerGroup(this, parent, END_TIME_LABEL, fTraceTimeRange, fTraceEndTime);
 120         fRangeGroup = new SpinnerGroup(this, parent, TIME_RANGE_LABEL, fTraceTimeRange, fTraceEndTime);
 121         fCurrentGroup = new SpinnerGroup(this, parent, CURRENT_TIME_LABEL, fTraceTimeRange, fTraceStartTime);
 122
 123         // Create the slider
 124         createSlider(parent);
 125     }
 126
 127     /*
 128      * (non-Javadoc)
 129      *
 130      * @see org.eclipse.ui.part.WorkbenchPart#setFocus()
 131      */
 132     @Override
 133     public void setFocus() {
 134         // TODO Auto-generated method stub
 135     }
 136
 137     // ------------------------------------------------------------------------
 138     // Operators
 139     // ------------------------------------------------------------------------
 140
 141     /**
 142      * One of the spinners has been updated. Synchronize the other widgets.
 143      */
 144     public void synchTimeFrameWidgets(SpinnerGroup trigger) {
 145         boolean trangeUpdated = false;
 146
 147         // Collect the data
 148         ITmfTimestamp startTime = fStartGroup.getCurrentTime();
 149         ITmfTimestamp endTime = fEndGroup.getCurrentTime();
 150         ITmfTimestamp timeRange = fRangeGroup.getCurrentTime();
 151         ITmfTimestamp currentTime = fCurrentGroup.getCurrentTime();
 152
 153         // If startTime was set beyond endTime, adjust endTime and interval
 154         if (trigger == fStartGroup) {
 155             if (startTime.compareTo(endTime, false) > 0) {
 156                 endTime = startTime;
 157                 trangeUpdated = true;
 158             }
 159         }
 160
 161         // If endTime was set beyond startTime, adjust startTime and interval
 162         if (trigger == fEndGroup) {
 163             if (endTime.compareTo(startTime, false) < 0) {
 164                 startTime = endTime;
 165                 trangeUpdated = true;
 166             }
 167         }
 168
 169         // If timeRange was set, adjust endTime
 170         if (trigger == fRangeGroup) {
 171             long start = startTime.getValue();
 172             long span = timeRange.getValue();
 173             ITmfTimestamp ts = new TmfTimestamp(start + span, startTime.getScale(), 0);
 174             if (ts.compareTo(fTraceEndTime, false) > 0) {
 175                 ts = fTraceEndTime.clone();
 176             }
 177             endTime = ts;
 178             trangeUpdated = true;
 179         }
 180
 181         // Compute the new time range
 182         TmfTimeRange subrange = new TmfTimeRange(startTime, endTime);
 183 //        int scale = startTime.getScale();
 184         ITmfTimestamp interval = startTime.getDelta(endTime);
 185
 186         // Update the spinner groups
 187         fStartGroup.setContent(fTraceTimeRange, startTime);
 188         fEndGroup.setContent(fTraceTimeRange, endTime);
 189         fRangeGroup.setContent(fTraceSpan, interval);
 190         fCurrentGroup.setContent(subrange, currentTime);
 191
 192         updateSlider(subrange, currentTime);
 193         // Notify other views, only if the update originated from this view
 194         if (fupdateExternalListeners) {
 195             if (!fCurrentTime.equals(currentTime)) {
 196                 fCurrentTime = currentTime;
 197                 broadcast(new TmfTimeSynchSignal(this, currentTime));
 198             }
 199
 200             // Notify the views if the time range has been impacted
 201             if (trangeUpdated) {
 202                 TmfTimeRange trange = new TmfTimeRange(startTime, endTime);
 203                 broadcast(new TmfRangeSynchSignal(this, trange, currentTime));
 204             }
 205         }
 206     }
 207
 208     // ------------------------------------------------------------------------
 209     // Slider Handling
 210     // ------------------------------------------------------------------------
 211
 212     /**
 213      * @param parent
 214      */
 215     private void createSlider(Composite parent) {
 216         fSlider = new Slider(parent, SWT.SMOOTH | SWT.FILL);
 217         fSlider.setMinimum(0);
 218         fSlider.setMaximum(SLIDER_RANGE + fSlider.getThumb());
 219         fSlider.setIncrement(SLIDER_RANGE / 100);
 220         fSlider.setPageIncrement(SLIDER_RANGE / 10);
 221         fSlider.setSelection(0);
 222
 223         GridData gridData = new GridData(SWT.LEFT, SWT.TOP, true, false);
 224         gridData.horizontalAlignment = SWT.FILL;
 225         gridData.horizontalSpan = 4;
 226         fSlider.setLayoutData(gridData);
 227
 228         fSlider.addListener(SWT.Selection, new Listener() {
 229             @Override
 230             public void handleEvent(Event event) {
 231                 int ratio = fSlider.getSelection();
 232                 ITmfTimestamp span = fCurrentGroup.getSpan();
 233                 long value = span.getValue() * ratio / SLIDER_RANGE;
 234                 ITmfTimestamp start = fCurrentGroup.getStartTime();
 235                 ITmfTimestamp current = new TmfTimestamp(start.getValue() + value, start.getScale(), 0);
 236                 fCurrentGroup.setValue(current);
 237             }
 238         });
 239
 240     }
 241
 242     /**
 243      * @param range
 244      * @param timestamp
 245      */
 246     private void updateSlider(TmfTimeRange range, ITmfTimestamp timestamp) {
 247
 248         // Ignore update if disposed
 249         if (fSlider.isDisposed()) {
 250             return;
 251         }
 252
 253         // Determine the new relative position
 254 //        int scale = range.getEndTime().getScale();
 255         long total = range.getStartTime().getDelta(range.getEndTime()).getValue();
 256         long relative = range.getStartTime().getDelta(timestamp).getValue();
 257
 258         // Set the slider value
 259         final long position = (total > 0) ? (relative * SLIDER_RANGE / total) : 0;
 260
 261         // Update the slider on the UI thread
 262         long current = fSlider.getSelection();
 263         if (position != current) {
 264             fSlider.getDisplay().asyncExec(new Runnable() {
 265                 @Override
 266                 public void run() {
 267                     fSlider.setSelection((int) position);
 268                 }
 269             });
 270         }
 271     }
 272
 273     /*
 274      * (non-Javadoc)
 275      *
 276      * @see java.lang.Object#toString()
 277      */
 278     @Override
 279     @SuppressWarnings("nls")
 280     public String toString() {
 281         return "[TimeFrameView]";
 282     }
 283
 284     // ------------------------------------------------------------------------
 285     // Signal Handling
 286     // ------------------------------------------------------------------------
 287
 288     /**
 289      * @param signal
 290      */
 291     @TmfSignalHandler
 292     public void experimentSelected(TmfExperimentSelectedSignal signal) {
 293
 294         // Update the trace reference
 295         fExperiment = signal.getExperiment();
 296
 297         // Update the time frame
 298         fTraceTimeRange = fExperiment.getTimeRange();
 299         fTraceStartTime = fTraceTimeRange.getStartTime();
 300         fTraceEndTime = fTraceTimeRange.getEndTime();
 301         fScale = fTraceStartTime.getScale();
 302
 303         // Update the widgets
 304         fStartGroup.setContent(fTraceTimeRange, fTraceStartTime);
 305         fEndGroup.setContent(fTraceTimeRange, fTraceEndTime);
 306         fCurrentGroup.setContent(fTraceTimeRange, fTraceStartTime);
 307
 308         fCurrentTime = fTraceStartTime;
 309
 310         ITmfTimestamp delta = fTraceStartTime.getDelta(fTraceEndTime);
 311         fTraceSpan = new TmfTimeRange(new TmfTimestamp(0, fScale, 0), delta);
 312         // fRangeGroup.setContent(fTraceSpan, delta);
 313         ITmfTimestamp start = new TmfTimestamp(1, (byte) -1, 0);
 314         fRangeGroup.setContent(fTraceSpan, start);
 315     }
 316
 317     /**
 318      * @param signal
 319      */
 320     @TmfSignalHandler
 321     public void experimentUpdated(TmfExperimentUpdatedSignal signal) {
 322         if (signal.getExperiment() != fExperiment) {
 323             return;
 324         }
 325
 326         // Update the time frame
 327         // fTraceTimeRange = signal.getTrace().getTimeRange();
 328         fTraceTimeRange = signal.getExperiment().getTimeRange();
 329         fTraceStartTime = fTraceTimeRange.getStartTime();
 330         fTraceEndTime = fTraceTimeRange.getEndTime();
 331         fScale = fTraceStartTime.getScale();
 332
 333         // Update the widgets
 334         fStartGroup.setContent(fTraceTimeRange, fStartGroup.getCurrentTime());
 335         fEndGroup.setContent(fTraceTimeRange, fTraceEndTime);
 336         fCurrentGroup.setContent(fTraceTimeRange, fCurrentGroup.getCurrentTime());
 337
 338         ITmfTimestamp delta = fTraceStartTime.getDelta(fTraceEndTime);
 339         fTraceSpan = new TmfTimeRange(new TmfTimestamp(0, fScale, 0), delta);
 340         fRangeGroup.setContent(fTraceSpan, delta);
 341     }
 342
 343     /**
 344      * @param signal
 345      */
 346     @TmfSignalHandler
 347     public void currentTimeRangeUpdated(TmfRangeSynchSignal signal) {
 348         if (signal.getSource() != this) {
 349             // Update the time frame
 350             TmfTimeRange selTimeRange = signal.getCurrentRange();
 351             ITmfTimestamp selStart = selTimeRange.getStartTime().normalize(0, fScale);
 352             ITmfTimestamp selEnd   = selTimeRange.getEndTime().normalize(0, fScale);
 353
 354             fupdateExternalListeners = false;
 355             // Update the widgets and prevent broadcast notifications to
 356             // the views which have been notified already.
 357             {
 358                 fStartGroup.setContent(fTraceTimeRange, selStart);
 359                 fEndGroup.setContent(fTraceTimeRange, selEnd);
 360
 361                 ITmfTimestamp delta = selStart.getDelta(selEnd);
 362
 363                 fRangeGroup.setContent(fTraceSpan, delta);
 364             }
 365
 366             // restore the external notification flag
 367             fupdateExternalListeners = true;
 368
 369         }
 370     }
 371
 372     /**
 373      * @param signal
 374      */
 375     @TmfSignalHandler
 376     public void currentTimeUpdated(TmfTimeSynchSignal signal) {
 377         if (signal.getSource() != this) {
 378             // prevent loop to external notifications
 379             fupdateExternalListeners = false;
 380             fCurrentTime = signal.getCurrentTime().normalize(0, fStartGroup.getCurrentTime().getScale());
 381             if (fStartGroup.getCurrentTime().compareTo(fCurrentTime, false) > 0) {
 382                 fStartGroup.setContent(new TmfTimeRange(fCurrentTime, fEndGroup.getCurrentTime()), fCurrentTime);
 383             }
 384             if (fEndGroup.getCurrentTime().compareTo(fCurrentTime, false) < 0) {
 385                 fEndGroup.setContent(new TmfTimeRange(fStartGroup.getCurrentTime(), fCurrentTime), fCurrentTime);
 386             }
 387             fCurrentGroup.setContent(null, fCurrentTime);
 388             updateSlider(fCurrentGroup.getTimeRange(), fCurrentTime);
 389
 390             // Enable external notifications
 391             fupdateExternalListeners = true;
 392         }
 393     }
 394
 395 }