org.eclipse.tracecompass.tmf.ui/src/org/eclipse/tracecompass/tmf/ui/views/statesystem/TmfStateSystemViewer.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  *   Florian Wininger - Initial API and implementation
  11  *   Alexandre Montplaisir - Refactoring, performance tweaks
  12  *   Bernd Hufmann - Updated signal handling
  13  *   Marc-Andre Laperle - Add time zone preference
  14  *   Geneviève Bastien - Moved state system explorer to use the abstract tree viewer
  15  *   Patrick Tasse - Refactoring
  16  *******************************************************************************/
  17
  18 package org.eclipse.tracecompass.tmf.ui.views.statesystem;
  19
  20 import java.util.ArrayList;
  21 import java.util.List;
  22
  23 import org.eclipse.jdt.annotation.NonNull;
  24 import org.eclipse.jface.viewers.AbstractTreeViewer;
  25 import org.eclipse.jface.viewers.Viewer;
  26 import org.eclipse.jface.viewers.ViewerComparator;
  27 import org.eclipse.swt.SWT;
  28 import org.eclipse.swt.graphics.Color;
  29 import org.eclipse.swt.widgets.Composite;
  30 import org.eclipse.swt.widgets.Display;
  31 import org.eclipse.tracecompass.statesystem.core.ITmfStateSystem;
  32 import org.eclipse.tracecompass.statesystem.core.exceptions.AttributeNotFoundException;
  33 import org.eclipse.tracecompass.statesystem.core.exceptions.StateSystemDisposedException;
  34 import org.eclipse.tracecompass.statesystem.core.exceptions.TimeRangeException;
  35 import org.eclipse.tracecompass.statesystem.core.interval.ITmfStateInterval;
  36 import org.eclipse.tracecompass.statesystem.core.statevalue.ITmfStateValue;
  37 import org.eclipse.tracecompass.tmf.core.signal.TmfSignalHandler;
  38 import org.eclipse.tracecompass.tmf.core.signal.TmfTimestampFormatUpdateSignal;
  39 import org.eclipse.tracecompass.tmf.core.statesystem.ITmfAnalysisModuleWithStateSystems;
  40 import org.eclipse.tracecompass.tmf.core.statesystem.TmfStateSystemAnalysisModule;
  41 import org.eclipse.tracecompass.tmf.core.timestamp.ITmfTimestamp;
  42 import org.eclipse.tracecompass.tmf.core.timestamp.TmfTimestamp;
  43 import org.eclipse.tracecompass.tmf.core.trace.ITmfTrace;
  44 import org.eclipse.tracecompass.tmf.core.trace.TmfTraceManager;
  45 import org.eclipse.tracecompass.tmf.core.trace.TmfTraceUtils;
  46 import org.eclipse.tracecompass.tmf.ui.viewers.tree.AbstractTmfTreeViewer;
  47 import org.eclipse.tracecompass.tmf.ui.viewers.tree.ITmfTreeColumnDataProvider;
  48 import org.eclipse.tracecompass.tmf.ui.viewers.tree.ITmfTreeViewerEntry;
  49 import org.eclipse.tracecompass.tmf.ui.viewers.tree.TmfTreeColumnData;
  50 import org.eclipse.tracecompass.tmf.ui.viewers.tree.TmfTreeViewerEntry;
  51
  52 /**
  53  * Displays the content of the state systems at the current time
  54  *
  55  * @author Florian Wininger
  56  * @author Alexandre Montplaisir
  57  * @author Geneviève Bastien
  58  * @since 3.0
  59  */
  60 public class TmfStateSystemViewer extends AbstractTmfTreeViewer {
  61
  62     private static final String EMPTY_STRING = ""; //$NON-NLS-1$
  63     private static final int DEFAULT_AUTOEXPAND = 2;
  64     private boolean fFilterStatus = false;
  65     private long fSelection = 0;
  66
  67     /* Order of columns */
  68     private static final int ATTRIBUTE_NAME_COL = 0;
  69     private static final int QUARK_COL = 1;
  70     private static final int VALUE_COL = 2;
  71     private static final int TYPE_COL = 3;
  72     private static final int START_TIME_COL = 4;
  73     private static final int END_TIME_COL = 5;
  74     private static final int ATTRIBUTE_FULLPATH_COL = 6;
  75
  76     /**
  77      * Base class to provide the labels for the tree viewer. Views extending
  78      * this class typically need to override the getColumnText method if they
  79      * have more than one column to display
  80      */
  81     protected static class StateSystemTreeLabelProvider extends TreeLabelProvider {
  82
  83         @Override
  84         public String getColumnText(Object element, int columnIndex) {
  85             if (element instanceof StateEntry) {
  86                 StateEntry entry = (StateEntry) element;
  87                 switch (columnIndex) {
  88                 case ATTRIBUTE_NAME_COL:
  89                     return entry.getName();
  90                 case QUARK_COL:
  91                     return String.valueOf(entry.getQuark());
  92                 case VALUE_COL:
  93                     return entry.getValue();
  94                 case TYPE_COL:
  95                     return entry.getType();
  96                 case START_TIME_COL:
  97                     return entry.getStartTime();
  98                 case END_TIME_COL:
  99                     return entry.getEndTime();
 100                 case ATTRIBUTE_FULLPATH_COL:
 101                     return entry.getFullPath();
 102                 default:
 103                     return EMPTY_STRING;
 104                 }
 105             }
 106             return super.getColumnText(element, columnIndex);
 107         }
 108
 109         @Override
 110         public Color getBackground(Object element, int columnIndex) {
 111             if (element instanceof StateEntry) {
 112                 if (((StateEntry) element).isModified()) {
 113                     return Display.getCurrent().getSystemColor(SWT.COLOR_YELLOW);
 114                 }
 115             }
 116             return super.getBackground(element, columnIndex);
 117         }
 118     }
 119
 120     /**
 121      * Constructor
 122      *
 123      * @param parent
 124      *            The parent containing this viewer
 125      */
 126     public TmfStateSystemViewer(Composite parent) {
 127         super(parent, false);
 128         this.setLabelProvider(new StateSystemTreeLabelProvider());
 129         getTreeViewer().setAutoExpandLevel(DEFAULT_AUTOEXPAND);
 130     }
 131
 132     @Override
 133     protected ITmfTreeColumnDataProvider getColumnDataProvider() {
 134         return new ITmfTreeColumnDataProvider() {
 135
 136             @Override
 137             public List<TmfTreeColumnData> getColumnData() {
 138                 List<TmfTreeColumnData> columns = new ArrayList<>();
 139                 TmfTreeColumnData column = new TmfTreeColumnData(Messages.TreeNodeColumnLabel);
 140                 columns.add(column);
 141                 column.setComparator(new ViewerComparator() {
 142                     @Override
 143                     public int compare(Viewer viewer, Object e1, Object e2) {
 144                         TmfTreeViewerEntry n1 = (TmfTreeViewerEntry) e1;
 145                         TmfTreeViewerEntry n2 = (TmfTreeViewerEntry) e2;
 146
 147                         return n1.getName().compareTo(n2.getName());
 148                     }
 149                 });
 150                 columns.add(new TmfTreeColumnData(Messages.QuarkColumnLabel));
 151                 columns.add(new TmfTreeColumnData(Messages.ValueColumnLabel));
 152                 columns.add(new TmfTreeColumnData(Messages.TypeColumnLabel));
 153                 columns.add(new TmfTreeColumnData(Messages.StartTimeColumLabel));
 154                 columns.add(new TmfTreeColumnData(Messages.EndTimeColumLabel));
 155                 columns.add(new TmfTreeColumnData(Messages.AttributePathColumnLabel));
 156                 return columns;
 157             }
 158
 159         };
 160     }
 161
 162     // ------------------------------------------------------------------------
 163     // Operations
 164     // ------------------------------------------------------------------------
 165
 166     @Override
 167     protected ITmfTreeViewerEntry updateElements(long start, long end, boolean selection) {
 168
 169         if (selection) {
 170             fSelection = start;
 171         } else {
 172             fSelection = TmfTraceManager.getInstance().getSelectionBeginTime().normalize(0, ITmfTimestamp.NANOSECOND_SCALE).getValue();
 173         }
 174
 175         if (getTrace() == null) {
 176             return null;
 177         }
 178
 179         ITmfTreeViewerEntry root = getInput();
 180
 181         if (root == null) {
 182             root = createRoot();
 183         } else if (fFilterStatus) {
 184             clearStateSystemEntries(root);
 185         }
 186
 187         /*
 188          * Update the values of the elements of the state systems at the
 189          * selection start time
 190          */
 191         boolean changed = updateStateSystemEntries(root, fSelection);
 192
 193         return selection || changed ? root : null;
 194     }
 195
 196     private ITmfTreeViewerEntry createRoot() {
 197         // 'Fake' root node
 198         TmfTreeViewerEntry rootEntry = new TmfTreeViewerEntry("root"); //$NON-NLS-1$
 199
 200         for (final ITmfTrace trace : TmfTraceManager.getTraceSetWithExperiment(getTrace())) {
 201             if (trace != null) {
 202                 rootEntry.addChild(createTraceEntry(trace));
 203             }
 204         }
 205         return rootEntry;
 206     }
 207
 208     private static TmfTreeViewerEntry createTraceEntry(ITmfTrace trace) {
 209         TmfTreeViewerEntry traceEntry = new TmfTreeViewerEntry(trace.getName());
 210         Iterable<ITmfAnalysisModuleWithStateSystems> modules = TmfTraceUtils.getAnalysisModulesOfClass(trace, ITmfAnalysisModuleWithStateSystems.class);
 211         for (ITmfAnalysisModuleWithStateSystems module : modules) {
 212             /* Just schedule the module, the data will be filled when available */
 213             module.schedule();
 214             if (module instanceof TmfStateSystemAnalysisModule) {
 215                 // TODO: add this method to ITmfAnalysisModuleWithStateSystems
 216                 ((TmfStateSystemAnalysisModule) module).waitForInitialization();
 217             }
 218             for (ITmfStateSystem ss : module.getStateSystems()) {
 219                 if (ss != null) {
 220                     traceEntry.addChild(new StateSystemEntry(ss));
 221                 }
 222             }
 223         }
 224         return traceEntry;
 225     }
 226
 227     private static void clearStateSystemEntries(ITmfTreeViewerEntry root) {
 228         for (ITmfTreeViewerEntry traceEntry : root.getChildren()) {
 229             for (ITmfTreeViewerEntry ssEntry : traceEntry.getChildren()) {
 230                 ssEntry.getChildren().clear();
 231             }
 232         }
 233     }
 234
 235     private boolean updateStateSystemEntries(ITmfTreeViewerEntry root, long timestamp) {
 236         boolean changed = false;
 237         for (ITmfTreeViewerEntry traceEntry : root.getChildren()) {
 238             for (ITmfTreeViewerEntry ssEntry : traceEntry.getChildren()) {
 239                 StateSystemEntry stateSystemEntry = (StateSystemEntry) ssEntry;
 240                 ITmfStateSystem ss = stateSystemEntry.getSS();
 241                 try {
 242                     List<ITmfStateInterval> fullState = ss.queryFullState(timestamp);
 243                     changed |= updateStateEntries(ss, fullState, stateSystemEntry, -1, timestamp);
 244                 } catch (TimeRangeException e) {
 245                     markOutOfRange(stateSystemEntry);
 246                     changed = true;
 247                 } catch (StateSystemDisposedException e) {
 248                     /* Ignored */
 249                 }
 250             }
 251         }
 252         return changed;
 253     }
 254
 255     private boolean updateStateEntries(ITmfStateSystem ss, List<ITmfStateInterval> fullState, TmfTreeViewerEntry parent, int parentQuark, long timestamp) {
 256         boolean changed = false;
 257         try {
 258             for (int quark : ss.getSubAttributes(parentQuark, false)) {
 259                 if (quark >= fullState.size()) {
 260                     // attribute was created after the full state query
 261                     continue;
 262                 }
 263                 ITmfStateInterval interval = fullState.get(quark);
 264                 StateEntry stateEntry = findStateEntry(parent, quark);
 265                 if (stateEntry == null) {
 266                     boolean modified = fFilterStatus ?
 267                             interval.getStartTime() == timestamp :
 268                                 !interval.getStateValue().isNull();
 269                     stateEntry = new StateEntry(ss.getAttributeName(quark), quark, ss.getFullAttributePath(quark),
 270                             interval.getStateValue(),
 271                             new TmfTimestamp(interval.getStartTime(), ITmfTimestamp.NANOSECOND_SCALE),
 272                             new TmfTimestamp(interval.getEndTime(), ITmfTimestamp.NANOSECOND_SCALE),
 273                             modified);
 274
 275                     // update children first to know if parent is really needed
 276                     updateStateEntries(ss, fullState, stateEntry, quark, timestamp);
 277
 278                     /*
 279                      * Add this entry to parent if filtering is off, or
 280                      * if the entry has children to display, or
 281                      * if there is a state change at the current timestamp
 282                      */
 283                     if (!fFilterStatus || stateEntry.hasChildren() || interval.getStartTime() == timestamp) {
 284                         parent.addChild(stateEntry);
 285                         changed = true;
 286                     }
 287                 } else {
 288                     stateEntry.update(interval.getStateValue(),
 289                             new TmfTimestamp(interval.getStartTime(), ITmfTimestamp.NANOSECOND_SCALE),
 290                             new TmfTimestamp(interval.getEndTime(), ITmfTimestamp.NANOSECOND_SCALE));
 291
 292                     // update children recursively
 293                     updateStateEntries(ss, fullState, stateEntry, quark, timestamp);
 294                 }
 295
 296             }
 297         } catch (AttributeNotFoundException e) {
 298             /* Should not happen, we're iterating on known attributes */
 299         }
 300         return changed;
 301     }
 302
 303     private static StateEntry findStateEntry(TmfTreeViewerEntry parent, int quark) {
 304         for (ITmfTreeViewerEntry child : parent.getChildren()) {
 305             StateEntry stateEntry = (StateEntry) child;
 306             if (stateEntry.getQuark() == quark) {
 307                 return stateEntry;
 308             }
 309         }
 310         return null;
 311     }
 312     /**
 313      * Set the entries as out of range
 314      */
 315     private static void markOutOfRange(ITmfTreeViewerEntry parent) {
 316         for (ITmfTreeViewerEntry entry : parent.getChildren()) {
 317             if (entry instanceof StateEntry) {
 318                 ((StateEntry) entry).setOutOfRange();
 319
 320                 /* Update this node's children recursively */
 321                 markOutOfRange(entry);
 322             }
 323         }
 324     }
 325
 326     /**
 327      * Set the filter status of the viewer. By default, all entries of all state
 328      * system are present, and the values that changed since last refresh are
 329      * shown in yellow. When the filter status is true, only the entries with
 330      * values modified at current time are displayed.
 331      */
 332     public void changeFilterStatus() {
 333         fFilterStatus = !fFilterStatus;
 334         if (fFilterStatus) {
 335             getTreeViewer().setAutoExpandLevel(AbstractTreeViewer.ALL_LEVELS);
 336         } else {
 337             getTreeViewer().setAutoExpandLevel(DEFAULT_AUTOEXPAND);
 338             clearContent();
 339         }
 340         updateContent(getSelectionBeginTime(), getSelectionEndTime(), true);
 341     }
 342
 343     /**
 344      * Update the display to use the updated timestamp format
 345      *
 346      * @param signal
 347      *            the incoming signal
 348      */
 349     @TmfSignalHandler
 350     public void timestampFormatUpdated(TmfTimestampFormatUpdateSignal signal) {
 351         updateContent(getSelectionBeginTime(), getSelectionEndTime(), true);
 352     }
 353
 354     private static class StateSystemEntry extends TmfTreeViewerEntry {
 355         private final @NonNull ITmfStateSystem fSS;
 356
 357         public StateSystemEntry(@NonNull ITmfStateSystem ss) {
 358             super(ss.getSSID());
 359             fSS = ss;
 360         }
 361
 362         public @NonNull ITmfStateSystem getSS() {
 363             return fSS;
 364         }
 365     }
 366
 367     private class StateEntry extends TmfTreeViewerEntry {
 368
 369         private final int fQuark;
 370         private final String fFullPath;
 371         private @NonNull TmfTimestamp fStart;
 372         private @NonNull TmfTimestamp fEnd;
 373         private ITmfStateValue fValue;
 374         private boolean fModified;
 375         private boolean fOutOfRange = false;
 376
 377         public StateEntry(String name, int quark, String fullPath, ITmfStateValue value, @NonNull TmfTimestamp start, @NonNull TmfTimestamp end, boolean modified) {
 378             super(name);
 379             fQuark = quark;
 380             fFullPath = fullPath;
 381             fStart = start;
 382             fEnd = end;
 383             fValue = value;
 384             fModified = modified;
 385         }
 386
 387         public int getQuark() {
 388             return fQuark;
 389         }
 390
 391         public String getFullPath() {
 392             return fFullPath;
 393         }
 394
 395         public String getStartTime() {
 396             if (fOutOfRange) {
 397                 return EMPTY_STRING;
 398             }
 399             return fStart.toString();
 400         }
 401
 402         public String getEndTime() {
 403             if (fOutOfRange) {
 404                 return EMPTY_STRING;
 405             }
 406             return fEnd.toString();
 407         }
 408
 409         public String getValue() {
 410             if (fOutOfRange) {
 411                 return Messages.OutOfRangeMsg;
 412             }
 413             switch (fValue.getType()) {
 414             case INTEGER:
 415             case LONG:
 416             case DOUBLE:
 417             case STRING:
 418                 return fValue.toString();
 419             case NULL:
 420             default:
 421                 return EMPTY_STRING;
 422             }
 423         }
 424
 425         public String getType() {
 426             if (fOutOfRange) {
 427                 return EMPTY_STRING;
 428             }
 429             switch (fValue.getType()) {
 430             case INTEGER:
 431                 return Messages.TypeInteger;
 432             case LONG:
 433                 return Messages.TypeLong;
 434             case DOUBLE:
 435                 return Messages.TypeDouble;
 436             case STRING:
 437                 return Messages.TypeString;
 438             case NULL:
 439             default:
 440                 return EMPTY_STRING;
 441             }
 442         }
 443
 444         public boolean isModified() {
 445             return fModified;
 446         }
 447
 448         public void update(ITmfStateValue value, @NonNull TmfTimestamp start, @NonNull TmfTimestamp end) {
 449             fModified = false;
 450             fOutOfRange = false;
 451             if (!start.equals(fStart)) {
 452                 fModified = true;
 453                 fStart = start;
 454                 fEnd = end;
 455                 fValue = value;
 456             }
 457         }
 458
 459         public void setOutOfRange() {
 460             fModified = false;
 461             fOutOfRange = true;
 462         }
 463     }
 464 }