org.eclipse.linuxtools.tmf.ui/src/org/eclipse/linuxtools/tmf/ui/viewers/timeAnalysis/TmfTimeAnalysisViewer.java

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