org.eclipse.linuxtools.tmf.ui/src/org/eclipse/linuxtools/tmf/ui/views/uml2sd/loader/TmfUml2SDSyncLoader.java

   1 /**********************************************************************
   2  * Copyright (c) 2011, 2012 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  *   Bernd Hufmann - Initial API and implementation
  11  **********************************************************************/
  12 package org.eclipse.linuxtools.tmf.ui.views.uml2sd.loader;
  13
  14 import java.util.ArrayList;
  15 import java.util.HashMap;
  16 import java.util.List;
  17 import java.util.Map;
  18 import java.util.concurrent.CopyOnWriteArrayList;
  19 import java.util.concurrent.locks.ReentrantLock;
  20
  21 import org.eclipse.core.runtime.IProgressMonitor;
  22 import org.eclipse.core.runtime.IStatus;
  23 import org.eclipse.core.runtime.Status;
  24 import org.eclipse.core.runtime.jobs.Job;
  25 import org.eclipse.jface.viewers.ISelection;
  26 import org.eclipse.jface.viewers.StructuredSelection;
  27 import org.eclipse.linuxtools.internal.tmf.ui.Activator;
  28 import org.eclipse.linuxtools.tmf.core.component.TmfComponent;
  29 import org.eclipse.linuxtools.tmf.core.event.ITmfEvent;
  30 import org.eclipse.linuxtools.tmf.core.event.ITmfEventField;
  31 import org.eclipse.linuxtools.tmf.core.event.ITmfTimestamp;
  32 import org.eclipse.linuxtools.tmf.core.event.TmfTimeRange;
  33 import org.eclipse.linuxtools.tmf.core.event.TmfTimestamp;
  34 import org.eclipse.linuxtools.tmf.core.request.ITmfDataRequest;
  35 import org.eclipse.linuxtools.tmf.core.request.ITmfEventRequest;
  36 import org.eclipse.linuxtools.tmf.core.request.TmfDataRequest;
  37 import org.eclipse.linuxtools.tmf.core.request.TmfEventRequest;
  38 import org.eclipse.linuxtools.tmf.core.signal.TmfRangeSynchSignal;
  39 import org.eclipse.linuxtools.tmf.core.signal.TmfSignal;
  40 import org.eclipse.linuxtools.tmf.core.signal.TmfSignalHandler;
  41 import org.eclipse.linuxtools.tmf.core.signal.TmfTimeSynchSignal;
  42 import org.eclipse.linuxtools.tmf.core.signal.TmfTraceClosedSignal;
  43 import org.eclipse.linuxtools.tmf.core.signal.TmfTraceSelectedSignal;
  44 import org.eclipse.linuxtools.tmf.core.trace.ITmfTrace;
  45 import org.eclipse.linuxtools.tmf.core.uml2sd.ITmfSyncSequenceDiagramEvent;
  46 import org.eclipse.linuxtools.tmf.core.uml2sd.TmfSyncSequenceDiagramEvent;
  47 import org.eclipse.linuxtools.tmf.ui.editors.ITmfTraceEditor;
  48 import org.eclipse.linuxtools.tmf.ui.views.uml2sd.SDView;
  49 import org.eclipse.linuxtools.tmf.ui.views.uml2sd.core.Frame;
  50 import org.eclipse.linuxtools.tmf.ui.views.uml2sd.core.GraphNode;
  51 import org.eclipse.linuxtools.tmf.ui.views.uml2sd.core.Lifeline;
  52 import org.eclipse.linuxtools.tmf.ui.views.uml2sd.dialogs.Criteria;
  53 import org.eclipse.linuxtools.tmf.ui.views.uml2sd.dialogs.FilterCriteria;
  54 import org.eclipse.linuxtools.tmf.ui.views.uml2sd.dialogs.FilterListDialog;
  55 import org.eclipse.linuxtools.tmf.ui.views.uml2sd.handlers.provider.ISDAdvancedPagingProvider;
  56 import org.eclipse.linuxtools.tmf.ui.views.uml2sd.handlers.provider.ISDFilterProvider;
  57 import org.eclipse.linuxtools.tmf.ui.views.uml2sd.handlers.provider.ISDFindProvider;
  58 import org.eclipse.linuxtools.tmf.ui.views.uml2sd.handlers.provider.ISDGraphNodeSupporter;
  59 import org.eclipse.linuxtools.tmf.ui.views.uml2sd.load.IUml2SDLoader;
  60 import org.eclipse.swt.widgets.Display;
  61 import org.eclipse.ui.IEditorPart;
  62 import org.eclipse.ui.ISelectionListener;
  63 import org.eclipse.ui.IWorkbenchPart;
  64 import org.eclipse.ui.IWorkbenchWindow;
  65 import org.eclipse.ui.PlatformUI;
  66 import org.eclipse.ui.progress.IProgressConstants;
  67
  68 /**
  69  * <p>
  70  * This class is a reference implementation of the
  71  * <code>org.eclipse.linuxtools.tmf.ui.Uml2SDLoader</code> extension point. It
  72  * provides a Sequence Diagram loader for a user space trace with specific trace
  73  * content for sending and receiving signals between components. I also includes
  74  * a default implementation for the <code>ITmfEvent</code> parsing.
  75  * </p>
  76  *
  77  * The class <code>TmfUml2SDSyncLoader</code> analyzes events from type
  78  * <code>ITmfEvent</code> and creates events type
  79  * <code>ITmfSyncSequenceDiagramEvent</code> if the <code>ITmfEvent</code>
  80  * contains all relevant information. The analysis checks that the event type
  81  * strings contains either string SEND or RECEIVE. If event type matches these
  82  * key words, the analyzer will look for strings sender, receiver and signal in
  83  * the event fields of type <code>ITmfEventField</code>. If all the data is
  84  * found a sequence diagram event from can be created. Note that Sync Messages
  85  * are assumed, which means start and end time are the same. <br>
  86  * <br>
  87  * The parsing of the <code>ITmfEvent</code> is done in the method
  88  * <code>getSequnceDiagramEvent()</code> of class
  89  * <code>TmfUml2SDSyncLoader</code>. By extending the class
  90  * <code>TmfUml2SDSyncLoader</code> and overwriting
  91  * <code>getSequnceDiagramEvent()</code> a customized parsing algorithm can be
  92  * implemented.<br>
  93  * <br>
  94  * Note that combined traces of multiple components, that contain the trace
  95  * information about the same interactions are not supported in the class
  96  * <code>TmfUml2SDSyncLoader</code>.
  97  *
  98  * @version 1.0
  99  * @author Bernd Hufmann
 100  */
 101 public class TmfUml2SDSyncLoader extends TmfComponent implements IUml2SDLoader, ISDFindProvider, ISDFilterProvider, ISDAdvancedPagingProvider, ISelectionListener  {
 102
 103     // ------------------------------------------------------------------------
 104     // Constants
 105     // ------------------------------------------------------------------------
 106     /**
 107      * Default title name.
 108      */
 109     protected final static String TITLE = Messages.TmfUml2SDSyncLoader_ViewName;
 110     /**
 111      * Default block size for background request.
 112      */
 113     protected final static int DEFAULT_BLOCK_SIZE = 50000;
 114     /**
 115      * Maximum number of messages per page.
 116      */
 117     protected final static int MAX_NUM_OF_MSG = 10000;
 118
 119     // ------------------------------------------------------------------------
 120     // Attributes
 121     // ------------------------------------------------------------------------
 122
 123     // Experiment attributes
 124     /**
 125      * The TMF trace reference.
 126      * @since 2.0
 127      */
 128     protected ITmfTrace fTrace = null;
 129     /**
 130      * The current indexing event request.
 131      */
 132     protected ITmfEventRequest fIndexRequest = null;
 133     /**
 134      * The current request to fill a page.
 135      */
 136     protected ITmfEventRequest fPageRequest = null;
 137     /**
 138      * Flag whether the time range signal was sent by this loader class or not
 139      */
 140     volatile protected boolean fIsSignalSent = false;
 141
 142     // The view and event attributes
 143     /**
 144      * The sequence diagram view reference.
 145      */
 146     protected SDView fView = null;
 147     /**
 148      * The current sequence diagram frame reference.
 149      */
 150     protected Frame fFrame = null;
 151     /**
 152      * The list of sequence diagram events of current page.
 153      */
 154     protected List<ITmfSyncSequenceDiagramEvent> fEvents = new ArrayList<ITmfSyncSequenceDiagramEvent>();
 155
 156     // Checkpoint and page attributes
 157     /**
 158      * The checkpoints of the whole sequence diagram trace (i.e. start time stamp of each page)
 159      */
 160     protected List<TmfTimeRange> fCheckPoints = new ArrayList<TmfTimeRange>(MAX_NUM_OF_MSG);
 161     /**
 162      * The current page displayed.
 163      */
 164     volatile protected int fCurrentPage = 0;
 165     /**
 166      * The current time selected.
 167      */
 168     protected ITmfTimestamp fCurrentTime = null;
 169     /**
 170      * Flag to specify that selection of message is done by selection or by signal.
 171      */
 172     volatile protected boolean fIsSelect = false;
 173
 174     // Search attributes
 175     /**
 176      * The job for searching across pages.
 177      */
 178     protected SearchJob fFindJob = null;
 179     /**
 180      * List of found nodes within a page.
 181      */
 182     protected List<GraphNode> fFindResults = new ArrayList<GraphNode>();
 183     /**
 184      * The current find criteria reference
 185      */
 186     protected Criteria fFindCriteria = null;
 187     /**
 188      * The current find index within the list of found nodes (<code>fFindeResults</code> within a page.
 189      */
 190     volatile protected int fCurrentFindIndex = 0;
 191
 192     // Filter attributes
 193     /**
 194      * The list of active filters.
 195      */
 196     protected List<FilterCriteria> fFilterCriteria = null;
 197
 198     // Thread synchronization
 199     /**
 200      * The synchronization lock.
 201      */
 202     protected ReentrantLock fLock = new ReentrantLock();
 203
 204     // ------------------------------------------------------------------------
 205     // Constructors
 206     // ------------------------------------------------------------------------
 207     /**
 208      * Default constructor
 209      */
 210     public TmfUml2SDSyncLoader() {
 211         super(TITLE);
 212     }
 213
 214     /**
 215      * Constructor
 216      *
 217      * @param name Name of loader
 218      */
 219     public TmfUml2SDSyncLoader(String name) {
 220         super(name);
 221     }
 222
 223     // ------------------------------------------------------------------------
 224     // Operations
 225     // ------------------------------------------------------------------------
 226     /**
 227      * Returns the current time if available else null.
 228      *
 229      * @return the current time if available else null
 230      */
 231     public ITmfTimestamp getCurrentTime() {
 232         fLock.lock();
 233         try {
 234             if (fCurrentTime != null) {
 235                 return fCurrentTime;
 236             }
 237             return null;
 238         } finally {
 239             fLock.unlock();
 240         }
 241     }
 242
 243     /**
 244      * Waits for the page request to be completed
 245      */
 246     public void waitForCompletion() {
 247         fLock.lock();
 248         ITmfEventRequest request = fPageRequest;
 249         fLock.unlock();
 250         if (request != null) {
 251             try {
 252                 request.waitForCompletion();
 253             } catch (InterruptedException e) {
 254                 // ignore
 255             }
 256         }
 257     }
 258
 259     /**
 260      * Signal handler for the trace selected signal.
 261      *
 262      * Spawns a request to index the trace (checkpoints creation) as well as it fills
 263      * the first page.
 264      *
 265      * @param signal The trace selected signal
 266      * @since 2.0
 267      */
 268     @TmfSignalHandler
 269     public void traceSelected(TmfTraceSelectedSignal signal) {
 270
 271         ITmfEventRequest indexRequest = null;
 272         fLock.lock();
 273         try {
 274             // Update the trace reference
 275             ITmfTrace trace = signal.getTrace();
 276             if (!trace.equals(fTrace)) {
 277                 fTrace = trace;
 278             } else {
 279                 return;
 280             }
 281
 282             final Job job = new IndexingJob("Indexing " + getName() + "..."); //$NON-NLS-1$ //$NON-NLS-2$
 283             job.setUser(false);
 284             job.schedule();
 285
 286             indexRequest = fIndexRequest;
 287
 288             cancelOngoingRequests();
 289
 290             TmfTimeRange window = TmfTimeRange.ETERNITY;
 291
 292             fIndexRequest = new TmfEventRequest(ITmfEvent.class, window, TmfDataRequest.ALL_DATA, DEFAULT_BLOCK_SIZE, ITmfDataRequest.ExecutionType.BACKGROUND) {
 293
 294                 private ITmfTimestamp fFirstTime = null;
 295                 private ITmfTimestamp fLastTime = null;
 296                 private int fNbSeqEvents = 0;
 297                 private final List<ITmfSyncSequenceDiagramEvent> fSdEvents = new ArrayList<ITmfSyncSequenceDiagramEvent>(MAX_NUM_OF_MSG);
 298
 299                 /*
 300                  * (non-Javadoc)
 301                  * @see org.eclipse.linuxtools.tmf.core.request.TmfDataRequest#handleData(org.eclipse.linuxtools.tmf.core.event.ITmfEvent)
 302                  */
 303                 @Override
 304                 public void handleData(ITmfEvent event) {
 305                     super.handleData(event);
 306
 307                     ITmfSyncSequenceDiagramEvent sdEvent = getSequenceDiagramEvent(event);
 308
 309                     if (sdEvent != null) {
 310                         ++fNbSeqEvents;
 311
 312                         if (fFirstTime == null) {
 313                             fFirstTime = event.getTimestamp();
 314                         }
 315
 316                         fLastTime = event.getTimestamp();
 317
 318                         if ((fNbSeqEvents % MAX_NUM_OF_MSG) == 0) {
 319                             fLock.lock();
 320                             try {
 321                                 fCheckPoints.add(new TmfTimeRange(fFirstTime, fLastTime));
 322                                 if (fView != null) {
 323                                     fView.updateCoolBar();
 324                                 }
 325                             } finally {
 326                                 fLock.unlock();
 327                             }
 328                             fFirstTime = null;
 329
 330                         }
 331
 332                         if (fNbSeqEvents > MAX_NUM_OF_MSG) {
 333                             // page is full
 334                             return;
 335                         }
 336
 337                         fSdEvents.add(sdEvent);
 338
 339                         if (fNbSeqEvents == MAX_NUM_OF_MSG) {
 340                             fillCurrentPage(fSdEvents);
 341                         }
 342                     }
 343                 }
 344
 345                 /*
 346                  * (non-Javadoc)
 347                  * @see org.eclipse.linuxtools.tmf.core.request.TmfDataRequest#handleSuccess()
 348                  */
 349                 @Override
 350                 public void handleSuccess() {
 351                     if ((fFirstTime != null) && (fLastTime != null)) {
 352
 353                         fLock.lock();
 354                         try {
 355                             fCheckPoints.add(new TmfTimeRange(fFirstTime, fLastTime));
 356                             if (fView != null) {
 357                                 fView.updateCoolBar();
 358                             }
 359                         } finally {
 360                             fLock.unlock();
 361                         }
 362                     }
 363
 364                     if (fNbSeqEvents <= MAX_NUM_OF_MSG) {
 365                         fillCurrentPage(fSdEvents);
 366                     }
 367
 368                     super.handleSuccess();
 369                 }
 370
 371                 /*
 372                  * (non-Javadoc)
 373                  * @see org.eclipse.linuxtools.tmf.core.request.TmfDataRequest#handleCompleted()
 374                  */
 375                 @Override
 376                 public void handleCompleted() {
 377                     if (fEvents.isEmpty()) {
 378                         fFrame = new Frame();
 379                         fView.setFrameSync(fFrame);
 380                     }
 381                     super.handleCompleted();
 382                     job.cancel();
 383                 }
 384             };
 385
 386         } finally {
 387             fLock.unlock();
 388         }
 389         if (indexRequest != null && !indexRequest.isCompleted()) {
 390             indexRequest.cancel();
 391         }
 392         resetLoader();
 393         fTrace.sendRequest(fIndexRequest);
 394
 395     }
 396
 397     /**
 398      * Signal handler for the trace closed signal.
 399      *
 400      * @param signal The trace closed signal
 401      * @since 2.0
 402      */
 403     @TmfSignalHandler
 404     public void traceClosed(TmfTraceClosedSignal signal) {
 405         if (signal.getTrace() != fTrace) {
 406             return;
 407         }
 408         ITmfEventRequest indexRequest = null;
 409         fLock.lock();
 410         try {
 411             indexRequest = fIndexRequest;
 412             fIndexRequest = null;
 413
 414             cancelOngoingRequests();
 415
 416             if (fFilterCriteria != null) {
 417                 fFilterCriteria.clear();
 418             }
 419
 420             FilterListDialog.deactivateSavedGlobalFilters();
 421         } finally {
 422             fTrace = null;
 423             fLock.unlock();
 424         }
 425         if (indexRequest != null && !indexRequest.isCompleted()) {
 426             indexRequest.cancel();
 427         }
 428
 429         resetLoader();
 430     }
 431
 432     /**
 433      * Moves to the page that contains the time provided by the signal. The messages will be selected
 434      * if the provided time is the time of a message.
 435      *
 436      * @param signal The Time synch signal.
 437      */
 438     @TmfSignalHandler
 439     public void synchToTime(TmfTimeSynchSignal signal) {
 440         fLock.lock();
 441         try {
 442             if ((signal.getSource() != this) && (fFrame != null) && (fCheckPoints.size() > 0)) {
 443                 fCurrentTime = signal.getCurrentTime();
 444                 fIsSelect = true;
 445                 moveToMessage();
 446             }
 447         } finally {
 448             fLock.unlock();
 449         }
 450     }
 451
 452     /**
 453      * Moves to the page that contains the current time provided by signal.
 454      * No message will be selected however the focus will be set to the message
 455      * if the provided time is the time of a message.
 456      *
 457      * @param signal The time range sync signal
 458      */
 459     @TmfSignalHandler
 460     public void synchToTimeRange(TmfRangeSynchSignal signal) {
 461         fLock.lock();
 462         try {
 463             if ((signal.getSource() != this) && (fFrame != null) && !fIsSignalSent && (fCheckPoints.size() > 0)) {
 464                 TmfTimeRange newTimeRange = signal.getCurrentRange();
 465
 466                 fIsSelect = false;
 467                 fCurrentTime = newTimeRange.getStartTime();
 468
 469                 moveToMessage();
 470             }
 471         } finally {
 472             fLock.unlock();
 473         }
 474
 475     }
 476
 477     /*
 478      * (non-Javadoc)
 479      * @see org.eclipse.linuxtools.tmf.ui.views.uml2sd.load.IUml2SDLoader#setViewer(org.eclipse.linuxtools.tmf.ui.views.uml2sd.SDView)
 480      */
 481     @Override
 482     public void setViewer(SDView viewer) {
 483
 484         fLock.lock();
 485         try {
 486             fView = viewer;
 487             PlatformUI.getWorkbench().getActiveWorkbenchWindow().getSelectionService().addPostSelectionListener(this);
 488             fView.setSDFindProvider(this);
 489             fView.setSDPagingProvider(this);
 490             fView.setSDFilterProvider(this);
 491
 492             resetLoader();
 493
 494             IEditorPart editor = fView.getSite().getPage().getActiveEditor();
 495             if (editor instanceof ITmfTraceEditor) {
 496                 ITmfTrace trace = ((ITmfTraceEditor) editor).getTrace();
 497                 if (trace != null) {
 498                     traceSelected(new TmfTraceSelectedSignal(this, trace));
 499                 }
 500             }
 501         } finally {
 502             fLock.unlock();
 503         }
 504     }
 505
 506     /*
 507      * (non-Javadoc)
 508      * @see org.eclipse.linuxtools.tmf.ui.views.uml2sd.load.IUml2SDLoader#getTitleString()
 509      */
 510     @Override
 511     public String getTitleString() {
 512         return getName();
 513     }
 514
 515     /*
 516      * (non-Javadoc)
 517      * @see org.eclipse.linuxtools.tmf.component.TmfComponent#dispose()
 518      */
 519     @Override
 520     public void dispose() {
 521        super.dispose();
 522        ITmfEventRequest indexRequest = null;
 523        fLock.lock();
 524        try {
 525            IWorkbenchWindow window = PlatformUI.getWorkbench().getActiveWorkbenchWindow();
 526            // During Eclipse shutdown the active workbench window is null
 527            if (window != null) {
 528                window.getSelectionService().removePostSelectionListener(this);
 529            }
 530
 531            indexRequest = fIndexRequest;
 532            fIndexRequest = null;
 533            cancelOngoingRequests();
 534
 535            fView.setSDFindProvider(null);
 536            fView.setSDPagingProvider(null);
 537            fView.setSDFilterProvider(null);
 538            fView = null;
 539        } finally {
 540            fLock.unlock();
 541        }
 542        if (indexRequest != null && !indexRequest.isCompleted()) {
 543            indexRequest.cancel();
 544        }
 545     }
 546
 547     /*
 548      * (non-Javadoc)
 549      * @see org.eclipse.hyades.uml2sd.ui.actions.provider.ISDGraphNodeSupporter#isNodeSupported(int)
 550      */
 551     @Override
 552     public boolean isNodeSupported(int nodeType) {
 553         switch (nodeType) {
 554         case ISDGraphNodeSupporter.LIFELINE:
 555         case ISDGraphNodeSupporter.SYNCMESSAGE:
 556             return true;
 557
 558         default:
 559             break;
 560         }
 561         return false;
 562     }
 563
 564     /*
 565      * (non-Javadoc)
 566      * @see org.eclipse.linuxtools.tmf.ui.views.uml2sd.handlers.provider.ISDGraphNodeSupporter#getNodeName(int, java.lang.String)
 567      */
 568     @Override
 569     public String getNodeName(int nodeType, String loaderClassName) {
 570         switch (nodeType) {
 571         case ISDGraphNodeSupporter.LIFELINE:
 572             return Messages.TmfUml2SDSyncLoader_CategoryLifeline;
 573          case ISDGraphNodeSupporter.SYNCMESSAGE:
 574              return Messages.TmfUml2SDSyncLoader_CategoryMessage;
 575         default:
 576             break;
 577         }
 578         return ""; //$NON-NLS-1$
 579     }
 580
 581     /*
 582      * (non-Javadoc)
 583      * @see org.eclipse.ui.ISelectionListener#selectionChanged(org.eclipse.ui.IWorkbenchPart, org.eclipse.jface.viewers.ISelection)
 584      */
 585     @Override
 586     public void selectionChanged(IWorkbenchPart part, ISelection selection) {
 587         ISelection sel = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getSelectionService().getSelection();
 588         if ((sel != null) && (sel instanceof StructuredSelection)) {
 589             StructuredSelection stSel = (StructuredSelection) sel;
 590             if (stSel.getFirstElement() instanceof TmfSyncMessage) {
 591                 TmfSyncMessage syncMsg = ((TmfSyncMessage) stSel.getFirstElement());
 592                 broadcast(new TmfTimeSynchSignal(this, syncMsg.getStartTime()));
 593             }
 594         }
 595     }
 596
 597     /*
 598      * (non-Javadoc)
 599      * @see
 600      * org.eclipse.hyades.uml2sd.ui.actions.provider.ISDFindProvider#find(org.eclipse.hyades.uml2sd.ui.actions.widgets.Criteria)
 601      */
 602     @Override
 603     public boolean find(Criteria toSearch) {
 604         fLock.lock();
 605         try {
 606             if (fFrame == null) {
 607                 return false;
 608             }
 609
 610             if ((fFindResults == null) || (fFindCriteria == null) || !fFindCriteria.compareTo(toSearch)) {
 611                 fFindResults = new CopyOnWriteArrayList<GraphNode>();
 612                 fFindCriteria = toSearch;
 613                 if (fFindCriteria.isLifeLineSelected()) {
 614                     for (int i = 0; i < fFrame.lifeLinesCount(); i++) {
 615                         if (fFindCriteria.matches(fFrame.getLifeline(i).getName())) {
 616                             fFindResults.add(fFrame.getLifeline(i));
 617                         }
 618                     }
 619                 }
 620
 621                 ArrayList<GraphNode> msgs = new ArrayList<GraphNode>();
 622                 if (fFindCriteria.isSyncMessageSelected()) {
 623                     for (int i = 0; i < fFrame.syncMessageCount(); i++) {
 624                         if (fFindCriteria.matches(fFrame.getSyncMessage(i).getName())) {
 625                             msgs.add(fFrame.getSyncMessage(i));
 626                         }
 627                     }
 628                 }
 629
 630                 if (!msgs.isEmpty()) {
 631                     fFindResults.addAll(msgs);
 632                 }
 633
 634                 @SuppressWarnings("rawtypes")
 635                 List selection = fView.getSDWidget().getSelection();
 636                 if ((selection != null) && (selection.size() == 1)) {
 637                     fCurrentFindIndex = fFindResults.indexOf(selection.get(0)) + 1;
 638                 } else {
 639                     fCurrentFindIndex = 0;
 640                 }
 641             } else {
 642                 fCurrentFindIndex++;
 643             }
 644
 645             if (fFindResults.size() > fCurrentFindIndex) {
 646                 GraphNode current = fFindResults.get(fCurrentFindIndex);
 647                 fView.getSDWidget().moveTo(current);
 648                 return true;
 649             }
 650             fFindResults = null;
 651             fCurrentFindIndex =0;
 652             return findInNextPages(fFindCriteria); // search in other page
 653         } finally {
 654             fLock.unlock();
 655         }
 656     }
 657
 658     /*
 659      * (non-Javadoc)
 660      * @see org.eclipse.linuxtools.tmf.ui.views.uml2sd.handlers.provider.ISDFindProvider#cancel()
 661      */
 662     @Override
 663     public void cancel() {
 664         cancelOngoingRequests();
 665     }
 666
 667     /*
 668      * (non-Javadoc)
 669      * @see org.eclipse.linuxtools.tmf.ui.views.uml2sd.handlers.provider.ISDFilterProvider#filter(java.util.List)
 670      */
 671     @SuppressWarnings("unchecked")
 672     @Override
 673     public boolean filter(List<?> filters) {
 674         fLock.lock();
 675         try {
 676             cancelOngoingRequests();
 677
 678             if (filters == null) {
 679                 fFilterCriteria =  new ArrayList<FilterCriteria>();
 680             } else {
 681                 List<FilterCriteria> list = (List<FilterCriteria>)filters;
 682                 fFilterCriteria =  new ArrayList<FilterCriteria>(list);
 683             }
 684
 685             fillCurrentPage(fEvents);
 686
 687         } finally {
 688             fLock.unlock();
 689         }
 690         return true;
 691     }
 692
 693     /*
 694      * (non-Javadoc)
 695      * @see org.eclipse.linuxtools.tmf.ui.views.uml2sd.handlers.provider.ISDPagingProvider#hasNextPage()
 696      */
 697     @Override
 698     public boolean hasNextPage() {
 699         fLock.lock();
 700         try {
 701             int size = fCheckPoints.size();
 702             if (size > 0) {
 703                 return fCurrentPage < (size - 1);
 704             }
 705         } finally {
 706             fLock.unlock();
 707         }
 708         return false;
 709     }
 710
 711     /*
 712      * (non-Javadoc)
 713      * @see org.eclipse.linuxtools.tmf.ui.views.uml2sd.handlers.provider.ISDPagingProvider#hasPrevPage()
 714      */
 715     @Override
 716     public boolean hasPrevPage() {
 717         fLock.lock();
 718         try {
 719             return fCurrentPage > 0;
 720         } finally {
 721             fLock.unlock();
 722         }
 723     }
 724
 725     /*
 726      * (non-Javadoc)
 727      * @see org.eclipse.linuxtools.tmf.ui.views.uml2sd.handlers.provider.ISDPagingProvider#nextPage()
 728      */
 729     @Override
 730     public void nextPage() {
 731         fLock.lock();
 732         try {
 733             // Safety check
 734             if (fCurrentPage >= (fCheckPoints.size() - 1)) {
 735                 return;
 736             }
 737
 738             cancelOngoingRequests();
 739             fCurrentTime = null;
 740             fCurrentPage++;
 741             moveToPage();
 742         } finally {
 743             fLock.unlock();
 744         }
 745     }
 746
 747     /*
 748      * (non-Javadoc)
 749      * @see org.eclipse.linuxtools.tmf.ui.views.uml2sd.handlers.provider.ISDPagingProvider#prevPage()
 750      */
 751     @Override
 752     public void prevPage() {
 753         fLock.lock();
 754         try {
 755             // Safety check
 756             if (fCurrentPage <= 0) {
 757                 return;
 758             }
 759
 760             cancelOngoingRequests();
 761             fCurrentTime = null;
 762             fCurrentPage--;
 763             moveToPage();
 764         } finally {
 765             fLock.unlock();
 766         }
 767     }
 768
 769     /*
 770      * (non-Javadoc)
 771      * @see org.eclipse.linuxtools.tmf.ui.views.uml2sd.handlers.provider.ISDPagingProvider#firstPage()
 772      */
 773     @Override
 774     public void firstPage() {
 775         fLock.lock();
 776         try {
 777
 778             cancelOngoingRequests();
 779             fCurrentTime = null;
 780             fCurrentPage = 0;
 781             moveToPage();
 782         } finally {
 783             fLock.unlock();
 784         }
 785     }
 786
 787     /*
 788      * (non-Javadoc)
 789      * @see org.eclipse.linuxtools.tmf.ui.views.uml2sd.handlers.provider.ISDPagingProvider#lastPage()
 790      */
 791     @Override
 792     public void lastPage() {
 793         fLock.lock();
 794         try {
 795             cancelOngoingRequests();
 796             fCurrentTime = null;
 797             fCurrentPage = fCheckPoints.size() - 1;
 798             moveToPage();
 799         } finally {
 800             fLock.unlock();
 801         }
 802     }
 803
 804     /*
 805      * (non-Javadoc)
 806      * @see org.eclipse.linuxtools.tmf.ui.views.uml2sd.handlers.provider.ISDAdvancedPagingProvider#currentPage()
 807      */
 808     @Override
 809     public int currentPage() {
 810         fLock.lock();
 811         try {
 812             return fCurrentPage;
 813         } finally {
 814             fLock.unlock();
 815         }
 816     }
 817
 818     /*
 819      * (non-Javadoc)
 820      * @see org.eclipse.linuxtools.tmf.ui.views.uml2sd.handlers.provider.ISDAdvancedPagingProvider#pagesCount()
 821      */
 822     @Override
 823     public int pagesCount() {
 824         fLock.lock();
 825         try {
 826             return fCheckPoints.size();
 827         } finally {
 828             fLock.unlock();
 829         }
 830     }
 831
 832     /*
 833      * (non-Javadoc)
 834      * @see org.eclipse.linuxtools.tmf.ui.views.uml2sd.handlers.provider.ISDAdvancedPagingProvider#pageNumberChanged(int)
 835      */
 836     @Override
 837     public void pageNumberChanged(int pagenNumber) {
 838         int localPageNumber = pagenNumber;
 839
 840         fLock.lock();
 841         try {
 842             cancelOngoingRequests();
 843
 844             if (localPageNumber < 0) {
 845                 localPageNumber = 0;
 846             }
 847             int size = fCheckPoints.size();
 848             if (localPageNumber > (size - 1)) {
 849                 localPageNumber = size - 1;
 850             }
 851             fCurrentPage = localPageNumber;
 852             moveToPage();
 853         } finally {
 854             fLock.unlock();
 855         }
 856     }
 857
 858     /*
 859      * (non-Javadoc)
 860      * @see org.eclipse.linuxtools.tmf.component.TmfComponent#broadcast(org.eclipse.linuxtools.tmf.signal.TmfSignal)
 861      */
 862     @Override
 863     public void broadcast(TmfSignal signal) {
 864         fIsSignalSent = true;
 865         super.broadcast(signal);
 866         fIsSignalSent = false;
 867     }
 868
 869     /**
 870      * Cancels any ongoing find operation
 871      */
 872     protected void cancelOngoingRequests() {
 873         fLock.lock();
 874         ITmfEventRequest pageRequest = null;
 875         try {
 876             // Cancel the search thread
 877             if (fFindJob != null) {
 878                 fFindJob.cancel();
 879             }
 880
 881             fFindResults = null;
 882             fFindCriteria = null;
 883             fCurrentFindIndex = 0;
 884
 885             pageRequest = fPageRequest;
 886             fPageRequest = null;
 887         } finally {
 888             fLock.unlock();
 889         }
 890         if (pageRequest != null && !pageRequest.isCompleted()) {
 891             pageRequest.cancel();
 892         }
 893     }
 894
 895     /**
 896      * Resets loader attributes
 897      */
 898     protected  void resetLoader() {
 899         fLock.lock();
 900         try {
 901             fCurrentTime = null;
 902             fEvents.clear();
 903             fCheckPoints.clear();
 904             fCurrentPage = 0;
 905             fCurrentFindIndex = 0;
 906             fFindCriteria = null;
 907             fFindResults = null;
 908             fView.setFrameSync(new Frame());
 909             fFrame = null;
 910         }
 911         finally {
 912             fLock.unlock();
 913         }
 914
 915     }
 916
 917     /**
 918      * Fills current page with sequence diagram content.
 919      *
 920      * @param events sequence diagram events
 921      */
 922     protected void fillCurrentPage(List<ITmfSyncSequenceDiagramEvent> events) {
 923
 924         fLock.lock();
 925         try {
 926             fEvents = new ArrayList<ITmfSyncSequenceDiagramEvent>(events);
 927             if (fView != null && !events.isEmpty()) {
 928                 fView.toggleWaitCursorAsync(true);
 929             }
 930         } finally {
 931             fLock.unlock();
 932         }
 933
 934         final Frame frame = new Frame();
 935
 936         if (!events.isEmpty()) {
 937             Map<String, Lifeline> nodeToLifelineMap = new HashMap<String, Lifeline>();
 938
 939             frame.setName(Messages.TmfUml2SDSyncLoader_FrameName);
 940
 941             for (int i = 0; i < events.size(); i++) {
 942
 943                 ITmfSyncSequenceDiagramEvent sdEvent = events.get(i);
 944
 945                 if ((nodeToLifelineMap.get(sdEvent.getSender()) == null) && (!filterLifeLine(sdEvent.getSender()))) {
 946                     Lifeline lifeline = new Lifeline();
 947                     lifeline.setName(sdEvent.getSender());
 948                     nodeToLifelineMap.put(sdEvent.getSender(), lifeline);
 949                     frame.addLifeLine(lifeline);
 950                 }
 951
 952                 if ((nodeToLifelineMap.get(sdEvent.getReceiver()) == null) && (!filterLifeLine(sdEvent.getReceiver()))) {
 953                     Lifeline lifeline = new Lifeline();
 954                     lifeline.setName(sdEvent.getReceiver());
 955                     nodeToLifelineMap.put(sdEvent.getReceiver(), lifeline);
 956                     frame.addLifeLine(lifeline);
 957                 }
 958             }
 959
 960             int eventOccurence = 1;
 961
 962             for (int i = 0; i < events.size(); i++) {
 963                 ITmfSyncSequenceDiagramEvent sdEvent = events.get(i);
 964
 965                 // Check message filter
 966                 if (filterMessage(sdEvent)) {
 967                     continue;
 968                 }
 969
 970                 // Set the message sender and receiver
 971                 Lifeline startLifeline = nodeToLifelineMap.get(sdEvent.getSender());
 972                 Lifeline endLifeline = nodeToLifelineMap.get(sdEvent.getReceiver());
 973
 974                 // Check if any of the lifelines were filtered
 975                 if ((startLifeline == null) || (endLifeline == null)) {
 976                     continue;
 977                 }
 978
 979                 int tmp = Math.max(startLifeline.getEventOccurrence(), endLifeline.getEventOccurrence());
 980                 eventOccurence = Math.max(eventOccurence, tmp);
 981
 982                 startLifeline.setCurrentEventOccurrence(eventOccurence);
 983                 endLifeline.setCurrentEventOccurrence(eventOccurence);
 984
 985                 TmfSyncMessage message = new TmfSyncMessage(sdEvent, eventOccurence++);
 986
 987                 message.setStartLifeline(startLifeline);
 988                 message.setEndLifeline(endLifeline);
 989
 990                 message.setTime(sdEvent.getStartTime());
 991
 992                 // add the message to the frame
 993                 frame.addMessage(message);
 994
 995             }
 996             fLock.lock();
 997             try {
 998                 if (!fView.getSDWidget().isDisposed()) {
 999                     fView.getSDWidget().getDisplay().asyncExec(new Runnable() {
1000
1001                         @Override
1002                         public void run() {
1003
1004                             fLock.lock();
1005                             try {
1006                                 // check if view was disposed in the meanwhile
1007                                 if ((fView != null) && (!fView.getSDWidget().isDisposed())) {
1008                                     fFrame = frame;
1009                                     fView.setFrame(fFrame);
1010
1011                                     if (fCurrentTime != null) {
1012                                         moveToMessageInPage();
1013                                     }
1014
1015                                     if (fFindCriteria != null) {
1016                                         find(fFindCriteria);
1017                                     }
1018
1019                                     fView.toggleWaitCursorAsync(false);
1020                                 }
1021                             }  finally {
1022                                 fLock.unlock();
1023                             }
1024
1025                         }
1026                     });
1027                 }
1028             }
1029             finally {
1030                 fLock.unlock();
1031             }
1032         }
1033     }
1034
1035     /**
1036      * Moves to a certain message defined by timestamp (across pages)
1037      */
1038     protected void moveToMessage() {
1039         int page = 0;
1040
1041         fLock.lock();
1042         try {
1043             page = getPage(fCurrentTime);
1044
1045             if (page == fCurrentPage) {
1046                 moveToMessageInPage();
1047                 return;
1048             }
1049             fCurrentPage = page;
1050             moveToPage(false);
1051         } finally {
1052             fLock.unlock();
1053         }
1054     }
1055
1056     /**
1057      * Moves to a certain message defined by timestamp in current page
1058      */
1059     protected void moveToMessageInPage() {
1060         fLock.lock();
1061         try {
1062                 if (!fView.getSDWidget().isDisposed()) {
1063                         // Check for GUI thread
1064                         if(Display.getCurrent() != null) {
1065                                 // Already in GUI thread - execute directly
1066                                 TmfSyncMessage prevMessage = null;
1067                                 TmfSyncMessage syncMessage = null;
1068                                 boolean isExactTime = false;
1069                                 for (int i = 0; i < fFrame.syncMessageCount(); i++) {
1070                                         if (fFrame.getSyncMessage(i) instanceof TmfSyncMessage) {
1071                                                 syncMessage = (TmfSyncMessage) fFrame.getSyncMessage(i);
1072                                                 if (syncMessage.getStartTime().compareTo(fCurrentTime, false) == 0) {
1073                                                         isExactTime = true;
1074                                                         break;
1075                                                 } else if ((syncMessage.getStartTime().compareTo(fCurrentTime, false) > 0) && (prevMessage != null)) {
1076                                                     syncMessage = prevMessage;
1077                                                     break;
1078                                                 }
1079                                                 prevMessage = syncMessage;
1080                                         }
1081                                 }
1082                                 if (fIsSelect && isExactTime) {
1083                                         fView.getSDWidget().moveTo(syncMessage);
1084                                 }
1085                                 else {
1086                                         fView.getSDWidget().ensureVisible(syncMessage);
1087                                         fView.getSDWidget().clearSelection();
1088                                         fView.getSDWidget().redraw();
1089                                 }
1090                         }
1091                         else {
1092                                 // Not in GUI thread - queue action in GUI thread.
1093                                 fView.getSDWidget().getDisplay().asyncExec(new Runnable() {
1094                                         @Override
1095                                         public void run() {
1096                                                 moveToMessageInPage();
1097                                         }
1098                                 });
1099                         }
1100                 }
1101         }
1102         finally {
1103             fLock.unlock();
1104         }
1105     }
1106
1107     /**
1108      * Moves to a certain message defined by timestamp (across pages)
1109      */
1110     protected void moveToPage() {
1111         moveToPage(true);
1112     }
1113
1114     /**
1115      * Moves to a certain page.
1116      *
1117      * @param notifyAll true to broadcast time range signal to other signal handlers else false
1118      */
1119     protected void moveToPage(boolean notifyAll) {
1120
1121         TmfTimeRange window = null;
1122
1123         fLock.lock();
1124         try {
1125             // Safety check
1126             if (fCurrentPage > fCheckPoints.size()) {
1127                 return;
1128             }
1129             window = fCheckPoints.get(fCurrentPage);
1130         } finally {
1131             fLock.unlock();
1132         }
1133
1134         if (window == null) {
1135             window = TmfTimeRange.ETERNITY;
1136         }
1137
1138         fPageRequest = new TmfEventRequest(ITmfEvent.class, window, TmfDataRequest.ALL_DATA, 1, ITmfDataRequest.ExecutionType.FOREGROUND) {
1139             private final List<ITmfSyncSequenceDiagramEvent> fSdEvent = new ArrayList<ITmfSyncSequenceDiagramEvent>();
1140
1141             @Override
1142             public void handleData(ITmfEvent event) {
1143                 super.handleData(event);
1144
1145                 ITmfSyncSequenceDiagramEvent sdEvent = getSequenceDiagramEvent(event);
1146
1147                 if (sdEvent != null) {
1148                     fSdEvent.add(sdEvent);
1149                 }
1150             }
1151
1152             @Override
1153             public void handleSuccess() {
1154                 fillCurrentPage(fSdEvent);
1155                 super.handleSuccess();
1156             }
1157
1158         };
1159
1160         fTrace.sendRequest(fPageRequest);
1161
1162         if (notifyAll) {
1163             TmfTimeRange timeRange = getSignalTimeRange(window.getStartTime());
1164             broadcast(new TmfRangeSynchSignal(this, timeRange, timeRange.getStartTime()));
1165         }
1166     }
1167
1168     /**
1169      * Gets page that contains timestamp
1170      *
1171      * @param time The timestamp
1172      * @return page that contains the time
1173      */
1174     protected int getPage(ITmfTimestamp time) {
1175         int page;
1176         int size;
1177         fLock.lock();
1178         try {
1179             size = fCheckPoints.size();
1180             for (page = 0; page < size; page++) {
1181                 TmfTimeRange timeRange = fCheckPoints.get(page);
1182                 if (timeRange.getEndTime().compareTo(time, false) >= 0) {
1183                     break;
1184                 }
1185             }
1186             if (page >= size) {
1187                 page = size - 1;
1188             }
1189             return page;
1190         } finally {
1191             fLock.unlock();
1192         }
1193     }
1194
1195     /**
1196      * Background search in trace for expression in criteria.
1197      *
1198      * @param findCriteria The find criteria
1199      * @return true if background request was started else false
1200      */
1201     protected boolean findInNextPages(Criteria findCriteria) {
1202         fLock.lock();
1203         try {
1204             if (fFindJob != null) {
1205                 return true;
1206             }
1207
1208             int nextPage = fCurrentPage + 1;
1209
1210             if ((nextPage) >= fCheckPoints.size()) {
1211                 // we are at the end
1212                 return false;
1213             }
1214
1215             TmfTimeRange window = new TmfTimeRange(fCheckPoints.get(nextPage).getStartTime(), fCheckPoints.get(fCheckPoints.size()-1).getEndTime());
1216             fFindJob = new SearchJob(findCriteria, window);
1217             fFindJob.schedule();
1218             fView.toggleWaitCursorAsync(true);
1219         } finally {
1220             fLock.unlock();
1221         }
1222         return true;
1223     }
1224
1225     /**
1226      * Gets time range for time range signal.
1227      *
1228      * @param startTime The start time of time range.
1229      * @return the time range
1230      */
1231     protected TmfTimeRange getSignalTimeRange(ITmfTimestamp startTime) {
1232         fLock.lock();
1233         try {
1234             long offset = fTrace == null ? 0 : fTrace.getCurrentRange().getEndTime().getDelta(fTrace.getCurrentRange().getStartTime()).normalize(0, startTime.getScale()).getValue();
1235             TmfTimestamp initialEndOfWindow = new TmfTimestamp(startTime.getValue() + offset, startTime.getScale(), startTime.getPrecision());
1236             return new TmfTimeRange(startTime, initialEndOfWindow);
1237         }
1238         finally {
1239             fLock.unlock();
1240         }
1241     }
1242
1243     /**
1244      * Checks if filter criteria matches the message name in given SD event.
1245      *
1246      * @param sdEvent The SD event to check
1247      * @return true if match else false.
1248      */
1249     protected boolean filterMessage(ITmfSyncSequenceDiagramEvent sdEvent) {
1250         fLock.lock();
1251         try {
1252             if (fFilterCriteria != null) {
1253                 for(FilterCriteria criteria : fFilterCriteria) {
1254                     if (criteria.isActive() && criteria.getCriteria().isSyncMessageSelected() && criteria.getCriteria().matches(sdEvent.getName())) {
1255                         return true;
1256                     }
1257                 }
1258             }
1259         } finally {
1260             fLock.unlock();
1261         }
1262         return false;
1263     }
1264
1265     /**
1266      * Checks if filter criteria matches a lifeline name (sender or receiver) in given SD event.
1267      *
1268      * @param lifeline the message receiver
1269      * @return true if match else false.
1270      */
1271     protected boolean filterLifeLine(String lifeline) {
1272         fLock.lock();
1273         try {
1274             if (fFilterCriteria != null) {
1275                 for(FilterCriteria criteria : fFilterCriteria) {
1276                     if (criteria.isActive() && criteria.getCriteria().isLifeLineSelected() && criteria.getCriteria().matches(lifeline)) {
1277                         return true;
1278                     }
1279                 }
1280             }
1281         } finally {
1282             fLock.unlock();
1283         }
1284         return false;
1285     }
1286
1287     /**
1288      * Job to search in trace for given time range.
1289      */
1290     protected class SearchJob extends Job {
1291
1292         /**
1293          * The search event request.
1294          */
1295         final protected SearchEventRequest fSearchRequest;
1296
1297         /**
1298          * Constructor
1299          *
1300          * @param findCriteria The search criteria
1301          * @param window Time range to search in
1302          */
1303         public SearchJob(Criteria findCriteria, TmfTimeRange window) {
1304             super(Messages.TmfUml2SDSyncLoader_SearchJobDescrition);
1305             fSearchRequest = new SearchEventRequest(window, TmfDataRequest.ALL_DATA, 1, ITmfDataRequest.ExecutionType.FOREGROUND, findCriteria);
1306         }
1307
1308         /*
1309          * (non-Javadoc)
1310          * @see org.eclipse.core.runtime.jobs.Job#run(org.eclipse.core.runtime.IProgressMonitor)
1311          */
1312         @Override
1313         protected IStatus run(IProgressMonitor monitor) {
1314             fSearchRequest.setMonitor(monitor);
1315
1316             fTrace.sendRequest(fSearchRequest);
1317
1318             try {
1319                 fSearchRequest.waitForCompletion();
1320             } catch (InterruptedException e) {
1321                 Activator.getDefault().logError("Search request interrupted!", e); //$NON-NLS-1$
1322             }
1323
1324             IStatus status = Status.OK_STATUS;
1325             if (fSearchRequest.isFound() && (fSearchRequest.getFoundTime() != null)) {
1326                 fCurrentTime = fSearchRequest.getFoundTime();
1327
1328                 // Avoid double-selection. Selection will be done when calling find(criteria)
1329                 // after moving to relevant page
1330                 fIsSelect = false;
1331                 if (!fView.getSDWidget().isDisposed()) {
1332                     fView.getSDWidget().getDisplay().asyncExec(new Runnable() {
1333
1334                         @Override
1335                         public void run() {
1336                             moveToMessage();
1337                         }
1338                     });
1339                 }
1340             }
1341             else {
1342                 if (monitor.isCanceled()) {
1343                     status = Status.CANCEL_STATUS;
1344                 }
1345                 else {
1346                     // String was not found
1347                     status = new Status(IStatus.WARNING, Activator.PLUGIN_ID, Messages.TmfUml2SDSyncLoader_SearchNotFound);
1348                 }
1349                 setProperty(IProgressConstants.KEEP_PROPERTY, Boolean.TRUE);
1350             }
1351             monitor.done();
1352
1353             fLock.lock();
1354             try {
1355                 fView.toggleWaitCursorAsync(false);
1356                 fFindJob = null;
1357             } finally {
1358                 fLock.unlock();
1359             }
1360
1361             return status;
1362         }
1363
1364         /*
1365          * (non-Javadoc)
1366          * @see org.eclipse.core.runtime.jobs.Job#canceling()
1367          */
1368         @Override
1369         protected void canceling() {
1370             fSearchRequest.cancel();
1371             fLock.lock();
1372             try {
1373                 fFindJob = null;
1374             } finally {
1375                 fLock.unlock();
1376             }
1377         }
1378     }
1379
1380     /**
1381      *  TMF event request for searching within trace.
1382      */
1383     protected class SearchEventRequest extends TmfEventRequest {
1384
1385         /**
1386          * The find criteria.
1387          */
1388         final private Criteria fCriteria;
1389         /**
1390          * A progress monitor
1391          */
1392         private IProgressMonitor fMonitor;
1393         /**
1394          * Flag to indicate that node was found according the criteria .
1395          */
1396         private boolean fIsFound = false;
1397         /**
1398          * Time stamp of found item.
1399          */
1400         private ITmfTimestamp fFoundTime = null;
1401
1402         /**
1403          * Constructor
1404          * @param range @see org.eclipse.linuxtools.tmf.request.TmfEventRequest#TmfEventRequest(...)
1405          * @param nbRequested @see org.eclipse.linuxtools.tmf.request.TmfEventRequest#handleData(...)
1406          * @param blockSize @see org.eclipse.linuxtools.tmf.request.TmfEventRequest#handleData(...)
1407          * @param execType @see org.eclipse.linuxtools.tmf.request.TmfEventRequest#handleData(...)
1408          * @param criteria The search criteria
1409          */
1410         public SearchEventRequest(TmfTimeRange range, int nbRequested, int blockSize, ExecutionType execType, Criteria criteria) {
1411             this(range, nbRequested, blockSize, execType, criteria, null);
1412         }
1413
1414         /**
1415          * Constructor
1416          * @param range @see org.eclipse.linuxtools.tmf.request.TmfEventRequest#TmfEventRequest(...)
1417          * @param nbRequested @see org.eclipse.linuxtools.tmf.request.TmfEventRequest#TmfEventRequest(...)
1418          * @param blockSize @see org.eclipse.linuxtools.tmf.request.TmfEventRequest#TmfEventRequest(...)
1419          * @param execType @see org.eclipse.linuxtools.tmf.request.TmfEventRequest#TmfEventRequest(...)
1420          * @param criteria The search criteria
1421          * @param monitor progress monitor
1422          */
1423         public SearchEventRequest(TmfTimeRange range, int nbRequested, int blockSize, ExecutionType execType, Criteria criteria, IProgressMonitor monitor) {
1424             super(ITmfEvent.class, range, nbRequested, blockSize, execType);
1425             fCriteria = new Criteria(criteria);
1426             fMonitor = monitor;
1427         }
1428
1429         /*
1430          * (non-Javadoc)
1431          * @see org.eclipse.linuxtools.tmf.request.TmfDataRequest#handleData(org.eclipse.linuxtools.tmf.event.TmfData)
1432          */
1433         @Override
1434         public void handleData(ITmfEvent event) {
1435             super.handleData(event);
1436
1437             if ((fMonitor!= null) && fMonitor.isCanceled()) {
1438                 super.cancel();
1439                 return;
1440             }
1441
1442             ITmfSyncSequenceDiagramEvent sdEvent = getSequenceDiagramEvent(event);
1443
1444             if (sdEvent != null) {
1445
1446                 if (fCriteria.isLifeLineSelected()) {
1447                     if (fCriteria.matches(sdEvent.getSender())) {
1448                         fFoundTime = event.getTimestamp();
1449                         fIsFound = true;
1450                         super.cancel();
1451                     }
1452
1453                     if (fCriteria.matches(sdEvent.getReceiver())) {
1454                         fFoundTime = event.getTimestamp();
1455                         fIsFound = true;
1456                         super.cancel();
1457                     }
1458                 }
1459
1460                 if (fCriteria.isSyncMessageSelected() && fCriteria.matches(sdEvent.getName())) {
1461                     fFoundTime = event.getTimestamp();
1462                     fIsFound = true;
1463                     super.cancel();
1464                 }
1465             }
1466         }
1467
1468         /**
1469          * Set progress monitor.
1470          *
1471          * @param monitor The monitor to assign
1472          */
1473         public void setMonitor(IProgressMonitor monitor) {
1474             fMonitor = monitor;
1475         }
1476
1477         /**
1478          * Check if find criteria was met.
1479          *
1480          * @return true if find criteria was met.
1481          */
1482         public boolean isFound() {
1483             return fIsFound;
1484         }
1485
1486         /**
1487          * Returns timestamp of found time.
1488          *
1489          * @return timestamp of found time.
1490          */
1491         public ITmfTimestamp getFoundTime() {
1492             return fFoundTime;
1493         }
1494     }
1495
1496     /**
1497      * Job class to provide progress monitor feedback.
1498      *
1499      * @version 1.0
1500      * @author Bernd Hufmann
1501      *
1502      */
1503     protected static class IndexingJob extends Job {
1504
1505         /**
1506          * @param name The job name
1507          */
1508         public IndexingJob(String name) {
1509             super(name);
1510         }
1511
1512         @Override
1513         protected IStatus run(IProgressMonitor monitor) {
1514             while (!monitor.isCanceled()) {
1515                 try {
1516                     Thread.sleep(100);
1517                 } catch (InterruptedException e) {
1518                     return Status.OK_STATUS;
1519                 }
1520             }
1521             monitor.done();
1522             return Status.OK_STATUS;
1523         }
1524     }
1525
1526
1527     /**
1528      * Returns sequence diagram event if details in given event are available else null.
1529      *
1530      * @param tmfEvent Event to parse for sequence diagram event details
1531      * @return sequence diagram event if details are available else null
1532      * @since 2.0
1533      */
1534     protected ITmfSyncSequenceDiagramEvent getSequenceDiagramEvent(ITmfEvent tmfEvent){
1535         //type = .*RECEIVE.* or .*SEND.*
1536         //content = sender:<sender name>:receiver:<receiver name>,signal:<signal name>
1537         String eventType = tmfEvent.getType().toString();
1538         if (eventType.contains(Messages.TmfUml2SDSyncLoader_EventTypeSend) || eventType.contains(Messages.TmfUml2SDSyncLoader_EventTypeReceive)) {
1539             Object sender = tmfEvent.getContent().getField(Messages.TmfUml2SDSyncLoader_FieldSender);
1540             Object receiver = tmfEvent.getContent().getField(Messages.TmfUml2SDSyncLoader_FieldReceiver);
1541             Object name = tmfEvent.getContent().getField(Messages.TmfUml2SDSyncLoader_FieldSignal);
1542             if ((sender instanceof ITmfEventField) && (receiver instanceof ITmfEventField) && (name instanceof ITmfEventField)) {
1543                 ITmfSyncSequenceDiagramEvent sdEvent = new TmfSyncSequenceDiagramEvent(tmfEvent,
1544                                 ((ITmfEventField) sender).getValue().toString(),
1545                                 ((ITmfEventField) receiver).getValue().toString(),
1546                                 ((ITmfEventField) name).getValue().toString());
1547
1548                 return sdEvent;
1549             }
1550         }
1551         return null;
1552     }
1553 }