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

   1 /*******************************************************************************
   2  * Copyright (c) 2014, 2015 École Polytechnique de Montréal and others.
   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.TmfSelectionRangeUpdatedSignal;
  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.TmfTraceClosedSignal;
  21 import org.eclipse.tracecompass.tmf.core.signal.TmfTraceOpenedSignal;
  22 import org.eclipse.tracecompass.tmf.core.signal.TmfTraceRangeUpdatedSignal;
  23 import org.eclipse.tracecompass.tmf.core.signal.TmfTraceSelectedSignal;
  24 import org.eclipse.tracecompass.tmf.core.signal.TmfTraceUpdatedSignal;
  25 import org.eclipse.tracecompass.tmf.core.signal.TmfWindowRangeUpdatedSignal;
  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     /** Current begin time of selection range */
  61     private long fSelectionBeginTime;
  62     /** Current end of selection range */
  63     private long fSelectionEndTime;
  64     /** The trace that is displayed by this viewer */
  65     private ITmfTrace fTrace;
  66     /** A signal throttler for range updates */
  67     private final TmfSignalThrottler fTimeRangeSyncThrottle = new TmfSignalThrottler(this, 200);
  68
  69     /**
  70      * Default constructor.
  71      */
  72     public TmfTimeViewer() {
  73         super();
  74     }
  75
  76     /**
  77      * Constructor that initializes the parent of the viewer
  78      *
  79      * @param parent
  80      *            The parent composite that holds this viewer
  81      */
  82     public TmfTimeViewer(Composite parent) {
  83         this(parent, ""); //$NON-NLS-1$
  84     }
  85
  86     /**
  87      * Constructor that initializes the parent of the viewer and that sets the
  88      * name of the viewer
  89      *
  90      * @param parent
  91      *            The parent composite that holds this viewer
  92      * @param name
  93      *            The name of the viewer
  94      */
  95     public TmfTimeViewer(Composite parent, String name) {
  96         init(parent, name);
  97     }
  98
  99     // ------------------------------------------------------------------------
 100     // Getter/Setters
 101     // ------------------------------------------------------------------------
 102
 103     /**
 104      * Sets the start time of the trace
 105      *
 106      * @param startTime
 107      *            The start time to set
 108      */
 109     protected void setStartTime(long startTime) {
 110         fStartTime = startTime;
 111     }
 112
 113     /**
 114      * Sets the end time of the trace
 115      *
 116      * @param endTime
 117      *            The start time to set
 118      */
 119     protected void setEndTime(long endTime) {
 120         fEndTime = endTime;
 121     }
 122
 123     /**
 124      * Sets the start time and end of the current time range window (visible
 125      * range)
 126      *
 127      * @param windowStartTime
 128      *            The start time to set
 129      * @param windowEndTime
 130      *            The start time to set
 131      * @since 1.0
 132      */
 133     protected void setWindowRange(long windowStartTime, long windowEndTime) {
 134         fWindowStartTime = windowStartTime;
 135         fWindowEndTime = windowEndTime;
 136     }
 137
 138     /**
 139      * Sets the begin and end time of the selected range without sending the
 140      * {@link TmfSelectionRangeUpdatedSignal} signal.
 141      *
 142      * @param selectionBeginTime
 143      *            The begin time to set
 144      * @param selectionEndTime
 145      *            The end time to set
 146      *
 147      * @since 1.0
 148      */
 149     protected void setSelectionRange(long selectionBeginTime, long selectionEndTime) {
 150         fSelectionBeginTime = selectionBeginTime;
 151         fSelectionEndTime = selectionEndTime;
 152     }
 153
 154     /**
 155      * Sets the trace that is displayed by this viewer.
 156      *
 157      * @param trace
 158      *            The trace to set
 159      */
 160     protected void setTrace(ITmfTrace trace) {
 161         fTrace = trace;
 162     }
 163
 164     /**
 165      * Gets the trace that is displayed by this viewer.
 166      *
 167      * @return the trace
 168      */
 169     protected ITmfTrace getTrace() {
 170         return fTrace;
 171     }
 172
 173     // ------------------------------------------------------------------------
 174     // ITmfTimeProvider
 175     // ------------------------------------------------------------------------
 176
 177     @Override
 178     public long getStartTime() {
 179         return fStartTime;
 180     }
 181
 182     @Override
 183     public long getEndTime() {
 184         return fEndTime;
 185     }
 186
 187     @Override
 188     public long getWindowStartTime() {
 189         return fWindowStartTime;
 190     }
 191
 192     @Override
 193     public long getWindowEndTime() {
 194         return fWindowEndTime;
 195     }
 196
 197     @Override
 198     public long getWindowDuration() {
 199         return getWindowEndTime() - getWindowStartTime();
 200     }
 201
 202     @Override
 203     public long getSelectionBeginTime() {
 204         return fSelectionBeginTime;
 205     }
 206
 207     @Override
 208     public long getSelectionEndTime() {
 209         return fSelectionEndTime;
 210     }
 211
 212     @Override
 213     public void updateSelectionRange(final long currentBeginTime, final long currentEndTime) {
 214         if (fTrace != null) {
 215             setSelectionRange(currentBeginTime, currentEndTime);
 216
 217             final ITmfTimestamp startTimestamp = new TmfTimestamp(getSelectionBeginTime(), ITmfTimestamp.NANOSECOND_SCALE);
 218             final ITmfTimestamp endTimestamp = new TmfTimestamp(getSelectionEndTime(), ITmfTimestamp.NANOSECOND_SCALE);
 219
 220             TmfSelectionRangeUpdatedSignal signal = new TmfSelectionRangeUpdatedSignal(this, startTimestamp, endTimestamp);
 221             broadcast(signal);
 222         }
 223     }
 224
 225     @Override
 226     public void updateWindow(long windowStartTime, long windowEndTime) {
 227
 228         setWindowRange(windowStartTime, windowEndTime);
 229
 230         // Build the new time range; keep the current time
 231         TmfTimeRange timeRange = new TmfTimeRange(
 232                 new TmfTimestamp(getWindowStartTime(), ITmfTimestamp.NANOSECOND_SCALE),
 233                 new TmfTimestamp(getWindowEndTime(), ITmfTimestamp.NANOSECOND_SCALE));
 234
 235         // Send the signal
 236         TmfWindowRangeUpdatedSignal signal = new TmfWindowRangeUpdatedSignal(this, timeRange);
 237         fTimeRangeSyncThrottle.queue(signal);
 238     }
 239
 240     // ------------------------------------------------------------------------
 241     // Operations
 242     // ------------------------------------------------------------------------
 243     /**
 244      * A Method to load a trace into the viewer.
 245      *
 246      * @param trace
 247      *            A trace to apply in the viewer
 248      */
 249     public void loadTrace(ITmfTrace trace) {
 250         fTrace = trace;
 251
 252         TmfTraceContext ctx = TmfTraceManager.getInstance().getCurrentTraceContext();
 253         long selectionStart = ctx.getSelectionRange().getStartTime().toNanos();
 254         long selectionEnd = ctx.getSelectionRange().getEndTime().toNanos();
 255         TmfTimeRange windowRange = ctx.getWindowRange();
 256
 257         long windowStartTime = windowRange.getStartTime().toNanos();
 258         long windowEndTime = windowRange.getEndTime().toNanos();
 259         long startTime = fTrace.getStartTime().toNanos();
 260         long endTime = fTrace.getEndTime().toNanos();
 261
 262         setSelectionRange(selectionStart, selectionEnd);
 263
 264         setStartTime(startTime);
 265         setWindowRange(windowStartTime, windowEndTime);
 266         setEndTime(endTime);
 267     }
 268
 269     /**
 270      * Resets the content of the viewer
 271      */
 272     public void reset() {
 273         // Reset the internal data
 274         setSelectionRange(0, 0);
 275         setStartTime(0);
 276         setWindowRange(0, 0);
 277         setEndTime(0);
 278         setTrace(null);
 279     }
 280
 281     // ------------------------------------------------------------------------
 282     // Signal Handler
 283     // ------------------------------------------------------------------------
 284
 285     /**
 286      * Signal handler for handling of the trace opened signal.
 287      *
 288      * @param signal
 289      *            The trace opened signal {@link TmfTraceOpenedSignal}
 290      */
 291     @TmfSignalHandler
 292     public void traceOpened(TmfTraceOpenedSignal signal) {
 293         fTrace = signal.getTrace();
 294         loadTrace(getTrace());
 295     }
 296
 297     /**
 298      * Signal handler for handling of the trace selected signal.
 299      *
 300      * @param signal
 301      *            The trace selected signal {@link TmfTraceSelectedSignal}
 302      */
 303     @TmfSignalHandler
 304     public void traceSelected(TmfTraceSelectedSignal signal) {
 305         if (fTrace != signal.getTrace()) {
 306             fTrace = signal.getTrace();
 307             loadTrace(getTrace());
 308         }
 309     }
 310
 311     /**
 312      * Signal handler for handling of the trace closed signal.
 313      *
 314      * @param signal
 315      *            The trace closed signal {@link TmfTraceClosedSignal}
 316      */
 317     @TmfSignalHandler
 318     public void traceClosed(TmfTraceClosedSignal signal) {
 319
 320         if (signal.getTrace() != fTrace) {
 321             return;
 322         }
 323
 324         // Reset the internal data
 325         fTrace = null;
 326         reset();
 327     }
 328
 329     /**
 330      * Signal handler for handling of the selected range signal.
 331      *
 332      * @param signal
 333      *            The {@link TmfSelectionRangeUpdatedSignal}
 334      * @since 1.0
 335      */
 336     @TmfSignalHandler
 337     public void selectionRangeUpdated(TmfSelectionRangeUpdatedSignal signal) {
 338         if ((signal.getSource() != this) && (fTrace != null)) {
 339             long selectedTime = signal.getBeginTime().toNanos();
 340             long selectedEndTime = signal.getEndTime().toNanos();
 341             setSelectionRange(selectedTime, selectedEndTime);
 342         }
 343     }
 344
 345     /**
 346      * Signal handler for handling of the window range signal.
 347      *
 348      * @param signal
 349      *            The {@link TmfWindowRangeUpdatedSignal}
 350      * @since 1.0
 351      */
 352     @TmfSignalHandler
 353     public void windowRangeUpdated(TmfWindowRangeUpdatedSignal signal) {
 354
 355         if (fTrace != null) {
 356             // Validate the time range
 357             TmfTimeRange range = signal.getCurrentRange().getIntersection(fTrace.getTimeRange());
 358             if (range == null) {
 359                 return;
 360             }
 361
 362             if (signal.getSource() != this) {
 363                 // Update the time range
 364                 long windowStartTime = range.getStartTime().toNanos();
 365                 long windowEndTime = range.getEndTime().toNanos();
 366
 367                 setWindowRange(windowStartTime, windowEndTime);
 368             }
 369         }
 370     }
 371
 372     /**
 373      * Signal handler for handling of the trace range updated signal.
 374      *
 375      * @param signal
 376      *            The trace range signal {@link TmfTraceRangeUpdatedSignal}
 377      */
 378     @TmfSignalHandler
 379     public void traceRangeUpdated(TmfTraceRangeUpdatedSignal signal) {
 380
 381         if (signal.getTrace() != fTrace) {
 382             return;
 383         }
 384
 385         TmfTimeRange fullRange = signal.getRange();
 386
 387         long traceStartTime = fullRange.getStartTime().toNanos();
 388         long traceEndTime = fullRange.getEndTime().toNanos();
 389
 390         setStartTime(traceStartTime);
 391         setEndTime(traceEndTime);
 392     }
 393
 394     /**
 395      * Signal handler for handling of the trace updated signal.
 396      *
 397      * @param signal
 398      *            The trace updated signal {@link TmfTraceUpdatedSignal}
 399      */
 400     @TmfSignalHandler
 401     public void traceUpdated(TmfTraceUpdatedSignal signal) {
 402         if (signal.getTrace() != fTrace) {
 403             return;
 404         }
 405         TmfTimeRange fullRange = signal.getTrace().getTimeRange();
 406
 407         long traceStartTime = fullRange.getStartTime().toNanos();
 408         long traceEndTime = fullRange.getEndTime().toNanos();
 409
 410         setStartTime(traceStartTime);
 411         setEndTime(traceEndTime);
 412     }
 413
 414 }