org.simantics.interop/src/org/simantics/interop/test/GraphComparatorViewer.java

   1 /*******************************************************************************
   2  * Copyright (c) 2007, 2010 Association for Decentralized Information Management
   3  * in Industry THTH ry.
   4  * All rights reserved. This program and the accompanying materials
   5  * are made available under the terms of the Eclipse Public License v1.0
   6  * which accompanies this distribution, and is available at
   7  * http://www.eclipse.org/legal/epl-v10.html
   8  *
   9  * Contributors:
  10  *     Foster Wheeler Energia Oy - initial API and implementation
  11  *******************************************************************************/
  12 package org.simantics.interop.test;
  13
  14 import java.io.File;
  15 import java.io.FileNotFoundException;
  16 import java.io.FileReader;
  17 import java.io.IOException;
  18 import java.io.PrintStream;
  19 import java.io.Serializable;
  20 import java.util.ArrayList;
  21 import java.util.Collection;
  22 import java.util.HashMap;
  23 import java.util.List;
  24 import java.util.Map;
  25 import java.util.Stack;
  26
  27 import javax.xml.parsers.SAXParser;
  28 import javax.xml.parsers.SAXParserFactory;
  29
  30 import org.eclipse.jface.action.Action;
  31 import org.eclipse.jface.action.IMenuListener;
  32 import org.eclipse.jface.action.IMenuManager;
  33 import org.eclipse.jface.action.MenuManager;
  34 import org.eclipse.jface.dialogs.Dialog;
  35 import org.eclipse.jface.dialogs.IDialogConstants;
  36 import org.eclipse.jface.dialogs.MessageDialog;
  37 import org.eclipse.jface.layout.GridDataFactory;
  38 import org.eclipse.jface.viewers.IStructuredContentProvider;
  39 import org.eclipse.jface.viewers.IStructuredSelection;
  40 import org.eclipse.jface.viewers.LabelProvider;
  41 import org.eclipse.jface.viewers.ListViewer;
  42 import org.eclipse.jface.viewers.Viewer;
  43 import org.eclipse.jface.window.IShellProvider;
  44 import org.eclipse.swt.SWT;
  45 import org.eclipse.swt.dnd.DND;
  46 import org.eclipse.swt.dnd.DropTarget;
  47 import org.eclipse.swt.dnd.DropTargetAdapter;
  48 import org.eclipse.swt.dnd.DropTargetEvent;
  49 import org.eclipse.swt.dnd.TextTransfer;
  50 import org.eclipse.swt.dnd.Transfer;
  51 import org.eclipse.swt.events.SelectionAdapter;
  52 import org.eclipse.swt.events.SelectionEvent;
  53 import org.eclipse.swt.layout.FillLayout;
  54 import org.eclipse.swt.layout.GridData;
  55 import org.eclipse.swt.layout.GridLayout;
  56 import org.eclipse.swt.widgets.Button;
  57 import org.eclipse.swt.widgets.Composite;
  58 import org.eclipse.swt.widgets.Control;
  59 import org.eclipse.swt.widgets.Display;
  60 import org.eclipse.swt.widgets.FileDialog;
  61 import org.eclipse.swt.widgets.Group;
  62 import org.eclipse.swt.widgets.Label;
  63 import org.eclipse.swt.widgets.Shell;
  64 import org.eclipse.swt.widgets.Text;
  65 import org.eclipse.ui.part.ViewPart;
  66 import org.simantics.Simantics;
  67 import org.simantics.db.ReadGraph;
  68 import org.simantics.db.Resource;
  69 import org.simantics.db.Session;
  70 import org.simantics.db.Statement;
  71 import org.simantics.db.common.ResourceArray;
  72 import org.simantics.db.common.request.ReadRequest;
  73 import org.simantics.db.common.utils.NameUtils;
  74 import org.simantics.db.exception.DatabaseException;
  75 import org.simantics.db.exception.ServiceException;
  76 import org.simantics.db.exception.ValidationException;
  77 import org.simantics.db.request.Read;
  78 import org.simantics.db.service.SerialisationSupport;
  79 import org.simantics.interop.test.GraphChanges.Modification;
  80 import org.simantics.layer0.Layer0;
  81 import org.simantics.ui.dnd.LocalObjectTransfer;
  82 import org.simantics.ui.dnd.ResourceReferenceTransfer;
  83 import org.simantics.ui.dnd.ResourceTransferUtils;
  84 import org.simantics.ui.utils.ResourceAdaptionUtils;
  85 import org.simantics.utils.datastructures.BijectionMap;
  86 import org.simantics.utils.datastructures.Pair;
  87 import org.simantics.utils.ui.ExceptionUtils;
  88 import org.xml.sax.Attributes;
  89 import org.xml.sax.InputSource;
  90 import org.xml.sax.SAXException;
  91 import org.xml.sax.XMLReader;
  92 import org.xml.sax.helpers.DefaultHandler;
  93
  94 /**
  95  * Simple multiline text viewer for seeing differences in two subgraphs.
  96  *
  97  * @author Marko Luukkainen <marko.luukkainen@vtt.fi>
  98  *
  99  */
 100 public class GraphComparatorViewer extends ViewPart{
 101
 102         private Session session;
 103
 104         private Composite composite;
 105
 106         private Label resourceText1;
 107         private Label resourceText2;
 108
 109         private Text text1;
 110         private Text text2;
 111
 112
 113         private List<Resource> traversed = new ArrayList<Resource>();
 114         private List<Resource> tested = new ArrayList<Resource>();
 115         private List<Resource> strong = new ArrayList<Resource>();
 116         private List<Resource> nonTraversed = new ArrayList<Resource>();
 117         private List<Resource> nonTested = new ArrayList<Resource>();
 118
 119
 120         @Override
 121         public void createPartControl(Composite parent) {
 122                 composite = new Composite(parent, SWT.NONE);
 123                 composite.setLayout(new GridLayout(2, false));
 124
 125                 session = Simantics.getSession();
 126
 127                 Composite topComposite = new Composite(composite, SWT.BORDER);
 128                 topComposite.setLayout(new GridLayout(3, false));
 129                 text1 = new Text(composite, SWT.MULTI|SWT.V_SCROLL);
 130                 text2 = new Text(composite, SWT.MULTI|SWT.V_SCROLL);
 131
 132                 GridDataFactory.fillDefaults().align(SWT.FILL, SWT.TOP).grab(true, false).span(2, 1).applyTo(topComposite);
 133                 GridDataFactory.fillDefaults().align(SWT.FILL, SWT.FILL).grab(true, true).applyTo(text1);
 134                 GridDataFactory.fillDefaults().align(SWT.FILL, SWT.FILL).grab(true, true).applyTo(text2);
 135
 136                 resourceText1 = createDropLabel(topComposite);
 137                 resourceText2 = createDropLabel(topComposite);
 138
 139                 Button button = new Button(topComposite, SWT.PUSH);
 140                 button.setText("Compare");
 141                 button.addSelectionListener(new SelectionAdapter() {
 142                         @Override
 143                         public void widgetSelected(SelectionEvent e) {
 144                                 compare();
 145                         }
 146                 });
 147
 148                 defaultConf();
 149
 150                 getViewSite().getActionBars().getToolBarManager().add(new Action("Config") {
 151                         @Override
 152                         public void run() {
 153                                 ConfigurationDialog dialog = new ConfigurationDialog(getSite().getShell());
 154                                 dialog.open();
 155                         }
 156                 });
 157
 158         }
 159
 160         private void defaultConf() {
 161                 traversed.clear();
 162                 tested.clear();
 163                 strong.clear();
 164                 nonTested.clear();
 165                 nonTraversed.clear();
 166                 try {
 167                 session.syncRequest(new ReadRequest() {
 168                         @Override
 169                         public void run(ReadGraph graph) throws DatabaseException {
 170                                 Layer0 l0 = Layer0.getInstance(graph);
 171                                 traversed.add(l0.ConsistsOf);
 172                                 tested.add(l0.IsWeaklyRelatedTo);
 173                                 nonTraversed.add(l0.InstanceOf);
 174                         }
 175                 });
 176                 } catch (Exception e) {
 177                         ExceptionUtils.logAndShowError(e);
 178                 }
 179         }
 180
 181         private void compare() {
 182                 text1.setText("");
 183                 text2.setText("");
 184                 final Resource r1 = (Resource)resourceText1.getData();
 185                 final Resource r2 = (Resource)resourceText2.getData();
 186                 if (r1 == null || r2 == null) {
 187                         if (r1 == null)
 188                                 text1.setText("Missing input!");
 189                         if (r2 == null)
 190                                 text2.setText("Missing input!");
 191                         return;
 192                 }
 193
 194                 session.asyncRequest(new ReadRequest() {
 195
 196                         @Override
 197                         public void run(final ReadGraph graph) throws DatabaseException {
 198                                 GraphComparator comparator = new GraphComparator(r1,r2);
 199
 200                                 comparator.addTested(tested);
 201                                 comparator.addTraversed(traversed);
 202                                 comparator.addNonTested(nonTested);
 203                                 comparator.addNonTraversed(nonTraversed);
 204                                 comparator.addStrong(strong);
 205
 206                                 comparator.test(graph);
 207                                 BijectionMap<Statement, Statement> map = comparator.getComparableStatements();
 208                                 Map<Statement, Integer> indices = new HashMap<Statement, Integer>();
 209                                 final StringBuilder sb1 = new StringBuilder();
 210                                 final StringBuilder sb2 = new StringBuilder();
 211                                 int index = 0;
 212
 213                                 GraphChanges changes = comparator.getChanges();
 214
 215                                 for (Modification mod : changes.getModifications()) {
 216                                         {
 217                                                 String sub;
 218                                                 try {
 219                                                         Statement s = mod.getLeftStm();
 220                                                         sub = NameUtils.getSafeName(graph, mod.getLeftSub());
 221                                                         String pre = NameUtils.getSafeName(graph, s.getPredicate());
 222                                                         String obj = NameUtils.getSafeName(graph, s.getObject());
 223                                                         if (map.containsLeft(s)) {
 224                                                                 index++;
 225                                                                 indices.put(s, index);
 226                                                                 sb1.append("["+index + "] ");
 227                                                         }
 228                                                         sb1.append(sub + " - " + pre + " - " + obj);
 229                                                         sb1.append(" ["+s.getSubject().getResourceId() + " " + s.getPredicate().getResourceId() + " " + s.getObject().getResourceId()+"]");
 230                                                         sb1.append("\n");
 231                                                 } catch (ValidationException e) {
 232                                                         e.printStackTrace();
 233                                                 } catch (ServiceException e) {
 234                                                         e.printStackTrace();
 235                                                 }
 236                                         }
 237                                         {
 238                                                 String sub;
 239                                                 try {
 240                                                         Statement s = mod.getRightStm();
 241                                                         sub = NameUtils.getSafeName(graph, mod.getRightSub());
 242                                                         String pre = NameUtils.getSafeName(graph, s.getPredicate());
 243                                                         String obj = NameUtils.getSafeName(graph, s.getObject());
 244                                                         if (map.containsRight(s)) {
 245                                                                 index = indices.get(map.getLeft(s));
 246                                                                 sb2.append("["+index + "] ");
 247                                                         }
 248                                                         sb2.append(sub + " - " + pre + " - " + obj);
 249                                                         sb2.append(" ["+s.getSubject().getResourceId() + " " + s.getPredicate().getResourceId() + " " + s.getObject().getResourceId()+"]");
 250                                                         sb2.append("\n");
 251                                                 } catch (ValidationException e) {
 252                                                         e.printStackTrace();
 253                                                 } catch (ServiceException e) {
 254                                                         e.printStackTrace();
 255                                                 }
 256                                         }
 257                                 }
 258                                 for (Statement s : changes.getDeletions()) {
 259                                         String sub;
 260                                         try {
 261
 262                                                 sub = NameUtils.getSafeName(graph, s.getSubject());
 263                                                 String pre = NameUtils.getSafeName(graph, s.getPredicate());
 264                                                 String obj = NameUtils.getSafeName(graph, s.getObject());
 265                                                 if (map.containsLeft(s)) {
 266                                                         index++;
 267                                                         indices.put(s, index);
 268                                                         sb1.append("["+index + "] ");
 269                                                 }
 270                                                 sb1.append(sub + " - " + pre + " - " + obj);
 271                                                 sb1.append(" ["+s.getSubject().getResourceId() + " " + s.getPredicate().getResourceId() + " " + s.getObject().getResourceId()+"]");
 272                                                 sb1.append("\n");
 273                                         } catch (ValidationException e) {
 274                                                 e.printStackTrace();
 275                                         } catch (ServiceException e) {
 276                                                 e.printStackTrace();
 277                                         }
 278
 279                                 }
 280
 281                                 for (Statement s : changes.getAdditions()) {
 282                                         String sub;
 283                                         try {
 284                                                 sub = NameUtils.getSafeName(graph, s.getSubject());
 285                                                 String pre = NameUtils.getSafeName(graph, s.getPredicate());
 286                                                 String obj = NameUtils.getSafeName(graph, s.getObject());
 287                                                 if (map.containsRight(s)) {
 288                                                         index = indices.get(map.getLeft(s));
 289                                                         sb2.append("["+index + "] ");
 290                                                 }
 291                                                 sb2.append(sub + " - " + pre + " - " + obj);
 292                                                 sb2.append(" ["+s.getSubject().getResourceId() + " " + s.getPredicate().getResourceId() + " " + s.getObject().getResourceId()+"]");
 293                                                 sb2.append("\n");
 294                                         } catch (ValidationException e) {
 295                                                 e.printStackTrace();
 296                                         } catch (ServiceException e) {
 297                                                 e.printStackTrace();
 298                                         }
 299
 300                                 }
 301                                 Display.getDefault().asyncExec(new Runnable() {
 302                                         @Override
 303                                         public void run() {
 304                                                 text1.setText(sb1.toString());
 305                                                 text2.setText(sb2.toString());
 306
 307                                         }
 308                                 });
 309                         }
 310                 });
 311         }
 312
 313         @Override
 314         public void setFocus() {
 315                 composite.setFocus();
 316         }
 317
 318         @Override
 319         public void dispose() {
 320                 super.dispose();
 321
 322         }
 323
 324
 325         // copy-paste from GraphDebugger
 326          public Label createDropLabel(Composite parent) {
 327                 final Label label = new Label(parent, SWT.BORDER);
 328                 label.setAlignment(SWT.CENTER);
 329                 label.setText("Drag a resource here to examine it in this debugger!");
 330                 label.setForeground(parent.getDisplay().getSystemColor(SWT.COLOR_DARK_GRAY));
 331                 GridData data = new GridData(SWT.FILL, SWT.TOP, true, false);
 332                 data.heightHint = 16;
 333                 label.setLayoutData(data);
 334
 335                 // Add resource id drop support to the drop-area.
 336                 DropTarget dropTarget = new DropTarget(label, DND.DROP_LINK | DND.DROP_COPY);
 337                 dropTarget.setTransfer(new Transfer[] { TextTransfer.getInstance(), ResourceReferenceTransfer.getInstance(), LocalObjectTransfer.getTransfer() });
 338                 dropTarget.addDropListener(new DropTargetAdapter() {
 339                     @Override
 340                     public void dragEnter(DropTargetEvent event) {
 341                         event.detail = DND.DROP_LINK;
 342                         //label.setBackground(green);
 343                         return;
 344                     }
 345                     @Override
 346                     public void dragLeave(DropTargetEvent event) {
 347                         label.setBackground(null);
 348                     }
 349
 350                     @Override
 351                     public void drop(DropTargetEvent event) {
 352                         label.setBackground(null);
 353                         ResourceArray[] data = parseEventData(event);
 354                         if (data == null || data.length != 1) {
 355                             event.detail = DND.DROP_NONE;
 356                             return;
 357                         }
 358                         final ResourceArray array = data[0];
 359                         final Resource r = array.resources[array.resources.length - 1];
 360
 361                         label.setData(r);
 362                         try {
 363                                                 label.setText(session.syncRequest(new Read<String>() {
 364                                                         @Override
 365                                                         public String perform(ReadGraph graph)
 366                                                                 throws DatabaseException {
 367                                                                 return NameUtils.getSafeName(graph, r);
 368                                                         }
 369                                                 }));
 370                                         } catch (DatabaseException e) {
 371                                                 e.printStackTrace();
 372                                         }
 373                     }
 374
 375                     private ResourceArray[] parseEventData(DropTargetEvent event) {
 376                         //System.out.println("DATA: " + event.data);
 377                         if (event.data instanceof String) {
 378                             try {
 379                                 SerialisationSupport support = session.getService(SerialisationSupport.class);
 380                                 return ResourceTransferUtils.readStringTransferable(support, (String) event.data).toResourceArrayArray();
 381                             } catch (IllegalArgumentException e) {
 382                                 e.printStackTrace();
 383                             } catch (DatabaseException e) {
 384                                 e.printStackTrace();
 385                             }
 386                         }
 387                         ResourceArray[] ret = ResourceAdaptionUtils.toResourceArrays(event.data);
 388                         if (ret.length > 0)
 389                             return ret;
 390                         return null;
 391                     }
 392                 });
 393
 394                 return label;
 395             }
 396
 397
 398
 399         private class ConfigurationDialog extends Dialog {
 400
 401                 protected ConfigurationDialog(Shell parentShell) {
 402                         super(parentShell);
 403                 }
 404
 405                 @Override
 406                 protected void createButtonsForButtonBar(Composite parent) {
 407                         createButton(parent, IDialogConstants.OK_ID, IDialogConstants.OK_LABEL, true);
 408                         createButton(parent, IDialogConstants.CLIENT_ID+1, "Load", false);
 409                         createButton(parent, IDialogConstants.CLIENT_ID+2, "Save", false);
 410                 }
 411
 412                 @Override
 413                 protected void buttonPressed(int buttonId) {
 414                         super.buttonPressed(buttonId);
 415                         if (buttonId == IDialogConstants.CLIENT_ID+1) {
 416                                 //load
 417                                 FileDialog dialog = new FileDialog(Display.getCurrent().getActiveShell(),SWT.OPEN);
 418                                 dialog.setFilterExtensions(new String[]{"*.xml"});
 419                                 String filename = dialog.open();
 420                                 if (filename == null)
 421                                 return;
 422                                 try {
 423                                         load(filename);
 424                                         traversedViewer.refresh();
 425                                         testedViewer.refresh();
 426                                         strongViewer.refresh();
 427                                         nonTestedViewer.refresh();
 428                                         nonTraversedViewer.refresh();
 429                                 } catch (Exception e1) {
 430                                         MessageDialog.openError(Display.getCurrent().getActiveShell(), "Cannot load file" , e1.getMessage());
 431                                 }
 432                         } else if (buttonId == IDialogConstants.CLIENT_ID+2) {
 433                                 //save
 434                                 FileDialog dialog = new FileDialog(Display.getCurrent().getActiveShell(),SWT.SAVE);
 435                         dialog.setFilterExtensions(new String[]{"*.xml"});
 436                         String filename = dialog.open();
 437                         if (filename == null)
 438                                 return;
 439                         try {
 440                                 saveConf(filename);
 441                                 if (!filename.endsWith("xml"))
 442                                         filename += ".xml";
 443                         } catch (FileNotFoundException e1) {
 444                                 MessageDialog.openError(Display.getCurrent().getActiveShell(), "Cannot save file" , e1.getMessage());
 445                                 } catch (IOException e1) {
 446                                         MessageDialog.openError(Display.getCurrent().getActiveShell(), "Cannot save file" , e1.getMessage());
 447                                 } catch (DatabaseException e1) {
 448                                         MessageDialog.openError(Display.getCurrent().getActiveShell(), "Cannot save file" , e1.getMessage());
 449                                 }
 450                         }
 451                 }
 452
 453                 private ListViewer traversedViewer;
 454                 private ListViewer testedViewer;
 455                 private ListViewer strongViewer;
 456                 private ListViewer nonTraversedViewer;
 457                 private ListViewer nonTestedViewer;
 458
 459                 @Override
 460                 protected Control createDialogArea(Composite parent) {
 461                          Composite composite = (Composite) super.createDialogArea(parent);
 462                          composite.setLayout(new FillLayout(SWT.VERTICAL));
 463
 464                          Group group = new Group(composite, SWT.NONE);
 465                          group.setText("Traversed");
 466                          group.setLayout(new FillLayout());
 467                          traversedViewer = new ListViewer(group);
 468
 469                          group = new Group(composite, SWT.NONE);
 470                          group.setText("Tested");
 471                          group.setLayout(new FillLayout());
 472                          testedViewer = new ListViewer(group);
 473
 474                          group = new Group(composite, SWT.NONE);
 475                          group.setText("Strong");
 476                          group.setLayout(new FillLayout());
 477                          strongViewer = new ListViewer(group);
 478
 479                          group = new Group(composite, SWT.NONE);
 480                          group.setText("NonTraversed");
 481                          group.setLayout(new FillLayout());
 482                          nonTraversedViewer = new ListViewer(group);
 483
 484                          group = new Group(composite, SWT.NONE);
 485                          group.setText("NonTested");
 486                          group.setLayout(new FillLayout());
 487                          nonTestedViewer = new ListViewer(group);
 488
 489                          traversedViewer.setContentProvider(new ResourceListContentProvider());
 490                          traversedViewer.setLabelProvider(new ResourceLabelProvider());
 491
 492                          testedViewer.setContentProvider(new ResourceListContentProvider());
 493                          testedViewer.setLabelProvider(new ResourceLabelProvider());
 494
 495                          strongViewer.setContentProvider(new ResourceListContentProvider());
 496                          strongViewer.setLabelProvider(new ResourceLabelProvider());
 497
 498                          nonTraversedViewer.setContentProvider(new ResourceListContentProvider());
 499                          nonTraversedViewer.setLabelProvider(new ResourceLabelProvider());
 500
 501                          nonTestedViewer.setContentProvider(new ResourceListContentProvider());
 502                          nonTestedViewer.setLabelProvider(new ResourceLabelProvider());
 503
 504                          MenuManager strongManager = new MenuManager();
 505                          strongManager.setRemoveAllWhenShown(true);
 506                          strongManager.addMenuListener(new ListPopupListener(strongViewer));
 507                          strongViewer.getControl().setMenu(strongManager.createContextMenu(strongViewer.getControl()));
 508
 509                          MenuManager nonTestedManager = new MenuManager();
 510                          nonTestedManager.setRemoveAllWhenShown(true);
 511                          nonTestedManager.addMenuListener(new ListPopupListener(nonTestedViewer));
 512                          nonTestedViewer.getControl().setMenu(nonTestedManager.createContextMenu(nonTestedViewer.getControl()));
 513
 514                          MenuManager nonTraversedManager = new MenuManager();
 515                          nonTraversedManager.setRemoveAllWhenShown(true);
 516                          nonTraversedManager.addMenuListener(new ListPopupListener(nonTraversedViewer));
 517                          nonTraversedViewer.getControl().setMenu(nonTraversedManager.createContextMenu(nonTraversedViewer.getControl()));
 518
 519                          MenuManager testedManager = new MenuManager();
 520                          testedManager.setRemoveAllWhenShown(true);
 521                          testedManager.addMenuListener(new ListPopupListener(testedViewer));
 522                          testedViewer.getControl().setMenu(testedManager.createContextMenu(testedViewer.getControl()));
 523
 524                          MenuManager traversedManager = new MenuManager();
 525                          traversedManager.setRemoveAllWhenShown(true);
 526                          traversedManager.addMenuListener(new ListPopupListener(traversedViewer));
 527                          traversedViewer.getControl().setMenu(traversedManager.createContextMenu(traversedViewer.getControl()));
 528
 529                          traversedViewer.setInput(traversed);
 530                          testedViewer.setInput(tested);
 531                          strongViewer.setInput(strong);
 532                          nonTestedViewer.setInput(nonTested);
 533                          nonTraversedViewer.setInput(nonTraversed);
 534
 535                          return composite;
 536                 }
 537
 538         }
 539
 540         private class ListPopupListener implements IMenuListener {
 541                 private ListViewer viewer;
 542
 543                 public ListPopupListener(ListViewer viewer) {
 544                         this.viewer = viewer;
 545                 }
 546
 547                 @Override
 548                 public void menuAboutToShow(IMenuManager manager) {
 549                         IStructuredSelection s = (IStructuredSelection)viewer.getSelection();
 550                         List<Object> list = (List<Object>)viewer.getInput();
 551                         manager.add(new AddAction(viewer, list));
 552                         if (!s.isEmpty()) {
 553                                 Object element = s.getFirstElement();
 554                                 manager.add(new DeleteAction(viewer, list, element));
 555                         }
 556
 557                 }
 558         }
 559
 560         private class DeleteAction extends Action {
 561                 private Viewer viewer;
 562                 private List<?> list;
 563                 private Object obj;
 564                 public DeleteAction(Viewer viewer, List<?> list, Object obj) {
 565                         super("Delete");
 566                         this.list = list;
 567                         this.obj = obj;
 568                         this.viewer = viewer;
 569                 }
 570
 571                 @Override
 572                 public void run() {
 573                         list.remove(obj);
 574                         viewer.refresh();
 575                 }
 576         }
 577
 578         private class AddAction extends Action {
 579                 private Viewer viewer;
 580                 private List<Object> list;
 581                 public AddAction(Viewer viewer, List<Object> list) {
 582                         super("Add");
 583                         this.list = list;
 584                         this.viewer = viewer;
 585                 }
 586
 587                 @Override
 588                 public void run() {
 589                         RelationChooseDialog dialog = new RelationChooseDialog(getSite().getShell());
 590                         if (dialog.open() == RelationChooseDialog.OK) {
 591                                 final String uri = dialog.getUri();
 592                                 try {
 593                                         Resource res = session.syncRequest(new Read<Resource>() {
 594                                                 @Override
 595                                                 public Resource perform(ReadGraph graph)
 596                                                                 throws DatabaseException {
 597                                                         try {
 598                                                                 return graph.getResource(uri);
 599                                                         } catch (Exception e) {
 600                                                                 return null;
 601                                                         }
 602                                                 }
 603                                         });
 604                                         if (res != null) {
 605                                                 list.add(res);
 606                                                 viewer.refresh();
 607                                         } else {
 608                                                 MessageDialog.openError(getSite().getShell(), "Error", "Relation '" + uri + "' not found.");
 609                                         }
 610                                 } catch (Exception e) {
 611
 612                                 }
 613
 614
 615                         }
 616
 617                 }
 618         }
 619
 620         private class RelationChooseDialog extends Dialog {
 621
 622                 private String uri = null;
 623                 private Text text;
 624                 public RelationChooseDialog(IShellProvider parentShell) {
 625                         super(parentShell);
 626                 }
 627
 628                 public RelationChooseDialog(Shell parentShell) {
 629                         super(parentShell);
 630                 }
 631
 632                 @Override
 633                 protected Control createDialogArea(Composite parent) {
 634                         Composite composite = (Composite) super.createDialogArea(parent);
 635                         composite.setLayout(new GridLayout(2, false));
 636                         Label label = new Label(composite, SWT.NONE);
 637                         label.setText("URI:");
 638
 639                         text = new Text(composite, SWT.SINGLE | SWT.BORDER);
 640                         text.setLayoutData(new GridData(SWT.FILL, SWT.CENTER, true, false));
 641
 642                         return composite;
 643                 }
 644
 645                 @Override
 646                 protected void okPressed() {
 647                         uri = text.getText();
 648                         super.okPressed();
 649                 }
 650
 651                 public String getUri() {
 652                         return uri;
 653                 }
 654
 655         }
 656
 657         private class ResourceListContentProvider implements IStructuredContentProvider {
 658
 659                 @SuppressWarnings("unchecked")
 660                 @Override
 661                 public Object[] getElements(Object inputElement) {
 662                         List<Resource> list = (List<Resource>)inputElement;
 663                         return list.toArray();
 664                 }
 665
 666                 @Override
 667                 public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {
 668
 669                 }
 670
 671                 @Override
 672                 public void dispose() {
 673
 674                 }
 675         }
 676
 677         private class ResourceLabelProvider extends LabelProvider {
 678
 679                 @Override
 680                 public String getText(Object element) {
 681                         final Resource res = (Resource) element;
 682                         try {
 683                                 return session.syncRequest(new Read<String>() {
 684                                         @Override
 685                                         public String perform(ReadGraph graph) throws DatabaseException {
 686                                                 return NameUtils.getSafeName(graph, res);
 687                                         }
 688                                 });
 689                         } catch (DatabaseException e) {
 690                                 return "Error: " + e.getMessage();
 691                         }
 692                 }
 693
 694         }
 695
 696         private boolean saveConf(String filename) throws IOException, DatabaseException {
 697                 File file = new File(filename);
 698                 if (file.exists()) {
 699                         if(!MessageDialog.openQuestion(Display.getCurrent().getActiveShell(), "Saving compare configuration", "Do you want to overwrite file'" + filename + "'?"))
 700                                 return false;
 701                 } else {
 702                         if(!file.createNewFile())
 703                                 return false;
 704                 }
 705                 final PrintStream ps = new PrintStream(file);
 706                 ps.println("<?xml version=\"1.0\"?>");
 707                 ps.println("<compare>");
 708                 session.syncRequest(new ReadRequest() {
 709
 710                         @Override
 711                         public void run(ReadGraph graph) throws DatabaseException {
 712                                 for (Resource r : traversed) {
 713                                         ps.println("<traversed uri=\"" + graph.getURI(r) + "\"/>");
 714                                 }
 715                                 for (Resource r : tested) {
 716                                         ps.println("<tested uri=\"" + graph.getURI(r) + "\"/>");
 717                                 }
 718                                 for (Resource r : strong) {
 719                                         ps.println("<strong uri=\"" + graph.getURI(r) + "\"/>");
 720                                 }
 721                                 for (Resource r : nonTraversed) {
 722                                         ps.println("<nontraversed uri=\"" + graph.getURI(r) + "\"/>");
 723                                 }
 724                                 for (Resource r : nonTested) {
 725                                         ps.println("<nontested uri=\"" + graph.getURI(r) + "\"/>");
 726                                 }
 727                         }
 728                 });
 729
 730                 ps.println("</compare>");
 731                 ps.flush();
 732                 ps.close();
 733                 return true;
 734         }
 735
 736         private void load(String filename) throws Exception {
 737                 final ImportListener listener = new ImportListener();
 738                 XMLParser parser = new XMLParser(listener);
 739                 parser.parse(filename);
 740
 741                 if (listener.getNonTested().size() +
 742                         listener.getNonTraversed().size() +
 743                         listener.getStrong().size() +
 744                         listener.getTested().size() +
 745                         listener.getTraversed().size() == 0)
 746                         return;
 747                 session.syncRequest(new ReadRequest() {
 748
 749                         @Override
 750                         public void run(ReadGraph graph) throws DatabaseException {
 751                                 tested.clear();
 752                                 traversed.clear();
 753                                 strong.clear();
 754                                 nonTested.clear();
 755                                 nonTraversed.clear();
 756                                 for (String uri : listener.getTested()) {
 757                                         tested.add(graph.getResource(uri));
 758                                 }
 759                                 for (String uri : listener.getTraversed()) {
 760                                         traversed.add(graph.getResource(uri));
 761                                 }
 762                                 for (String uri : listener.getStrong()) {
 763                                         strong.add(graph.getResource(uri));
 764                                 }
 765
 766                                 for (String uri : listener.getNonTested()) {
 767                                         nonTested.add(graph.getResource(uri));
 768                                 }
 769                                 for (String uri : listener.getNonTraversed()) {
 770                                         nonTraversed.add(graph.getResource(uri));
 771                                 }
 772
 773                         }
 774                 });
 775
 776
 777
 778         }
 779
 780         public static class ImportListener {
 781
 782
 783                 private Collection<String> traversed = new ArrayList<String>();
 784                 private Collection<String> tested = new ArrayList<String>();
 785                 private Collection<String> strong = new ArrayList<String>();
 786                 private Collection<String> nonTraversed = new ArrayList<String>();
 787                 private Collection<String> nonTested = new ArrayList<String>();
 788
 789
 790                 public void done() {
 791
 792                 }
 793
 794
 795                 public void addTraversed(String uri) {
 796                         traversed.add(uri);
 797                 }
 798
 799                 public void addTested(String uri) {
 800                         tested.add(uri);
 801                 }
 802
 803                 public void addStrong(String uri) {
 804                         strong.add(uri);
 805                 }
 806
 807                 public void addNonTraversed(String uri) {
 808                         nonTraversed.add(uri);
 809                 }
 810
 811                 public void addNonTested(String uri) {
 812                         nonTested.add(uri);
 813                 }
 814
 815                 public Collection<String> getTraversed() {
 816                         return traversed;
 817                 }
 818
 819                 public Collection<String> getNonTested() {
 820                         return nonTested;
 821                 }
 822
 823                 public Collection<String> getNonTraversed() {
 824                         return nonTraversed;
 825                 }
 826
 827                 public Collection<String> getStrong() {
 828                         return strong;
 829                 }
 830
 831                 public Collection<String> getTested() {
 832                         return tested;
 833                 }
 834
 835         }
 836
 837
 838
 839         public static class XMLParser {
 840
 841                 private ImportListener listener;
 842
 843                 public XMLParser(ImportListener listener) {
 844                         this.listener = listener;
 845                 }
 846
 847                 public void parse(String filename) throws Exception{
 848                         ParserBean p = new ParserBean();
 849                         p.parse(filename);
 850                 }
 851
 852                 private void handleElement(Stack<Element> parents, Element element) throws SAXException{
 853                         String name = element.qName;
 854                         if(name.equals("traversed")) {
 855                                 for (Attribute a : element.attributes) {
 856                                         String propertyName = a.localName;
 857                                         String value = a.value;
 858                                         if (propertyName.equals("uri")) {
 859                                                 listener.addTraversed(value);
 860
 861                                         }
 862                                 }
 863                         } else if(name.equals("tested")) {
 864                                 for (Attribute a : element.attributes) {
 865                                         String propertyName = a.localName;
 866                                         String value = a.value;
 867                                         if (propertyName.equals("uri")) {
 868                                                 listener.addTested(value);
 869
 870                                         }
 871                                 }
 872                         } else if(name.equals("strong")) {
 873                                 for (Attribute a : element.attributes) {
 874                                         String propertyName = a.localName;
 875                                         String value = a.value;
 876                                         if (propertyName.equals("uri")) {
 877                                                 listener.addStrong(value);
 878
 879                                         }
 880                                 }
 881                         } else if(name.equals("nontraversed")) {
 882                                 for (Attribute a : element.attributes) {
 883                                         String propertyName = a.localName;
 884                                         String value = a.value;
 885                                         if (propertyName.equals("uri")) {
 886                                                 listener.addNonTraversed(value);
 887
 888                                         }
 889                                 }
 890                         } else if(name.equals("nontested")) {
 891                                 for (Attribute a : element.attributes) {
 892                                         String propertyName = a.localName;
 893                                         String value = a.value;
 894                                         if (propertyName.equals("uri")) {
 895                                                 listener.addNonTested(value);
 896
 897                                         }
 898                                 }
 899                         } else if (name.equals("compare")) {
 900
 901                         } else {
 902                                 throw new SAXException("Unknown element '" + name + "'. The file does not contain ExtIO configuration.");
 903
 904                         }
 905                 }
 906
 907
 908                 public class ParserBean extends DefaultHandler implements Serializable {
 909
 910                         private static final long serialVersionUID = -4995836637014958966L;
 911
 912                         private Stack<Element> current = new Stack<Element>();
 913                         private Stack<String> texts = new Stack<String>();
 914
 915                         public ParserBean() {
 916                                 super();
 917                         }
 918
 919                         public void parse(String filename) throws Exception {
 920                                 SAXParserFactory spf = SAXParserFactory.newInstance();
 921                                 SAXParser saxParser = spf.newSAXParser();
 922
 923                                 XMLReader reader = saxParser.getXMLReader();
 924                                 FileReader file = new FileReader(filename);
 925                                 reader.setContentHandler(this);
 926                                 reader.parse(new InputSource(file));
 927                                 listener.done();
 928                         }
 929
 930                         @Override
 931                         public void startElement(String uri, String localName, String name,
 932                                         Attributes attributes) throws SAXException {
 933                                 current.push(new Element(uri,localName,name,attributes));
 934                                 texts.push(new String());
 935                         }
 936
 937                         @Override
 938                         public void endElement(String uri, String localName, String name)
 939                                         throws SAXException {
 940                                 Element e = null;
 941                                 String text = null;
 942                                 if (!current.empty()) {
 943                                         e = current.pop();
 944                                         text = texts.pop();
 945                                 }
 946                                 if (e != null) {
 947                                         e.setValue(text.trim());
 948                                 }
 949                                 if (e != null) {
 950                                         handleElement(current,e);
 951                                 }
 952                         }
 953
 954                         @Override
 955                         public void characters(char[] ch, int start, int length)
 956                                         throws SAXException {
 957                                 if (!current.empty()) {
 958
 959                                         String text = texts.pop();
 960
 961                                         String value = new String(
 962                                 ch, start, length);
 963                                 text += value;
 964                                 texts.push(text);
 965                              }
 966                         }
 967                 }
 968
 969                 public class Attribute {
 970                         public String localName;
 971                         public String qName;
 972                         public String uri;
 973                         public String value;
 974
 975                         public Attribute(String localName, String qName, String uri, String value) {
 976                                 this.localName = localName;
 977                                 this.qName = qName;
 978                                 this.uri = uri;
 979                                 this.value = value;
 980                         }
 981                 }
 982
 983                 public class Element implements Serializable {
 984                         private static final long serialVersionUID = -5207502156942818875L;
 985                         String uri;
 986                         String localName;
 987                         String qName;
 988                         String value = null;
 989                         List<Attribute> attributes = new ArrayList<Attribute>();
 990
 991                         public Element(String uri, String localName, String qName, Attributes attributes) {
 992                                 this.uri = uri;
 993                                 this.localName = localName;
 994                                 this.qName = qName;
 995                                 for (int i = 0; i < attributes.getLength(); i++) {
 996                                         this.attributes.add(new Attribute(attributes.getLocalName(i),attributes.getQName(i),attributes.getURI(i),attributes.getValue(i)));
 997                                 }
 998                         }
 999
1000                         public String getUri() {
1001                                 return uri;
1002                         }
1003
1004                         public String getLocalName() {
1005                                 return localName;
1006                         }
1007
1008                         public String getQName() {
1009                                 return qName;
1010                         }
1011
1012                         public String getValue() {
1013                                 return value;
1014                         }
1015
1016                         public List<Attribute> getAttributes() {
1017                                 return attributes;
1018                         }
1019
1020                         public void setValue(String value) {
1021                                 this.value = value;
1022                         }
1023
1024                 }
1025
1026         }
1027
1028 }