bundles/org.simantics.document.ui/src/org/simantics/document/ui/dialogs/AnnotationConfigurator.java

   1 package org.simantics.document.ui.dialogs;
   2
   3 import java.util.ArrayList;
   4 import java.util.Collection;
   5 import java.util.List;
   6
   7 import org.eclipse.jface.viewers.ISelection;
   8 import org.eclipse.jface.viewers.StructuredSelection;
   9 import org.eclipse.swt.widgets.Composite;
  10 import org.eclipse.ui.IWorkbenchPartSite;
  11 import org.simantics.Simantics;
  12 import org.simantics.annotation.ontology.AnnotationResource;
  13 import org.simantics.db.ReadGraph;
  14 import org.simantics.db.Resource;
  15 import org.simantics.db.Statement;
  16 import org.simantics.db.VirtualGraph;
  17 import org.simantics.db.WriteGraph;
  18 import org.simantics.db.common.request.WriteRequest;
  19 import org.simantics.db.common.request.WriteResultRequest;
  20 import org.simantics.db.exception.DatabaseException;
  21 import org.simantics.db.layer0.variable.Variable;
  22 import org.simantics.db.request.Read;
  23 import org.simantics.db.service.VirtualGraphSupport;
  24 import org.simantics.layer0.Layer0;
  25 import org.simantics.selectionview.ComparableTabContributor;
  26 import org.simantics.selectionview.IPropertyTab;
  27 import org.simantics.selectionview.TabContribution;
  28 import org.simantics.utils.ui.ExceptionUtils;
  29
  30 /**
  31  * Tool for configuring annotations for a resource before it is instantiated.
  32  *
  33  * @author Marko Luukkainen <marko.luukkainen@vtt.fi>
  34  *
  35  */
  36 public class AnnotationConfigurator {
  37
  38         private Resource type;
  39         private Resource lib;
  40         boolean useVG = false;
  41         Variable annotationHolderVariable;
  42
  43         public AnnotationConfigurator(Resource type, Resource lib) {
  44                 this.type = type;
  45                 this.lib = lib;
  46
  47         }
  48
  49         public void createComposite(Composite parent) {
  50                 annotationHolderVariable = createAnnotationHolder2();
  51
  52 //              IWorkbenchPage page = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage();
  53 //              IWorkbenchPartSite site = page.getActivePart().getSite();
  54                 IWorkbenchPartSite site = null;
  55
  56                 Collection<ComparableTabContributor> contribution = getAnnotationTab(annotationHolderVariable);
  57                 ISelection selection = new StructuredSelection(annotationHolderVariable);
  58                 for (ComparableTabContributor c : contribution) {
  59
  60                         IPropertyTab tab = c.create(parent, site, Simantics.getSessionContext(), selection);
  61                         tab.setInput(Simantics.getSessionContext(), selection, false);
  62                 }
  63         }
  64
  65
  66 //      private Resource createAnnotationHolder() {
  67 //              VirtualGraph vg = null;
  68 //              if (useVG) {
  69 //                      VirtualGraphSupport support = Simantics.getSession().getService(VirtualGraphSupport.class);
  70 //                      vg = support.getMemoryPersistent("document_annotation");
  71 //              }
  72 //              Resource annotationHolder = null;
  73 //              try {
  74 //                      annotationHolder = Simantics.getSession().syncRequest(new WriteResultRequest<Resource>(vg) {
  75 //                              public Resource perform(WriteGraph graph) throws DatabaseException {
  76 //                                      Layer0 l0 = Layer0.getInstance(graph);
  77 //                                      Resource annotationHolderDoc = graph.newResource();
  78 //                                      graph.claim(annotationHolderDoc, l0.InstanceOf, type);
  79 //                                      graph.claimLiteral(annotationHolderDoc, l0.HasName, "Template");
  80 //                                      graph.claim(lib, l0.ConsistsOf, annotationHolderDoc);
  81 //                                      return annotationHolderDoc;
  82 //                              }
  83 //                      });
  84 //
  85 //              } catch (DatabaseException e1) {
  86 //                      ExceptionUtils.logAndShowError(e1);
  87 //              }
  88 //              return annotationHolder;
  89 //      }
  90
  91         private Variable createAnnotationHolder2() {
  92                 VirtualGraph vg = null;
  93                 if (useVG) {
  94                         VirtualGraphSupport support = Simantics.getSession().getService(VirtualGraphSupport.class);
  95                         vg = support.getMemoryPersistent("document_annotation"); //$NON-NLS-1$
  96                 }
  97                 Variable annotationHolder = null;
  98                 try {
  99                         annotationHolder = Simantics.getSession().syncRequest(new WriteResultRequest<Variable>(vg) {
 100                                 public Variable perform(WriteGraph graph) throws DatabaseException {
 101                                         Layer0 l0 = Layer0.getInstance(graph);
 102                                         Resource annotationHolderDoc = graph.newResource();
 103                                         graph.claim(annotationHolderDoc, l0.InstanceOf, type);
 104                                         graph.claimLiteral(annotationHolderDoc, l0.HasName, "Template"); //$NON-NLS-1$
 105                                         graph.claim(lib, l0.ConsistsOf, annotationHolderDoc);
 106                                         if (graph.isInstanceOf(lib, type)) {
 107                                                 copyAnnotations(graph, lib, annotationHolderDoc);
 108                                         }
 109                                         return graph.adapt(annotationHolderDoc, Variable.class);
 110                                 }
 111                         });
 112
 113                 } catch (DatabaseException e1) {
 114                         ExceptionUtils.logAndShowError(e1);
 115                 }
 116                 return annotationHolder;
 117         }
 118
 119 //      private Variable createAnnotationHolder3() {
 120 //              Resource r = createAnnotationHolder();
 121 //              return new StandardGraphChildVariable(null, null, r);
 122 //      }
 123
 124         private Collection<ComparableTabContributor> getAnnotationTab(final Object selection) {
 125                 try {
 126                         return Simantics.getSession().syncRequest(new Read<Collection<ComparableTabContributor>>() {
 127                                 @SuppressWarnings({ "rawtypes", "unchecked" })
 128                                 @Override
 129                                 public Collection<ComparableTabContributor> perform(ReadGraph graph)
 130                                                 throws DatabaseException {
 131                                         AnnotationResource ann = AnnotationResource.getInstance(graph);
 132                                         TabContribution contribution = graph.adapt(ann.SelectionTabContribution, TabContribution.class);
 133                                         Collection<ComparableTabContributor> coll = new ArrayList<ComparableTabContributor>();
 134                                         contribution.contribute(graph, selection, coll);
 135                                         return coll;
 136                                 }
 137                         });
 138                 } catch (DatabaseException e) {
 139                         ExceptionUtils.logAndShowError(e);
 140                         return null;
 141                 }
 142         }
 143
 144         public void apply(final Resource to) throws DatabaseException{
 145                 Simantics.getSession().syncRequest(new WriteRequest() {
 146
 147                         @Override
 148                         public void perform(WriteGraph graph) throws DatabaseException {
 149                                 apply(graph, to);
 150                         }
 151                 });
 152
 153         }
 154
 155         public void apply(WriteGraph graph, Resource to) throws DatabaseException{
 156                 Resource from = annotationHolderVariable.getPossibleRepresents(graph);
 157                 copyAnnotations(graph, from, to);
 158
 159         }
 160
 161         private void copyAnnotations(WriteGraph graph, Resource from, Resource to) throws DatabaseException{
 162                 Layer0 l0 = Layer0.getInstance(graph);
 163                 AnnotationResource ann = AnnotationResource.getInstance(graph);
 164
 165                 List<Statement> annotations = new ArrayList<Statement>();
 166                 for (Statement s : graph.getStatements(from, l0.HasProperty)) {
 167                         if (graph.isInstanceOf(s.getObject(),ann.Annotation) ){
 168                                 annotations.add(s);
 169                         }
 170                 }
 171
 172                 for (Statement annotation : annotations) {
 173                         Resource annotationInstance = graph.newResource();
 174                         graph.claim(to, annotation.getPredicate(), annotationInstance);
 175                         for (Resource type : graph.getObjects(annotation.getObject(), l0.InstanceOf)) {
 176                                 graph.claim(annotationInstance, l0.InstanceOf, type);
 177                         }
 178                         for (Statement property : graph.getStatements(annotation.getObject(), l0.HasProperty)) {
 179                                 if (property.isAsserted(annotation.getObject()))
 180                                         continue;
 181                                 graph.claimLiteral(annotationInstance, property.getPredicate(), graph.getValue(property.getObject()));
 182                         }
 183                 }
 184         }
 185
 186         public void dispose() {
 187
 188                 if (useVG) {
 189                         VirtualGraphSupport support = Simantics.getSession().getService(VirtualGraphSupport.class);
 190                         VirtualGraph vg = support.getMemoryPersistent("document_annotation"); //$NON-NLS-1$
 191                         support.discard(vg);
 192                 } else {
 193
 194                         Simantics.getSession().asyncRequest(new WriteRequest() {
 195
 196                                 @Override
 197                                 public void perform(WriteGraph graph) throws DatabaseException {
 198                                         Resource r = annotationHolderVariable.getPossibleRepresents(graph);
 199                                         graph.deny(r);
 200
 201                                 }
 202                         });
 203
 204                 }
 205
 206         }
 207 }