org.eclipse.tracecompass.tmf.ui/src/org/eclipse/tracecompass/tmf/ui/viewers/TmfTimeViewer.java

   1 /*******************************************************************************
   2  * Copyright (c) 2014 École Polytechnique de Montréal
   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  *   Bernd Hufmann - Initial API and implementation in TmfXYChartViewer
  11  *   Geneviève Bastien - Moved methods from TmfXYChartViewer to this interface
  12  *******************************************************************************/
  13
  14 package org.eclipse.tracecompass.tmf.ui.viewers;
  15
  16 import org.eclipse.swt.widgets.Composite;
  17 import org.eclipse.tracecompass.tmf.core.signal.TmfRangeSynchSignal;
  18 import org.eclipse.tracecompass.tmf.core.signal.TmfSignalHandler;
  19 import org.eclipse.tracecompass.tmf.core.signal.TmfSignalThrottler;
  20 import org.eclipse.tracecompass.tmf.core.signal.TmfTimeSynchSignal;
  21 import org.eclipse.tracecompass.tmf.core.signal.TmfTraceClosedSignal;
  22 import org.eclipse.tracecompass.tmf.core.signal.TmfTraceOpenedSignal;
  23 import org.eclipse.tracecompass.tmf.core.signal.TmfTraceRangeUpdatedSignal;
  24 import org.eclipse.tracecompass.tmf.core.signal.TmfTraceSelectedSignal;
  25 import org.eclipse.tracecompass.tmf.core.signal.TmfTraceUpdatedSignal;
  26 import org.eclipse.tracecompass.tmf.core.timestamp.ITmfTimestamp;
  27 import org.eclipse.tracecompass.tmf.core.timestamp.TmfTimeRange;
  28 import org.eclipse.tracecompass.tmf.core.timestamp.TmfTimestamp;
  29 import org.eclipse.tracecompass.tmf.core.trace.ITmfTrace;
  30 import org.eclipse.tracecompass.tmf.core.trace.TmfTraceContext;
  31 import org.eclipse.tracecompass.tmf.core.trace.TmfTraceManager;
  32
  33 /**
  34  * Abstract class that extends {@link TmfViewer} that adds methods to
  35  * synchronize with a trace's time information.
  36  *
  37  * This class will be extended by viewers who require time information to update
  38  * their content.
  39  *
  40  * <pre>
  41  * It provides three times of data:
  42  *   - start and end time of the trace (available)
  43  *   - start, end and duration of the current time window, ie the visible time range
  44  *   - start and end of the time range selected
  45  * </pre>
  46  *
  47  * @author Bernd Hufmann
  48  * @author Geneviève Bastien
  49  */
  50 public abstract class TmfTimeViewer extends TmfViewer implements ITmfTimeProvider {
  51
  52     /** Start time of trace */
  53     private long fStartTime;
  54     /** End time of trace */
  55     private long fEndTime;
  56     /** Start time of current time range */
  57     private long fWindowStartTime;
  58     /** End time of current time range */
  59     private long fWindowEndTime;
  60     /** Duration of current time range */
  61     private long fWindowDuration;
  62     /** Current begin time of selection range */
  63     private long fSelectionBeginTime;
  64     /** Current end of selection range */
  65     private long fSelectionEndTime;
  66     /** The trace that is displayed by this viewer */
  67     private ITmfTrace fTrace;
  68     /** A signal throttler for range updates */
  69     private final TmfSignalThrottler fTimeRangeSyncThrottle = new TmfSignalThrottler(this, 200);
  70
  71     /**
  72      * Default constructor.
  73      */
  74     public TmfTimeViewer() {
  75         super();
  76     }
  77
  78     /**
  79      * Constructor that initializes the parent of the viewer
  80      *
  81      * @param parent
  82      *            The parent composite that holds this viewer
  83      */
  84     public TmfTimeViewer(Composite parent) {
  85         this(parent, ""); //$NON-NLS-1$
  86     }
  87
  88     /**
  89      * Constructor that initializes the parent of the viewer and that sets the
  90      * name of the viewer
  91      *
  92      * @param parent
  93      *            The parent composite that holds this viewer
  94      * @param name
  95      *            The name of the viewer
  96      */
  97     public TmfTimeViewer(Composite parent, String name) {
  98         init(parent, name);
  99     }
 100
 101     // ------------------------------------------------------------------------
 102     // Getter/Setters
 103     // ------------------------------------------------------------------------
 104
 105     /**
 106      * Sets the start time of the trace
 107      *
 108      * @param startTime
 109      *            The start time to set
 110      */
 111     protected void setStartTime(long startTime) {
 112         fStartTime = startTime;
 113     }
 114
 115     /**
 116      * Sets the end time of the trace
 117      *
 118      * @param endTime
 119      *            The start time to set
 120      */
 121     protected void setEndTime(long endTime) {
 122         fEndTime = endTime;
 123     }
 124
 125     /**
 126      * Sets the start time of the current time range window (visible range)
 127      *
 128      * @param windowStartTime
 129      *            The start time to set
 130      */
 131     protected void setWindowStartTime(long windowStartTime) {
 132         fWindowStartTime = windowStartTime;
 133     }
 134
 135     /**
 136      * Sets the end time of the current time range window (visible range)
 137      *
 138      * @param windowEndTime
 139      *            The start time to set
 140      */
 141     protected void setWindowEndTime(long windowEndTime) {
 142         fWindowEndTime = windowEndTime;
 143     }
 144
 145     /**
 146      * Sets the duration of the current time range window (visible range)
 147      *
 148      * @param windowDuration
 149      *            The window duration
 150      */
 151     protected void setWindowDuration(long windowDuration) {
 152         fWindowDuration = windowDuration;
 153     }
 154
 155     /**
 156      * Sets the begin time of the selected range.
 157      *
 158      * @param selectionBeginTime
 159      *            The begin time to set
 160      */
 161     protected void setSelectionBeginTime(long selectionBeginTime) {
 162         fSelectionBeginTime = selectionBeginTime;
 163     }
 164
 165     /**
 166      * Sets the end time of the selected range.
 167      *
 168      * @param selectionEndTime
 169      *            The end time to set
 170      */
 171     protected void setSelectionEndTime(long selectionEndTime) {
 172         fSelectionEndTime = selectionEndTime;
 173     }
 174
 175     /**
 176      * Sets the trace that is displayed by this viewer.
 177      *
 178      * @param trace
 179      *            The trace to set
 180      */
 181     protected void setTrace(ITmfTrace trace) {
 182         fTrace = trace;
 183     }
 184
 185     /**
 186      * Gets the trace that is displayed by this viewer.
 187      *
 188      * @return the trace
 189      */
 190     protected ITmfTrace getTrace() {
 191         return fTrace;
 192     }
 193
 194     // ------------------------------------------------------------------------
 195     // ITmfTimeProvider
 196     // ------------------------------------------------------------------------
 197
 198     @Override
 199     public long getStartTime() {
 200         return fStartTime;
 201     }
 202
 203     @Override
 204     public long getEndTime() {
 205         return fEndTime;
 206     }
 207
 208     @Override
 209     public long getWindowStartTime() {
 210         return fWindowStartTime;
 211     }
 212
 213     @Override
 214     public long getWindowEndTime() {
 215         return fWindowEndTime;
 216     }
 217
 218     @Override
 219     public long getWindowDuration() {
 220         return fWindowDuration;
 221     }
 222
 223     @Override
 224     public long getSelectionBeginTime() {
 225         return fSelectionBeginTime;
 226     }
 227
 228     @Override
 229     public long getSelectionEndTime() {
 230         return fSelectionEndTime;
 231     }
 232
 233     @Override
 234     public void updateSelectionRange(final long currentBeginTime, final long currentEndTime) {
 235         if (fTrace != null) {
 236             setSelectionBeginTime(currentBeginTime);
 237             setSelectionEndTime(currentEndTime);
 238
 239             final ITmfTimestamp startTimestamp = new TmfTimestamp(getSelectionBeginTime(), ITmfTimestamp.NANOSECOND_SCALE);
 240             final ITmfTimestamp endTimestamp = new TmfTimestamp(getSelectionEndTime(), ITmfTimestamp.NANOSECOND_SCALE);
 241
 242             TmfTimeSynchSignal signal = new TmfTimeSynchSignal(this, startTimestamp, endTimestamp);
 243             broadcast(signal);
 244         }
 245     }
 246
 247     @Override
 248     public void updateWindow(long windowStartTime, long windowEndTime) {
 249
 250         setWindowStartTime(windowStartTime);
 251         setWindowEndTime(windowEndTime);
 252         setWindowDuration(windowEndTime - windowStartTime);
 253
 254         // Build the new time range; keep the current time
 255         TmfTimeRange timeRange = new TmfTimeRange(
 256                 new TmfTimestamp(getWindowStartTime(), ITmfTimestamp.NANOSECOND_SCALE),
 257                 new TmfTimestamp(getWindowEndTime(), ITmfTimestamp.NANOSECOND_SCALE));
 258
 259         // Send the signal
 260         TmfRangeSynchSignal signal = new TmfRangeSynchSignal(this, timeRange);
 261         fTimeRangeSyncThrottle.queue(signal);
 262     }
 263
 264     // ------------------------------------------------------------------------
 265     // Operations
 266     // ------------------------------------------------------------------------
 267     /**
 268      * A Method to load a trace into the viewer.
 269      *
 270      * @param trace
 271      *            A trace to apply in the viewer
 272      */
 273     public void loadTrace(ITmfTrace trace) {
 274         fTrace = trace;
 275
 276         TmfTraceContext ctx = TmfTraceManager.getInstance().getCurrentTraceContext();
 277         long timestamp = ctx.getSelectionRange().getStartTime().normalize(0, ITmfTimestamp.NANOSECOND_SCALE).getValue();
 278         TmfTimeRange windowRange = ctx.getWindowRange();
 279
 280         long windowStartTime = windowRange.getStartTime().normalize(0, ITmfTimestamp.NANOSECOND_SCALE).getValue();
 281         long windowEndTime = windowRange.getEndTime().normalize(0, ITmfTimestamp.NANOSECOND_SCALE).getValue();
 282         long windowDuration = windowEndTime - windowStartTime;
 283         long startTime = fTrace.getStartTime().normalize(0, ITmfTimestamp.NANOSECOND_SCALE).getValue();
 284         long endTime = fTrace.getEndTime().normalize(0, ITmfTimestamp.NANOSECOND_SCALE).getValue();
 285
 286         setSelectionBeginTime(timestamp);
 287         setSelectionEndTime(timestamp);
 288         setStartTime(startTime);
 289         setWindowStartTime(windowStartTime);
 290         setWindowEndTime(windowEndTime);
 291         setWindowDuration(windowDuration);
 292         setEndTime(endTime);
 293     }
 294
 295     /**
 296      * Resets the content of the viewer
 297      */
 298     public void reset() {
 299         // Reset the internal data
 300         setSelectionBeginTime(0);
 301         setSelectionEndTime(0);
 302         setStartTime(0);
 303         setWindowStartTime(0);
 304         setWindowDuration(0);
 305         setEndTime(0);
 306         setWindowEndTime(0);
 307         setTrace(null);
 308     }
 309
 310     // ------------------------------------------------------------------------
 311     // Signal Handler
 312     // ------------------------------------------------------------------------
 313
 314     /**
 315      * Signal handler for handling of the trace opened signal.
 316      *
 317      * @param signal
 318      *            The trace opened signal {@link TmfTraceOpenedSignal}
 319      */
 320     @TmfSignalHandler
 321     public void traceOpened(TmfTraceOpenedSignal signal) {
 322         fTrace = signal.getTrace();
 323         loadTrace(getTrace());
 324     }
 325
 326     /**
 327      * Signal handler for handling of the trace selected signal.
 328      *
 329      * @param signal
 330      *            The trace selected signal {@link TmfTraceSelectedSignal}
 331      */
 332     @TmfSignalHandler
 333     public void traceSelected(TmfTraceSelectedSignal signal) {
 334         if (fTrace != signal.getTrace()) {
 335             fTrace = signal.getTrace();
 336             loadTrace(getTrace());
 337         }
 338     }
 339
 340     /**
 341      * Signal handler for handling of the trace closed signal.
 342      *
 343      * @param signal
 344      *            The trace closed signal {@link TmfTraceClosedSignal}
 345      */
 346     @TmfSignalHandler
 347     public void traceClosed(TmfTraceClosedSignal signal) {
 348
 349         if (signal.getTrace() != fTrace) {
 350             return;
 351         }
 352
 353         // Reset the internal data
 354         fTrace = null;
 355         reset();
 356     }
 357
 358     /**
 359      * Signal handler for handling of the time synch signal, ie the selected range.
 360      *
 361      * @param signal
 362      *            The time synch signal {@link TmfTimeSynchSignal}
 363      */
 364     @TmfSignalHandler
 365     public void selectionRangeUpdated(TmfTimeSynchSignal signal) {
 366         if ((signal.getSource() != this) && (fTrace != null)) {
 367             ITmfTimestamp selectedTime = signal.getBeginTime().normalize(0, ITmfTimestamp.NANOSECOND_SCALE);
 368             ITmfTimestamp selectedEndTime = signal.getEndTime().normalize(0, ITmfTimestamp.NANOSECOND_SCALE);
 369             setSelectionBeginTime(selectedTime.getValue());
 370             setSelectionEndTime(selectedEndTime.getValue());
 371         }
 372     }
 373
 374     /**
 375      * Signal handler for handling of the time range synch signal, ie the visible range.
 376      *
 377      * @param signal
 378      *            The time range synch signal {@link TmfRangeSynchSignal}
 379      */
 380     @TmfSignalHandler
 381     public void timeRangeUpdated(TmfRangeSynchSignal signal) {
 382
 383         if (fTrace != null) {
 384             // Validate the time range
 385             TmfTimeRange range = signal.getCurrentRange().getIntersection(fTrace.getTimeRange());
 386             if (range == null) {
 387                 return;
 388             }
 389
 390             if (signal.getSource() != this) {
 391                 // Update the time range
 392                 long windowStartTime = range.getStartTime().normalize(0, ITmfTimestamp.NANOSECOND_SCALE).getValue();
 393                 long windowEndTime = range.getEndTime().normalize(0, ITmfTimestamp.NANOSECOND_SCALE).getValue();
 394                 long windowDuration = windowEndTime - windowStartTime;
 395
 396                 setWindowStartTime(windowStartTime);
 397                 setWindowEndTime(windowEndTime);
 398                 setWindowDuration(windowDuration);
 399             }
 400         }
 401     }
 402
 403     /**
 404      * Signal handler for handling of the trace range updated signal.
 405      *
 406      * @param signal
 407      *            The trace range signal {@link TmfTraceRangeUpdatedSignal}
 408      */
 409     @TmfSignalHandler
 410     public void traceRangeUpdated(TmfTraceRangeUpdatedSignal signal) {
 411
 412         if (signal.getTrace() != fTrace) {
 413             return;
 414         }
 415
 416         TmfTimeRange fullRange = signal.getRange();
 417
 418         long traceStartTime = fullRange.getStartTime().normalize(0, ITmfTimestamp.NANOSECOND_SCALE).getValue();
 419         long traceEndTime = fullRange.getEndTime().normalize(0, ITmfTimestamp.NANOSECOND_SCALE).getValue();
 420
 421         setStartTime(traceStartTime);
 422         setEndTime(traceEndTime);
 423     }
 424
 425     /**
 426      * Signal handler for handling of the trace updated signal.
 427      *
 428      * @param signal
 429      *            The trace updated signal {@link TmfTraceUpdatedSignal}
 430      */
 431     @TmfSignalHandler
 432     public void traceUpdated(TmfTraceUpdatedSignal signal) {
 433         if (signal.getTrace() != fTrace) {
 434             return;
 435         }
 436         TmfTimeRange fullRange = signal.getTrace().getTimeRange();
 437         long traceStartTime = fullRange.getStartTime().normalize(0, ITmfTimestamp.NANOSECOND_SCALE).getValue();
 438         long traceEndTime = fullRange.getEndTime().normalize(0, ITmfTimestamp.NANOSECOND_SCALE).getValue();
 439
 440         setStartTime(traceStartTime);
 441         setEndTime(traceEndTime);
 442     }
 443
 444 }