org.eclipse.linuxtools.lttng.ui/src/org/eclipse/linuxtools/lttng/ui/views/common/AbsTimeUpdateView.java

   1 /*******************************************************************************
   2  * Copyright (c) 2009, 2010 Ericsson
   3  *
   4  * All rights reserved. This program and the accompanying materials are
   5  * made available under the terms of the Eclipse Public License v1.0 which
   6  * accompanies this distribution, and is available at
   7  * http://www.eclipse.org/legal/epl-v10.html
   8  *
   9  * Contributors:
  10  *   Alvaro Sanchez-Leon (alvsan09@gmail.com) - Initial API and implementation
  11  *******************************************************************************/
  12 package org.eclipse.linuxtools.lttng.ui.views.common;
  13
  14 import java.util.Arrays;
  15
  16 import org.eclipse.linuxtools.lttng.LttngConstants;
  17 import org.eclipse.linuxtools.lttng.control.LttngCoreProviderFactory;
  18 import org.eclipse.linuxtools.lttng.control.LttngSyntheticEventProvider;
  19 import org.eclipse.linuxtools.lttng.event.LttngSyntheticEvent;
  20 import org.eclipse.linuxtools.lttng.event.LttngTimestamp;
  21 import org.eclipse.linuxtools.lttng.request.ILttngSyntEventRequest;
  22 import org.eclipse.linuxtools.lttng.request.IRequestStatusListener;
  23 import org.eclipse.linuxtools.lttng.request.LttngSyntEventRequest;
  24 import org.eclipse.linuxtools.lttng.request.RequestCompletedSignal;
  25 import org.eclipse.linuxtools.lttng.request.RequestStartedSignal;
  26 import org.eclipse.linuxtools.lttng.state.evProcessor.ITransEventProcessor;
  27 import org.eclipse.linuxtools.lttng.ui.TraceDebug;
  28 import org.eclipse.linuxtools.lttng.ui.model.trange.ItemContainer;
  29 import org.eclipse.linuxtools.tmf.event.TmfTimeRange;
  30 import org.eclipse.linuxtools.tmf.event.TmfTimestamp;
  31 import org.eclipse.linuxtools.tmf.experiment.TmfExperiment;
  32 import org.eclipse.linuxtools.tmf.request.ITmfDataRequest.ExecutionType;
  33 import org.eclipse.linuxtools.tmf.request.TmfDataRequest;
  34 import org.eclipse.linuxtools.tmf.signal.TmfRangeSynchSignal;
  35 import org.eclipse.linuxtools.tmf.signal.TmfSignalHandler;
  36 import org.eclipse.linuxtools.tmf.signal.TmfSignalManager;
  37 import org.eclipse.linuxtools.tmf.signal.TmfTimeSynchSignal;
  38 import org.eclipse.linuxtools.tmf.ui.viewers.timeAnalysis.ITimeAnalysisViewer;
  39 import org.eclipse.linuxtools.tmf.ui.viewers.timeAnalysis.TmfTimeScaleSelectionEvent;
  40 import org.eclipse.linuxtools.tmf.ui.viewers.timeAnalysis.TmfTimeSelectionEvent;
  41 import org.eclipse.linuxtools.tmf.ui.viewers.timeAnalysis.model.ITmfTimeAnalysisEntry;
  42 import org.eclipse.linuxtools.tmf.ui.views.TmfView;
  43 import org.eclipse.swt.widgets.Display;
  44
  45 /**
  46  * <p>
  47  * Abstract class used as a base for views handling specific time range data
  48  * requests
  49  * </p>
  50  * <p>
  51  * The class handles a single element queue of data requests, i.e. request can
  52  * be triggered from different sources e.g. opening a file as well as a new
  53  * selected time window
  54  * </p>
  55  *
  56  * @author alvaro
  57  *
  58  */
  59 public abstract class AbsTimeUpdateView extends TmfView implements IRequestStatusListener {
  60
  61         // ========================================================================
  62         // Data
  63         // ========================================================================
  64
  65 //       private static final long INITIAL_WINDOW_OFFSET = (1L * 1    * 1000 * 1000); // .001sec
  66 //       private static final long INITIAL_WINDOW_OFFSET = (1L * 10   * 1000 * 1000); // .01sec
  67          private static final long INITIAL_WINDOW_OFFSET = (1L * 100  * 1000 * 1000); // .1sec
  68 //       private static final long INITIAL_WINDOW_OFFSET = (1L * 1000 * 1000 * 1000); // 1sec
  69
  70         /**
  71          * Number of events before a GUI refresh
  72          */
  73         protected static final Long INPUT_CHANGED_REFRESH = 75000L;
  74         private static final long DEFAULT_OFFSET = 0;
  75
  76         protected boolean synch = true; // time synchronization, used to be an option
  77         protected ITimeAnalysisViewer tsfviewer = null;
  78
  79         private LttngSyntEventRequest fCurrentRequest = null;
  80
  81         protected LttngSyntheticEventProvider fProvider = LttngCoreProviderFactory.getEventProvider(getProviderId());
  82
  83         // ========================================================================
  84         // Constructor
  85         // ========================================================================
  86         public AbsTimeUpdateView(String viewID) {
  87                 super(viewID);
  88                 // freqState = UiCommonFactory.getQueue(this);
  89         }
  90
  91         // ========================================================================
  92         // Methods
  93         // ========================================================================
  94
  95         /**
  96          * Returns the number of events after which the relevant display will
  97          * be refreshed
  98          *
  99          * @return
 100          */
 101         protected Long getInputChangedRefresh() {
 102             return INPUT_CHANGED_REFRESH;
 103         }
 104
 105         /*
 106          * (non-Javadoc)
 107          *
 108          * @seeorg.eclipse.linuxtools.lttng.state.IStateDataRequestListener#
 109          * processingStarted(org.eclipse.linuxtools.lttng.state.StateDataRequest)
 110          */
 111         @Override
 112         @TmfSignalHandler
 113         public synchronized void processingStarted(RequestStartedSignal signal) {
 114                 LttngSyntEventRequest request = signal.getRequest();
 115                 if (request != null) {
 116                         // update queue with the id of the current request.
 117                         // freqState.requestStarted(request);
 118
 119                         // if there was no new request then this one is still on
 120                         // prepare for the reception of new data
 121                         waitCursor(true);
 122
 123                         // no new time range for zoom orders
 124                         TmfTimeRange trange = null;
 125                         // Time Range will be used to filter out events which are
 126                         // not visible in one pixel
 127                         trange = request.getRange();
 128
 129                         // indicate if the data model needs to be cleared e.g. a new
 130                         // experiment is being selected
 131                         boolean clearData = request.isclearDataInd();
 132                         // Indicate if current data needs to be cleared and if so
 133                         // specify the new experiment time range that applies
 134                         ModelUpdatePrep(trange, clearData);
 135                 }
 136         }
 137
 138         /*
 139          * (non-Javadoc)
 140          *
 141          * @seeorg.eclipse.linuxtools.lttng.state.IStateDataRequestListener#
 142          * processingCompleted(org.eclipse.linuxtools.lttng.state.StateDataRequest)
 143          */
 144         @Override
 145         @TmfSignalHandler
 146         public void processingCompleted(RequestCompletedSignal signal) {
 147                 ILttngSyntEventRequest request = signal.getRequest();
 148
 149                 if (request == null) {
 150                         return;
 151                 }
 152
 153                 // Update wait cursor
 154                 waitCursor(false);
 155
 156                 // No data refresh actions for cancelled requests.
 157                 if (request.isCancelled() || request.isFailed()) {
 158                         if (TraceDebug.isDEBUG()) {
 159                                 TmfTimeRange trange = request.getRange();
 160                                 if (request.isCancelled()) {
 161                                         TraceDebug.debug("Request cancelled " //$NON-NLS-1$
 162                                                         + trange.getStartTime() + "-" + trange.getEndTime() //$NON-NLS-1$
 163                                                         + " Handled Events: " + request.getSynEventCount() //$NON-NLS-1$
 164                                                         + " " + request.toString(), 15); //$NON-NLS-1$
 165                                 } else if (request.isFailed()) {
 166                                         TraceDebug.debug("Request Failed " + trange.getStartTime() //$NON-NLS-1$
 167                                                         + "-" + trange.getEndTime() + " Handled Events: " //$NON-NLS-1$ //$NON-NLS-2$
 168                                                         + request.getSynEventCount() + " " //$NON-NLS-1$
 169                                                         + request.toString());
 170                                 }
 171                         }
 172
 173                         return;
 174                 } else {
 175                         modelInputChanged(request, true);
 176                 }
 177         }
 178
 179         /**
 180          * Registers as listener of time selection from other views
 181          *
 182          * @param signal
 183          */
 184         public void synchToTime(TmfTimeSynchSignal signal) {
 185                 if (synch) {
 186                         Object source = signal.getSource();
 187                         if (signal != null && source != null && source != this) {
 188                                 // Internal value is expected in nano seconds.
 189                                 long selectedTime = signal.getCurrentTime().getValue();
 190                                 if (tsfviewer != null) {
 191                                         tsfviewer.setSelectedTime(selectedTime, true, source);
 192
 193                                         ParamsUpdater paramUpdater = getParamsUpdater();
 194                                     Long savedSelTime = paramUpdater.getSelectedTime();
 195                                     if ((savedSelTime == null) || (savedSelTime != selectedTime)) {
 196                                     // Update the parameter updater to save the selected time
 197                                     paramUpdater.setSelectedTime(selectedTime);
 198                                 }
 199                                 }
 200                         }
 201                 }
 202         }
 203
 204         /**
 205          * Process the reception of time window adjustment in this view if the
 206          * source of the update is not this view.
 207          *
 208          * @param signal
 209          * @param clearingData
 210          */
 211         public void synchToTimeRange(TmfRangeSynchSignal signal, boolean clearingData) {
 212                 if (synch) {
 213                         Object source = signal.getSource();
 214                         if (signal != null && source != null && source != this) {
 215                                 // Internal value is expected in nano seconds.
 216                                 TmfTimeRange trange = signal.getCurrentRange();
 217                                 TmfExperiment<?> experiment = TmfExperiment.getCurrentExperiment();
 218                                 if (experiment == null) {
 219                                         TraceDebug.debug("Current selected experiment is null"); //$NON-NLS-1$
 220                                         return;
 221                                 }
 222
 223                                 // Clearing of process data is configurable
 224                                 eventRequest(trange, experiment.getTimeRange(), clearingData, ExecutionType.FOREGROUND);
 225                         }
 226                 }
 227         }
 228
 229         /**
 230          * Trigger time synchronisation to other views this method shall be called
 231          * when a check has been performed to note that an actual change of time has
 232          * been performed vs a pure re-selection of the same time
 233          *
 234          * @param time
 235          * @param source
 236          */
 237         protected void synchTimeNotification(long time, Object source) {
 238                 // if synchronisation selected
 239                 if (synch) {
 240                         // Notify other views
 241                         TmfSignalManager.dispatchSignal(new TmfTimeSynchSignal(source, new LttngTimestamp(time)));
 242                 }
 243         }
 244
 245         /**
 246          * Common implementation of ITmfTimeSelectionListener, not used by all the
 247          * views extending this abstract class
 248          *
 249          * @param event
 250          */
 251         protected void tsfTmProcessSelEvent(TmfTimeSelectionEvent event) {
 252                 Object source = event.getSource();
 253                 if (source == null) {
 254                         return;
 255                 }
 256
 257                 ParamsUpdater paramUpdater = getParamsUpdater();
 258                 Long savedSelTime = paramUpdater.getSelectedTime();
 259
 260                 long selTimens = event.getSelectedTime();
 261
 262                 // make sure the new selected time is different than saved before
 263                 // executing update
 264                 if (savedSelTime == null || savedSelTime != selTimens) {
 265                         // Notify listener views.
 266                         synchTimeNotification(selTimens, source);
 267
 268                         // Update the parameter updater to save the selected time
 269                         paramUpdater.setSelectedTime(selTimens);
 270
 271                         if (TraceDebug.isDEBUG()) {
 272                                 TraceDebug.debug("Selected Time: " + new LttngTimestamp(selTimens) + "\n\t\t" + getName()); //$NON-NLS-1$ //$NON-NLS-2$
 273                         }
 274                 }
 275         }
 276
 277         /**
 278          * Common implementation of ITmfTimeScaleSelectionListener, not used by all
 279          * the views extending this abstract class
 280          *
 281          * @param event
 282          */
 283         protected void tsfTmProcessTimeScaleEvent(TmfTimeScaleSelectionEvent event) {
 284         // source needed to keep track of source values
 285         Object source = event.getSource();
 286
 287         boolean newParams = false;
 288         TmfTimeRange trange = null;
 289         Long selectedTime = null;
 290
 291         // update all information and get relevant data
 292             synchronized (this) {
 293                 if (source != null) {
 294                     // Update the parameter updater before carrying out a read request
 295                     ParamsUpdater paramUpdater = getParamsUpdater();
 296                     newParams = paramUpdater.processTimeScaleEvent(event);
 297
 298                     if (newParams) {
 299                         // Read the updated time window
 300                         trange = paramUpdater.getTrange();
 301                         if (trange != null) {
 302                             selectedTime = paramUpdater.getSelectedTime();
 303                         }
 304                     }
 305                 }
 306             }
 307
 308             // Check for selectedTime is sufficient since it is only set if
 309             // newParams is true and trange is not null
 310                 if (selectedTime != null) {
 311                     // Notify listener views. to perform data requests
 312             // upon this notification
 313
 314                     // Note that this has to be done outside the synchronized statement
 315                     // because otherwise we could end-up in a deadlock if a ongoing
 316                     // request needs to be canceled.
 317             synchTimeRangeNotification(trange, selectedTime, source);
 318                 }
 319         }
 320
 321         /**
 322          * Inform registered listeners about the new time range
 323          *
 324          * @param trange
 325          * @param selectedTime
 326          * @param source
 327          */
 328         protected void synchTimeRangeNotification(TmfTimeRange trange, Long selectedTime, Object source) {
 329                 // if synchronisation selected
 330                 if (synch) {
 331                         // Notify other views
 332                         TmfSignalManager.dispatchSignal(new TmfRangeSynchSignal(source, trange, new LttngTimestamp(selectedTime)));
 333                 }
 334         }
 335
 336         /**
 337          * @param zoomedTRange
 338          * @param experimentTRange
 339          * @param clearingData
 340          * @param execType
 341          */
 342         public void eventRequest(TmfTimeRange zoomedTRange, TmfTimeRange experimentTRange, boolean clearingData, ExecutionType execType) {
 343
 344                 // timeRange is the Experiment time range
 345                 boolean sent = processDataRequest(zoomedTRange, experimentTRange, DEFAULT_OFFSET, TmfDataRequest.ALL_DATA, clearingData, execType);
 346
 347                 if (sent) {
 348                         waitCursor(true);
 349                 }
 350         }
 351
 352         /**
 353          * @param offset
 354          * @param nbRequested
 355          * @param startTime
 356          * @param clearingData
 357          * @param execType
 358          */
 359         public void eventRequest(long offset, TmfTimeRange range, boolean clearingData, ExecutionType execType) {
 360
 361                 // timeRange is the Experiment time range
 362                 boolean sent = processDataRequest(range, null, offset, TmfDataRequest.ALL_DATA, clearingData, execType);
 363
 364                 if (sent) {
 365                         waitCursor(true);
 366                 }
 367         }
 368
 369 //      /**
 370 //       * @param zoomedTRange
 371 //       * @param experimentTRange
 372 //       * @param execType
 373 //       */
 374 //      public void dataRequest(TmfTimeRange zoomedTRange,
 375 //                      TmfTimeRange experimentTRange, boolean clearingData) {
 376 //
 377 //              // timeRange is the Experiment time range
 378 //               boolean sent = processDataRequest(zoomedTRange, experimentTRange, clearingData);
 379 //
 380 //              if (sent) {
 381 //                      waitCursor(true);
 382 //              }
 383 //      }
 384
 385         /**
 386          * send data request directly e.g. doesn't use a queue
 387          *
 388          * @param requestTrange
 389          * @param listener
 390          * @param experimentTRange
 391          * @param execType
 392          * @param processor
 393          * @return
 394          */
 395         private boolean processDataRequest(TmfTimeRange requestTrange,
 396                         TmfTimeRange experimentTRange, long offset, int nbRequested, boolean clearingData, ExecutionType execType) {
 397                 // Validate input
 398                 if (requestTrange == null) {
 399                         TraceDebug.debug("Invalid input"); //$NON-NLS-1$
 400                         return false;
 401                 }
 402
 403                 // Cancel the currently executing request before starting a new one
 404                 fProvider.conditionallyCancelRequests();
 405                 fCurrentRequest = new LttngSyntEventRequest(
 406                                 requestTrange, offset, nbRequested,
 407                                 LttngConstants.DEFAULT_BLOCK_SIZE, this, experimentTRange, getEventProcessor(),
 408                                 TmfExperiment.getCurrentExperiment().getName(), execType) {
 409
 410                         Long fCount = getSynEventCount();
 411                         ITransEventProcessor processor = getProcessor();
 412                         TmfTimestamp frunningTimeStamp;
 413
 414                         /*
 415                          * (non-Javadoc)
 416                          *
 417                          * @see
 418                          * org.eclipse.linuxtools.lttng.request.LttngSyntEventRequest#handleData
 419                          * ()
 420                          */
 421 ////                    int handleDataCount = 0;
 422 ////                    int handleDataValidCount = 0;
 423 //                      @Override
 424 //                      public void handleData() {
 425 //                              LttngSyntheticEvent[] result = getData();
 426 //
 427 //                              TmfEvent evt = (result.length > 0) ? result[0] : null;
 428 ////                            handleDataCount++;
 429
 430                         @Override
 431                         public void handleData(LttngSyntheticEvent event) {
 432                                 super.handleData(event);
 433                                 if (event != null) {
 434 //                                      handleDataValidCount++;
 435                                         LttngSyntheticEvent synEvent = (LttngSyntheticEvent) event;
 436                                         // process event
 437                                         switch (synEvent.getSynType()) {
 438
 439                                             case STARTREQ: {
 440                                                 handleRequestStarted();
 441                                                 break;
 442                                             }
 443
 444                                             case BEFORE: {
 445                                                 processor.process(event, synEvent.getTraceModel());
 446                                                 fCount++;
 447                                                 if ((fCount != 0) && (fCount % getInputChangedRefresh() == 0)) {
 448                                                     // send partial update
 449                                                     modelInputChanged(this, false);
 450
 451                                                     if (TraceDebug.isDEBUG()) {
 452                                                         frunningTimeStamp = event.getTimestamp();
 453                                                         TraceDebug.debug("handled: " + fCount + " sequence: " + synEvent.getSynType()); //$NON-NLS-1$ //$NON-NLS-2$
 454                                                     }
 455                                                 }
 456                                                 break;
 457                                             }
 458
 459                                             case AFTER:
 460                                                 // fall-through
 461                                             case ENDREQ:{
 462                                                 processor.process(event, synEvent.getTraceModel());
 463                                                 break;
 464                                             }
 465
 466                                             default:
 467                           // nothing to do
 468                           break;
 469                                     }
 470                                 }
 471                         }
 472
 473                         public void handleRequestStarted() {
 474                                 notifyStarting();
 475                         }
 476
 477                         @Override
 478                         public void done() {
 479 //                              if (TraceDebug.isDEBUG()) {
 480 //                                      TraceDebug.debug("AbsTimeUpdateView: Received=" + handleDataCount + ", Valid=" + handleDataCount + ", fCount=" + fCount);
 481 //                              }
 482                                 super.done();
 483                         }
 484
 485                         @Override
 486                         public void handleCompleted() {
 487                                 super.handleCompleted();
 488
 489                                 // Data is not complete and should be handled as such
 490                                 if (isFailed() || isCancelled()) {
 491                                         modelIncomplete(this);
 492                                 }
 493
 494                                 if (TraceDebug.isDEBUG()) {
 495                                         if (frunningTimeStamp != null) {
 496                                                 TraceDebug.debug("Last event time stamp: " + frunningTimeStamp.getValue()); //$NON-NLS-1$
 497                                         }
 498                                 }
 499                         }
 500                 };
 501
 502                 // send the request to TMF
 503                 fCurrentRequest.startRequestInd(fProvider);
 504                 fCurrentRequest.setclearDataInd(clearingData);
 505                 return true;
 506         }
 507
 508         /**
 509          * Returns an initial smaller window to allow the user to select the area of
 510          * interest
 511          *
 512          * @param experimentTRange
 513          * @return
 514          */
 515         protected TmfTimeRange getInitTRange(TmfTimeRange experimentTRange) {
 516                 TmfTimestamp expStartTime = experimentTRange.getStartTime();
 517                 TmfTimestamp expEndTime = experimentTRange.getEndTime();
 518                 TmfTimestamp initialEndOfWindow = new LttngTimestamp(expStartTime
 519                                 .getValue()
 520                                 + INITIAL_WINDOW_OFFSET);
 521                 if (initialEndOfWindow.compareTo(expEndTime, false) < 0) {
 522                         return new TmfTimeRange(expStartTime, initialEndOfWindow);
 523                 }
 524
 525                 // The original size of the experiment is smaller than proposed adjusted
 526                 // time
 527                 return experimentTRange;
 528         }
 529
 530         /**
 531          * Request the Time Analysis widget to enable or disable the wait cursor
 532          * e.g. data request in progress or data request completed
 533          *
 534          * @param waitInd
 535          */
 536         protected void waitCursor(final boolean waitInd) {
 537                 if ((tsfviewer != null) && (!tsfviewer.getControl().isDisposed())) {
 538                         Display display = tsfviewer.getControl().getDisplay();
 539
 540                         // Perform the updates on the UI thread
 541                         display.asyncExec(new Runnable() {
 542                                 @Override
 543                                 public void run() {
 544                                         if ((tsfviewer != null) && (!tsfviewer.getControl().isDisposed())) {
 545                                                 tsfviewer.waitCursor(waitInd);
 546                                         }
 547                                 }
 548                         });
 549                 }
 550         }
 551
 552         /**
 553          * View preparation to override the current local information
 554          *
 555          * @param timeRange
 556          *            - new total time range e.g. Experiment level
 557          * @param clearAllData
 558          */
 559         protected void ModelUpdatePrep(TmfTimeRange timeRange, boolean clearAllData) {
 560                 ItemContainer<?> itemContainer = getItemContainer();
 561                 if (clearAllData) {
 562                         // start fresh e.g. new experiment selected
 563                         itemContainer.clearItems();
 564                 } else {
 565                         // clear children but keep processes
 566                         itemContainer.clearChildren();
 567                 }
 568
 569                 // Obtain the current resource array
 570                 ITmfTimeAnalysisEntry[] itemArr = itemContainer.readItems();
 571
 572                 // clean up data and boundaries
 573                 displayModel(itemArr, -1, -1, false, -1, -1, null);
 574
 575                 ParamsUpdater updater = getParamsUpdater();
 576                 if (updater != null) {
 577                         // Start over
 578                         updater.setEventsDiscarded(0);
 579
 580                         // Update new visible time range if available
 581                         if (timeRange != null) {
 582                                 updater.update(timeRange.getStartTime().getValue(), timeRange.getEndTime().getValue());
 583                         }
 584                 }
 585         }
 586
 587         /**
 588          * Initialize the model and view before reloading items
 589          *
 590          * @param boundaryRange
 591          * @param visibleRange
 592          * @param source
 593          */
 594         protected void ModelUpdateInit(TmfTimeRange boundaryRange, TmfTimeRange visibleRange, Object source) {
 595                 // Update the view boundaries
 596                 if (boundaryRange != null) {
 597                         ItemContainer<?> itemContainer = getItemContainer();
 598                         if (itemContainer != null) {
 599                                 itemContainer.clearItems();
 600                                 // Obtain the current process array
 601                                 ITmfTimeAnalysisEntry[] itemArr = itemContainer.readItems();
 602
 603                                 long startTime = boundaryRange.getStartTime().getValue();
 604                                 long endTime = boundaryRange.getEndTime().getValue();
 605
 606                                 // Update the view part
 607                                 displayModel(itemArr, startTime, endTime, true, visibleRange.getStartTime().getValue(), visibleRange
 608                                                 .getEndTime().getValue(), source);
 609                         }
 610                 }
 611
 612                 // update the view filtering parameters
 613                 if (visibleRange != null) {
 614                         ParamsUpdater updater = getParamsUpdater();
 615                         if (updater != null) {
 616                                 // Start over
 617                                 updater.setEventsDiscarded(0);
 618                                 // Update new visible time range if available
 619                                 updater.update(visibleRange.getStartTime().getValue(), visibleRange.getEndTime().getValue());
 620                         }
 621                 }
 622         }
 623
 624         /**
 625          * Actions taken by the view to refresh its widget(s) with the updated data
 626          * model
 627          *
 628          * @param request
 629          * @param complete
 630          *            true: yes, false: partial update
 631          */
 632         @SuppressWarnings("deprecation")
 633         protected void modelInputChanged(ILttngSyntEventRequest request, boolean complete) {
 634                 long experimentStartTime = -1;
 635                 long experimentEndTime = -1;
 636                 TmfTimeRange experimentTimeRange = request.getExperimentTimeRange();
 637                 if (experimentTimeRange != null) {
 638                         experimentStartTime = experimentTimeRange.getStartTime().getValue();
 639                         experimentEndTime = experimentTimeRange.getEndTime().getValue();
 640                 }
 641
 642                 // Obtain the current resource list
 643                 ITmfTimeAnalysisEntry[] itemArr = getItemContainer().readItems();
 644
 645                 if (itemArr != null) {
 646                         // Sort the array by pid
 647                         Arrays.sort(itemArr);
 648
 649                         // Update the view part
 650                         displayModel(itemArr, experimentStartTime, experimentEndTime, false, request.getRange().getStartTime()
 651                                         .getValue(), request.getRange().getEndTime().getValue(), request.getSource());
 652                 }
 653
 654                 if (complete) {
 655                         // reselect to original time
 656                         ParamsUpdater paramUpdater = getParamsUpdater();
 657                         if ((paramUpdater != null) && (tsfviewer != null) && (!tsfviewer.getControl().isDisposed())) {
 658                                 final Long selTime = paramUpdater.getSelectedTime();
 659                                 if (selTime != null) {
 660                                         TraceDebug.debug("View: " + getName() + "\n\t\tRestoring the selected time to: " + selTime); //$NON-NLS-1$ //$NON-NLS-2$
 661                                         Display display = tsfviewer.getControl().getDisplay();
 662                                         display.asyncExec(new Runnable() {
 663                                                 @Override
 664                                                 public void run() {
 665                                                         if ((tsfviewer != null) && (!tsfviewer.getControl().isDisposed())) {
 666                                                                 tsfviewer.setSelectedTime(selTime, false, this);
 667                                                         }
 668                                                 }
 669                                         });
 670                                 }
 671
 672 //                              System.out.println(System.currentTimeMillis() + ": AbsTimeUpdate (" + getName() + ") completed");
 673
 674                                 if (TraceDebug.isDEBUG()) {
 675                                         int eventCount = 0;
 676                                         Long count = request.getSynEventCount();
 677                                         for (int pos = 0; pos < itemArr.length; pos++) {
 678                                                 eventCount += itemArr[pos].getTraceEvents().size();
 679                                         }
 680
 681                                         int discarded = paramUpdater.getEventsDiscarded();
 682                                         int discardedOutofOrder = paramUpdater.getEventsDiscardedWrongOrder();
 683                                         int discardedOutofViewRange = paramUpdater.getEventsDiscardedOutOfViewRange();
 684                                         int dicardedNotVisible = paramUpdater.getEventsDiscardedNotVisible();
 685
 686                                         TmfTimeRange range = request.getRange();
 687                                         StringBuilder sb = new StringBuilder("View: " + getName() + ", Events handled: " + count //$NON-NLS-1$ //$NON-NLS-2$
 688                                                         + ", Events loaded in view: " + eventCount + ", Number of events discarded: " + discarded //$NON-NLS-1$ //$NON-NLS-2$
 689                                                         + "\n\tNumber of events discarded with start time earlier than next good time: " //$NON-NLS-1$
 690                                                         + discardedOutofOrder + "\n\tDiscarded Not visible: " + dicardedNotVisible //$NON-NLS-1$
 691                                                         + "\n\tDiscarded out of view Range: " + discardedOutofViewRange); //$NON-NLS-1$
 692
 693                                         sb.append("\n\t\tRequested Time Range: " + range.getStartTime() + "-" + range.getEndTime()); //$NON-NLS-1$ //$NON-NLS-2$
 694                                         sb.append("\n\t\tExperiment Time Range: " + experimentStartTime + "-" + experimentEndTime); //$NON-NLS-1$ //$NON-NLS-2$
 695                                         TraceDebug.debug(sb.toString());
 696                                 }
 697                         }
 698
 699                 }
 700         }
 701
 702         // /**
 703         // * Obtains the remainder fraction on unit Seconds of the entered value in
 704         // * nanoseconds. e.g. input: 1241207054171080214 ns The number of seconds
 705         // can
 706         // * be obtain by removing the last 9 digits: 1241207054 the fractional
 707         // * portion of seconds, expressed in ns is: 171080214
 708         // *
 709         // * @param v
 710         // * @return
 711         // */
 712         // protected String formatNs(long v) {
 713         // StringBuffer str = new StringBuffer();
 714         // boolean neg = v < 0;
 715         // if (neg) {
 716         // v = -v;
 717         // str.append('-');
 718         // }
 719         //
 720         // String strVal = String.valueOf(v);
 721         // if (v < 1000000000) {
 722         // return strVal;
 723         // }
 724         //
 725         // // Extract the last nine digits (e.g. fraction of a S expressed in ns
 726         // return strVal.substring(strVal.length() - 9);
 727         // }
 728
 729         /**
 730          * The request was stopped, the data is incomplete
 731          *
 732          * @param request
 733          */
 734         protected abstract void modelIncomplete(ILttngSyntEventRequest request);
 735
 736         /**
 737          * Returns the Event processor instance related to a specific view
 738          *
 739          * @return
 740          */
 741         protected abstract ITransEventProcessor getEventProcessor();
 742
 743         /**
 744          * To be overridden by some sub-classes although may not be needed in some
 745          * e.g. statistics view
 746          *
 747          * @param items
 748          * @param startBoundTime
 749          * @param endBoundTime
 750          * @param updateTimeBounds
 751          *            - Time bounds updated needed e.g. if a new Experiment or trace
 752          *            is selected
 753          * @param startVisibleWindow
 754          * @param endVisibleWindow
 755          * @param source
 756          */
 757         protected abstract void displayModel(final ITmfTimeAnalysisEntry[] items, final long startBoundTime,
 758                         final long endBoundTime, final boolean updateTimeBounds, final long startVisibleWindow,
 759                         final long endVisibleWindow, final Object source);
 760
 761         /**
 762          * To be overridden by some sub-classes although may not be needed in some
 763          * e.g. statistics view
 764          *
 765          * @return
 766          */
 767         protected abstract ParamsUpdater getParamsUpdater();
 768
 769         /**
 770          * Returns the model's item container
 771          *
 772          * @return
 773          */
 774         protected abstract ItemContainer<?> getItemContainer();
 775
 776         /**
 777          * Returns LTTng Synthetic Provider ID used for current view
 778          *
 779          * @return
 780          */
 781         protected abstract int getProviderId();
 782 }