org.simantics.plant3d/src/org/simantics/plant3d/scenegraph/controlpoint/ControlPointFactory.java

   1 package org.simantics.plant3d.scenegraph.controlpoint;
   2
   3 import java.util.HashMap;
   4 import java.util.List;
   5 import java.util.Map;
   6
   7 import org.simantics.Simantics;
   8 import org.simantics.db.ReadGraph;
   9 import org.simantics.db.Resource;
  10 import org.simantics.db.exception.DatabaseException;
  11 import org.simantics.db.request.Read;
  12 import org.simantics.plant3d.ontology.Plant3D;
  13 import org.simantics.plant3d.scenegraph.PipelineComponent;
  14 import org.simantics.plant3d.scenegraph.controlpoint.PipeControlPoint.Type;
  15 import org.simantics.plant3d.utils.Item;
  16 import org.simantics.plant3d.utils.P3DUtil;
  17
  18 public class ControlPointFactory {
  19
  20         private static Map<String,Instruction> cache = new HashMap<String, Instruction>();
  21
  22
  23         public static void preloadCache() throws Exception {
  24                 List<Item> items = P3DUtil.getEnds();
  25                 items.addAll(P3DUtil.getInlines());
  26                 items.addAll(P3DUtil.getNozzles());
  27                 items.addAll(P3DUtil.getTurns());
  28
  29                 for (Item item : items) {
  30                         Instruction inst = createInstruction(item.getUri());
  31                         cache.put(item.getUri(), inst);
  32                 }
  33         }
  34
  35         public static PipeControlPoint create(PipelineComponent component) throws Exception {
  36                 Instruction inst = cache.get(component.getType());
  37                 if (inst == null) {
  38                         inst = createInstruction(component.getType());
  39                         cache.put(component.getType(), inst);
  40                 }
  41                 if (inst == null) {
  42                         return null;
  43                 }
  44
  45                 PipeControlPoint pcp = new PipeControlPoint(component);
  46                 pcp.setType(inst.type);
  47                 pcp.setFixed(inst.fixed);
  48                 pcp.setRotate(inst.isRotate);
  49                 pcp.setReverse(inst.isReverse);
  50                 switch(inst.type) {
  51                 case END:
  52
  53                         break;
  54                 case INLINE:
  55                         if (inst.isOffset || inst.isSizeChange) {
  56                                 PipeControlPoint sub = new PipeControlPoint(component);
  57                                 pcp.children.add(sub);
  58                                 sub.parent = pcp;
  59                                 sub.setType(inst.type);
  60                                 sub.setFixed(inst.fixed);
  61                                 sub.setSub(true);
  62                                 sub.setDeletable(false);
  63                                 if (inst.isOffset)
  64                                         pcp.setOffset(0.0);
  65                         }
  66
  67                         break;
  68                 case TURN:
  69
  70                         break;
  71                 }
  72                 return pcp;
  73         }
  74
  75
  76         private static class Instruction {
  77                 Type type;
  78                 boolean fixed;
  79                 boolean isOffset;
  80                 boolean isSizeChange;
  81                 boolean isRotate;
  82                 boolean isReverse;
  83
  84         }
  85
  86         private static Instruction createInstruction(final String type) throws Exception {
  87                 return Simantics.getSession().syncRequest(new Read<Instruction>() {
  88                         @Override
  89                         public Instruction perform(ReadGraph graph) throws DatabaseException {
  90                                 Resource res = graph.getResource(type);
  91                                 Plant3D p3d = Plant3D.getInstance(graph);
  92                                 Instruction i = new Instruction();
  93                                 i.fixed = false;
  94                                 i.isOffset = false;
  95                                 i.isSizeChange = false;
  96                                 i.isRotate = false;
  97                                 i.isReverse = false;
  98                                 i.type = Type.INLINE;
  99                                 if (graph.isInheritedFrom(res, p3d.Nozzle)) {
 100                                         i.fixed = true;
 101                                         i.isOffset = false;
 102                                         i.isSizeChange = false;
 103                                         i.type = Type.END;
 104                                 } else if (graph.isInheritedFrom(res, p3d.InlineComponent)){
 105
 106                                         i.type = Type.INLINE;
 107                                         if (graph.hasStatement(res,p3d.VariableLengthInlineComponent)) {
 108                                                 i.fixed = false;
 109                                         } else if (graph.hasStatement(res,p3d.FixedLengthInlineComponent)) {
 110                                                 i.fixed = true;
 111                                         }
 112
 113                                         if (graph.hasStatement(res,p3d.SizeChangeComponent)) {
 114                                                 i.isSizeChange = true;
 115                                         }
 116
 117                                         if (graph.hasStatement(res,p3d.OffsetComponent)) {
 118                                                 i.isOffset = true;
 119                                         }
 120                                         if (graph.hasStatement(res,p3d.RotateComponent)) {
 121                                                 i.isRotate = true;
 122                                         }
 123
 124                                         if (graph.hasStatement(res,p3d.ReverseComponent)) {
 125                                                 i.isReverse = true;
 126                                         }
 127
 128                                 } else if (graph.isInheritedFrom(res, p3d.TurnComponent)) {
 129                                         i.type = Type.TURN;
 130                                         if (graph.hasStatement(res,p3d.VariableAngleTurnComponent)) {
 131                                                 i.fixed = false;
 132                                         } else if (graph.hasStatement(res,p3d.FixedAngleTurnComponent)) {
 133                                                 i.fixed = true;
 134                                         }
 135                                 } else if (graph.isInheritedFrom(res, p3d.EndComponent)) {
 136                                         i.fixed = false;
 137                                         i.type = Type.END;
 138                                 } else {
 139                                         return null;
 140                                 }
 141                                 return i;
 142                         }
 143                 });
 144         }
 145
 146 }