tmf/org.eclipse.tracecompass.tmf.ui/src/org/eclipse/tracecompass/tmf/ui/views/callstack/CallStackView.java

   1 /*******************************************************************************
   2  * Copyright (c) 2013, 2016 Ericsson 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  *   Patrick Tasse - Initial API and implementation
  11  *   Bernd Hufmann - Updated signal handling
  12  *   Marc-Andre Laperle - Map from binary file
  13  *******************************************************************************/
  14
  15 package org.eclipse.tracecompass.tmf.ui.views.callstack;
  16
  17 import java.util.ArrayList;
  18 import java.util.Collections;
  19 import java.util.Comparator;
  20 import java.util.HashMap;
  21 import java.util.Iterator;
  22 import java.util.List;
  23 import java.util.Map;
  24
  25 import org.eclipse.core.runtime.IProgressMonitor;
  26 import org.eclipse.jdt.annotation.NonNull;
  27 import org.eclipse.jdt.annotation.Nullable;
  28 import org.eclipse.jface.action.Action;
  29 import org.eclipse.jface.action.GroupMarker;
  30 import org.eclipse.jface.action.IAction;
  31 import org.eclipse.jface.action.IMenuManager;
  32 import org.eclipse.jface.action.IToolBarManager;
  33 import org.eclipse.jface.action.Separator;
  34 import org.eclipse.jface.dialogs.IDialogConstants;
  35 import org.eclipse.jface.dialogs.IDialogSettings;
  36 import org.eclipse.jface.resource.ImageDescriptor;
  37 import org.eclipse.jface.util.IPropertyChangeListener;
  38 import org.eclipse.jface.util.PropertyChangeEvent;
  39 import org.eclipse.jface.viewers.DoubleClickEvent;
  40 import org.eclipse.jface.viewers.IDoubleClickListener;
  41 import org.eclipse.jface.viewers.ISelection;
  42 import org.eclipse.jface.viewers.IStructuredSelection;
  43 import org.eclipse.swt.SWT;
  44 import org.eclipse.swt.events.MouseAdapter;
  45 import org.eclipse.swt.events.MouseEvent;
  46 import org.eclipse.swt.graphics.Image;
  47 import org.eclipse.swt.widgets.Composite;
  48 import org.eclipse.swt.widgets.Display;
  49 import org.eclipse.tracecompass.internal.tmf.ui.Activator;
  50 import org.eclipse.tracecompass.internal.tmf.ui.ITmfImageConstants;
  51 import org.eclipse.tracecompass.internal.tmf.ui.Messages;
  52 import org.eclipse.tracecompass.statesystem.core.ITmfStateSystem;
  53 import org.eclipse.tracecompass.statesystem.core.StateSystemUtils;
  54 import org.eclipse.tracecompass.statesystem.core.exceptions.AttributeNotFoundException;
  55 import org.eclipse.tracecompass.statesystem.core.exceptions.StateSystemDisposedException;
  56 import org.eclipse.tracecompass.statesystem.core.exceptions.StateValueTypeException;
  57 import org.eclipse.tracecompass.statesystem.core.exceptions.TimeRangeException;
  58 import org.eclipse.tracecompass.statesystem.core.interval.ITmfStateInterval;
  59 import org.eclipse.tracecompass.statesystem.core.statevalue.ITmfStateValue;
  60 import org.eclipse.tracecompass.statesystem.core.statevalue.ITmfStateValue.Type;
  61 import org.eclipse.tracecompass.tmf.core.signal.TmfSelectionRangeUpdatedSignal;
  62 import org.eclipse.tracecompass.tmf.core.signal.TmfSignalHandler;
  63 import org.eclipse.tracecompass.tmf.core.signal.TmfTraceClosedSignal;
  64 import org.eclipse.tracecompass.tmf.core.signal.TmfTraceSelectedSignal;
  65 import org.eclipse.tracecompass.tmf.core.signal.TmfWindowRangeUpdatedSignal;
  66 import org.eclipse.tracecompass.tmf.core.timestamp.ITmfTimestamp;
  67 import org.eclipse.tracecompass.tmf.core.timestamp.TmfNanoTimestamp;
  68 import org.eclipse.tracecompass.tmf.core.timestamp.TmfTimeRange;
  69 import org.eclipse.tracecompass.tmf.core.timestamp.TmfTimestamp;
  70 import org.eclipse.tracecompass.tmf.core.timestamp.TmfTimestampDelta;
  71 import org.eclipse.tracecompass.tmf.core.trace.ITmfTrace;
  72 import org.eclipse.tracecompass.tmf.core.trace.TmfTraceUtils;
  73 import org.eclipse.tracecompass.tmf.ui.editors.ITmfTraceEditor;
  74 import org.eclipse.tracecompass.tmf.ui.symbols.ISymbolProvider;
  75 import org.eclipse.tracecompass.tmf.ui.symbols.ISymbolProviderPreferencePage;
  76 import org.eclipse.tracecompass.tmf.ui.symbols.SymbolProviderConfigDialog;
  77 import org.eclipse.tracecompass.tmf.ui.symbols.SymbolProviderManager;
  78 import org.eclipse.tracecompass.tmf.ui.views.timegraph.AbstractTimeGraphView;
  79 import org.eclipse.tracecompass.tmf.ui.widgets.timegraph.ITimeGraphTimeListener;
  80 import org.eclipse.tracecompass.tmf.ui.widgets.timegraph.TimeGraphContentProvider;
  81 import org.eclipse.tracecompass.tmf.ui.widgets.timegraph.TimeGraphTimeEvent;
  82 import org.eclipse.tracecompass.tmf.ui.widgets.timegraph.TimeGraphViewer;
  83 import org.eclipse.tracecompass.tmf.ui.widgets.timegraph.model.ITimeEvent;
  84 import org.eclipse.tracecompass.tmf.ui.widgets.timegraph.model.ITimeGraphEntry;
  85 import org.eclipse.tracecompass.tmf.ui.widgets.timegraph.model.NullTimeEvent;
  86 import org.eclipse.tracecompass.tmf.ui.widgets.timegraph.model.TimeEvent;
  87 import org.eclipse.tracecompass.tmf.ui.widgets.timegraph.model.TimeGraphEntry;
  88 import org.eclipse.tracecompass.tmf.ui.widgets.timegraph.widgets.TimeGraphControl;
  89 import org.eclipse.tracecompass.tmf.ui.widgets.timegraph.widgets.TimeGraphSelection;
  90 import org.eclipse.ui.IEditorPart;
  91 import org.eclipse.ui.IWorkbenchActionConstants;
  92
  93 /**
  94  * Main implementation for the Call Stack view
  95  *
  96  * @author Patrick Tasse
  97  */
  98 public class CallStackView extends AbstractTimeGraphView {
  99
 100     // ------------------------------------------------------------------------
 101     // Constants
 102     // ------------------------------------------------------------------------
 103
 104     /** View ID. */
 105     public static final String ID = "org.eclipse.linuxtools.tmf.ui.views.callstack"; //$NON-NLS-1$
 106
 107     private static final String[] COLUMN_NAMES = new String[] {
 108             Messages.CallStackView_FunctionColumn,
 109             Messages.CallStackView_DepthColumn,
 110             Messages.CallStackView_EntryTimeColumn,
 111             Messages.CallStackView_ExitTimeColumn,
 112             Messages.CallStackView_DurationColumn
 113     };
 114
 115     private static final String[] FILTER_COLUMN_NAMES = new String[] {
 116             Messages.CallStackView_ThreadColumn
 117     };
 118
 119     /** Timeout between updates in the build thread in ms */
 120     private static final long BUILD_UPDATE_TIMEOUT = 500;
 121
 122     // Fraction of a function duration to be added as spacing
 123     private static final double SPACING_RATIO = 0.01;
 124
 125     private static final Image THREAD_IMAGE = Activator.getDefault().getImageFromPath("icons/obj16/thread_obj.gif"); //$NON-NLS-1$
 126     private static final Image STACKFRAME_IMAGE = Activator.getDefault().getImageFromPath("icons/obj16/stckframe_obj.gif"); //$NON-NLS-1$
 127
 128     private static final String IMPORT_BINARY_ICON_PATH = "icons/obj16/binaries_obj.gif"; //$NON-NLS-1$
 129
 130     private static final ImageDescriptor SORT_BY_NAME_ICON = Activator.getDefault().getImageDescripterFromPath("icons/etool16/sort_alpha.gif"); //$NON-NLS-1$
 131     private static final ImageDescriptor SORT_BY_NAME_REV_ICON = Activator.getDefault().getImageDescripterFromPath("icons/etool16/sort_alpha_rev.gif"); //$NON-NLS-1$
 132     private static final ImageDescriptor SORT_BY_ID_ICON = Activator.getDefault().getImageDescripterFromPath("icons/etool16/sort_num.gif"); //$NON-NLS-1$
 133     private static final ImageDescriptor SORT_BY_ID_REV_ICON = Activator.getDefault().getImageDescripterFromPath("icons/etool16/sort_num_rev.gif"); //$NON-NLS-1$
 134     private static final ImageDescriptor SORT_BY_TIME_ICON = Activator.getDefault().getImageDescripterFromPath("icons/etool16/sort_time.gif"); //$NON-NLS-1$
 135     private static final ImageDescriptor SORT_BY_TIME_REV_ICON = Activator.getDefault().getImageDescripterFromPath("icons/etool16/sort_time_rev.gif"); //$NON-NLS-1$
 136     private static final String SORT_OPTION_KEY = "sort.option"; //$NON-NLS-1$
 137
 138     private enum SortOption {
 139         BY_NAME, BY_NAME_REV, BY_ID, BY_ID_REV, BY_TIME, BY_TIME_REV
 140     }
 141
 142     private @NonNull SortOption fSortOption = SortOption.BY_NAME;
 143     private @NonNull Comparator<ITimeGraphEntry> fThreadComparator = new ThreadNameComparator(false);
 144     private Action fSortByNameAction;
 145     private Action fSortByIdAction;
 146     private Action fSortByTimeAction;
 147
 148     // ------------------------------------------------------------------------
 149     // Fields
 150     // ------------------------------------------------------------------------
 151
 152     private final Map<ITmfTrace, ISymbolProvider> fSymbolProviders = new HashMap<>();
 153
 154     // The next event action
 155     private Action fNextEventAction;
 156
 157     // The previous event action
 158     private Action fPrevEventAction;
 159
 160     // The next item action
 161     private Action fNextItemAction;
 162
 163     // The previous item action
 164     private Action fPreviousItemAction;
 165
 166     // The action to import a binary file mapping */
 167     private Action fConfigureSymbolsAction;
 168
 169     // The saved time sync. signal used when switching off the pinning of a view
 170     private TmfSelectionRangeUpdatedSignal fSavedTimeSyncSignal;
 171
 172     // The saved window range signal used when switching off the pinning of
 173     // a view
 174     private TmfWindowRangeUpdatedSignal fSavedRangeSyncSignal;
 175
 176     // ------------------------------------------------------------------------
 177     // Classes
 178     // ------------------------------------------------------------------------
 179
 180     private static class TraceEntry extends TimeGraphEntry {
 181         public TraceEntry(String name, long startTime, long endTime) {
 182             super(name, startTime, endTime);
 183         }
 184
 185         @Override
 186         public boolean hasTimeEvents() {
 187             return false;
 188         }
 189     }
 190
 191     private static class ThreadEntry extends TimeGraphEntry {
 192         // The call stack quark
 193         private final int fCallStackQuark;
 194         // The state system from which this entry comes
 195         private final ITmfStateSystem fSS;
 196         // The thread id
 197         private final long fThreadId;
 198
 199         public ThreadEntry(ITmfStateSystem ss, String name, long threadId, int callStackQuark, long startTime, long endTime) {
 200             super(name, startTime, endTime);
 201             fCallStackQuark = callStackQuark;
 202             fThreadId = threadId;
 203             fSS = ss;
 204         }
 205
 206         @Override
 207         public boolean hasTimeEvents() {
 208             return false;
 209         }
 210
 211         public int getCallStackQuark() {
 212             return fCallStackQuark;
 213         }
 214
 215         public long getThreadId() {
 216             return fThreadId;
 217         }
 218
 219         @Nullable
 220         public ITmfStateSystem getStateSystem() {
 221             return fSS;
 222         }
 223     }
 224
 225     private class CallStackComparator implements Comparator<ITimeGraphEntry> {
 226         @Override
 227         public int compare(ITimeGraphEntry o1, ITimeGraphEntry o2) {
 228             if (o1 instanceof ThreadEntry && o2 instanceof ThreadEntry) {
 229                 return fThreadComparator.compare(o1, o2);
 230             }
 231             return 0;
 232         }
 233     }
 234
 235     private static class ThreadNameComparator implements Comparator<ITimeGraphEntry> {
 236         private boolean reverse;
 237
 238         public ThreadNameComparator(boolean reverse) {
 239             this.reverse = reverse;
 240         }
 241
 242         @Override
 243         public int compare(ITimeGraphEntry o1, ITimeGraphEntry o2) {
 244             return reverse ? o2.getName().compareTo(o1.getName()) :
 245                     o1.getName().compareTo(o2.getName());
 246         }
 247     }
 248
 249     private static class ThreadIdComparator implements Comparator<ITimeGraphEntry> {
 250         private boolean reverse;
 251
 252         public ThreadIdComparator(boolean reverse) {
 253             this.reverse = reverse;
 254         }
 255
 256         @Override
 257         public int compare(ITimeGraphEntry o1, ITimeGraphEntry o2) {
 258             ThreadEntry t1 = (ThreadEntry) o1;
 259             ThreadEntry t2 = (ThreadEntry) o2;
 260             return reverse ? Long.compare(t2.getThreadId(), t1.getThreadId()) :
 261                     Long.compare(t1.getThreadId(), t2.getThreadId());
 262         }
 263     }
 264
 265     private static class ThreadTimeComparator implements Comparator<ITimeGraphEntry> {
 266         private boolean reverse;
 267
 268         public ThreadTimeComparator(boolean reverse) {
 269             this.reverse = reverse;
 270         }
 271
 272         @Override
 273         public int compare(ITimeGraphEntry o1, ITimeGraphEntry o2) {
 274             return reverse ? Long.compare(o2.getStartTime(), o1.getStartTime()) :
 275                     Long.compare(o1.getStartTime(), o2.getStartTime());
 276         }
 277     }
 278
 279     private static class CallStackTreeLabelProvider extends TreeLabelProvider {
 280
 281         @Override
 282         public Image getColumnImage(Object element, int columnIndex) {
 283             if (columnIndex == 0) {
 284                 if (element instanceof ThreadEntry) {
 285                     return THREAD_IMAGE;
 286                 } else if (element instanceof CallStackEntry) {
 287                     CallStackEntry entry = (CallStackEntry) element;
 288                     if (entry.getFunctionName().length() > 0) {
 289                         return STACKFRAME_IMAGE;
 290                     }
 291                 }
 292             }
 293             return null;
 294         }
 295
 296         @Override
 297         public String getColumnText(Object element, int columnIndex) {
 298             if (element instanceof CallStackEntry) {
 299                 CallStackEntry entry = (CallStackEntry) element;
 300                 if (columnIndex == 0) {
 301                     return entry.getFunctionName();
 302                 } else if (columnIndex == 1 && entry.getFunctionName().length() > 0) {
 303                     int depth = entry.getStackLevel();
 304                     return Integer.toString(depth);
 305                 } else if (columnIndex == 2 && entry.getFunctionName().length() > 0) {
 306                     ITmfTimestamp ts = new TmfTimestamp(entry.getFunctionEntryTime(), ITmfTimestamp.NANOSECOND_SCALE);
 307                     return ts.toString();
 308                 } else if (columnIndex == 3 && entry.getFunctionName().length() > 0) {
 309                     ITmfTimestamp ts = new TmfTimestamp(entry.getFunctionExitTime(), ITmfTimestamp.NANOSECOND_SCALE);
 310                     return ts.toString();
 311                 } else if (columnIndex == 4 && entry.getFunctionName().length() > 0) {
 312                     ITmfTimestamp ts = new TmfTimestampDelta(entry.getFunctionExitTime() - entry.getFunctionEntryTime(), ITmfTimestamp.NANOSECOND_SCALE);
 313                     return ts.toString();
 314                 }
 315             } else if (element instanceof ITimeGraphEntry) {
 316                 if (columnIndex == 0) {
 317                     return ((ITimeGraphEntry) element).getName();
 318                 }
 319             }
 320             return ""; //$NON-NLS-1$
 321         }
 322
 323     }
 324
 325     private class CallStackFilterContentProvider extends TimeGraphContentProvider {
 326         @Override
 327         public boolean hasChildren(Object element) {
 328             if (element instanceof TraceEntry) {
 329                 return super.hasChildren(element);
 330             }
 331             return false;
 332         }
 333
 334         @Override
 335         public ITimeGraphEntry[] getChildren(Object parentElement) {
 336             if (parentElement instanceof TraceEntry) {
 337                 return super.getChildren(parentElement);
 338             }
 339             return new ITimeGraphEntry[0];
 340         }
 341     }
 342
 343     // ------------------------------------------------------------------------
 344     // Constructors
 345     // ------------------------------------------------------------------------
 346
 347     /**
 348      * Default constructor
 349      */
 350     public CallStackView() {
 351         super(ID, new CallStackPresentationProvider());
 352         ((CallStackPresentationProvider) getPresentationProvider()).setCallStackView(this);
 353         setTreeColumns(COLUMN_NAMES);
 354         setTreeLabelProvider(new CallStackTreeLabelProvider());
 355         setEntryComparator(new CallStackComparator());
 356         setFilterColumns(FILTER_COLUMN_NAMES);
 357         setFilterContentProvider(new CallStackFilterContentProvider());
 358         setFilterLabelProvider(new CallStackTreeLabelProvider());
 359     }
 360
 361     // ------------------------------------------------------------------------
 362     // ViewPart
 363     // ------------------------------------------------------------------------
 364
 365     @Override
 366     public void createPartControl(Composite parent) {
 367         super.createPartControl(parent);
 368
 369         getTimeGraphViewer().addTimeListener(new ITimeGraphTimeListener() {
 370             @Override
 371             public void timeSelected(TimeGraphTimeEvent event) {
 372                 synchingToTime(event.getBeginTime());
 373             }
 374         });
 375
 376         getTimeGraphCombo().getTreeViewer().addDoubleClickListener(new IDoubleClickListener() {
 377             @Override
 378             public void doubleClick(DoubleClickEvent event) {
 379                 Object selection = ((IStructuredSelection) event.getSelection()).getFirstElement();
 380                 if (selection instanceof CallStackEntry) {
 381                     CallStackEntry entry = (CallStackEntry) selection;
 382                     if (entry.getFunctionName().length() > 0) {
 383                         long entryTime = entry.getFunctionEntryTime();
 384                         long exitTime = entry.getFunctionExitTime();
 385                         long spacingTime = (long) ((exitTime - entryTime) * SPACING_RATIO);
 386                         entryTime -= spacingTime;
 387                         exitTime += spacingTime;
 388                         TmfTimeRange range = new TmfTimeRange(new TmfNanoTimestamp(entryTime), new TmfNanoTimestamp(exitTime));
 389                         broadcast(new TmfWindowRangeUpdatedSignal(CallStackView.this, range));
 390                         getTimeGraphViewer().setStartFinishTime(entryTime, exitTime);
 391                         startZoomThread(entryTime, exitTime);
 392                     }
 393                 }
 394             }
 395         });
 396
 397         getTimeGraphViewer().getTimeGraphControl().addMouseListener(new MouseAdapter() {
 398             @Override
 399             public void mouseDoubleClick(MouseEvent e) {
 400                 TimeGraphControl timeGraphControl = getTimeGraphViewer().getTimeGraphControl();
 401                 ISelection selection = timeGraphControl.getSelection();
 402                 if (selection instanceof TimeGraphSelection) {
 403                     Object o = ((TimeGraphSelection) selection).getFirstElement();
 404                     if (o instanceof CallStackEvent) {
 405                         CallStackEvent event = (CallStackEvent) o;
 406                         long startTime = event.getTime();
 407                         long endTime = startTime + event.getDuration();
 408                         long spacingTime = (long) ((endTime - startTime) * SPACING_RATIO);
 409                         startTime -= spacingTime;
 410                         endTime += spacingTime;
 411                         TmfTimeRange range = new TmfTimeRange(new TmfNanoTimestamp(startTime), new TmfNanoTimestamp(endTime));
 412                         broadcast(new TmfWindowRangeUpdatedSignal(CallStackView.this, range));
 413                         getTimeGraphViewer().setStartFinishTime(startTime, endTime);
 414                         startZoomThread(startTime, endTime);
 415                     }
 416                 }
 417             }
 418         });
 419
 420         contributeToActionBars();
 421         loadSortOption();
 422
 423         IEditorPart editor = getSite().getPage().getActiveEditor();
 424         if (editor instanceof ITmfTraceEditor) {
 425             ITmfTrace trace = ((ITmfTraceEditor) editor).getTrace();
 426             if (trace != null) {
 427                 traceSelected(new TmfTraceSelectedSignal(this, trace));
 428             }
 429         }
 430     }
 431
 432     /**
 433      * Handler for the selection range signal.
 434      *
 435      * @param signal
 436      *            The incoming signal
 437      * @since 1.0
 438      */
 439     @Override
 440     @TmfSignalHandler
 441     public void selectionRangeUpdated(final TmfSelectionRangeUpdatedSignal signal) {
 442
 443         fSavedTimeSyncSignal = isPinned() ? new TmfSelectionRangeUpdatedSignal(signal.getSource(), signal.getBeginTime(), signal.getEndTime()) : null;
 444
 445         if (signal.getSource() == this || getTrace() == null || isPinned()) {
 446             return;
 447         }
 448         final long beginTime = signal.getBeginTime().toNanos();
 449         final long endTime = signal.getEndTime().toNanos();
 450         Display.getDefault().asyncExec(new Runnable() {
 451             @Override
 452             public void run() {
 453                 if (getTimeGraphCombo().isDisposed()) {
 454                     return;
 455                 }
 456                 if (beginTime == endTime) {
 457                     getTimeGraphViewer().setSelectedTime(beginTime, true);
 458                 } else {
 459                     getTimeGraphViewer().setSelectionRange(beginTime, endTime, true);
 460                 }
 461                 synchingToTime(beginTime);
 462                 startZoomThread(getTimeGraphViewer().getTime0(), getTimeGraphViewer().getTime1());
 463                 List<TimeGraphEntry> entryList = getEntryList(getTrace());
 464                 if (entryList == null) {
 465                     return;
 466                 }
 467                 TimeGraphViewer viewer = getTimeGraphViewer();
 468                 for (TimeGraphEntry traceEntry : entryList) {
 469                     for (ITimeGraphEntry child : traceEntry.getChildren()) {
 470                         ThreadEntry threadEntry = (ThreadEntry) child;
 471                         ITmfStateSystem ss = threadEntry.getStateSystem();
 472                         if (ss == null || beginTime < ss.getStartTime() || beginTime > ss.getCurrentEndTime()) {
 473                             continue;
 474                         }
 475                         try {
 476                             int quark = threadEntry.getCallStackQuark();
 477                             ITmfStateInterval stackInterval = ss.querySingleState(beginTime, quark);
 478                             if (beginTime == stackInterval.getStartTime()) {
 479                                 int stackLevel = stackInterval.getStateValue().unboxInt();
 480                                 ITimeGraphEntry selectedEntry = threadEntry.getChildren().get(Math.max(0, stackLevel - 1));
 481                                 getTimeGraphCombo().setSelection(selectedEntry);
 482                                 viewer.getTimeGraphControl().fireSelectionChanged();
 483                                 break;
 484                             }
 485                         } catch (AttributeNotFoundException | TimeRangeException | StateSystemDisposedException | StateValueTypeException e) {
 486                             Activator.getDefault().logError("Error querying state system", e); //$NON-NLS-1$
 487                         }
 488                     }
 489                 }
 490             }
 491         });
 492     }
 493
 494     /**
 495      * @since 2.0
 496      */
 497     @Override
 498     @TmfSignalHandler
 499     public void windowRangeUpdated(final TmfWindowRangeUpdatedSignal signal) {
 500
 501         if (isPinned()) {
 502             fSavedRangeSyncSignal = new TmfWindowRangeUpdatedSignal(signal.getSource(), signal.getCurrentRange());
 503             fSavedTimeSyncSignal = null;
 504         }
 505
 506         if ((signal.getSource() == this) || isPinned()) {
 507             return;
 508         }
 509         super.windowRangeUpdated(signal);
 510     }
 511
 512     // ------------------------------------------------------------------------
 513     // Internal
 514     // ------------------------------------------------------------------------
 515
 516     @Override
 517     @TmfSignalHandler
 518     public void traceClosed(TmfTraceClosedSignal signal) {
 519         super.traceClosed(signal);
 520         synchronized(fSymbolProviders){
 521             for(ITmfTrace trace : getTracesToBuild(signal.getTrace())){
 522                 fSymbolProviders.remove(trace);
 523             }
 524         }
 525     }
 526
 527     /**
 528      * @since 2.0
 529      */
 530     @Override
 531     protected void refresh() {
 532         super.refresh();
 533         updateConfigureSymbolsAction();
 534     }
 535
 536     @Override
 537     protected void buildEntryList(final ITmfTrace trace, final ITmfTrace parentTrace, final IProgressMonitor monitor) {
 538         if (monitor.isCanceled()) {
 539             return;
 540         }
 541         AbstractCallStackAnalysis module = getCallStackModule(trace);
 542         if (module == null) {
 543             addUnavailableEntry(trace, parentTrace);
 544             return;
 545         }
 546         ITmfStateSystem ss = module.getStateSystem();
 547         if (ss == null) {
 548             addUnavailableEntry(trace, parentTrace);
 549             return;
 550         }
 551
 552         Map<ITmfTrace, TraceEntry> traceEntryMap = new HashMap<>();
 553         Map<Integer, ThreadEntry> threadEntryMap = new HashMap<>();
 554         String[] threadPaths = module.getThreadsPattern();
 555
 556         long start = ss.getStartTime();
 557
 558         boolean complete = false;
 559         while (!complete) {
 560             if (monitor.isCanceled()) {
 561                 return;
 562             }
 563             complete = ss.waitUntilBuilt(BUILD_UPDATE_TIMEOUT);
 564             if (ss.isCancelled()) {
 565                 return;
 566             }
 567             long end = ss.getCurrentEndTime();
 568             if (start == end && !complete) { // when complete execute one last time regardless of end time
 569                 continue;
 570             }
 571
 572             ISymbolProvider provider = fSymbolProviders.get(trace);
 573             if (provider == null) {
 574                 provider = SymbolProviderManager.getInstance().getSymbolProvider(trace);
 575                 provider.loadConfiguration(monitor);
 576                 fSymbolProviders.put(trace, provider);
 577             }
 578
 579             getConfigureSymbolsAction().setEnabled(true);
 580
 581             List<Integer> threadQuarks = ss.getQuarks(threadPaths);
 582             TraceEntry traceEntry = traceEntryMap.get(trace);
 583             if (traceEntry == null) {
 584                 traceEntry = new TraceEntry(trace.getName(), start, end + 1);
 585                 traceEntryMap.put(trace, traceEntry);
 586                 traceEntry.sortChildren(fThreadComparator);
 587                 addToEntryList(parentTrace, Collections.singletonList(traceEntry));
 588             } else {
 589                 traceEntry.updateEndTime(end);
 590             }
 591             for (int i = 0; i < threadQuarks.size(); i++) {
 592                 if (monitor.isCanceled()) {
 593                     return;
 594                 }
 595                 int threadQuark = threadQuarks.get(i);
 596                 try {
 597                     String[] callStackPath = module.getCallStackPath();
 598                     int callStackQuark = ss.getQuarkRelative(threadQuark, callStackPath);
 599                     String threadName = ss.getAttributeName(threadQuark);
 600                     long threadEnd = end + 1;
 601                     ITmfStateInterval endInterval = ss.querySingleState(ss.getCurrentEndTime(), callStackQuark);
 602                     if (endInterval.getStateValue().isNull() && endInterval.getStartTime() != ss.getStartTime()) {
 603                         threadEnd = endInterval.getStartTime();
 604                     }
 605                     ThreadEntry threadEntry = threadEntryMap.get(threadQuark);
 606                     if (threadEntry == null) {
 607                         long threadId = ss.querySingleState(ss.getCurrentEndTime(), threadQuark).getStateValue().unboxLong();
 608                         long threadStart = start;
 609                         ITmfStateInterval startInterval = ss.querySingleState(start, callStackQuark);
 610                         if (startInterval.getStateValue().isNull()) {
 611                             threadStart = Math.min(startInterval.getEndTime() + 1, end + 1);
 612                         }
 613                         threadEntry = new ThreadEntry(ss, threadName, threadId, callStackQuark, threadStart, threadEnd);
 614                         threadEntryMap.put(threadQuark, threadEntry);
 615                         traceEntry.addChild(threadEntry);
 616                     } else {
 617                         threadEntry.updateEndTime(threadEnd);
 618                     }
 619                     int level = 1;
 620                     for (int stackLevelQuark : ss.getSubAttributes(callStackQuark, false)) {
 621                         if (level > threadEntry.getChildren().size()) {
 622                             CallStackEntry callStackEntry = new CallStackEntry(threadName, stackLevelQuark, level, trace, ss);
 623                             threadEntry.addChild(callStackEntry);
 624                         }
 625                         level++;
 626                     }
 627                 } catch (AttributeNotFoundException e) {
 628                     Activator.getDefault().logError("Error querying state system", e); //$NON-NLS-1$
 629                 } catch (StateSystemDisposedException e) {
 630                     /* Ignored */
 631                 }
 632             }
 633             if (parentTrace == getTrace()) {
 634                 synchronized (this) {
 635                     setStartTime(getStartTime() == SWT.DEFAULT ? start : Math.min(getStartTime(), start));
 636                     setEndTime(getEndTime() == SWT.DEFAULT ? end + 1 : Math.max(getEndTime(), end + 1));
 637                 }
 638                 synchingToTime(getTimeGraphViewer().getSelectionBegin());
 639                 refresh();
 640             }
 641             for (ITimeGraphEntry threadEntry : traceEntry.getChildren()) {
 642                 for (ITimeGraphEntry callStackEntry : threadEntry.getChildren()) {
 643                     if (monitor.isCanceled()) {
 644                         return;
 645                     }
 646                     buildStatusEvents(parentTrace, (CallStackEntry) callStackEntry, monitor, start, end);
 647                 }
 648             }
 649             start = end;
 650         }
 651     }
 652
 653     private void addUnavailableEntry(ITmfTrace trace, ITmfTrace parentTrace) {
 654         String name = Messages.CallStackView_StackInfoNotAvailable + ' ' + '(' + trace.getName() + ')';
 655         TraceEntry unavailableEntry = new TraceEntry(name, 0, 0);
 656         addToEntryList(parentTrace, Collections.singletonList(unavailableEntry));
 657         if (parentTrace == getTrace()) {
 658             refresh();
 659         }
 660     }
 661
 662     private void buildStatusEvents(ITmfTrace trace, CallStackEntry entry, @NonNull IProgressMonitor monitor, long start, long end) {
 663         ITmfStateSystem ss = entry.getStateSystem();
 664         long resolution = Math.max(1, (end - ss.getStartTime()) / getDisplayWidth());
 665         List<ITimeEvent> eventList = getEventList(entry, start, end + 1, resolution, monitor);
 666         if (eventList != null) {
 667             for (ITimeEvent event : eventList) {
 668                 entry.addEvent(event);
 669             }
 670         }
 671         if (trace == getTrace()) {
 672             redraw();
 673         }
 674     }
 675
 676     /**
 677      * @since 2.0
 678      */
 679     @Override
 680     protected final List<ITimeEvent> getEventList(TimeGraphEntry tgentry, long startTime, long endTime, long resolution, IProgressMonitor monitor) {
 681         if (!(tgentry instanceof CallStackEntry)) {
 682             return null;
 683         }
 684         CallStackEntry entry = (CallStackEntry) tgentry;
 685         ITmfStateSystem ss = entry.getStateSystem();
 686         long start = Math.max(startTime, ss.getStartTime());
 687         long end = Math.min(endTime, ss.getCurrentEndTime() + 1);
 688         if (end <= start) {
 689             return null;
 690         }
 691         List<ITimeEvent> eventList = null;
 692         try {
 693             List<ITmfStateInterval> stackIntervals = StateSystemUtils.queryHistoryRange(ss, entry.getQuark(), start, end - 1, resolution, monitor);
 694             eventList = new ArrayList<>(stackIntervals.size());
 695             long lastEndTime = -1;
 696             boolean lastIsNull = true;
 697             for (ITmfStateInterval statusInterval : stackIntervals) {
 698                 if (monitor.isCanceled()) {
 699                     return null;
 700                 }
 701                 long time = statusInterval.getStartTime();
 702                 long duration = statusInterval.getEndTime() - time + 1;
 703                 if (!statusInterval.getStateValue().isNull()) {
 704                     final int modulo = CallStackPresentationProvider.NUM_COLORS / 2;
 705                     int value = statusInterval.getStateValue().toString().hashCode() % modulo + modulo;
 706                     eventList.add(new CallStackEvent(entry, time, duration, value));
 707                     lastIsNull = false;
 708                 } else {
 709                     if (lastEndTime == -1) {
 710                         // add null event if it intersects the start time
 711                         eventList.add(new NullTimeEvent(entry, time, duration));
 712                     } else {
 713                         if (lastEndTime != time && lastIsNull) {
 714                             // add unknown event if between two null states
 715                             eventList.add(new TimeEvent(entry, lastEndTime, time - lastEndTime));
 716                         }
 717                         if (time + duration >= endTime) {
 718                             // add null event if it intersects the end time
 719                             eventList.add(new NullTimeEvent(entry, time, duration));
 720                         }
 721                     }
 722                     lastIsNull = true;
 723                 }
 724                 lastEndTime = time + duration;
 725             }
 726         } catch (AttributeNotFoundException e) {
 727             Activator.getDefault().logError("Error querying state system", e); //$NON-NLS-1$
 728         } catch (TimeRangeException e) {
 729             Activator.getDefault().logError("Error querying state system", e); //$NON-NLS-1$
 730         } catch (StateSystemDisposedException e) {
 731             /* Ignored */
 732         }
 733         return eventList;
 734     }
 735
 736     /**
 737      * @since 2.0
 738      */
 739     @Override
 740     protected void synchingToTime(long time) {
 741         List<TimeGraphEntry> entryList = getEntryList(getTrace());
 742         if (entryList == null) {
 743             return;
 744         }
 745         for (TimeGraphEntry traceEntry : entryList) {
 746             for (ITimeGraphEntry threadEntry : traceEntry.getChildren()) {
 747                 ITmfStateSystem ss = ((ThreadEntry) threadEntry).getStateSystem();
 748                 if (ss == null) {
 749                     continue;
 750                 }
 751                 if (ss.isCancelled()) {
 752                     continue;
 753                 }
 754                 if (time < ss.getStartTime() || time > ss.getCurrentEndTime()) {
 755                     continue;
 756                 }
 757                 for (ITimeGraphEntry child : threadEntry.getChildren()) {
 758                     CallStackEntry callStackEntry = (CallStackEntry) child;
 759                     ITmfTrace trace = callStackEntry.getTrace();
 760                     try {
 761                         ITmfStateInterval stackLevelInterval = ss.querySingleState(time, callStackEntry.getQuark());
 762                         ITmfStateValue nameValue = stackLevelInterval.getStateValue();
 763                         String name = getFunctionName(trace, nameValue);
 764                         callStackEntry.setFunctionName(name);
 765                         if (name.length() > 0) {
 766                             callStackEntry.setFunctionEntryTime(stackLevelInterval.getStartTime());
 767                             callStackEntry.setFunctionExitTime(stackLevelInterval.getEndTime() + 1);
 768                         }
 769                     } catch (AttributeNotFoundException e) {
 770                         Activator.getDefault().logError("Error querying state system", e); //$NON-NLS-1$
 771                     } catch (StateSystemDisposedException e) {
 772                         /* Ignored */
 773                     }
 774                 }
 775             }
 776         }
 777         if (Display.getCurrent() != null) {
 778             getTimeGraphCombo().refresh();
 779         }
 780     }
 781
 782     String getFunctionName(ITmfTrace trace, ITmfStateValue nameValue) {
 783         long address = Long.MAX_VALUE;
 784         String name = ""; //$NON-NLS-1$
 785         try {
 786             if (nameValue.getType() == Type.STRING) {
 787                 name = nameValue.unboxStr();
 788                 try {
 789                     address = Long.parseLong(name, 16);
 790                 } catch (NumberFormatException e) {
 791                     // ignore
 792                 }
 793             } else if (nameValue.getType() == Type.INTEGER) {
 794                 name = "0x" + Integer.toHexString(nameValue.unboxInt()); //$NON-NLS-1$
 795                 address = nameValue.unboxInt();
 796             } else if (nameValue.getType() == Type.LONG) {
 797                 name = "0x" + Long.toHexString(nameValue.unboxLong()); //$NON-NLS-1$
 798                 address = nameValue.unboxLong();
 799             }
 800         } catch (StateValueTypeException e) {
 801         }
 802         if (address != Long.MAX_VALUE) {
 803             ISymbolProvider provider = fSymbolProviders.get(trace);
 804             if (provider != null) {
 805                 String symbol = provider.getSymbolText(address);
 806                 if (symbol != null) {
 807                     name = symbol;
 808                 }
 809             }
 810         }
 811         return name;
 812     }
 813
 814     private void makeActions() {
 815         fPreviousItemAction = getTimeGraphViewer().getPreviousItemAction();
 816         fPreviousItemAction.setText(Messages.TmfTimeGraphViewer_PreviousItemActionNameText);
 817         fPreviousItemAction.setToolTipText(Messages.TmfTimeGraphViewer_PreviousItemActionToolTipText);
 818         fNextItemAction = getTimeGraphViewer().getNextItemAction();
 819         fNextItemAction.setText(Messages.TmfTimeGraphViewer_NextItemActionNameText);
 820         fNextItemAction.setToolTipText(Messages.TmfTimeGraphViewer_NextItemActionToolTipText);
 821     }
 822
 823     private void contributeToActionBars() {
 824         // Create pin action
 825         contributePinActionToToolBar();
 826         fPinAction.addPropertyChangeListener(new IPropertyChangeListener() {
 827             @Override
 828             public void propertyChange(PropertyChangeEvent event) {
 829                 if (IAction.CHECKED.equals(event.getProperty()) && !isPinned()) {
 830                     if (fSavedRangeSyncSignal != null) {
 831                         windowRangeUpdated(fSavedRangeSyncSignal);
 832                         fSavedRangeSyncSignal = null;
 833                     }
 834
 835                     if (fSavedTimeSyncSignal != null) {
 836                         selectionRangeUpdated(fSavedTimeSyncSignal);
 837                         fSavedTimeSyncSignal = null;
 838                     }
 839                 }
 840             }
 841         });
 842     }
 843
 844     /**
 845      * @since 2.0
 846      */
 847     @Override
 848     protected void fillLocalToolBar(IToolBarManager manager) {
 849         makeActions();
 850         manager.add(getConfigureSymbolsAction());
 851         manager.add(new Separator());
 852         manager.add(getSortByNameAction());
 853         manager.add(getSortByIdAction());
 854         manager.add(getSortByTimeAction());
 855         manager.add(new Separator());
 856         manager.add(getTimeGraphCombo().getShowFilterDialogAction());
 857         manager.add(new Separator());
 858         manager.add(getTimeGraphViewer().getResetScaleAction());
 859         manager.add(getPreviousEventAction());
 860         manager.add(getNextEventAction());
 861         manager.add(new Separator());
 862         manager.add(getTimeGraphViewer().getToggleBookmarkAction());
 863         manager.add(getTimeGraphViewer().getPreviousMarkerAction());
 864         manager.add(getTimeGraphViewer().getNextMarkerAction());
 865         manager.add(new Separator());
 866         manager.add(fPreviousItemAction);
 867         manager.add(fNextItemAction);
 868         manager.add(getTimeGraphViewer().getZoomInAction());
 869         manager.add(getTimeGraphViewer().getZoomOutAction());
 870     }
 871
 872     /**
 873      * @since 2.0
 874      */
 875     @Override
 876     protected void fillTimeGraphEntryContextMenu(IMenuManager contextMenu) {
 877         contextMenu.add(new GroupMarker(IWorkbenchActionConstants.GROUP_REORGANIZE));
 878         contextMenu.add(getSortByNameAction());
 879         contextMenu.add(getSortByIdAction());
 880         contextMenu.add(getSortByTimeAction());
 881     }
 882
 883     /**
 884      * Get the the next event action.
 885      *
 886      * @return The action object
 887      */
 888     private Action getNextEventAction() {
 889         if (fNextEventAction == null) {
 890             fNextEventAction = new Action() {
 891                 @Override
 892                 public void run() {
 893                     TimeGraphViewer viewer = getTimeGraphViewer();
 894                     ITimeGraphEntry entry = viewer.getSelection();
 895                     if (entry instanceof CallStackEntry) {
 896                         try {
 897                             CallStackEntry callStackEntry = (CallStackEntry) entry;
 898                             ITmfStateSystem ss = callStackEntry.getStateSystem();
 899                             long time = Math.max(ss.getStartTime(), Math.min(ss.getCurrentEndTime(), viewer.getSelectionBegin()));
 900                             ThreadEntry threadEntry = (ThreadEntry) callStackEntry.getParent();
 901                             int quark = ss.getParentAttributeQuark(callStackEntry.getQuark());
 902                             ITmfStateInterval stackInterval = ss.querySingleState(time, quark);
 903                             long newTime = stackInterval.getEndTime() + 1;
 904                             viewer.setSelectedTimeNotify(newTime, true);
 905                             stackInterval = ss.querySingleState(Math.min(ss.getCurrentEndTime(), newTime), quark);
 906                             int stackLevel = stackInterval.getStateValue().unboxInt();
 907                             ITimeGraphEntry selectedEntry = threadEntry.getChildren().get(Math.max(0, stackLevel - 1));
 908                             getTimeGraphCombo().setSelection(selectedEntry);
 909                             viewer.getTimeGraphControl().fireSelectionChanged();
 910                             startZoomThread(viewer.getTime0(), viewer.getTime1());
 911
 912                         } catch (AttributeNotFoundException | TimeRangeException | StateSystemDisposedException | StateValueTypeException e) {
 913                             Activator.getDefault().logError("Error querying state system", e); //$NON-NLS-1$
 914                         }
 915                     }
 916                 }
 917             };
 918
 919             fNextEventAction.setText(Messages.TmfTimeGraphViewer_NextEventActionNameText);
 920             fNextEventAction.setToolTipText(Messages.TmfTimeGraphViewer_NextEventActionToolTipText);
 921             fNextEventAction.setImageDescriptor(Activator.getDefault().getImageDescripterFromPath(ITmfImageConstants.IMG_UI_NEXT_EVENT));
 922         }
 923
 924         return fNextEventAction;
 925     }
 926
 927     /**
 928      * Get the previous event action.
 929      *
 930      * @return The Action object
 931      */
 932     private Action getPreviousEventAction() {
 933         if (fPrevEventAction == null) {
 934             fPrevEventAction = new Action() {
 935                 @Override
 936                 public void run() {
 937                     TimeGraphViewer viewer = getTimeGraphCombo().getTimeGraphViewer();
 938                     ITimeGraphEntry entry = viewer.getSelection();
 939                     if (entry instanceof CallStackEntry) {
 940                         try {
 941                             CallStackEntry callStackEntry = (CallStackEntry) entry;
 942                             ITmfStateSystem ss = callStackEntry.getStateSystem();
 943                             long time = Math.max(ss.getStartTime(), Math.min(ss.getCurrentEndTime(), viewer.getSelectionBegin()));
 944                             ThreadEntry threadEntry = (ThreadEntry) callStackEntry.getParent();
 945                             int quark = ss.getParentAttributeQuark(callStackEntry.getQuark());
 946                             ITmfStateInterval stackInterval = ss.querySingleState(time, quark);
 947                             if (stackInterval.getStartTime() == time && time > ss.getStartTime()) {
 948                                 stackInterval = ss.querySingleState(time - 1, quark);
 949                             }
 950                             viewer.setSelectedTimeNotify(stackInterval.getStartTime(), true);
 951                             int stackLevel = stackInterval.getStateValue().unboxInt();
 952                             ITimeGraphEntry selectedEntry = threadEntry.getChildren().get(Math.max(0, stackLevel - 1));
 953                             getTimeGraphCombo().setSelection(selectedEntry);
 954                             viewer.getTimeGraphControl().fireSelectionChanged();
 955                             startZoomThread(viewer.getTime0(), viewer.getTime1());
 956
 957                         } catch (AttributeNotFoundException | TimeRangeException | StateSystemDisposedException | StateValueTypeException e) {
 958                             Activator.getDefault().logError("Error querying state system", e); //$NON-NLS-1$
 959                         }
 960                     }
 961                 }
 962             };
 963
 964             fPrevEventAction.setText(Messages.TmfTimeGraphViewer_PreviousEventActionNameText);
 965             fPrevEventAction.setToolTipText(Messages.TmfTimeGraphViewer_PreviousEventActionToolTipText);
 966             fPrevEventAction.setImageDescriptor(Activator.getDefault().getImageDescripterFromPath(ITmfImageConstants.IMG_UI_PREV_EVENT));
 967         }
 968
 969         return fPrevEventAction;
 970     }
 971
 972     private static @Nullable AbstractCallStackAnalysis getCallStackModule(@NonNull ITmfTrace trace) {
 973         /*
 974          * Since we cannot know the exact analysis ID (in separate plugins), we
 975          * will search using the analysis type.
 976          */
 977         Iterable<AbstractCallStackAnalysis> modules =
 978                 TmfTraceUtils.getAnalysisModulesOfClass(trace, AbstractCallStackAnalysis.class);
 979         Iterator<AbstractCallStackAnalysis> it = modules.iterator();
 980         if (!it.hasNext()) {
 981             /* This trace does not provide a call-stack analysis */
 982             return null;
 983         }
 984
 985         /*
 986          * We only look at the first module we find.
 987          *
 988          * TODO Handle the advanced case where one trace provides more than one
 989          * call-stack analysis.
 990          */
 991         AbstractCallStackAnalysis module = it.next();
 992         /* This analysis is not automatic, we need to schedule it on-demand */
 993         module.schedule();
 994         if (!module.waitForInitialization()) {
 995             /* The initialization did not succeed */
 996             return null;
 997         }
 998         return module;
 999     }
1000
1001     // ------------------------------------------------------------------------
1002     // Methods related to function name mapping
1003     // ------------------------------------------------------------------------
1004
1005     private Action getSortByNameAction() {
1006         if (fSortByNameAction == null) {
1007             fSortByNameAction = new Action(Messages.CallStackView_SortByThreadName, IAction.AS_CHECK_BOX) {
1008                 @Override
1009                 public void run() {
1010                     if (fSortOption == SortOption.BY_NAME) {
1011                         saveSortOption(SortOption.BY_NAME_REV);
1012                     } else {
1013                         saveSortOption(SortOption.BY_NAME);
1014                     }
1015                 }
1016             };
1017             fSortByNameAction.setToolTipText(Messages.CallStackView_SortByThreadName);
1018             fSortByNameAction.setImageDescriptor(SORT_BY_NAME_ICON);
1019         }
1020         return fSortByNameAction;
1021     }
1022
1023     private Action getSortByIdAction() {
1024         if (fSortByIdAction == null) {
1025             fSortByIdAction = new Action(Messages.CallStackView_SortByThreadId, IAction.AS_CHECK_BOX) {
1026                 @Override
1027                 public void run() {
1028                     if (fSortOption == SortOption.BY_ID) {
1029                         saveSortOption(SortOption.BY_ID_REV);
1030                     } else {
1031                         saveSortOption(SortOption.BY_ID);
1032                     }
1033                 }
1034             };
1035             fSortByIdAction.setToolTipText(Messages.CallStackView_SortByThreadId);
1036             fSortByIdAction.setImageDescriptor(SORT_BY_ID_ICON);
1037         }
1038         return fSortByIdAction;
1039     }
1040
1041     private Action getSortByTimeAction() {
1042         if (fSortByTimeAction == null) {
1043             fSortByTimeAction = new Action(Messages.CallStackView_SortByThreadTime, IAction.AS_CHECK_BOX) {
1044                 @Override
1045                 public void run() {
1046                     if (fSortOption == SortOption.BY_TIME) {
1047                         saveSortOption(SortOption.BY_TIME_REV);
1048                     } else {
1049                         saveSortOption(SortOption.BY_TIME);
1050                     }
1051                 }
1052             };
1053             fSortByTimeAction.setToolTipText(Messages.CallStackView_SortByThreadTime);
1054             fSortByTimeAction.setImageDescriptor(SORT_BY_TIME_ICON);
1055         }
1056         return fSortByTimeAction;
1057     }
1058
1059     private void loadSortOption() {
1060         IDialogSettings settings = Activator.getDefault().getDialogSettings();
1061         IDialogSettings section = settings.getSection(getClass().getName());
1062         if (section == null) {
1063             return;
1064         }
1065         String sortOption = section.get(SORT_OPTION_KEY);
1066         if (sortOption == null) {
1067             return;
1068         }
1069
1070         // reset defaults
1071         getSortByNameAction().setChecked(false);
1072         getSortByNameAction().setImageDescriptor(SORT_BY_NAME_ICON);
1073         getSortByIdAction().setChecked(false);
1074         getSortByIdAction().setImageDescriptor(SORT_BY_ID_ICON);
1075         getSortByTimeAction().setChecked(false);
1076         getSortByTimeAction().setImageDescriptor(SORT_BY_TIME_ICON);
1077
1078         if (sortOption.equals(SortOption.BY_NAME.name())) {
1079             fSortOption = SortOption.BY_NAME;
1080             fThreadComparator = new ThreadNameComparator(false);
1081             getSortByNameAction().setChecked(true);
1082         } else if (sortOption.equals(SortOption.BY_NAME_REV.name())) {
1083             fSortOption = SortOption.BY_NAME_REV;
1084             fThreadComparator = new ThreadNameComparator(true);
1085             getSortByNameAction().setChecked(true);
1086             getSortByNameAction().setImageDescriptor(SORT_BY_NAME_REV_ICON);
1087         } else if (sortOption.equals(SortOption.BY_ID.name())) {
1088             fSortOption = SortOption.BY_ID;
1089             fThreadComparator = new ThreadIdComparator(false);
1090             getSortByIdAction().setChecked(true);
1091         } else if (sortOption.equals(SortOption.BY_ID_REV.name())) {
1092             fSortOption = SortOption.BY_ID_REV;
1093             fThreadComparator = new ThreadIdComparator(true);
1094             getSortByIdAction().setChecked(true);
1095             getSortByIdAction().setImageDescriptor(SORT_BY_ID_REV_ICON);
1096         } else if (sortOption.equals(SortOption.BY_TIME.name())) {
1097             fSortOption = SortOption.BY_TIME;
1098             fThreadComparator = new ThreadTimeComparator(false);
1099             getSortByTimeAction().setChecked(true);
1100         } else if (sortOption.equals(SortOption.BY_TIME_REV.name())) {
1101             fSortOption = SortOption.BY_TIME_REV;
1102             fThreadComparator = new ThreadTimeComparator(true);
1103             getSortByTimeAction().setChecked(true);
1104             getSortByTimeAction().setImageDescriptor(SORT_BY_TIME_REV_ICON);
1105         }
1106     }
1107
1108     private void saveSortOption(SortOption sortOption) {
1109         IDialogSettings settings = Activator.getDefault().getDialogSettings();
1110         IDialogSettings section = settings.getSection(getClass().getName());
1111         if (section == null) {
1112             section = settings.addNewSection(getClass().getName());
1113         }
1114         section.put(SORT_OPTION_KEY, sortOption.name());
1115         loadSortOption();
1116         List<TimeGraphEntry> entryList = getEntryList(getTrace());
1117         if (entryList == null) {
1118             return;
1119         }
1120         for (TimeGraphEntry traceEntry : entryList) {
1121             traceEntry.sortChildren(fThreadComparator);
1122         }
1123         refresh();
1124     }
1125
1126     private Action getConfigureSymbolsAction() {
1127         if (fConfigureSymbolsAction != null) {
1128             return fConfigureSymbolsAction;
1129         }
1130
1131         fConfigureSymbolsAction = new Action(Messages.CallStackView_ConfigureSymbolProvidersText) {
1132             @Override
1133             public void run() {
1134                 SymbolProviderConfigDialog dialog = new SymbolProviderConfigDialog(getSite().getShell(), getProviderPages());
1135                 if (dialog.open() == IDialogConstants.OK_ID) {
1136                     refresh();
1137                 }
1138             }
1139         };
1140
1141         fConfigureSymbolsAction.setToolTipText(Messages.CallStackView_ConfigureSymbolProvidersTooltip);
1142         fConfigureSymbolsAction.setImageDescriptor(Activator.getDefault().getImageDescripterFromPath(IMPORT_BINARY_ICON_PATH));
1143         fConfigureSymbolsAction.setEnabled(false);
1144
1145         return fConfigureSymbolsAction;
1146     }
1147
1148     /**
1149      * @return an array of {@link ISymbolProviderPreferencePage} that will
1150      *         configure the current traces
1151      */
1152     private ISymbolProviderPreferencePage[] getProviderPages() {
1153         List<ISymbolProviderPreferencePage> pages = new ArrayList<>();
1154         ITmfTrace trace = getTrace();
1155         if (trace != null) {
1156             for (ITmfTrace subTrace : getTracesToBuild(trace)) {
1157                 ISymbolProvider provider = fSymbolProviders.get(subTrace);
1158                 if (provider != null) {
1159                     ISymbolProviderPreferencePage page = provider.createPreferencePage();
1160                     if (page != null) {
1161                         pages.add(page);
1162                     }
1163                 }
1164             }
1165         }
1166         return pages.toArray(new ISymbolProviderPreferencePage[pages.size()]);
1167     }
1168
1169     /**
1170      * Update the enable status of the configure symbols action
1171      */
1172     private void updateConfigureSymbolsAction() {
1173         ISymbolProviderPreferencePage[] providerPages = getProviderPages();
1174         getConfigureSymbolsAction().setEnabled(providerPages.length > 0);
1175     }
1176
1177 }