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