tmf/org.eclipse.tracecompass.tmf.ui/src/org/eclipse/tracecompass/tmf/ui/viewers/xycharts/linecharts/TmfCommonXLineChartViewer.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  *   Geneviève Bastien - Initial API and implementation
  11  *******************************************************************************/
  12
  13 package org.eclipse.tracecompass.tmf.ui.viewers.xycharts.linecharts;
  14
  15 import java.util.LinkedHashMap;
  16 import java.util.Map;
  17 import java.util.Map.Entry;
  18
  19 import org.eclipse.core.runtime.IProgressMonitor;
  20 import org.eclipse.core.runtime.NullProgressMonitor;
  21 import org.eclipse.swt.SWT;
  22 import org.eclipse.swt.graphics.Point;
  23 import org.eclipse.swt.widgets.Composite;
  24 import org.eclipse.swt.widgets.Display;
  25 import org.eclipse.tracecompass.tmf.core.signal.TmfSignalManager;
  26 import org.eclipse.tracecompass.tmf.core.trace.ITmfTrace;
  27 import org.eclipse.tracecompass.tmf.ui.signal.TmfTimeViewAlignmentInfo;
  28 import org.eclipse.tracecompass.tmf.ui.signal.TmfTimeViewAlignmentSignal;
  29 import org.eclipse.tracecompass.tmf.ui.viewers.xycharts.TmfChartTimeStampFormat;
  30 import org.eclipse.tracecompass.tmf.ui.viewers.xycharts.TmfXYChartViewer;
  31 import org.swtchart.IAxisTick;
  32 import org.swtchart.ILineSeries;
  33 import org.swtchart.ILineSeries.PlotSymbolType;
  34 import org.swtchart.ISeries;
  35 import org.swtchart.ISeries.SeriesType;
  36 import org.swtchart.ISeriesSet;
  37 import org.swtchart.LineStyle;
  38 import org.swtchart.Range;
  39
  40 /**
  41  * Abstract line chart viewer class implementation. All series in this viewer
  42  * use the same X axis values. They are automatically created as values are
  43  * provided for a key. Series by default will be displayed as a line. Each
  44  * series appearance can be overridden when creating it.
  45  *
  46  * @author - Geneviève Bastien
  47  */
  48 public abstract class TmfCommonXLineChartViewer extends TmfXYChartViewer {
  49
  50     private static final double DEFAULT_MAXY = Double.MIN_VALUE;
  51     private static final double DEFAULT_MINY = Double.MAX_VALUE;
  52
  53     /* The desired number of points per pixel */
  54     private static final double RESOLUTION = 1.0;
  55
  56     private static final int[] LINE_COLORS = { SWT.COLOR_BLUE, SWT.COLOR_RED, SWT.COLOR_GREEN,
  57             SWT.COLOR_MAGENTA, SWT.COLOR_CYAN,
  58             SWT.COLOR_DARK_BLUE, SWT.COLOR_DARK_RED, SWT.COLOR_DARK_GREEN,
  59             SWT.COLOR_DARK_MAGENTA, SWT.COLOR_DARK_CYAN, SWT.COLOR_DARK_YELLOW,
  60             SWT.COLOR_BLACK, SWT.COLOR_GRAY };
  61     private static final LineStyle[] LINE_STYLES = { LineStyle.SOLID, LineStyle.DASH, LineStyle.DOT, LineStyle.DASHDOT };
  62
  63     private final Map<String, double[]> fSeriesValues = new LinkedHashMap<>();
  64     private double[] fXValues;
  65     private double fResolution;
  66
  67     private UpdateThread fUpdateThread;
  68
  69     /**
  70      * Constructor
  71      *
  72      * @param parent
  73      *            The parent composite
  74      * @param title
  75      *            The title of the viewer
  76      * @param xLabel
  77      *            The label of the xAxis
  78      * @param yLabel
  79      *            The label of the yAXIS
  80      */
  81     public TmfCommonXLineChartViewer(Composite parent, String title, String xLabel, String yLabel) {
  82         super(parent, title, xLabel, yLabel);
  83
  84         setResolution(RESOLUTION);
  85         setTooltipProvider(new TmfCommonXLineChartTooltipProvider(this));
  86     }
  87
  88     /**
  89      * Set the number of requests per pixel that should be done on this chart
  90      *
  91      * @param resolution
  92      *            The number of points per pixels
  93      */
  94     protected void setResolution(double resolution) {
  95         fResolution = resolution;
  96     }
  97
  98     @Override
  99     public void loadTrace(ITmfTrace trace) {
 100         super.loadTrace(trace);
 101         reinitialize();
 102     }
 103
 104     /**
 105      * Forces a reinitialization of the data sources, even if it has already
 106      * been initialized for this trace before
 107      */
 108     protected void reinitialize() {
 109         fSeriesValues.clear();
 110         Thread thread = new Thread() {
 111             // Don't use TmfUiRefreshHandler (bug 467751)
 112             @Override
 113             public void run() {
 114                 initializeDataSource();
 115                 if (!getSwtChart().isDisposed()) {
 116                     getDisplay().asyncExec(new Runnable() {
 117                         @Override
 118                         public void run() {
 119                             if (!getSwtChart().isDisposed()) {
 120                                 /* Delete the old series */
 121                                 clearContent();
 122                                 createSeries();
 123                             }
 124                         }
 125                     });
 126                 }
 127             }
 128         };
 129         thread.start();
 130     }
 131
 132     /**
 133      * Initialize the source of the data for this viewer. This method is run in
 134      * a separate thread, so this is where for example one can execute an
 135      * analysis module and wait for its completion to initialize the series
 136      */
 137     protected void initializeDataSource() {
 138
 139     }
 140
 141     private class UpdateThread extends Thread {
 142         private final IProgressMonitor fMonitor;
 143         private final int fNumRequests;
 144
 145         public UpdateThread(int numRequests) {
 146             super("Line chart update"); //$NON-NLS-1$
 147             fNumRequests = numRequests;
 148             fMonitor = new NullProgressMonitor();
 149         }
 150
 151         @Override
 152         public void run() {
 153             Display.getDefault().syncExec(new Runnable() {
 154                 @Override
 155                 public void run() {
 156                     updateData(getWindowStartTime(), getWindowEndTime(), fNumRequests, fMonitor);
 157                 }
 158             });
 159             updateThreadFinished(this);
 160         }
 161
 162         public void cancel() {
 163             fMonitor.setCanceled(true);
 164         }
 165     }
 166
 167     private synchronized void newUpdateThread() {
 168         cancelUpdate();
 169         if (!getSwtChart().isDisposed()) {
 170             final int numRequests = (int) (getSwtChart().getPlotArea().getBounds().width * fResolution);
 171             fUpdateThread = new UpdateThread(numRequests);
 172             fUpdateThread.start();
 173         }
 174     }
 175
 176     private synchronized void updateThreadFinished(UpdateThread thread) {
 177         if (thread == fUpdateThread) {
 178             fUpdateThread = null;
 179         }
 180     }
 181
 182     /**
 183      * Cancels the currently running update thread. It is automatically called
 184      * when the content is updated, but child viewers may want to call it
 185      * manually to do some operations before calling
 186      * {@link TmfCommonXLineChartViewer#updateContent}
 187      */
 188     protected synchronized void cancelUpdate() {
 189         if (fUpdateThread != null) {
 190             fUpdateThread.cancel();
 191         }
 192     }
 193
 194     @Override
 195     protected void updateContent() {
 196         getDisplay().asyncExec(new Runnable() {
 197             @Override
 198             public void run() {
 199                 newUpdateThread();
 200             }
 201         });
 202     }
 203
 204     /**
 205      * Convenience method to compute the values of the X axis for a given time
 206      * range. This method will return at most nb values, equally separated from
 207      * start to end. The step between values will be at least 1.0, so the number
 208      * of values returned can be lower than nb.
 209      *
 210      * The returned time values are in internal time, ie to get trace time, the
 211      * time offset needs to be added to those values.
 212      *
 213      * @param start
 214      *            The start time of the time range
 215      * @param end
 216      *            End time of the range
 217      * @param nb
 218      *            The maximum number of steps in the x axis.
 219      * @return The time values (converted to double) to match every step.
 220      */
 221     protected static final double[] getXAxis(long start, long end, int nb) {
 222         long steps = (end - start);
 223         int nbVals = nb;
 224         if (steps < nb) {
 225             nbVals = (int) steps;
 226             if (nbVals <= 0) {
 227                 nbVals = 1;
 228             }
 229         }
 230         double step = steps / (double) nbVals;
 231
 232         double timestamps[] = new double[nbVals];
 233         double curTime = 1;
 234         for (int i = 0; i < nbVals; i++) {
 235             timestamps[i] = curTime;
 236             curTime += step;
 237         }
 238         return timestamps;
 239     }
 240
 241     /**
 242      * Set the values of the x axis. There is only one array of values for the x
 243      * axis for all series of a line chart so it needs to be set once here.
 244      *
 245      * @param xaxis
 246      *            The values for the x axis. The values must be in internal
 247      *            time, ie time offset have been subtracted from trace time
 248      *            values.
 249      */
 250     protected final void setXAxis(double[] xaxis) {
 251         fXValues = xaxis;
 252     }
 253
 254     /**
 255      * Update the series data because the time range has changed. The x axis
 256      * values for this data update can be computed using the
 257      * {@link TmfCommonXLineChartViewer#getXAxis(long, long, int)} method which
 258      * will return a list of uniformely separated time values.
 259      *
 260      * Each series values should be set by calling the
 261      * {@link TmfCommonXLineChartViewer#setSeries(String, double[])}.
 262      *
 263      * This method is responsible for calling the
 264      * {@link TmfCommonXLineChartViewer#updateDisplay()} when needed for the new
 265      * values to be displayed.
 266      *
 267      * @param start
 268      *            The start time of the range for which the get the data
 269      * @param end
 270      *            The end time of the range
 271      * @param nb
 272      *            The number of 'points' in the chart.
 273      * @param monitor
 274      *            The progress monitor object
 275      */
 276     protected abstract void updateData(long start, long end, int nb, IProgressMonitor monitor);
 277
 278     /**
 279      * Set the data for a given series of the graph. The series does not need to
 280      * be created before calling this, but it needs to have at least as many
 281      * values as the x axis.
 282      *
 283      * If the series does not exist, it will automatically be created at display
 284      * time, with the default values.
 285      *
 286      * @param seriesName
 287      *            The name of the series for which to set the values
 288      * @param seriesValues
 289      *            The array of values for the series
 290      */
 291     protected void setSeries(String seriesName, double[] seriesValues) {
 292         if (fXValues.length > seriesValues.length) {
 293             throw new IllegalStateException();
 294         }
 295         fSeriesValues.put(seriesName, seriesValues);
 296     }
 297
 298     /**
 299      * Add a new series to the XY line chart. By default, it is a simple solid
 300      * line.
 301      *
 302      * @param seriesName
 303      *            The name of the series to create
 304      * @return The series so that the concrete viewer can modify its properties
 305      *         if required
 306      */
 307     protected ILineSeries addSeries(String seriesName) {
 308         ISeriesSet seriesSet = getSwtChart().getSeriesSet();
 309         int seriesCount = seriesSet.getSeries().length;
 310         ILineSeries series = (ILineSeries) seriesSet.createSeries(SeriesType.LINE, seriesName);
 311         series.setVisible(true);
 312         series.enableArea(false);
 313         series.setLineStyle(LINE_STYLES[(seriesCount / (LINE_COLORS.length)) % LINE_STYLES.length]);
 314         series.setSymbolType(PlotSymbolType.NONE);
 315         series.setLineColor(Display.getDefault().getSystemColor(LINE_COLORS[seriesCount % LINE_COLORS.length]));
 316         return series;
 317     }
 318
 319     /**
 320      * Delete a series from the chart and its values from the viewer.
 321      *
 322      * @param seriesName
 323      *            Name of the series to delete
 324      */
 325     protected void deleteSeries(String seriesName) {
 326         ISeries series = getSwtChart().getSeriesSet().getSeries(seriesName);
 327         if (series != null) {
 328             getSwtChart().getSeriesSet().deleteSeries(series.getId());
 329         }
 330         fSeriesValues.remove(seriesName);
 331     }
 332
 333     /**
 334      * Update the chart's values before refreshing the viewer
 335      */
 336     protected void updateDisplay() {
 337         Display.getDefault().asyncExec(new Runnable() {
 338             final TmfChartTimeStampFormat tmfChartTimeStampFormat = new TmfChartTimeStampFormat(getTimeOffset());
 339
 340             @Override
 341             public void run() {
 342                 if (!getSwtChart().isDisposed()) {
 343                     double[] xValues = fXValues;
 344                     if (xValues.length < 1) {
 345                         return;
 346                     }
 347                     double maxy = DEFAULT_MAXY;
 348                     double miny = DEFAULT_MINY;
 349                     for (Entry<String, double[]> entry : fSeriesValues.entrySet()) {
 350                         ILineSeries series = (ILineSeries) getSwtChart().getSeriesSet().getSeries(entry.getKey());
 351                         if (series == null) {
 352                             series = addSeries(entry.getKey());
 353                         }
 354                         series.setXSeries(xValues);
 355                         /* Find the minimal and maximum values in this series */
 356                         for (double value : entry.getValue()) {
 357                             maxy = Math.max(maxy, value);
 358                             miny = Math.min(miny, value);
 359                         }
 360                         series.setYSeries(entry.getValue());
 361                     }
 362                     if (maxy == DEFAULT_MAXY) {
 363                         maxy = 1.0;
 364                     }
 365
 366                     IAxisTick xTick = getSwtChart().getAxisSet().getXAxis(0).getTick();
 367                     xTick.setFormat(tmfChartTimeStampFormat);
 368
 369                     final double start = xValues[0];
 370                     int lastX = xValues.length - 1;
 371                     double end = (start == xValues[lastX]) ? start + 1 : xValues[lastX];
 372                     getSwtChart().getAxisSet().getXAxis(0).setRange(new Range(start, end));
 373                     if (maxy > miny) {
 374                         getSwtChart().getAxisSet().getYAxis(0).setRange(new Range(miny, maxy));
 375                     }
 376                     getSwtChart().redraw();
 377
 378                     if (isSendTimeAlignSignals()) {
 379                         // The width of the chart might have changed and its
 380                         // time axis might be misaligned with the other views
 381                         Point viewPos = TmfCommonXLineChartViewer.this.getParent().getParent().toDisplay(0, 0);
 382                         int axisPos = getSwtChart().toDisplay(0, 0).x + getPointAreaOffset();
 383                         int timeAxisOffset = axisPos - viewPos.x;
 384                         TmfTimeViewAlignmentInfo timeAlignmentInfo = new TmfTimeViewAlignmentInfo(getControl().getShell(), viewPos, timeAxisOffset);
 385                         TmfSignalManager.dispatchSignal(new TmfTimeViewAlignmentSignal(TmfCommonXLineChartViewer.this, timeAlignmentInfo, true));
 386                     }
 387                 }
 388             }
 389         });
 390     }
 391
 392     /**
 393      * Create the series once the initialization of the viewer's data source is
 394      * done. Series do not need to be created before setting their values, but
 395      * if their appearance needs to be customized, this method is a good place
 396      * to do so. It is called only once per trace.
 397      */
 398     protected void createSeries() {
 399
 400     }
 401
 402     @Override
 403     protected void clearContent() {
 404         getSwtChart().getAxisSet().getXAxis(0).getTick().setFormat(null);
 405         super.clearContent();
 406     }
 407
 408 }