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