tmf/org.eclipse.tracecompass.tmf.ui.tests/widgetStubs/org/eclipse/tracecompass/tmf/ui/tests/uml2sd/load/TestLoaders.java

   1 /*******************************************************************************
   2  * Copyright (c) 2013, 2014 Ericsson
   3  * All rights reserved. This program and the accompanying materials
   4  * are made available under the terms of the Eclipse Public License v1.0
   5  * which accompanies this distribution, and is available at
   6  * http://www.eclipse.org/legal/epl-v10.html
   7  *
   8  * Contributors:
   9  *     Bernd Hufmann - Initial API and implementation
  10  *******************************************************************************/
  11
  12 package org.eclipse.tracecompass.tmf.ui.tests.uml2sd.load;
  13
  14 import java.net.URL;
  15 import java.util.ArrayList;
  16 import java.util.List;
  17
  18 import org.eclipse.jface.action.Action;
  19 import org.eclipse.jface.resource.ImageDescriptor;
  20 import org.eclipse.jface.viewers.ISelection;
  21 import org.eclipse.jface.viewers.StructuredSelection;
  22 import org.eclipse.swt.graphics.Image;
  23 import org.eclipse.tracecompass.tmf.core.timestamp.TmfTimestamp;
  24 import org.eclipse.tracecompass.tmf.ui.views.uml2sd.SDView;
  25 import org.eclipse.tracecompass.tmf.ui.views.uml2sd.core.AsyncMessageReturn;
  26 import org.eclipse.tracecompass.tmf.ui.views.uml2sd.core.BasicExecutionOccurrence;
  27 import org.eclipse.tracecompass.tmf.ui.views.uml2sd.core.EllipsisMessage;
  28 import org.eclipse.tracecompass.tmf.ui.views.uml2sd.core.ExecutionOccurrence;
  29 import org.eclipse.tracecompass.tmf.ui.views.uml2sd.core.Frame;
  30 import org.eclipse.tracecompass.tmf.ui.views.uml2sd.core.GraphNode;
  31 import org.eclipse.tracecompass.tmf.ui.views.uml2sd.core.HotSpot;
  32 import org.eclipse.tracecompass.tmf.ui.views.uml2sd.core.Lifeline;
  33 import org.eclipse.tracecompass.tmf.ui.views.uml2sd.core.LifelineCategories;
  34 import org.eclipse.tracecompass.tmf.ui.views.uml2sd.core.Stop;
  35 import org.eclipse.tracecompass.tmf.ui.views.uml2sd.core.SyncMessage;
  36 import org.eclipse.tracecompass.tmf.ui.views.uml2sd.core.SyncMessageReturn;
  37 import org.eclipse.tracecompass.tmf.ui.views.uml2sd.dialogs.Criteria;
  38 import org.eclipse.tracecompass.tmf.ui.views.uml2sd.dialogs.FilterCriteria;
  39 import org.eclipse.tracecompass.tmf.ui.views.uml2sd.drawings.IImage;
  40 import org.eclipse.tracecompass.tmf.ui.views.uml2sd.handlers.provider.ISDFilterProvider;
  41 import org.eclipse.tracecompass.tmf.ui.views.uml2sd.handlers.provider.ISDFindProvider;
  42 import org.eclipse.tracecompass.tmf.ui.views.uml2sd.handlers.provider.ISDGraphNodeSupporter;
  43 import org.eclipse.tracecompass.tmf.ui.views.uml2sd.handlers.provider.ISDPagingProvider;
  44 import org.eclipse.tracecompass.tmf.ui.views.uml2sd.load.IUml2SDLoader;
  45 import org.eclipse.ui.ISelectionListener;
  46 import org.eclipse.ui.IWorkbenchPart;
  47 import org.eclipse.ui.PlatformUI;
  48
  49 /**
  50  * Test loader class.
  51  */
  52 @SuppressWarnings("javadoc")
  53 public class TestLoaders implements IUml2SDLoader, ISDFindProvider, ISDFilterProvider, ISDPagingProvider, ISelectionListener {
  54
  55     public SDView v;
  56     public int page;
  57     private List<GraphNode> findResults = new ArrayList<>();
  58     private Criteria findCriteria;
  59     private int currentFindIndex = 0;
  60
  61     private Frame savedFrame = null;
  62
  63     public TestLoaders() {
  64         this("");
  65     }
  66
  67     /**
  68      * Constructor
  69      *
  70      * @param name
  71      */
  72     public TestLoaders(String name) {
  73         page = 1;
  74     }
  75
  76     @Override
  77     public void setViewer(SDView j) {
  78         PlatformUI.getWorkbench().getActiveWorkbenchWindow().getSelectionService().addPostSelectionListener(this);
  79         v = j;
  80         v.setSDPagingProvider(this);
  81         v.setSDFindProvider(this);
  82         v.setSDFilterProvider(this);
  83         page = 1;
  84         createFrame();
  85     }
  86
  87     @Override
  88     public boolean hasNextPage() {
  89         return page == 1;
  90     }
  91
  92     @Override
  93     public boolean hasPrevPage() {
  94         return page == 2;
  95     }
  96
  97     @Override
  98     public void prevPage() {
  99         page--;
 100         createFrame();
 101     }
 102
 103     @Override
 104     public void nextPage() {
 105         page++;
 106         createFrame();
 107     }
 108
 109     private void createFrame() {
 110         Frame testFrame = new Frame();
 111         if (page == 1) {
 112             testFrame.setName("Sequence Diagram - First Page");
 113             LifelineCategories tt[] = new LifelineCategories[2];
 114             tt[0] = new LifelineCategories();
 115             tt[1] = new LifelineCategories();
 116             tt[1].setName("Categorie 1");
 117             tt[1].setImage(new LocalImageImpl("obj16/node_obj.gif"));
 118             tt[0].setImage(new LocalImageImpl("obj16/class.gif"));
 119             tt[0].setName("Categorie 0");
 120             testFrame.setLifelineCategories(tt);
 121             Lifeline lifeline = new Lifeline();
 122             lifeline.setName("LifeLine 0");
 123             testFrame.addLifeLine(lifeline);
 124             EllipsisMessage mn = new EllipsisMessage();
 125             lifeline.getNewEventOccurrence();
 126             mn.setStartLifeline(lifeline);
 127             mn.setName("******************* EllipsisisMessage TEST ****************");
 128             testFrame.addMessage(mn);
 129             SyncMessage mn3 = new SyncMessage();
 130             mn3.setStartLifeline(lifeline);
 131             testFrame.addMessage(mn3);
 132             SyncMessage mn2 = new SyncMessage();
 133             lifeline.getNewEventOccurrence();
 134             lifeline.setCategory(0);
 135             mn2.setEndLifeline(lifeline);
 136             mn2.setName("*******************Sync TEST ****************");
 137             testFrame.addMessage(mn2);
 138             for (int i = 1; i < 300; i++) {
 139                 lifeline = new Lifeline();
 140                 lifeline.setName((new StringBuilder("LifeLine ")).append(i).toString());
 141                 lifeline.setCategory(1);
 142                 testFrame.addLifeLine(lifeline);
 143                 SyncMessage m3 = new SyncMessage();
 144                 testFrame.getLifeline(i - 1).getNewEventOccurrence();
 145                 m3.setStartLifeline(testFrame.getLifeline(i - 1));
 146                 m3.setEndLifeline(testFrame.getLifeline(i));
 147                 m3.setName((new StringBuilder("Sync Message ")).append(i).toString());
 148                 testFrame.addMessage(m3);
 149 //                if (i == 11)
 150 //                    m3.setTime(new TmfTimestamp(i - 400));
 151 //                else if (i == 6)
 152 //                    m3.setTime(new TmfTimestamp(i));
 153 //                else
 154                     m3.setTime(TmfTimestamp.fromSeconds(i + 1));
 155             }
 156
 157             for (int i = testFrame.lifeLinesCount() - 1; i > 0; i--) {
 158                 SyncMessageReturn m = new SyncMessageReturn();
 159                 testFrame.getLifeline(i).getNewEventOccurrence();
 160                 m.setStartLifeline(testFrame.getLifeline(i));
 161                 m.setEndLifeline(testFrame.getLifeline(i - 1));
 162                 testFrame.addMessage(m);
 163                 m.setName((new StringBuilder("Sync Message return ")).append(i).toString());
 164                 if (i + 1 < testFrame.lifeLinesCount()) {
 165                     SyncMessage h = testFrame.getSyncMessage(i + 1);
 166                     m.setMessage(h);
 167                 }
 168             }
 169
 170             for (int i = 0; i < testFrame.lifeLinesCount(); i++) {
 171                 if (i > 0) {
 172                     ExecutionOccurrence occ = new ExecutionOccurrence();
 173                     occ.setStartOccurrence(testFrame.getSyncMessage(i).getEventOccurrence() + 1);
 174                     occ.setEndOccurrence(testFrame.getSyncMessageReturn(testFrame.syncMessageReturnCount() - i).getEventOccurrence());
 175                     testFrame.getLifeline(i).addExecution(occ);
 176                     occ.setName("******************* Execution Occurance TEST ****************");
 177                 }
 178             }
 179
 180             Stop s = new Stop();
 181             s.setLifeline(testFrame.getLifeline(1));
 182             s.setEventOccurrence(testFrame.getLifeline(1).getNewEventOccurrence());
 183             testFrame.getLifeline(1).addNode(s);
 184             HotSpot gg = new HotSpot();
 185             gg.setImage(new LocalImageImpl("obj16/plus_obj.gif"));
 186             gg.setExecution((BasicExecutionOccurrence) testFrame.getLifeline(1).getExecutions().get(0));
 187             AsyncMessageReturn m = new AsyncMessageReturn();
 188             m.setStartLifeline(testFrame.getLifeline(1));
 189             m.setEndLifeline(testFrame.getLifeline(3));
 190             m.setStartOccurrence(2);
 191             m.setEndOccurrence(6);
 192             m.setStartTime(TmfTimestamp.fromSeconds(2));
 193             m.setEndTime(TmfTimestamp.fromSeconds(6));
 194             m.setName("*******************Async TEST ****************");
 195             testFrame.addMessage(m);
 196             v.setFrame(testFrame);
 197             v.getSDWidget().setReorderMode(true);
 198         } else {
 199
 200 //        if (page == 2) {
 201             testFrame.setName("Sequence Diagram");
 202             Lifeline lifeline = new Lifeline();
 203             lifeline.setName("LifeLine 0");
 204             testFrame.addLifeLine(lifeline);
 205             lifeline = new Lifeline();
 206             lifeline.setName("LifeLine 1");
 207             testFrame.addLifeLine(lifeline);
 208             for (int i = 1; i < 30; i++) {
 209                 SyncMessage m3 = new SyncMessage();
 210                 m3.autoSetStartLifeline(testFrame.getLifeline(0));
 211                 m3.autoSetEndLifeline(testFrame.getLifeline(0));
 212                 m3.setName((new StringBuilder("Message ")).append(i).toString());
 213                 testFrame.addMessage(m3);
 214                 SyncMessageReturn m = new SyncMessageReturn();
 215                 m.autoSetStartLifeline(testFrame.getLifeline(0));
 216                 m.autoSetEndLifeline(testFrame.getLifeline(0));
 217                 testFrame.addMessage(m);
 218                 m.setName((new StringBuilder("Message return ")).append(i).toString());
 219                 ExecutionOccurrence occ = new ExecutionOccurrence();
 220                 occ.setStartOccurrence(testFrame.getSyncMessage(i - 1).getEventOccurrence());
 221                 occ.setEndOccurrence(testFrame.getSyncMessageReturn(i - 1).getEventOccurrence());
 222                 testFrame.getLifeline(0).addExecution(occ);
 223             }
 224         }
 225         v.setFrame(testFrame);
 226     }
 227
 228     @Override
 229     public boolean find(Criteria toSearch) {
 230         Frame frame = v.getFrame();
 231
 232         if (frame == null) {
 233             return false;
 234         }
 235         if (findResults == null || findCriteria == null || !findCriteria.compareTo(toSearch)) {
 236             findResults = new ArrayList<>();
 237             findCriteria = toSearch;
 238             if (findCriteria.isLifeLineSelected()) {
 239                 for (int i = 0; i < frame.lifeLinesCount(); i++) {
 240                     if (findCriteria.matches(frame.getLifeline(i).getName())) {
 241                         findResults.add(frame.getLifeline(i));
 242                     }
 243                 }
 244
 245             }
 246             ArrayList<GraphNode> msgs = new ArrayList<>();
 247             if (findCriteria.isSyncMessageSelected()) {
 248                 for (int i = 0; i < frame.syncMessageCount(); i++) {
 249                     if (findCriteria.matches(frame.getSyncMessage(i).getName())) {
 250                         msgs.add(frame.getSyncMessage(i));
 251                     }
 252                 }
 253
 254                 for (int i = 0; i < frame.syncMessageReturnCount(); i++) {
 255                     if (findCriteria.matches(frame.getSyncMessageReturn(i).getName())) {
 256                         msgs.add(frame.getSyncMessageReturn(i));
 257                     }
 258                 }
 259
 260             }
 261             // if(msgs.size() > 0) {
 262             // GraphNode temp[] = msgs.toArray(new GraphNode[0]);
 263             // Arrays.sort(temp, new DateComparator());
 264             // findResults.addAll(Arrays.asList(temp));
 265             // }
 266
 267             msgs = new ArrayList<>();
 268             if (findCriteria.isAsyncMessageSelected()) {
 269                 for (int i = 0; i < frame.asyncMessageCount(); i++) {
 270                     if (findCriteria.matches(frame.getAsyncMessage(i).getName())) {
 271                         msgs.add(frame.getAsyncMessage(i));
 272                     }
 273                 }
 274
 275                 for (int i = 0; i < frame.asyncMessageReturnCount(); i++) {
 276                     if (findCriteria.matches(frame.getAsyncMessageReturn(i).getName())) {
 277                         msgs.add(frame.getAsyncMessageReturn(i));
 278                     }
 279                 }
 280
 281             }
 282             // if(msgs.size() > 0) {
 283             // GraphNode temp[] = msgs.toArray(new GraphNode[0]);
 284             // Arrays.sort(temp, new DateComparator());
 285             // findResults.addAll(Arrays.asList(temp));
 286             // }
 287
 288             List<GraphNode> selection = v.getSDWidget().getSelection();
 289             if (selection != null && selection.size() == 1) {
 290                 currentFindIndex = findResults.indexOf(selection.get(0)) + 1;
 291             } else {
 292                 currentFindIndex = 0;
 293             }
 294         } else {
 295             currentFindIndex++;
 296         }
 297         if (findResults.size() > currentFindIndex) {
 298             GraphNode current = findResults.get(currentFindIndex);
 299             v.getSDWidget().moveTo(current);
 300             return true;
 301         }
 302         // return notFoundYet(findCriteria); // search in other page
 303         return false;
 304     }
 305
 306     @Override
 307     public void cancel() {
 308         findResults = null;
 309         findCriteria = null;
 310         currentFindIndex = 0;
 311     }
 312
 313     public boolean isLifelineSupported() {
 314         return false;
 315     }
 316
 317     public boolean isSyncMessageSupported() {
 318         return false;
 319     }
 320
 321     public boolean isSyncMessageReturnSupported() {
 322         return false;
 323     }
 324
 325     public boolean isAsyncMessageSupported() {
 326         return false;
 327     }
 328
 329     public boolean isAsyncMessageReturnSupported() {
 330         return false;
 331     }
 332
 333     public boolean isStopSupported() {
 334         return false;
 335     }
 336
 337     public Action getFindAction() {
 338         return null;
 339     }
 340
 341     @Override
 342     public boolean filter(List<FilterCriteria> filters) {
 343
 344         if (savedFrame != null) {
 345             savedFrame = v.getFrame();
 346         }
 347
 348         Frame frame = v.getFrame();
 349
 350         if (frame == null) {
 351             return false;
 352         }
 353
 354         if (filters.size() != 1) {
 355             return false;
 356         }
 357
 358         FilterCriteria filterCriteria = filters.get(0);
 359
 360         // One way is to set visiblity of the item, but this only works for messages and not
 361         // for lifelines! It's better to create a new frame without the filtered messages.
 362         boolean found = false;
 363         if (filterCriteria.getCriteria().isSyncMessageSelected()) {
 364             for (int i = 0; i < frame.syncMessageCount(); i++) {
 365                 if (filterCriteria.getCriteria().matches(frame.getSyncMessage(i).getName())) {
 366                     frame.getSyncMessage(i).setVisible(false);
 367                     found = true;
 368                 }
 369             }
 370
 371             for (int i = 0; i < frame.syncMessageReturnCount(); i++) {
 372                 if (filterCriteria.getCriteria().matches(frame.getSyncMessageReturn(i).getName())) {
 373                     frame.getSyncMessageReturn(i).setVisible(false);
 374                     found = true;
 375                 }
 376             }
 377         }
 378
 379         v.getSDWidget().redraw();
 380         return found;
 381     }
 382
 383     public ArrayList<?> getCurrentFilters() {
 384         return null;
 385     }
 386
 387     @Override
 388     public String getTitleString() {
 389         return "Test Loader";
 390     }
 391
 392     @Override
 393     public void dispose() {
 394     }
 395
 396
 397     @Override
 398     public void selectionChanged(IWorkbenchPart part, ISelection selection) {
 399         ISelection sel = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getSelectionService().getSelection();
 400         if (sel != null && (sel instanceof StructuredSelection)) {
 401             StructuredSelection stSel = (StructuredSelection) sel;
 402             if (stSel.getFirstElement() instanceof HotSpot) {
 403                 // OpenToolBox gg = new OpenToolBox(v);
 404                 // gg.run();
 405             }
 406         }
 407     }
 408
 409     @Override
 410     public boolean isNodeSupported(int nodeType) {
 411         switch (nodeType) {
 412         case ISDGraphNodeSupporter.LIFELINE:
 413         case ISDGraphNodeSupporter.SYNCMESSAGE:
 414         case ISDGraphNodeSupporter.SYNCMESSAGERETURN:
 415         case ISDGraphNodeSupporter.ASYNCMESSAGE:
 416         case ISDGraphNodeSupporter.ASYNCMESSAGERETURN:
 417         case ISDGraphNodeSupporter.STOP:
 418             return true;
 419
 420         default:
 421             break;
 422         }
 423         return false;
 424     }
 425
 426     @Override
 427     public String getNodeName(int nodeType, String loaderClassName) {
 428         return null;
 429     }
 430
 431     public static class LocalImageImpl implements IImage {
 432         protected Image img;
 433
 434         public LocalImageImpl(String file) {
 435             img = null;
 436             img = getResourceImage(file);
 437         }
 438
 439         public LocalImageImpl(Image img_) {
 440             img = null;
 441             img = img_;
 442         }
 443
 444         public Image getResourceImage(String _name) {
 445             ImageDescriptor imgage;
 446             try {
 447                 URL BASIC_URL = new URL("platform", "localhost", "plugin");
 448                 URL url = new URL(BASIC_URL, (new StringBuilder("plugin/org.eclipse.tracecompass.tmf.ui/icons/")).append(_name).toString());
 449                 imgage = ImageDescriptor.createFromURL(url);
 450                 return imgage.createImage();
 451             } catch (Exception e) {
 452                 System.err.println(e);
 453             }
 454             return null;
 455         }
 456
 457         @Override
 458         public Object getImage() {
 459             return img;
 460         }
 461
 462         @Override
 463         public void dispose() {
 464             if (img != null) {
 465                 img.dispose();
 466             }
 467         }
 468
 469     }
 470
 471     @Override
 472     public void firstPage() {
 473         page = 0;
 474         createFrame();
 475
 476     }
 477
 478     @Override
 479     public void lastPage() {
 480         page = 2;
 481         createFrame();
 482     }
 483 }