org.eclipse.linuxtools.lttng.ui/src/org/eclipse/linuxtools/lttng/ui/views/controlflow/ControlFlowView.java

   1 /*******************************************************************************
   2  * Copyright (c) 2009, 2010 Ericsson
   3  *
   4  * All rights reserved. This program and the accompanying materials are made
   5  * 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: Alvaro Sanchez-Leon - Initial implementation
  10  *******************************************************************************/
  11 package org.eclipse.linuxtools.lttng.ui.views.controlflow;
  12
  13 import java.util.Vector;
  14
  15 import org.eclipse.jface.action.Action;
  16 import org.eclipse.jface.action.IMenuListener;
  17 import org.eclipse.jface.action.IMenuManager;
  18 import org.eclipse.jface.action.IToolBarManager;
  19 import org.eclipse.jface.action.MenuManager;
  20 import org.eclipse.jface.action.Separator;
  21 import org.eclipse.jface.dialogs.MessageDialog;
  22 import org.eclipse.jface.viewers.DoubleClickEvent;
  23 import org.eclipse.jface.viewers.IDoubleClickListener;
  24 import org.eclipse.jface.viewers.ISelection;
  25 import org.eclipse.jface.viewers.ISelectionChangedListener;
  26 import org.eclipse.jface.viewers.IStructuredContentProvider;
  27 import org.eclipse.jface.viewers.IStructuredSelection;
  28 import org.eclipse.jface.viewers.ITableLabelProvider;
  29 import org.eclipse.jface.viewers.LabelProvider;
  30 import org.eclipse.jface.viewers.SelectionChangedEvent;
  31 import org.eclipse.jface.viewers.StructuredViewer;
  32 import org.eclipse.jface.viewers.TableViewer;
  33 import org.eclipse.jface.viewers.Viewer;
  34 import org.eclipse.jface.viewers.ViewerFilter;
  35 import org.eclipse.linuxtools.lttng.control.LttngCoreProviderFactory;
  36 import org.eclipse.linuxtools.lttng.event.LttngTimestamp;
  37 import org.eclipse.linuxtools.lttng.request.ILttngSyntEventRequest;
  38 import org.eclipse.linuxtools.lttng.state.evProcessor.ITransEventProcessor;
  39 import org.eclipse.linuxtools.lttng.ui.TraceDebug;
  40 import org.eclipse.linuxtools.lttng.ui.model.trange.ItemContainer;
  41 import org.eclipse.linuxtools.lttng.ui.model.trange.TimeRangeEventProcess;
  42 import org.eclipse.linuxtools.lttng.ui.model.trange.TimeRangeViewerProvider;
  43 import org.eclipse.linuxtools.lttng.ui.views.common.AbsTimeUpdateView;
  44 import org.eclipse.linuxtools.lttng.ui.views.common.ParamsUpdater;
  45 import org.eclipse.linuxtools.lttng.ui.views.controlflow.evProcessor.FlowEventToHandlerFactory;
  46 import org.eclipse.linuxtools.lttng.ui.views.controlflow.model.FlowModelFactory;
  47 import org.eclipse.linuxtools.tmf.event.TmfEvent;
  48 import org.eclipse.linuxtools.tmf.event.TmfTimeRange;
  49 import org.eclipse.linuxtools.tmf.experiment.TmfExperiment;
  50 import org.eclipse.linuxtools.tmf.request.ITmfDataRequest.ExecutionType;
  51 import org.eclipse.linuxtools.tmf.signal.TmfExperimentSelectedSignal;
  52 import org.eclipse.linuxtools.tmf.signal.TmfRangeSynchSignal;
  53 import org.eclipse.linuxtools.tmf.signal.TmfSignalHandler;
  54 import org.eclipse.linuxtools.tmf.signal.TmfTimeSynchSignal;
  55 import org.eclipse.linuxtools.tmf.ui.viewers.TmfViewerFactory;
  56 import org.eclipse.linuxtools.tmf.ui.viewers.timeAnalysis.ITmfTimeFilterSelectionListener;
  57 import org.eclipse.linuxtools.tmf.ui.viewers.timeAnalysis.ITmfTimeScaleSelectionListener;
  58 import org.eclipse.linuxtools.tmf.ui.viewers.timeAnalysis.ITmfTimeSelectionListener;
  59 import org.eclipse.linuxtools.tmf.ui.viewers.timeAnalysis.TmfTimeFilterSelectionEvent;
  60 import org.eclipse.linuxtools.tmf.ui.viewers.timeAnalysis.TmfTimeScaleSelectionEvent;
  61 import org.eclipse.linuxtools.tmf.ui.viewers.timeAnalysis.TmfTimeSelectionEvent;
  62 import org.eclipse.linuxtools.tmf.ui.viewers.timeAnalysis.model.ITmfTimeAnalysisEntry;
  63 import org.eclipse.swt.SWT;
  64 import org.eclipse.swt.custom.SashForm;
  65 import org.eclipse.swt.custom.ScrolledComposite;
  66 import org.eclipse.swt.events.KeyEvent;
  67 import org.eclipse.swt.events.KeyListener;
  68 import org.eclipse.swt.graphics.Image;
  69 import org.eclipse.swt.graphics.Point;
  70 import org.eclipse.swt.graphics.Rectangle;
  71 import org.eclipse.swt.widgets.Composite;
  72 import org.eclipse.swt.widgets.Display;
  73 import org.eclipse.swt.widgets.Menu;
  74 import org.eclipse.swt.widgets.ScrollBar;
  75 import org.eclipse.swt.widgets.Table;
  76 import org.eclipse.swt.widgets.TableColumn;
  77 import org.eclipse.swt.widgets.TableItem;
  78 import org.eclipse.ui.IActionBars;
  79 import org.eclipse.ui.IWorkbenchActionConstants;
  80 import org.eclipse.ui.PlatformUI;
  81 import org.eclipse.ui.plugin.AbstractUIPlugin;
  82
  83 /**
  84  * <b><u>ControlFlowView</u></b>
  85  */
  86 /**
  87  * @author alvaro
  88  *
  89  */
  90 public class ControlFlowView extends AbsTimeUpdateView implements
  91                 ITmfTimeSelectionListener, ITmfTimeScaleSelectionListener,
  92                 ITmfTimeFilterSelectionListener {
  93
  94     public static final String ID = "org.eclipse.linuxtools.lttng.ui.views.controlflow";
  95
  96         // ========================================================================
  97         // Table data
  98         // ========================================================================
  99         private final String PROCESS_COLUMN = "Process";
 100         private final String BRAND_COLUMN = "Brand";
 101         private final String PID_COLUMN = "PID";
 102         private final String TGID_COLUMN = "TGID";
 103         private final String PPID_COLUMN = "PPID";
 104         private final String CPU_COLUMN = "CPU";
 105         private final String BIRTH_SEC_COLUMN = "Birth sec";
 106         private final String BIRTH_NSEC_COLUMN = "Birth nsec";
 107         private final String TRACE = "TRACE";
 108
 109         private final String[] columnNames = new String[] { PROCESS_COLUMN, /* */
 110         BRAND_COLUMN,/* */
 111         PID_COLUMN,/* */
 112         TGID_COLUMN,/* */
 113         PPID_COLUMN,/* */
 114         CPU_COLUMN, /* */
 115         BIRTH_SEC_COLUMN,/* */
 116         BIRTH_NSEC_COLUMN,/* */
 117         TRACE /* */
 118         };
 119
 120         // ========================================================================
 121         // Data
 122         // ========================================================================
 123         private TableViewer tableViewer;
 124         // private int totalNumItems = 0;
 125         // Actions
 126         private Action doubleClickAction;
 127         private Action resetScale;
 128         private Action nextEvent;
 129         private Action prevEvent;
 130         private Action nextTrace;
 131         private Action prevTrace;
 132         private Action showLegend;
 133         private Action filterTraces;
 134         private Action zoomIn;
 135         private Action zoomOut;
 136         private Action zoomFilter;
 137
 138         private ViewProcessFilter tableFilter = null;
 139         private ScrolledComposite scrollFrame = null;
 140
 141         // private static SimpleDateFormat stimeformat = new SimpleDateFormat(
 142         // "yy/MM/dd HH:mm:ss");
 143
 144         // private TraceModelImplFactory fact;
 145
 146         // ========================================================================
 147         // Methods
 148         // ========================================================================
 149         /*
 150          * The content provider class is responsible for providing objects to the
 151          * view. It can wrap existing objects in adapters or simply return objects
 152          * as-is. These objects may be sensitive to the current input of the view,
 153          * or ignore it and always show the same content (like Task List, for
 154          * example).
 155          */
 156
 157         class ViewContentProvider implements
 158         /* ILazyContentProvider, */IStructuredContentProvider {
 159                 private TableViewer cviewer = null;
 160                 private ITmfTimeAnalysisEntry[] elements = null;
 161
 162                 public ViewContentProvider(TableViewer v) {
 163                         cviewer = v;
 164                 }
 165
 166                 @Override
 167                 public void inputChanged(Viewer v, Object oldInput, Object newInput) {
 168                         this.elements = (ITmfTimeAnalysisEntry[]) newInput;
 169                         if (elements != null) {
 170                                 TraceDebug.debug("Total number of processes provided to Control Flow view: " + elements.length);
 171                         } else {
 172                                 TraceDebug.debug("New input = null");
 173                         }
 174                 }
 175
 176                 @Override
 177                 public void dispose() {
 178
 179                 }
 180
 181                 // Needed with the use of virtual tables in order to initialize items
 182                 // which were not initially visible.
 183                 public void updateElement(int index) {
 184                         cviewer.replace(elements[index], index);
 185                 }
 186
 187                 @Override
 188                 public Object[] getElements(Object inputElement) {
 189                         return elements;
 190                 }
 191         }
 192
 193         class ViewLabelProvider extends LabelProvider implements ITableLabelProvider {
 194                 @Override
 195                 public String getColumnText(Object obj, int index) {
 196                         String strRes = ""; //$NON-NLS-1$
 197                         LttngTimestamp time;
 198                         if (obj instanceof TimeRangeEventProcess) {
 199                                 TimeRangeEventProcess process = (TimeRangeEventProcess) obj;
 200                                 switch (index) {
 201                                 case 0:
 202                                         strRes = process.getName();
 203                                         break;
 204                                 case 1:
 205                                         strRes = process.getBrand();
 206                                         break;
 207                                 case 2:
 208                                         strRes = process.getPid().toString();
 209                                         break;
 210                                 case 3:
 211                                         strRes = process.getTgid().toString();
 212                                         break;
 213                                 case 4:
 214                                         strRes = process.getPpid().toString();
 215                                         break;
 216                                 case 5:
 217                                         strRes = process.getCpu().toString();
 218                                         break;
 219                                 case 6:
 220                                         time = new LttngTimestamp(process.getCreationTime()
 221                                                         .longValue());
 222                                         strRes = time.getSeconds();
 223                                         break;
 224                                 case 7:
 225                                         time = new LttngTimestamp(process.getCreationTime()
 226                                                         .longValue());
 227                                         strRes = time.getNanoSeconds();
 228                                         break;
 229                                 case 8:
 230                                         strRes = process.getTraceID();
 231                                         break;
 232                                 default:
 233                                         break;
 234                                 }
 235                         } else {
 236                                 return getText(obj);
 237                         }
 238
 239                         return strRes;
 240                 }
 241
 242                 @Override
 243                 public Image getColumnImage(Object obj, int index) {
 244                         return getImage(obj);
 245                 }
 246
 247                 @Override
 248                 public Image getImage(Object obj) {
 249                         // No image needed for the time being
 250                         // return PlatformUI.getWorkbench().getSharedImages().getImage(
 251                         // ISharedImages.IMG_OBJ_ELEMENT);
 252                         return null;
 253                 }
 254         }
 255
 256         class ViewProcessFilter extends ViewerFilter {
 257
 258                 private Vector<ITmfTimeAnalysisEntry> filteredSet = new Vector<ITmfTimeAnalysisEntry>();
 259                 StructuredViewer viewer;
 260
 261                 public ViewProcessFilter(StructuredViewer rviewer) {
 262                         this.viewer = rviewer;
 263                 }
 264
 265                 public void setFilter(Vector<ITmfTimeAnalysisEntry> filtered) {
 266                         if (filtered != null) {
 267                                 this.filteredSet = filtered;
 268                                 viewer.refresh();
 269                         }
 270                 }
 271
 272                 @Override
 273                 public boolean select(Viewer viewer, Object parentElement,
 274                                 Object element) {
 275                         boolean filteredIn = true;
 276                         if (element instanceof ITmfTimeAnalysisEntry) {
 277                                 ITmfTimeAnalysisEntry process = (ITmfTimeAnalysisEntry) element;
 278                                 if (filteredSet.contains(process)) {
 279                                         // The element is marked to be filtered out
 280                                         return false;
 281                                 }
 282                         } else {
 283                                 TraceDebug.debug("Unexpected type of filter element received: "
 284                                                 + element.toString());
 285                         }
 286                         // Compare element versus a list of filtered out
 287                         return filteredIn;
 288                 }
 289         }
 290
 291         /**
 292          * The constructor.
 293          */
 294         public ControlFlowView() {
 295                 super(ID);
 296         }
 297
 298         /**
 299          * This is a callback that will allow us to create the viewer and initialize
 300          * it.
 301          */
 302         /*
 303          * (non-Javadoc)
 304          *
 305          * @see
 306          * org.eclipse.linuxtools.tmf.ui.views.TmfView#createPartControl(org.eclipse
 307          * .swt.widgets.Composite)
 308          */
 309         @Override
 310         public void createPartControl(Composite parent) {
 311
 312                 scrollFrame = new ScrolledComposite(parent, SWT.V_SCROLL);
 313
 314                 scrollFrame.setExpandVertical(true);
 315                 scrollFrame.setExpandHorizontal(true);
 316                 scrollFrame.setAlwaysShowScrollBars(true);
 317
 318                 SashForm sash = new SashForm(scrollFrame, SWT.NONE);
 319                 scrollFrame.setContent(sash);
 320
 321                 tableViewer = new TableViewer(sash, SWT.FULL_SELECTION | SWT.H_SCROLL);
 322                 tableViewer.setContentProvider(new ViewContentProvider(tableViewer));
 323                 tableViewer.setLabelProvider(new ViewLabelProvider());
 324                 Table table = tableViewer.getTable();
 325                 tableViewer.addSelectionChangedListener(new ISelectionChangedListener() {
 326                         @Override
 327                         public void selectionChanged(SelectionChangedEvent event) {
 328                                 ISelection sel = event.getSelection();
 329                                 if (!sel.isEmpty()) {
 330                                         Object firstSel = null;
 331                                         if (sel instanceof IStructuredSelection) {
 332                                                 firstSel = ((IStructuredSelection) sel).getFirstElement();
 333
 334                                                 // Make sure the selection is visible
 335                                                 updateScrollOrigin();
 336
 337                                                 if (firstSel instanceof ITmfTimeAnalysisEntry) {
 338                                                         ITmfTimeAnalysisEntry trace = (ITmfTimeAnalysisEntry) firstSel;
 339                                                         tsfviewer.setSelectedTrace(trace);
 340                                                 }
 341                                         }
 342                                 }
 343                         }
 344
 345                         /**
 346                          * Make sure the selected item is visible
 347                          */
 348                         private void updateScrollOrigin() {
 349                                 Table table = tableViewer.getTable();
 350                                 if (table != null && table.getItemCount() > 0) {
 351                                         TableItem item = table.getSelection()[0];
 352                                         if (item == null) {
 353                                                 // no selected reference to go up or down
 354                                                 return;
 355                                         }
 356
 357                                         Rectangle itemRect = item.getBounds();
 358                                         int step = itemRect.height;
 359
 360                                         // calculate height of horizontal bar
 361                                         int hscrolly = 0;
 362                                         ScrollBar hbar = scrollFrame.getHorizontalBar();
 363                                         if (hbar != null) {
 364                                                 hscrolly = hbar.getSize().y;
 365                                         }
 366
 367                                         int visibleHeight = scrollFrame.getSize().y - hscrolly;
 368
 369                                         // the current scrollbar offset to adjust i.e. start
 370                                         // of
 371                                         // the visible window
 372                                         Point origin = scrollFrame.getOrigin();
 373                                         // end of visible window
 374                                         int endy = origin.y + visibleHeight;
 375
 376                                         int itemStartPos = itemRect.y + table.getHeaderHeight() + table.getBorderWidth()
 377                                                         + table.getParent().getBorderWidth();
 378
 379                                         // Item End Position
 380                                         int itemEndPos = itemStartPos + step;
 381
 382                                         // check if need to go up
 383                                         if (origin.y >= step && itemStartPos < origin.y) {
 384                                                 // one step up
 385                                                 scrollFrame.setOrigin(origin.x, origin.y - step);
 386
 387                                         }
 388
 389                                                         // check if it needs to go down
 390                                         if (itemEndPos > endy) {
 391                                                 // one step down
 392                                                 scrollFrame.setOrigin(origin.x, origin.y + step);
 393
 394                                                         }
 395                                 }
 396                         }
 397                 });
 398
 399                 // Listen to page up /down and Home / Enc keys
 400                 tableViewer.getTable().addKeyListener(new KeyListener() {
 401                         @Override
 402                         public void keyPressed(KeyEvent e) {
 403                                 Table table = tableViewer.getTable();
 404                                 Point origin = scrollFrame.getOrigin();
 405                                 if (table == null || table.getItemCount() < 1) {
 406                                         // nothing to page
 407                                         return;
 408                                 }
 409
 410                                 TableItem item;
 411                                 int count;
 412
 413                                 switch (e.keyCode) {
 414                                 case SWT.PAGE_DOWN:
 415                                         updateScrollPageDown();
 416                                         break;
 417                                 case SWT.PAGE_UP:
 418                                         updateScrollUp();
 419                                         break;
 420                                 case SWT.HOME:
 421                                         // Home
 422                                         count = table.getItemCount();
 423                                         item = table.getItem(0);
 424                                         // Go to the top
 425                                         scrollFrame.setOrigin(origin.x, 0);
 426                                         break;
 427                                 case SWT.END:
 428                                         // End Selected
 429                                         count = table.getItemCount();
 430                                         item = table.getItem(count - 1);
 431                                         int itemStartPos = item.getBounds().y;
 432                                         // Get to the bottom
 433                                         scrollFrame.setOrigin(origin.x, itemStartPos);
 434                                         break;
 435                                 default:
 436                                         break;
 437                                 }
 438                         }
 439
 440                         @Override
 441                         public void keyReleased(KeyEvent e) {
 442                                 // Nothing to do
 443
 444                         }
 445
 446                         /**
 447                          * Scroll one page down
 448                          */
 449                         private void updateScrollPageDown() {
 450                                 // null protection before calling private method
 451                                 Table table = tableViewer.getTable();
 452                                 int step = table.getItemHeight();
 453
 454                                 int hscrolly = 0;
 455                                 ScrollBar hbar = scrollFrame.getHorizontalBar();
 456                                 if (hbar != null) {
 457                                         hscrolly = hbar.getSize().y;
 458                                 }
 459
 460                                 Point origin = scrollFrame.getOrigin();
 461                                 int visibleHeight = scrollFrame.getSize().y - hscrolly;
 462                                 int endy = origin.y + visibleHeight;
 463
 464                                 scrollFrame.setOrigin(origin.x, endy - step);
 465                         }
 466
 467                         /**
 468                          * Scroll one page up
 469                          */
 470                         private void updateScrollUp() {
 471                                 // null protection before calling private method
 472                                 Table table = tableViewer.getTable();
 473                                 int step = table.getItemHeight();
 474
 475                                 int hscrolly = 0;
 476                                 ScrollBar hbar = scrollFrame.getHorizontalBar();
 477                                 if (hbar != null) {
 478                                         hscrolly = hbar.getSize().y;
 479                                 }
 480
 481                                 Point origin = scrollFrame.getOrigin();
 482                                 int visibleHeight = scrollFrame.getSize().y - hscrolly;
 483                                 int pageUpPos = origin.y - visibleHeight + step;
 484                                 pageUpPos = pageUpPos > 0 ? pageUpPos : 0;
 485                                 scrollFrame.setOrigin(origin.x, pageUpPos);
 486                         }
 487
 488                 });
 489                 // Describe table
 490                 applyTableLayout(table);
 491
 492                 int borderWidth = table.getBorderWidth();
 493
 494                 int itemHeight = table.getItemHeight() + checkForSWTBugItemHeightAdjustement();
 495                 int headerHeight = table.getHeaderHeight();
 496                 table.getVerticalBar().setVisible(false);
 497
 498                 tsfviewer = TmfViewerFactory.createViewer(sash,
 499  new TimeRangeViewerProvider(getParamsUpdater()));
 500
 501                 tsfviewer.addWidgetSelectionListner(this);
 502                 tsfviewer.addWidgetTimeScaleSelectionListner(this);
 503
 504                 // Traces shall not be grouped to allow synchronisation
 505                 tsfviewer.groupTraces(false);
 506                 tsfviewer.setItemHeight(itemHeight);
 507                 tsfviewer.setBorderWidth(borderWidth);
 508                 tsfviewer.setHeaderHeight(headerHeight);
 509                 tsfviewer.setVisibleVerticalScroll(false);
 510                 // Names provided by the table
 511                 tsfviewer.setNameWidthPref(0);
 512                 tsfviewer.setAcceptSelectionAPIcalls(true);
 513
 514                 // Viewer to notify selection to this class
 515                 // This class will synchronise selections with table.
 516                 tsfviewer.addWidgetSelectionListner(this);
 517                 tsfviewer.addFilterSelectionListner(this);
 518                 tsfviewer.addWidgetTimeScaleSelectionListner(this);
 519
 520                 sash.setWeights(new int[] { 1, 1 });
 521                 // Create the help context id for the viewer's control
 522                 // TODO: Associate with help system
 523                 PlatformUI.getWorkbench().getHelpSystem().setHelp(
 524                                 tableViewer.getControl(),
 525                                 "org.eclipse.linuxtools.lttnng.ui.views.flow.viewer"); //$NON-NLS-1$
 526
 527                 makeActions();
 528                 hookContextMenu();
 529                 hookDoubleClickAction();
 530                 contributeToActionBars();
 531
 532                 // scrollFrame.addControlListener(new ControlAdapter() {
 533                 //
 534                 // @Override
 535                 // public void controlResized(ControlEvent e) {
 536                 // tsfviewer.resizeControls();
 537                 // updateScrolls(scrollFrame);
 538                 // }
 539                 // });
 540
 541                 // set the initial view parameter values
 542                 // Experiment start and end time
 543                 // as well as time space width in pixels, used by the time analysis
 544                 // widget
 545                 // Read relevant values
 546                 int timeSpaceWidth = tsfviewer.getTimeSpace();
 547                 if (timeSpaceWidth < 0) {
 548                         timeSpaceWidth = -timeSpaceWidth;
 549                 }
 550
 551                 TmfExperiment<?> experiment = TmfExperiment.getCurrentExperiment();
 552                 if (experiment != null) {
 553                         TmfTimeRange experimentTRange = experiment.getTimeRange();
 554
 555                         // send request and received the adjusted time used
 556                         TmfTimeRange adjustedTimeRange = initialExperimentDataRequest(this,
 557                                         experimentTRange);
 558
 559                         // initialize widget time boundaries and filtering parameters
 560                         ModelUpdateInit(experimentTRange, adjustedTimeRange, this);
 561                 } else {
 562                         TraceDebug.debug("No selected experiment information available");
 563                 }
 564         }
 565
 566         private void hookContextMenu() {
 567                 MenuManager menuMgr = new MenuManager("#PopupMenu"); //$NON-NLS-1$
 568                 menuMgr.setRemoveAllWhenShown(true);
 569                 menuMgr.addMenuListener(new IMenuListener() {
 570                         @Override
 571                         public void menuAboutToShow(IMenuManager manager) {
 572                                 ControlFlowView.this.fillContextMenu(manager);
 573                         }
 574                 });
 575                 Menu menu = menuMgr.createContextMenu(tableViewer.getControl());
 576                 tableViewer.getControl().setMenu(menu);
 577                 getSite().registerContextMenu(menuMgr, tableViewer);
 578         }
 579
 580         private void contributeToActionBars() {
 581                 IActionBars bars = getViewSite().getActionBars();
 582                 fillLocalPullDown(bars.getMenuManager());
 583                 fillLocalToolBar(bars.getToolBarManager());
 584         }
 585
 586         private void fillLocalPullDown(IMenuManager manager) {
 587                 manager.add(new Separator());
 588                 // manager.add(showLegend);
 589                 manager.add(new Separator());
 590                 manager.add(resetScale);
 591                 manager.add(nextEvent);
 592                 manager.add(prevEvent);
 593                 manager.add(nextTrace);
 594                 manager.add(prevTrace);
 595                 // manager.add(filterTraces);
 596                 manager.add(zoomIn);
 597                 manager.add(zoomOut);
 598                 manager.add(zoomFilter);
 599                 manager.add(new Separator());
 600         }
 601
 602         private void fillContextMenu(IMenuManager manager) {
 603                 // manager.add(showLegend);
 604                 manager.add(new Separator());
 605                 manager.add(resetScale);
 606                 manager.add(nextEvent);
 607                 manager.add(prevEvent);
 608                 manager.add(nextTrace);
 609                 manager.add(prevTrace);
 610                 // manager.add(showLegend);
 611                 // manager.add(filterTraces);
 612                 manager.add(zoomIn);
 613                 manager.add(zoomOut);
 614                 manager.add(zoomFilter);
 615                 manager.add(new Separator());
 616                 manager.add(new Separator(IWorkbenchActionConstants.MB_ADDITIONS));
 617         }
 618
 619         private void fillLocalToolBar(IToolBarManager manager) {
 620                 // manager.add(showLegend);
 621                 manager.add(new Separator());
 622                 manager.add(resetScale);
 623                 manager.add(nextEvent);
 624                 manager.add(prevEvent);
 625                 manager.add(nextTrace);
 626                 manager.add(prevTrace);
 627                 // manager.add(filterTraces);
 628                 manager.add(zoomIn);
 629                 manager.add(zoomOut);
 630                 manager.add(zoomFilter);
 631                 manager.add(new Separator());
 632         }
 633
 634         private void makeActions() {
 635                 // resetScale
 636                 resetScale = new Action() {
 637                         @Override
 638                         public void run() {
 639                                 if (tsfviewer != null) {
 640                                         tsfviewer.resetStartFinishTime();
 641                                 }
 642
 643                         }
 644                 };
 645                 resetScale.setText(Messages.getString("ControlFlowView.Action.Reset")); //$NON-NLS-1$
 646                 resetScale.setToolTipText(Messages
 647                                 .getString("ControlFlowView.Action.Reset.ToolTip")); //$NON-NLS-1$
 648                 resetScale.setImageDescriptor(AbstractUIPlugin
 649                                 .imageDescriptorFromPlugin(Messages
 650                                                 .getString("ControlFlowView.tmf.UI"),
 651                                                 "icons/home_nav.gif"));
 652
 653                 // nextEvent
 654                 nextEvent = new Action() {
 655                         @Override
 656                         public void run() {
 657                                 if (tsfviewer != null) {
 658                                         tsfviewer.selectNextEvent();
 659                                 }
 660                         }
 661                 };
 662                 nextEvent.setText(Messages
 663                                 .getString("ControlFlowView.Action.NextEvent")); //$NON-NLS-1$
 664                 nextEvent.setToolTipText(Messages
 665                                 .getString("ControlFlowView.Action.NextEvent.Tooltip")); //$NON-NLS-1$
 666                 nextEvent.setImageDescriptor(AbstractUIPlugin
 667                                 .imageDescriptorFromPlugin(Messages
 668                                                 .getString("ControlFlowView.tmf.UI"),
 669                                                 "icons/next_event.gif"));
 670
 671                 // prevEvent
 672                 prevEvent = new Action() {
 673                 @Override
 674                 public void run() {
 675                                 if (tsfviewer != null) {
 676                                         tsfviewer.selectPrevEvent();
 677                                 }
 678                         }
 679                 };
 680                 prevEvent.setText(Messages
 681                                 .getString("ControlFlowView.Action.PrevEvent")); //$NON-NLS-1$
 682                 prevEvent.setToolTipText(Messages
 683                                 .getString("ControlFlowView.Action.PrevEvent.Tooltip")); //$NON-NLS-1$
 684                 prevEvent.setImageDescriptor(AbstractUIPlugin
 685                                 .imageDescriptorFromPlugin(Messages
 686                                                 .getString("ControlFlowView.tmf.UI"),
 687                                                 "icons/prev_event.gif"));
 688
 689                 // nextTrace
 690                 nextTrace = new Action() {
 691                         @Override
 692                         public void run() {
 693                                 if (tsfviewer != null) {
 694                                         tsfviewer.selectNextTrace();
 695                                 }
 696                         }
 697                 };
 698                 nextTrace.setText(Messages
 699                                 .getString("ControlFlowView.Action.NextProcess")); //$NON-NLS-1$
 700                 nextTrace.setToolTipText(Messages
 701                                 .getString("ControlFlowView.Action.NextProcess.ToolTip")); //$NON-NLS-1$
 702                 nextTrace.setImageDescriptor(AbstractUIPlugin
 703                                 .imageDescriptorFromPlugin(Messages
 704                                                 .getString("ControlFlowView.tmf.UI"),
 705                                                 "icons/next_item.gif"));
 706
 707                 // prevTrace
 708                 prevTrace = new Action() {
 709                         @Override
 710                         public void run() {
 711                                 if (tsfviewer != null) {
 712                                         tsfviewer.selectPrevTrace();
 713                                 }
 714                         }
 715                 };
 716                 prevTrace.setText(Messages
 717                                 .getString("ControlFlowView.Action.PreviousProcess")); //$NON-NLS-1$
 718                 prevTrace.setToolTipText(Messages
 719                                 .getString("ControlFlowView.Action.PreviousProcess.Tooltip")); //$NON-NLS-1$
 720                 prevTrace.setImageDescriptor(AbstractUIPlugin
 721                                 .imageDescriptorFromPlugin(Messages
 722                                                 .getString("ControlFlowView.tmf.UI"),
 723                                                 "icons/prev_item.gif"));
 724
 725                 // showLegend
 726                 showLegend = new Action() {
 727                         @Override
 728                         public void run() {
 729                                 if (tsfviewer != null) {
 730                                         tsfviewer.showLegend();
 731                                 }
 732                         }
 733                 };
 734                 showLegend.setText(Messages.getString("ControlFlowView.Action.Legend")); //$NON-NLS-1$
 735                 showLegend.setToolTipText(Messages
 736                                 .getString("ControlFlowView.Action.Legend.ToolTip")); //$NON-NLS-1$
 737
 738                 // filterTraces
 739                 filterTraces = new Action() {
 740                         @Override
 741                         public void run() {
 742                                 if (tsfviewer != null) {
 743                                         tsfviewer.filterTraces();
 744                                 }
 745                         }
 746                 };
 747                 filterTraces.setText(Messages
 748                                 .getString("ControlFlowView.Action.Filter")); //$NON-NLS-1$
 749                 filterTraces.setToolTipText(Messages
 750                                 .getString("ControlFlowView.Action.Filter.ToolTip")); //$NON-NLS-1$
 751                 filterTraces.setImageDescriptor(AbstractUIPlugin
 752                                 .imageDescriptorFromPlugin(Messages
 753                                                 .getString("ControlFlowView.tmf.UI"),
 754                                                 "icons/filter_items.gif"));
 755
 756                 // zoomIn
 757                 zoomIn = new Action() {
 758                         @Override
 759                         public void run() {
 760                                 if (tsfviewer != null) {
 761                                         tsfviewer.zoomIn();
 762                                 }
 763                         }
 764                 };
 765                 zoomIn.setText(Messages.getString("ControlFlowView.Action.ZoomIn")); //$NON-NLS-1$
 766                 zoomIn.setToolTipText(Messages
 767                                 .getString("ControlFlowView.Action.ZoomIn.Tooltip")); //$NON-NLS-1$
 768                 zoomIn.setImageDescriptor(AbstractUIPlugin.imageDescriptorFromPlugin(
 769                                 Messages.getString("ControlFlowView.tmf.UI"),
 770                                 "icons/zoomin_nav.gif"));
 771
 772                 // zoomOut
 773                 zoomOut = new Action() {
 774                         @Override
 775                         public void run() {
 776                                 if (tsfviewer != null) {
 777                                         tsfviewer.zoomOut();
 778                                 }
 779                         }
 780                 };
 781                 zoomOut.setText(Messages.getString("ControlFlowView.Action.ZoomOut")); //$NON-NLS-1$
 782                 zoomOut.setToolTipText(Messages
 783                                 .getString("ControlFlowView.Action.ZoomOut.tooltip")); //$NON-NLS-1$
 784                 zoomOut.setImageDescriptor(AbstractUIPlugin.imageDescriptorFromPlugin(
 785                                 Messages.getString("ControlFlowView.tmf.UI"),
 786                                 "icons/zoomout_nav.gif"));
 787
 788                 // zoomFilter
 789                 zoomFilter = new Action() {
 790                         @Override
 791                         public void run() {
 792                                 // Nothing to do, however the selection status is needed by the
 793                                 // application
 794                         }
 795                 };
 796                 zoomFilter.setText(Messages
 797                                 .getString("ControlFlowView.Action.ZoomFilter")); //$NON-NLS-1$
 798                 zoomFilter.setToolTipText(Messages
 799                                 .getString("ControlFlowView.Action.ZoomFilter.tooltip")); //$NON-NLS-1$
 800                 zoomFilter.setImageDescriptor(AbstractUIPlugin
 801                                 .imageDescriptorFromPlugin(Messages
 802                                                 .getString("ControlFlowView.tmf.UI"),
 803                                                 "icons/filter_items.gif"));
 804                 zoomFilter.setChecked(false);
 805
 806                 // PlatformUI.getWorkbench().getSharedImages().getImage(ISharedImages.IMG_ELCL_SYNCED);
 807
 808                 doubleClickAction = new Action() {
 809                         @Override
 810                         public void run() {
 811                                 ISelection selection = tableViewer.getSelection();
 812                                 Object obj = ((IStructuredSelection) selection)
 813                                                 .getFirstElement();
 814                                 showMessage("Double-click detected on " + obj.toString()); //$NON-NLS-1$
 815                         }
 816                 };
 817         }
 818
 819         private void hookDoubleClickAction() {
 820                 tableViewer.addDoubleClickListener(new IDoubleClickListener() {
 821                         @Override
 822                         public void doubleClick(DoubleClickEvent event) {
 823                                 doubleClickAction.run();
 824                         }
 825                 });
 826         }
 827
 828         private void showMessage(String message) {
 829                 MessageDialog.openInformation(tableViewer.getControl().getShell(),
 830                                 Messages.getString("ControlFlowView.msgSlogan"), message); //$NON-NLS-1$
 831         }
 832
 833         /**
 834          * Passing the focus request to the viewer's control.
 835          */
 836         @Override
 837         public void setFocus() {
 838                 tableViewer.getControl().setFocus();
 839         }
 840
 841         /*
 842          * (non-Javadoc)
 843          *
 844          * @see org.eclipse.linuxtools.lttng.ui.views.common.AbsTimeUpdateView#
 845          * tsfTmProcessSelEvent
 846          * (org.eclipse.linuxtools.tmf.ui.viewers.timeAnalysis.TmfTimeSelectionEvent
 847          * )
 848          */
 849         @Override
 850         public void tsfTmProcessSelEvent(TmfTimeSelectionEvent event) {
 851                 // common implementation
 852                 super.tsfTmProcessSelEvent(event);
 853
 854                 // Reselect the table viewer to widget selection
 855                 ISelection sel = tsfviewer.getSelectionTrace();
 856                 if (sel != null && !sel.isEmpty()) {
 857                         tableViewer.setSelection(sel);
 858                 }
 859         }
 860
 861         /*
 862          * (non-Javadoc)
 863          *
 864          * @see org.eclipse.linuxtools.tmf.ui.viewers.timeAnalysis.
 865          * ITmfTimeScaleSelectionListener
 866          * #tsfTmProcessTimeScaleEvent(org.eclipse.linuxtools
 867          * .tmf.ui.viewers.timeAnalysis.TmfTimeScaleSelectionEvent)
 868          */
 869         @Override
 870         public void tsfTmProcessTimeScaleEvent(TmfTimeScaleSelectionEvent event) {
 871                 super.tsfTmProcessTimeScaleEvent(event);
 872         }
 873
 874         private void applyTableLayout(Table table) {
 875                 for (int i = 0; i < columnNames.length; i++) {
 876                         TableColumn tableColumn = new TableColumn(table, SWT.LEFT);
 877                         tableColumn.setText(columnNames[i]);
 878                         tableColumn.pack();
 879                 }
 880                 table.setHeaderVisible(true);
 881                 table.setLinesVisible(true);
 882         }
 883
 884         /*
 885          * (non-Javadoc)
 886          *
 887          * @see
 888          * org.eclipse.linuxtools.lttng.ui.views.common.AbsTimeUpdateView#displayModel
 889          * (org.eclipse.linuxtools.tmf.ui.viewers.timeAnalysis.model.
 890          * ITmfTimeAnalysisEntry[], long, long, boolean, long, long,
 891          * java.lang.Object)
 892          */
 893         @Override
 894         public void displayModel(final ITmfTimeAnalysisEntry[] items,
 895                         final long startBoundTime, final long endBoundTime,
 896                         final boolean updateTimeBounds, final long startVisibleWindow,
 897                         final long endVisibleWindow, final Object source) {
 898
 899                 if(tableViewer != null) {
 900                         final Table table = tableViewer.getTable();
 901
 902                         // Ignore update if widget is disposed
 903                         if (table.isDisposed()) return;
 904
 905                         Display display = table.getDisplay();
 906
 907                         // Perform the updates on the UI thread)
 908                         display.asyncExec(new Runnable() {
 909                                 @Override
 910                                 public void run() {
 911                                         if (!table.isDisposed()) {
 912                                                 tableViewer.setInput(items); // This shall be the minimal
 913                                                 // initial
 914                                                 tableFilter = new ViewProcessFilter(tableViewer);
 915                                                 tableViewer.setFilters(new ViewerFilter[] { tableFilter });
 916
 917                                                 resizeTableColumns(table);
 918                                                 table.update();
 919                                                 tableViewer.refresh();
 920
 921                                                 tsfviewer.display(items, startBoundTime, endBoundTime,
 922                                                                 updateTimeBounds);
 923
 924                                                 // validate visible boundaries
 925                                                 if (startVisibleWindow > -1 && endVisibleWindow > -1) {
 926                                                         tsfviewer.setSelectVisTimeWindow(startVisibleWindow,
 927                                                                         endVisibleWindow, source);
 928                                                 }
 929
 930                                                 tsfviewer.resizeControls();
 931
 932                                                 // Adjust the size of the vertical scroll bar to fit the
 933                                                 // contents
 934                                                 if (scrollFrame != null) {
 935                                                         updateScrolls(scrollFrame);
 936                                                 }
 937                                         }
 938                                 }
 939                         });
 940                 }
 941         }
 942
 943         @Override
 944         public void dispose() {
 945                 // dispose parent resources
 946                 super.dispose();
 947
 948                 tsfviewer.removeFilterSelectionListner(this);
 949                 tsfviewer.removeWidgetSelectionListner(this);
 950                 tsfviewer.removeWidgetTimeScaleSelectionListner(this);
 951                 tableViewer = null;
 952                 tsfviewer = null;
 953         }
 954
 955         /**
 956          * @param tableComposite
 957          * @param table
 958          */
 959         private synchronized void resizeTableColumns(Table table) {
 960                 if (table != null) {
 961                         Composite parent = table.getParent();
 962                         int tableWidthSum = parent.getBorderWidth();
 963
 964                         TableColumn[] columns = table.getColumns();
 965                         for (TableColumn column : columns) {
 966                                 column.pack();
 967                                 tableWidthSum += column.getWidth();
 968                         }
 969                 }
 970         }
 971
 972         @Override
 973         public void tmfTaProcessFilterSelection(TmfTimeFilterSelectionEvent event) {
 974                 if (tableFilter != null) {
 975                         Vector<ITmfTimeAnalysisEntry> filteredout = event.getFilteredOut();
 976                         if (filteredout != null) {
 977                                 tableFilter.setFilter(filteredout);
 978                         } else {
 979                                 tableFilter.setFilter(new Vector<ITmfTimeAnalysisEntry>());
 980                         }
 981                         tableViewer.refresh();
 982                 }
 983         }
 984
 985         /**
 986          * @param scrollFrame
 987          * @param wrapper
 988          */
 989         private void updateScrolls(final ScrolledComposite scrollFrame) {
 990                 scrollFrame.setMinSize(tableViewer.getTable().computeSize(SWT.DEFAULT, SWT.DEFAULT));
 991         }
 992
 993         /**
 994          * Registers as listener of time selection from other views
 995          *
 996          * @param signal
 997          */
 998         @Override
 999         @TmfSignalHandler
1000         public void synchToTime(TmfTimeSynchSignal signal) {
1001                 super.synchToTime(signal);
1002         }
1003
1004         /**
1005          * Annotation Registers as listener of time range selection from other views
1006          * The implementation handles the entry of the signal.
1007          *
1008          * @param signal
1009          */
1010         @TmfSignalHandler
1011         public void synchToTimeRange(TmfRangeSynchSignal signal) {
1012                 if (zoomFilter != null) {
1013                         synchToTimeRange(signal, zoomFilter.isChecked());
1014                 }
1015         }
1016
1017         @Override
1018         public void modelIncomplete(ILttngSyntEventRequest request) {
1019                 // Nothing to do
1020                 // The data will be refreshed on the next request
1021         }
1022
1023         /*
1024          * (non-Javadoc)
1025          *
1026          * @see org.eclipse.linuxtools.lttng.ui.views.common.AbsTimeUpdateView#
1027          * getEventProcessor()
1028          */
1029         @Override
1030         public ITransEventProcessor getEventProcessor() {
1031                 return FlowEventToHandlerFactory.getInstance();
1032         }
1033
1034         /**
1035          * @param signal
1036          */
1037         @TmfSignalHandler
1038         public void experimentSelected(
1039                         TmfExperimentSelectedSignal<? extends TmfEvent> signal) {
1040                 if (signal != null) {
1041                         TmfTimeRange experimentTRange = signal.getExperiment()
1042                                         .getTimeRange();
1043
1044                         // prepare time intervals in widget
1045                         ModelUpdateInit(experimentTRange, experimentTRange, signal
1046                                         .getSource());
1047
1048                         // request initial data
1049                         initialExperimentDataRequest(signal
1050                                         .getSource(), experimentTRange);
1051                 }
1052         }
1053
1054         /**
1055          * @param source
1056          * @param experimentTRange
1057          * @return Adjusted time window used for the request (smaller window to
1058          *         initialize view)
1059          */
1060         private TmfTimeRange initialExperimentDataRequest(Object source,
1061                         TmfTimeRange experimentTRange) {
1062                 // Adjust the initial time window to a shorter interval to allow
1063                 // user to select the interesting area based on the perspective
1064                 TmfTimeRange initTimeWindow = getInitTRange(experimentTRange);
1065
1066                 dataRequest(initTimeWindow, experimentTRange, true, ExecutionType.FOREGROUND);
1067                 if (TraceDebug.isDEBUG()) {
1068                         TraceDebug.debug("Initialization request time range is: "
1069                                         + initTimeWindow.getStartTime().toString() + "-"
1070                                         + initTimeWindow.getEndTime().toString());
1071                 }
1072
1073                 return initTimeWindow;
1074         }
1075
1076         // *** HACK ***
1077         //
1078         //
1079         //
1080         public int checkForSWTBugItemHeightAdjustement() {
1081                 int returnedAjustement = 0;
1082                 String desktopSessionName = System.getenv("DESKTOP_SESSION");
1083
1084                 // Gnome : most common case, no adjustement
1085                 if ( desktopSessionName.equals("gnome") ) {
1086                         returnedAjustement = 0;
1087                 }
1088                 // Kde : ajustement of 2 is needed
1089                 else if ( desktopSessionName.equals("kde") ) {
1090                         returnedAjustement = 2;
1091                 }
1092
1093                 return returnedAjustement;
1094         }
1095
1096         /*
1097          * (non-Javadoc)
1098          *
1099          * @see org.eclipse.linuxtools.lttng.ui.views.common.AbsTimeUpdateView#
1100          * getParamsUpdater()
1101          */
1102         @Override
1103         protected ParamsUpdater getParamsUpdater() {
1104                 return FlowModelFactory.getParamsUpdater();
1105         }
1106
1107         /*
1108          * (non-Javadoc)
1109          *
1110          * @see org.eclipse.linuxtools.lttng.ui.views.common.AbsTimeUpdateView#
1111          * getItemContainer()
1112          */
1113         @Override
1114         protected ItemContainer<?> getItemContainer() {
1115                 return FlowModelFactory.getProcContainer();
1116         }
1117
1118         /*
1119          * (non-Javadoc)
1120          * @see org.eclipse.linuxtools.lttng.ui.views.common.AbsTimeUpdateView#getProviderId()
1121          */
1122         @Override
1123         protected int getProviderId() {
1124             return LttngCoreProviderFactory.CONTROL_FLOW_LTTNG_SYTH_EVENT_PROVIDER;
1125         }
1126 }