org.eclipse.linuxtools.lttng.ui/src/org/eclipse/linuxtools/internal/lttng/ui/viewers/timeAnalysis/TmfTimeAnalysisViewer.java

   1 /*****************************************************************************
   2  * Copyright (c) 2007, 2008, 2009, 2010 Intel Corporation, Ericsson
   3  * All rights reserved. This program and the accompanying materials
   4  * are made available under the terms of the Eclipse Public License v1.0
   5  * which accompanies this distribution, and is available at
   6  * http://www.eclipse.org/legal/epl-v10.html
   7  *
   8  * Contributors:
   9  *    Intel Corporation - Initial API and implementation
  10  *    Ruslan A. Scherbakov, Intel - Initial API and implementation
  11  *    Alexander N. Alexeev, Intel - Add monitors statistics support
  12  *    Alvaro Sanchez-Leon - Adapted for TMF
  13  *
  14  * $Id: ThreadStatesView.java,v 1.7 2008/05/19 15:07:21 jkubasta Exp $
  15  *****************************************************************************/
  16
  17 package org.eclipse.linuxtools.internal.lttng.ui.viewers.timeAnalysis;
  18
  19 import java.util.Iterator;
  20 import java.util.Vector;
  21
  22 import org.eclipse.jface.viewers.ISelection;
  23 import org.eclipse.jface.viewers.ISelectionProvider;
  24 import org.eclipse.jface.viewers.IStructuredSelection;
  25 import org.eclipse.linuxtools.internal.lttng.ui.viewers.timeAnalysis.dialogs.TmfTimeFilterDialog;
  26 import org.eclipse.linuxtools.internal.lttng.ui.viewers.timeAnalysis.dialogs.TmfTimeLegend;
  27 import org.eclipse.linuxtools.internal.lttng.ui.viewers.timeAnalysis.model.ITimeEvent;
  28 import org.eclipse.linuxtools.internal.lttng.ui.viewers.timeAnalysis.model.ITmfTimeAnalysisEntry;
  29 import org.eclipse.linuxtools.internal.lttng.ui.viewers.timeAnalysis.model.TimeEvent;
  30 import org.eclipse.linuxtools.internal.lttng.ui.viewers.timeAnalysis.widgets.ITimeDataProvider;
  31 import org.eclipse.linuxtools.internal.lttng.ui.viewers.timeAnalysis.widgets.TimeScaleCtrl;
  32 import org.eclipse.linuxtools.internal.lttng.ui.viewers.timeAnalysis.widgets.TmfTimeStatesCtrl;
  33 import org.eclipse.linuxtools.internal.lttng.ui.viewers.timeAnalysis.widgets.TmfTimeTipHandler;
  34 import org.eclipse.linuxtools.internal.lttng.ui.viewers.timeAnalysis.widgets.TraceColorScheme;
  35 import org.eclipse.linuxtools.internal.lttng.ui.viewers.timeAnalysis.widgets.Utils;
  36 import org.eclipse.swt.SWT;
  37 import org.eclipse.swt.events.ControlAdapter;
  38 import org.eclipse.swt.events.ControlEvent;
  39 import org.eclipse.swt.events.SelectionEvent;
  40 import org.eclipse.swt.events.SelectionListener;
  41 import org.eclipse.swt.graphics.Rectangle;
  42 import org.eclipse.swt.layout.GridLayout;
  43 import org.eclipse.swt.widgets.Composite;
  44 import org.eclipse.swt.widgets.Control;
  45 import org.eclipse.swt.widgets.ScrollBar;
  46
  47 public class TmfTimeAnalysisViewer implements ITimeAnalysisViewer, ITimeDataProvider, SelectionListener {
  48
  49         /** vars */
  50         private long _minTimeInterval;
  51         private long _selectedTime;
  52         private long _beginTime;
  53         private long _endTime;
  54         private long _time0;
  55         private long _time1;
  56         private long _time0_;
  57         private long _time1_;
  58         private long _time0_extSynch = 0;
  59         private long _time1_extSynch = 0;
  60         private boolean _timeRangeFixed;
  61         private int _nameWidthPref = 200;
  62         private int _minNameWidth = 6;
  63         private int _nameWidth;
  64         private Composite _dataViewer;
  65
  66         private TmfTimeStatesCtrl _stateCtrl;
  67         private TimeScaleCtrl _timeScaleCtrl;
  68         private TmfTimeTipHandler _threadTip;
  69         private TraceColorScheme _colors;
  70         private TmfTimeAnalysisProvider _utilImplm;
  71
  72         private boolean _acceptSetSelAPICalls = false;
  73         Vector<ITmfTimeSelectionListener> widgetSelectionListners = new Vector<ITmfTimeSelectionListener>();
  74         Vector<ITmfTimeScaleSelectionListener> widgetTimeScaleSelectionListners = new Vector<ITmfTimeScaleSelectionListener>();
  75         Vector<ITmfTimeFilterSelectionListener> widgetFilterSelectionListeners = new Vector<ITmfTimeFilterSelectionListener>();
  76
  77         // Calender Time format, using Epoch reference or Relative time
  78         // format(default
  79         private boolean calendarTimeFormat = false;
  80         private int borderWidth = 4;
  81         private int timeScaleHeight = 22;
  82
  83         /** ctor */
  84         public TmfTimeAnalysisViewer(Composite parent, TmfTimeAnalysisProvider provider) {
  85         createDataViewer(parent, provider);
  86         }
  87
  88     /* (non-Javadoc)
  89      * @see org.eclipse.linuxtools.tmf.ui.widgets.timeAnalysis.api.ITimeAnalysisWidget#display(org.eclipse.linuxtools.tmf.ui.widgets.timeAnalysis.model.TmfTaTrace[])
  90      */
  91     @Override
  92         public void display(ITmfTimeAnalysisEntry[] traceArr) {
  93         modelUpdate(traceArr);
  94     }
  95
  96         @Override
  97         public void display(ITmfTimeAnalysisEntry[] traceArr, long start, long end,
  98                         boolean updateTimeBounds) {
  99                 modelUpdate(traceArr, start, end, updateTimeBounds);
 100     }
 101
 102     public void controlMoved(ControlEvent e) {
 103         }
 104
 105         @Override
 106         public void controlResized(ControlEvent e) {
 107                 resizeControls();
 108         }
 109
 110         // called from the display order in the API
 111         public void modelUpdate(ITmfTimeAnalysisEntry[] traces) {
 112                 if (null != _stateCtrl) {
 113                         //loadOptions();
 114                         updateInternalData(traces);
 115                         _stateCtrl.redraw();
 116                         _timeScaleCtrl.redraw();
 117                 }
 118         }
 119
 120         // called from the display order in the API
 121         public void modelUpdate(ITmfTimeAnalysisEntry[] traces, long start,
 122                         long end, boolean updateTimeBounds) {
 123                 if (null != _stateCtrl) {
 124                         //loadOptions();
 125                         updateInternalData(traces, start, end);
 126                         if (updateTimeBounds) {
 127                                 _timeRangeFixed = true;
 128                                 // set window to match limits
 129                                 setStartFinishTime(_time0_, _time1_);
 130                         } else {
 131                                 _stateCtrl.redraw();
 132                                 _timeScaleCtrl.redraw();
 133                         }
 134                 }
 135         }
 136
 137         @Override
 138         public void itemUpdate(ITmfTimeAnalysisEntry parent, TimeEvent item) {
 139                 if (null != parent && null != item) {
 140                         _stateCtrl.refreshPartial(parent, item);
 141                         _stateCtrl.redraw();
 142                         _timeScaleCtrl.redraw();
 143                 }
 144         }
 145
 146         public void selectionChanged() {
 147         }
 148
 149         protected String getViewTypeStr() {
 150                 return "viewoption.threads"; //$NON-NLS-1$
 151         }
 152
 153         int getMarginWidth(int idx) {
 154                 return 0;
 155         }
 156
 157         int getMarginHeight(int idx) {
 158                 return 0;
 159         }
 160
 161         void loadOptions() {
 162                 _minTimeInterval = 1;
 163                 _selectedTime = -1;
 164                 _nameWidth = Utils.loadIntOption(getPreferenceString("namewidth"), //$NON-NLS-1$
 165                                 _nameWidthPref, _minNameWidth, 1000);
 166         }
 167
 168         void saveOptions() {
 169                 Utils.saveIntOption(getPreferenceString("namewidth"), _nameWidth); //$NON-NLS-1$
 170         }
 171
 172         protected Control createDataViewer(Composite parent,
 173                         TmfTimeAnalysisProvider utilImplm) {
 174                 loadOptions();
 175                 _utilImplm = utilImplm;
 176                 _colors = new TraceColorScheme();
 177                 _dataViewer = new Composite(parent, SWT.NULL);
 178                 _dataViewer.setLayoutData(GridUtil.createFill());
 179                 GridLayout gl = new GridLayout();
 180                 gl.marginHeight = borderWidth;
 181                 gl.marginWidth = 0;
 182                 gl.verticalSpacing = 0;
 183                 gl.horizontalSpacing = 0;
 184                 _dataViewer.setLayout(gl);
 185
 186                 _timeScaleCtrl = new TimeScaleCtrl(_dataViewer, _colors);
 187                 _timeScaleCtrl.setTimeProvider(this);
 188                 _timeScaleCtrl.setLayoutData(GridUtil.createHorizontalFill());
 189                 _timeScaleCtrl.setHeight(timeScaleHeight);
 190
 191                 _stateCtrl = new TmfTimeStatesCtrl(_dataViewer, _colors, _utilImplm);
 192
 193                 _stateCtrl.setTimeProvider(this);
 194                 _stateCtrl.addSelectionListener(this);
 195                 _stateCtrl.setLayoutData(GridUtil.createFill());
 196                 _dataViewer.addControlListener(new ControlAdapter() {
 197                         @Override
 198                         public void controlResized(ControlEvent event) {
 199                                 resizeControls();
 200                         }
 201                 });
 202                 resizeControls();
 203                 _dataViewer.update();
 204                 _threadTip = new TmfTimeTipHandler(parent.getShell(), _utilImplm, this);
 205                 _threadTip.activateHoverHelp(_stateCtrl);
 206                 return _dataViewer;
 207         }
 208
 209         public void dispose() {
 210                 saveOptions();
 211                 _stateCtrl.dispose();
 212                 _dataViewer.dispose();
 213                 _colors.dispose();
 214         }
 215
 216         @Override
 217         public void resizeControls() {
 218                 Rectangle r = _dataViewer.getClientArea();
 219                 if (r.isEmpty())
 220                         return;
 221
 222                 int width = r.width;
 223                 if (_nameWidth > width - _minNameWidth)
 224                         _nameWidth = width - _minNameWidth;
 225                 if (_nameWidth < _minNameWidth)
 226                         _nameWidth = _minNameWidth;
 227         }
 228
 229         /** Tries to set most convenient time range for display. */
 230         void setTimeRange(Object traces[]) {
 231                 _endTime = 0;
 232                 _beginTime = -1;
 233 //              ITimeEvent event;
 234                 for (int i = 0; i < traces.length; i++) {
 235                         ITmfTimeAnalysisEntry entry = (ITmfTimeAnalysisEntry) traces[i];
 236                         if (entry.getStopTime() >= entry.getStartTime() && entry.getStopTime() > 0) {
 237                             if (_beginTime < 0 || entry.getStartTime() < _beginTime) {
 238                                 _beginTime = entry.getStartTime();
 239                             }
 240                             if (entry.getStopTime() > _endTime) {
 241                                 _endTime = entry.getStopTime();
 242                             }
 243                         }
 244                         /*
 245                          * This is not needed if entry startTime and stopTime are properly set!
 246                         List<TimeEvent> list = entry.getTraceEvents();
 247                         int len = list.size();
 248                         if (len > 0) {
 249                 event = (ITimeEvent) list.get(0);
 250                 if (_beginTime < 0 || event.getTime() < _beginTime) {
 251                     _beginTime = event.getTime();
 252                 }
 253                                 event = (ITimeEvent) list.get(list.size() - 1);
 254                                 long eventEndTime = event.getTime() + (event.getDuration() > 0 ? event.getDuration() : 0);
 255                                 if (eventEndTime > _endTime) {
 256                                         _endTime = eventEndTime;
 257                                 }
 258                         }
 259                         */
 260                 }
 261
 262                 if (_beginTime < 0)
 263                         _beginTime = 0;
 264         }
 265
 266         void setTimeBounds() {
 267                 //_time0_ = _beginTime - (long) ((_endTime - _beginTime) * 0.02);
 268             _time0_ = _beginTime;
 269                 if (_time0_ < 0)
 270                         _time0_ = 0;
 271                 // _time1_ = _time0_ + (_endTime - _time0_) * 1.05;
 272                 _time1_ = _endTime;
 273                 // _time0_ = Math.floor(_time0_);
 274                 // _time1_ = Math.ceil(_time1_);
 275                 if (!_timeRangeFixed) {
 276                         _time0 = _time0_;
 277                         _time1 = _time1_;
 278                 }
 279         if (_time1 - _time0 < _minTimeInterval) {
 280             _time1 = _time0 + _minTimeInterval;
 281         }
 282         }
 283
 284         /**
 285          * @param traces
 286          */
 287         void updateInternalData(ITmfTimeAnalysisEntry[] traces) {
 288                 if (null == traces)
 289                         traces = new ITmfTimeAnalysisEntry[0];
 290                 setTimeRange(traces);
 291                 refreshAllData(traces);
 292         }
 293
 294         /**
 295          * @param traces
 296          * @param start
 297          * @param end
 298          */
 299         void updateInternalData(ITmfTimeAnalysisEntry[] traces, long start, long end) {
 300                 if (null == traces)
 301                         traces = new ITmfTimeAnalysisEntry[0];
 302                 if ((start == 0 && end == 0) || start < 0 || end < 0) {
 303                         // Start and end time are unspecified and need to be determined from
 304                         // individual processes
 305                         setTimeRange(traces);
 306                 } else {
 307                         _beginTime = start;
 308                         _endTime = end;
 309                 }
 310
 311                 refreshAllData(traces);
 312         }
 313
 314         /**
 315          * @param traces
 316          */
 317         private void refreshAllData(ITmfTimeAnalysisEntry[] traces) {
 318                 setTimeBounds();
 319                 if (_selectedTime < _beginTime) {
 320                     _selectedTime = _beginTime;
 321                 } else if (_selectedTime > _endTime) {
 322             _selectedTime = _endTime;
 323                 }
 324                 _stateCtrl.refreshData(traces);
 325                 filterOutNotification();
 326         }
 327
 328         @Override
 329         public void setFocus() {
 330                 if (null != _stateCtrl)
 331                         _stateCtrl.setFocus();
 332         }
 333
 334         @Override
 335         public boolean isInFocus() {
 336                 return _stateCtrl.isInFocus();
 337         }
 338
 339         @Override
 340         public ITmfTimeAnalysisEntry getSelectedTrace() {
 341                 return _stateCtrl.getSelectedTrace();
 342         }
 343
 344         @Override
 345         public ISelection getSelection() {
 346                 return _stateCtrl.getSelection();
 347         }
 348
 349         @Override
 350         public ISelection getSelectionTrace() {
 351                 return _stateCtrl.getSelectionTrace();
 352         }
 353
 354         @Override
 355         public long getTime0() {
 356                 return _time0;
 357         }
 358
 359         @Override
 360         public long getTime1() {
 361                 return _time1;
 362         }
 363
 364         @Override
 365         public long getMinTimeInterval() {
 366                 return _minTimeInterval;
 367         }
 368
 369         @Override
 370         public int getNameSpace() {
 371                 return _nameWidth;
 372         }
 373
 374         @Override
 375         public void setNameSpace(int width) {
 376                 _nameWidth = width;
 377                 width = _stateCtrl.getClientArea().width;
 378                 if (_nameWidth > width - 6)
 379                         _nameWidth = width - 6;
 380                 if (_nameWidth < 6)
 381                         _nameWidth = 6;
 382                 _stateCtrl.adjustScrolls();
 383                 _stateCtrl.redraw();
 384                 _timeScaleCtrl.redraw();
 385         }
 386
 387         @Override
 388         public int getTimeSpace() {
 389                 int w = _stateCtrl.getClientArea().width;
 390                 return w - _nameWidth;
 391         }
 392
 393         @Override
 394         public long getSelectedTime() {
 395                 return _selectedTime;
 396         }
 397
 398         @Override
 399         public long getBeginTime() {
 400                 return _beginTime;
 401         }
 402
 403         @Override
 404         public long getEndTime() {
 405                 return _endTime;
 406         }
 407
 408         @Override
 409         public long getMaxTime() {
 410                 return _time1_;
 411         }
 412
 413         @Override
 414         public long getMinTime() {
 415                 return _time0_;
 416         }
 417
 418         /*
 419          * (non-Javadoc)
 420          *
 421          * @see
 422          * org.eclipse.linuxtools.tmf.ui.viewers.timeAnalysis.widgets.ITimeDataProvider
 423          * #setStartFinishTimeNotify(long, long)
 424          */
 425         @Override
 426         public void setStartFinishTimeNotify(long time0, long time1) {
 427                 setStartFinishTime(time0, time1);
 428                 notifyStartFinishTimeSelectionListeners(time0, time1);
 429         }
 430
 431
 432     /* (non-Javadoc)
 433      * @see org.eclipse.linuxtools.tmf.ui.viewers.timeAnalysis.widgets.ITimeDataProvider#notifyStartFinishTime()
 434      */
 435     @Override
 436         public void notifyStartFinishTime() {
 437         notifyStartFinishTimeSelectionListeners(_time0, _time1);
 438     }
 439
 440     /*
 441          * (non-Javadoc)
 442          *
 443          * @see
 444          * org.eclipse.linuxtools.tmf.ui.viewers.timeAnalysis.widgets.ITimeDataProvider
 445          * #setStartFinishTime(long, long)
 446          */
 447         @Override
 448         public void setStartFinishTime(long time0, long time1) {
 449                 _time0 = time0;
 450         if (_time0 < _time0_)
 451             _time0 = _time0_;
 452         if (_time0 > _time1_)
 453             _time0 = _time1_;
 454                 _time1 = time1;
 455         if (_time1 < _time0_)
 456             _time1 = _time0_;
 457         if (_time1 > _time1_)
 458             _time1 = _time1_;
 459                 if (_time1 - _time0 < _minTimeInterval)
 460                     _time1 = _time0 + _minTimeInterval;
 461                 _timeRangeFixed = true;
 462                 _stateCtrl.adjustScrolls();
 463                 _stateCtrl.redraw();
 464                 _timeScaleCtrl.redraw();
 465         }
 466
 467         @Override
 468         public void setTimeBounds(long beginTime, long endTime) {
 469             _beginTime = beginTime;
 470             _endTime = endTime;
 471             _time0_ = beginTime;
 472             _time1_ = endTime;
 473             _stateCtrl.adjustScrolls();
 474         }
 475
 476         @Override
 477         public void resetStartFinishTime() {
 478                 setStartFinishTimeNotify(_time0_, _time1_);
 479                 _timeRangeFixed = false;
 480         }
 481
 482         @Override
 483         public void setSelectedTimeInt(long time, boolean ensureVisible) {
 484                 // Trace.debug("currentTime:" + _selectedTime + " new time:" + time);
 485                 _selectedTime = time;
 486                 if (_selectedTime > _endTime) {
 487                         _endTime = _selectedTime;
 488                         _time1_ = _selectedTime;
 489                 }
 490                 if (_selectedTime < _beginTime) {
 491                         _beginTime = _selectedTime;
 492                         _time0_ = _selectedTime;
 493                 }
 494                 long time0 = _time0;
 495                 long time1 = _time1;
 496                 if (ensureVisible) {
 497                         double timeSpace = (_time1 - _time0) * .02;
 498                         double timeMid = (_time1 - _time0) * .1;
 499                         if (_selectedTime < _time0 + timeSpace) {
 500                                 long dt = (long) (_time0 - _selectedTime + timeMid);
 501                                 _time0 -= dt;
 502                                 _time1 -= dt;
 503                         } else if (_selectedTime > _time1 - timeSpace) {
 504                                 long dt = (long) (_selectedTime - _time1 + timeMid);
 505                                 _time0 += dt;
 506                                 _time1 += dt;
 507                         }
 508                         if (_time0 < _time0_) {
 509                                 _time1 = Math.min(_time1_, _time1 + (_time0_ - _time0));
 510                                 _time0 = _time0_;
 511                         } else if (_time1 > _time1_) {
 512                                 _time0 = Math.max(_time0_, _time0 - (_time1 - _time1_));
 513                                 _time1 = _time1_;
 514                         }
 515                 }
 516                 if (_time1 - _time0 < _minTimeInterval) {
 517                         _time1 = _time0 + _minTimeInterval;
 518                 }
 519                 _stateCtrl.adjustScrolls();
 520                 _stateCtrl.redraw();
 521                 _timeScaleCtrl.redraw();
 522                 if (time0 != _time0 || time1 != _time1) {
 523                         notifyStartFinishTimeSelectionListeners(_time0, _time1);
 524                 }
 525         }
 526
 527         @Override
 528         public void widgetDefaultSelected(SelectionEvent e) {
 529                 // TODO: Opening call stack shall be replaced to a configurable view
 530                 // new OpenCallStackViewAction().openView(false);
 531                 // Replaced by event notification
 532                 // updateModelSelection();
 533                 notifySelectionListeners(TmfTimeSelectionEvent.Type.WIDGET_DEF_SEL);
 534         }
 535
 536         @Override
 537         public void widgetSelected(SelectionEvent e) {
 538                 // Replace by event notification
 539                 // updateModelSelection();
 540                 notifySelectionListeners(TmfTimeSelectionEvent.Type.WIDGET_SEL);
 541         }
 542
 543         @Override
 544         public void selectNextEvent() {
 545                 _stateCtrl.selectNextEvent();
 546         }
 547
 548         @Override
 549         public void selectPrevEvent() {
 550                 _stateCtrl.selectPrevEvent();
 551         }
 552
 553         @Override
 554         public void selectNextTrace() {
 555                 _stateCtrl.selectNextTrace();
 556         }
 557
 558         @Override
 559         public void selectPrevTrace() {
 560                 _stateCtrl.selectPrevTrace();
 561         }
 562
 563         @Override
 564         public void groupTraces(boolean on) {
 565                 _stateCtrl.groupTraces(on);
 566         }
 567
 568         @Override
 569         public void filterTraces() {
 570                 if (_dataViewer == null || _dataViewer.isDisposed())
 571                         return;
 572
 573                 if (TmfTimeFilterDialog.getTraceFilter(_dataViewer.getShell(), _stateCtrl
 574                                 .getTraces(), _stateCtrl.getTraceFilter())) {
 575                         _stateCtrl.refreshData();
 576                         filterOutNotification();
 577                 }
 578         }
 579
 580         @Override
 581         public void showLegend() {
 582                 if (_dataViewer == null || _dataViewer.isDisposed())
 583                         return;
 584
 585                 TmfTimeLegend.open(_dataViewer.getShell(), _utilImplm);
 586         }
 587
 588         public void toggleThreadsInteractionDrawing() {
 589                 _stateCtrl.toggleTraceInteractionDrawing();
 590         }
 591
 592         public void setThreadJoinDrawing(boolean on) {
 593                 _stateCtrl.setTraceJoinDrawing(on);
 594         }
 595
 596         public void setThreadWaitDrawing(boolean on) {
 597                 _stateCtrl.setTraceWaitDrawing(on);
 598         }
 599
 600         public void setThreadReleaseDrawing(boolean on) {
 601                 _stateCtrl.setTraceReleaseDrawing(on);
 602         }
 603
 604         public boolean getThreadInteractionDrawing() {
 605                 return _stateCtrl.getTracesInteractionDrawing();
 606         }
 607
 608         public boolean getThreadJoinDrawing() {
 609                 return _stateCtrl.getTraceJoinDrawing();
 610         }
 611
 612         public boolean getThreadWaitDrawing() {
 613                 return _stateCtrl.getTraceWaitDrawing();
 614         }
 615
 616         public boolean getThreadReleaseDrawing() {
 617                 return _stateCtrl.getTraceReleaseDrawing();
 618         }
 619
 620         protected void select(Object obj) {
 621                 if (obj == null)
 622                         return;
 623                 // TODO: ThreadDetails Adaption removed, might need replacement
 624                 // if (obj instanceof ThreadDetails) {
 625                 // obj = ((ThreadDetails) obj).getThread();
 626                 // }
 627                 if (obj instanceof ITmfTimeAnalysisEntry) {
 628                         // _stateCtrl.selectThread((TsfTmTrace) obj);
 629                 }
 630         }
 631
 632         @Override
 633         public void zoomIn() {
 634                 _stateCtrl.zoomIn();
 635         }
 636
 637         @Override
 638         public void zoomOut() {
 639                 _stateCtrl.zoomOut();
 640         }
 641
 642         private String getPreferenceString(String string) {
 643                 return getViewTypeStr() + "." + string; //$NON-NLS-1$
 644         }
 645
 646         @Override
 647         public void addWidgetSelectionListner(ITmfTimeSelectionListener listener) {
 648                 widgetSelectionListners.add(listener);
 649         }
 650
 651         @Override
 652         public void removeWidgetSelectionListner(ITmfTimeSelectionListener listener) {
 653                 widgetSelectionListners.removeElement(listener);
 654         }
 655
 656         @Override
 657         public void addWidgetTimeScaleSelectionListner(
 658                         ITmfTimeScaleSelectionListener listener) {
 659                 widgetTimeScaleSelectionListners.add(listener);
 660         }
 661
 662         @Override
 663         public void removeWidgetTimeScaleSelectionListner(
 664                         ITmfTimeScaleSelectionListener listener) {
 665                 widgetTimeScaleSelectionListners.removeElement(listener);
 666         }
 667
 668         @Override
 669         public void setSelectedTime(long time, boolean ensureVisible, Object source) {
 670                 if (_acceptSetSelAPICalls == false || this == source) {
 671                         return;
 672                 }
 673
 674                 setSelectedTimeInt(time, ensureVisible);
 675         }
 676
 677         @Override
 678         public void setSelectedEvent(ITimeEvent event, Object source) {
 679                 if (_acceptSetSelAPICalls == false || event == null || source == this) {
 680                         return;
 681                 }
 682                 ITmfTimeAnalysisEntry trace = event.getEntry();
 683                 if (trace != null) {
 684                         _stateCtrl.selectItem(trace, false);
 685                 }
 686
 687                 setSelectedTimeInt(event.getTime(), true);
 688         }
 689
 690         @Override
 691         public void setSelectedTraceTime(ITmfTimeAnalysisEntry trace, long time, Object source) {
 692                 if (_acceptSetSelAPICalls == false || trace == null || source == this) {
 693                         return;
 694                 }
 695
 696                 if (trace != null) {
 697                         _stateCtrl.selectItem(trace, false);
 698                 }
 699
 700                 setSelectedTimeInt(time, true);
 701         }
 702
 703         @Override
 704         public void setSelectedTrace(ITmfTimeAnalysisEntry trace) {
 705                 if (trace == null) {
 706                         return;
 707                 }
 708
 709                 _stateCtrl.selectItem(trace, false);
 710         }
 711
 712         /*
 713          * (non-Javadoc)
 714          *
 715          * @see
 716          * org.eclipse.linuxtools.tmf.ui.viewers.timeAnalysis.ITimeAnalysisViewer
 717          * #setSelectVisTimeWindow(long, long, java.lang.Object)
 718          */
 719         @Override
 720         public void setSelectVisTimeWindow(long time0, long time1, Object source) {
 721                 if (_acceptSetSelAPICalls == false || source == this) {
 722                         return;
 723                 }
 724
 725                 setStartFinishTime(time0, time1);
 726
 727                 // update notification time values since we are now in synch with the
 728                 // external application
 729                 updateExtSynchTimers();
 730         }
 731
 732         @Override
 733         public void setAcceptSelectionAPIcalls(boolean acceptCalls) {
 734                 _acceptSetSelAPICalls = acceptCalls;
 735         }
 736
 737         private synchronized void notifySelectionListeners(
 738                         TmfTimeSelectionEvent.Type rtype) {
 739                 // Any listeners out there ?
 740                 if (widgetSelectionListners.size() > 0) {
 741                         // Locate the event selected
 742                         ISelection selection = getSelection();
 743                         Object sel = null;
 744                         if (selection != null && !selection.isEmpty()) {
 745                                 sel = ((IStructuredSelection) selection).getFirstElement();
 746                         }
 747
 748                         if (sel != null) {
 749                                 // Notify Selection Listeners
 750                                 TmfTimeSelectionEvent event = new TmfTimeSelectionEvent(this,
 751                                                 rtype, sel, getSelectedTime());
 752
 753                                 for (Iterator<ITmfTimeSelectionListener> iter = widgetSelectionListners
 754                                                 .iterator(); iter.hasNext();) {
 755                                         ITmfTimeSelectionListener listener = (ITmfTimeSelectionListener) iter
 756                                                         .next();
 757                                         listener.tsfTmProcessSelEvent(event);
 758                                 }
 759                         }
 760                 }
 761         }
 762
 763         public void notifyStartFinishTimeSelectionListeners(long _time0, long _time1) {
 764                 if (widgetTimeScaleSelectionListners.size() > 0) {
 765                         // Check if the time has actually changed from last notification
 766                         if (_time0 != _time0_extSynch || _time1 != _time1_extSynch) {
 767                                 // Notify Time Scale Selection Listeners
 768                                 TmfTimeScaleSelectionEvent event = new TmfTimeScaleSelectionEvent(
 769                                                 this, _time0, _time1, getTimeSpace(), getSelectedTime());
 770
 771                                 for (Iterator<ITmfTimeScaleSelectionListener> iter = widgetTimeScaleSelectionListners
 772                                                 .iterator(); iter.hasNext();) {
 773                                         ITmfTimeScaleSelectionListener listener = (ITmfTimeScaleSelectionListener) iter
 774                                                         .next();
 775                                         listener.tsfTmProcessTimeScaleEvent(event);
 776                                 }
 777
 778                                 // update external synch timers
 779                                 updateExtSynchTimers();
 780                         }
 781                 }
 782         }
 783
 784         /**
 785          * update the cache timers used to identify the need to send a time window
 786          * update to external registered listeners
 787          */
 788         private void updateExtSynchTimers() {
 789                 // last time notification cache
 790                 _time0_extSynch = _time0;
 791                 _time1_extSynch = _time1;
 792         }
 793
 794         @Override
 795         public void setTimeCalendarFormat(boolean toAbsoluteCaltime) {
 796                 calendarTimeFormat = toAbsoluteCaltime;
 797         }
 798
 799         @Override
 800         public boolean isCalendarFormat() {
 801                 return calendarTimeFormat;
 802         }
 803
 804         @Override
 805         public int getBorderWidth() {
 806                 return borderWidth;
 807         }
 808
 809         @Override
 810         public void setBorderWidth(int borderWidth) {
 811                 if (borderWidth > -1) {
 812             this.borderWidth = borderWidth;
 813             GridLayout gl = (GridLayout)_dataViewer.getLayout();
 814             gl.marginHeight = borderWidth;
 815                 }
 816         }
 817
 818         @Override
 819         public int getHeaderHeight() {
 820                 return timeScaleHeight;
 821         }
 822
 823         @Override
 824         public void setHeaderHeight(int headerHeight) {
 825                 if (headerHeight > -1) {
 826                         this.timeScaleHeight = headerHeight;
 827                         _timeScaleCtrl.setHeight(headerHeight);
 828                 }
 829         }
 830
 831         @Override
 832         public int getItemHeight() {
 833                 if (_stateCtrl != null) {
 834                         return _stateCtrl.getItemHeight();
 835                 }
 836                 return 0;
 837         }
 838
 839         @Override
 840         public void setItemHeight(int rowHeight) {
 841                 if (_stateCtrl != null) {
 842                         _stateCtrl.setItemHeight(rowHeight);
 843                 }
 844         }
 845
 846     @Override
 847     public void setMinimumItemWidth(int width) {
 848         if (_stateCtrl != null) {
 849             _stateCtrl.setMinimumItemWidth(width);
 850         }
 851     }
 852
 853         @Override
 854         public boolean isVisibleVerticalScroll() {
 855                 if (_stateCtrl != null) {
 856                         _stateCtrl.isVisibleVerticalScroll();
 857                 }
 858                 return false;
 859         }
 860
 861         @Override
 862         public void setVisibleVerticalScroll(boolean visibleVerticalScroll) {
 863                 if (_stateCtrl != null) {
 864                         _stateCtrl.setVisibleVerticalScroll(visibleVerticalScroll);
 865                 }
 866         }
 867
 868         @Override
 869         public void setNameWidthPref(int width) {
 870                 _nameWidthPref = width;
 871                 if (width == 0) {
 872                         _minNameWidth = 0;
 873             _nameWidth = 0;
 874                 }
 875         }
 876
 877         @Override
 878         public int getNameWidthPref(int width) {
 879                 return _nameWidthPref;
 880         }
 881
 882         @Override
 883         public void addFilterSelectionListner(ITmfTimeFilterSelectionListener listener) {
 884                 widgetFilterSelectionListeners.add(listener);
 885         }
 886
 887         @Override
 888         public void removeFilterSelectionListner(
 889                         ITmfTimeFilterSelectionListener listener) {
 890                 widgetFilterSelectionListeners.remove(listener);
 891         }
 892
 893         private void filterOutNotification() {
 894                 TmfTimeFilterSelectionEvent event = new TmfTimeFilterSelectionEvent(this);
 895                 event.setFilteredOut(_stateCtrl.getFilteredOut());
 896                 for (ITmfTimeFilterSelectionListener listener : widgetFilterSelectionListeners) {
 897                         listener.tmfTaProcessFilterSelection(event);
 898                 }
 899         }
 900
 901         /**
 902          * needed in case there's a need to associate a context menu
 903          *
 904          * @return the state control (selection provider)
 905          */
 906         @Override
 907         public Control getControl() {
 908                 return _stateCtrl;
 909         }
 910
 911         /**
 912          * Get the selection provider
 913          *
 914      * @return the selection provider
 915          */
 916         @Override
 917         public ISelectionProvider getSelectionProvider() {
 918                 return _stateCtrl;
 919         }
 920
 921         /*
 922          * (non-Javadoc)
 923          *
 924          * @see
 925          * org.eclipse.linuxtools.tmf.ui.viewers.timeAnalysis.ITimeAnalysisViewer
 926          * #waitCursor(boolean)
 927          */
 928         @Override
 929         public void waitCursor(boolean waitInd) {
 930                 _stateCtrl.waitCursor(waitInd);
 931         }
 932
 933     /* (non-Javadoc)
 934      * @see org.eclipse.linuxtools.tmf.ui.viewers.timeAnalysis.ITimeAnalysisViewer#getHorizontalBar()
 935      */
 936     @Override
 937     public ScrollBar getHorizontalBar() {
 938         return _stateCtrl.getHorizontalBar();
 939     }
 940
 941     /* (non-Javadoc)
 942      * @see org.eclipse.linuxtools.tmf.ui.viewers.timeAnalysis.ITimeAnalysisViewer#getVerticalBar()
 943      */
 944     @Override
 945     public ScrollBar getVerticalBar() {
 946         return _stateCtrl.getVerticalBar();
 947     }
 948
 949     /* (non-Javadoc)
 950      * @see org.eclipse.linuxtools.tmf.ui.viewers.timeAnalysis.ITimeAnalysisViewer#setTopIndex(int)
 951      */
 952     @Override
 953     public void setTopIndex(int index) {
 954         _stateCtrl.setTopIndex(index);
 955     }
 956
 957 }