org.eclipse.linuxtools.tmf.ui/src/org/eclipse/linuxtools/tmf/ui/widgets/timegraph/TimeGraphViewer.java

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