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