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