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