dev/org.simantics.proconf.processeditor/src/fi/vtt/simantics/processeditor/views/ProcessEditor.java

   1 /*******************************************************************************\r
   2  * Copyright (c) 2007 VTT Technical Research Centre of Finland and others.\r
   3  * All rights reserved. This program and the accompanying materials\r
   4  * are made available under the terms of the Eclipse Public License v1.0\r
   5  * which accompanies this distribution, and is available at\r
   6  * http://www.eclipse.org/legal/epl-v10.html\r
   7  *\r
   8  * Contributors:\r
   9  *     VTT Technical Research Centre of Finland - initial API and implementation\r
  10  *******************************************************************************/\r
  11 package fi.vtt.simantics.processeditor.views;\r
  12 \r
  13 import java.util.ArrayList;\r
  14 import java.util.Collection;\r
  15 import java.util.HashMap;\r
  16 import java.util.List;\r
  17 import java.util.Map;\r
  18 \r
  19 import org.eclipse.jface.action.Action;\r
  20 import org.eclipse.jface.dialogs.Dialog;\r
  21 import org.eclipse.jface.dialogs.IDialogConstants;\r
  22 import org.eclipse.jface.viewers.ISelection;\r
  23 import org.eclipse.jface.viewers.ISelectionChangedListener;\r
  24 import org.eclipse.jface.viewers.SelectionChangedEvent;\r
  25 import org.eclipse.swt.SWT;\r
  26 import org.eclipse.swt.events.KeyEvent;\r
  27 import org.eclipse.swt.events.KeyListener;\r
  28 import org.eclipse.swt.events.SelectionEvent;\r
  29 import org.eclipse.swt.events.SelectionListener;\r
  30 import org.eclipse.swt.layout.GridData;\r
  31 import org.eclipse.swt.widgets.Button;\r
  32 import org.eclipse.swt.widgets.Composite;\r
  33 import org.eclipse.swt.widgets.Control;\r
  34 import org.eclipse.swt.widgets.Label;\r
  35 import org.eclipse.swt.widgets.Shell;\r
  36 import org.eclipse.swt.widgets.Text;\r
  37 import org.eclipse.ui.IWorkbenchPart;\r
  38 import org.eclipse.ui.views.contentoutline.IContentOutlinePage;\r
  39 import org.simantics.db.Graph;\r
  40 import org.simantics.db.Resource;\r
  41 import org.simantics.db.Session;\r
  42 import org.simantics.db.management.ISessionContext;\r
  43 import org.simantics.layer0.utils.EntityFactory;\r
  44 import org.simantics.layer0.utils.IEntity;\r
  45 import org.simantics.layer0.utils.Property;\r
  46 import org.simantics.proconf.g3d.base.JmeRenderingComponent;\r
  47 import org.simantics.proconf.g3d.base.ScenegraphAdapter;\r
  48 import org.simantics.proconf.g3d.base.ScenegraphAdapterImpl;\r
  49 import org.simantics.proconf.g3d.base.SelectionAdapter;\r
  50 import org.simantics.proconf.g3d.base.ThreeDimensionalEditorBase;\r
  51 import org.simantics.proconf.g3d.common.StructuredResourceSelection;\r
  52 import org.simantics.proconf.g3d.scenegraph.IGeometryNode;\r
  53 import org.simantics.proconf.g3d.scenegraph.IGraphicsNode;\r
  54 import org.simantics.proconf.g3d.scenegraph.ISelectableNode;\r
  55 import org.simantics.proconf.g3d.scenegraph.ParameterizedModelNode;\r
  56 import org.simantics.proconf.g3d.shapes.FloorShape;\r
  57 import org.simantics.proconf.g3d.stubs.G3DNode;\r
  58 import org.simantics.utils.ErrorLogger;\r
  59 import org.simantics.utils.ui.jface.MenuTools;\r
  60 \r
  61 import com.jme.math.Vector3f;\r
  62 import com.jme.scene.Geometry;\r
  63 \r
  64 import fi.vtt.simantics.processeditor.Activator;\r
  65 import fi.vtt.simantics.processeditor.ProcessResource;\r
  66 import fi.vtt.simantics.processeditor.actions.InsertComponentAction;\r
  67 import fi.vtt.simantics.processeditor.actions.InsertEquipmentAction;\r
  68 import fi.vtt.simantics.processeditor.actions.InsertNozzleAction;\r
  69 import fi.vtt.simantics.processeditor.actions.RoutePipeAction;\r
  70 import fi.vtt.simantics.processeditor.common.ControlPointTools;\r
  71 import fi.vtt.simantics.processeditor.common.PipingRules;\r
  72 import fi.vtt.simantics.processeditor.scenegraph.NonVisibleNode;\r
  73 import fi.vtt.simantics.processeditor.scenegraph.PipelineComponentNode;\r
  74 import fi.vtt.simantics.processeditor.scenegraph.PipeComponentNode;\r
  75 import fi.vtt.simantics.processeditor.scenegraph.PipeRunNode;\r
  76 import fi.vtt.simantics.processeditor.stubs.PipeControlPoint;\r
  77 import fi.vtt.simantics.processeditor.stubs.PipeRun;\r
  78 import fi.vtt.simantics.processeditor.stubs.Plant;\r
  79 import fi.vtt.simantics.processeditor.stubs.Plant3DResource;\r
  80 import fi.vtt.simantics.processeditor.tools.PlantEditContribution;\r
  81 import fi.vtt.simantics.processeditor.tools.PlantVisualizationContribution;\r
  82 \r
  83 public class ProcessEditor extends ThreeDimensionalEditorBase {\r
  84     \r
  85     private Resource plantResource = null;\r
  86     \r
  87     //private List<AnimationController> animationControllers = new ArrayList<AnimationController>();\r
  88 \r
  89     private Action configureFloorAction = null;\r
  90 \r
  91     private Geometry floorShape = null;\r
  92 \r
  93     public ProcessEditor(ISessionContext session) {\r
  94         super(session);\r
  95         addEditorContribution(new PlantEditContribution(this));\r
  96         addEditorContribution(new PlantVisualizationContribution(this));\r
  97     }\r
  98     \r
  99     public ProcessEditor(ISessionContext session,JmeRenderingComponent component) {\r
 100         super(session,component);\r
 101         addEditorContribution(new PlantEditContribution(this));\r
 102         addEditorContribution(new PlantVisualizationContribution(this));\r
 103     }\r
 104     \r
 105     @Override\r
 106     protected ScenegraphAdapter createScenegraphAdapter() {\r
 107         return new ProcessEditorAdapter(session,getRenderingComponent());\r
 108     }\r
 109     \r
 110     @Override\r
 111     public void createControl(Graph graph,Composite parent) {\r
 112         super.createControl(graph,parent);\r
 113 \r
 114         floorShape = FloorShape.getShape(getRenderingComponent().getDisplaySystem().getRenderer(), 100.f,0.2f);\r
 115         getRenderingComponent().getNoCastRoot().attachChild(floorShape);\r
 116         floorShape.setLocalTranslation(new Vector3f(0.f,-0.01f,0.f));\r
 117     }\r
 118 \r
 119     @Override\r
 120     protected void makeActions(Graph graph) {\r
 121         super.makeActions(graph);\r
 122 \r
 123         //actions.add(new ShowTrendsAction(this));\r
 124 \r
 125         configureFloorAction = new Action() {\r
 126                 public void run() {\r
 127                         FloorConfigureDialog dialog = new FloorConfigureDialog(ProcessEditor.this.parent.getShell());\r
 128                         if (dialog.open() == FloorConfigureDialog.CANCEL)\r
 129                                 return;\r
 130                         if (dialog.isFloorEnabled()) {\r
 131                                 if (floorShape.getParent() == null)\r
 132                                         getRenderingComponent().getNoCastRoot().attachChild(floorShape);\r
 133                         } else {\r
 134                                 floorShape.removeFromParent();\r
 135                         }\r
 136                         floorShape.setLocalTranslation(new Vector3f(0.f,(float)dialog.getFloorHeight(),0.f));\r
 137                         \r
 138                 }\r
 139         };\r
 140         configureFloorAction.setText("Configure floor");\r
 141         configureFloorAction.setImageDescriptor(Activator.imageDescriptorFromPlugin("fi.vtt.proconf.ode", "icons/silk/shape_align_bottom.png"));\r
 142 \r
 143 //        ContextActionFactory extended[] = ContextActionRegistry.getActions("fi.vtt.proconf.shapeeditor.processeditorview");\r
 144 //        for (ContextActionFactory c : extended) {\r
 145 //              actions.add(c.createAction(this));\r
 146 //        }\r
 147     }\r
 148     \r
 149 //    protected void stopAnimations() {\r
 150 //      animationSystem.stop();\r
 151 //    }\r
 152     \r
 153     protected void fillLocalPullDown() {\r
 154         super.fillLocalPullDown();\r
 155         MenuTools.getOrCreate(getMenuID(),"Advanced", menuManager).add(configureFloorAction);\r
 156     }\r
 157     \r
 158     protected class ProcessEditorAdapter extends ScenegraphAdapterImpl {\r
 159         \r
 160          public ProcessEditorAdapter(Session session, JmeRenderingComponent component) {\r
 161                         super(session, component);\r
 162          }\r
 163          \r
 164          private class NormalScengraphQuery extends ScenegraphQuery {\r
 165                 \r
 166                 public NormalScengraphQuery(Resource node) {\r
 167                                 super(node);\r
 168                         } \r
 169                  \r
 170                  \r
 171                  @Override\r
 172                 public void shapeAdded(Graph graph, IGraphicsNode node) {\r
 173                          // FIXME : this won't work like in previous ProConf\r
 174                 }\r
 175          }\r
 176          \r
 177          private Map<Resource,PipeRunControlPointQuery> pipeRunQueries = new HashMap<Resource, PipeRunControlPointQuery>();\r
 178 \r
 179                 protected ScenegraphQuery newSubnodeListener(G3DNode node) {\r
 180                 if (node.isInstanceOf(ProcessResource.plant3Dresource.PipeRun)) {\r
 181                     PipeRunControlPointQuery query = new PipeRunControlPointQuery(node.getResource());\r
 182                     pipeRunQueries.put(node.getResource(), query);\r
 183                     node.getGraph().performQuery(query);\r
 184 //                  return new SubnodeListener(node) {\r
 185 //                      @Override\r
 186 //                      public void shapeAdded(IGraphicsNode node) {\r
 187 //                          if (node instanceof IGeometryNode) {\r
 188 //                              updateGeometry((IGeometryNode)node);\r
 189 //                              \r
 190 //                          }\r
 191 //                          node.setVisible(true);\r
 192 //                      }\r
 193 //                  };\r
 194                 }\r
 195                 return new NormalScengraphQuery(node.getResource());\r
 196                  \r
 197             }\r
 198                 \r
 199                 @Override\r
 200                 protected NodePropertyQuery newRootPropertyListener(G3DNode root) {\r
 201                         // currently Plant does not have any properties.\r
 202                         return null;\r
 203                 }\r
 204                 \r
 205                 private class TransformationQuery extends NodeTransformationQuery {\r
 206                         \r
 207                         public TransformationQuery(Resource res) {\r
 208                                 super(res);\r
 209                         }\r
 210                         \r
 211                         @Override\r
 212                         public void shapeUpdated(Graph graph, IGraphicsNode shape) {\r
 213                                 //if (shape instanceof IGeometryNode) {\r
 214                 //    updateGeometry((IGeometryNode)shape);\r
 215                 //} else {\r
 216                         shape.updateTransform(graph);\r
 217                 //}\r
 218                         }\r
 219                 }\r
 220                 \r
 221                 @Override\r
 222                 protected NodeTransformationQuery newTransformationListener(G3DNode root) {\r
 223                         return new TransformationQuery(root.getResource());\r
 224                 }\r
 225                 \r
 226                 private class NormalNodePropertyQuery extends org.simantics.proconf.g3d.base.ScenegraphAdapterImpl.NodePropertyQuery {\r
 227                         \r
 228                         public NormalNodePropertyQuery(Resource resource) {\r
 229                                 super(resource);\r
 230                         }\r
 231 \r
 232                         @Override\r
 233                         public void shapeUpdated(Graph graph,IGraphicsNode shape) {\r
 234                                 if (shape instanceof IGeometryNode) {\r
 235                     updateGeometry((IGeometryNode)shape);\r
 236                 } else {\r
 237                         shape.updateTransform(graph);\r
 238                 }\r
 239                         }\r
 240                 }\r
 241          @Override\r
 242         protected NodePropertyQuery newPropertyListener(G3DNode node) {\r
 243                 return new NormalNodePropertyQuery(node.getResource());\r
 244         }\r
 245    \r
 246          @Override\r
 247                 protected IGraphicsNode instantiateNode(IGraphicsNode parent,\r
 248                                 G3DNode node) {\r
 249                         Plant3DResource p3r = ProcessResource.plant3Dresource;\r
 250                         IGraphicsNode newNode = null;\r
 251                         try {\r
 252                                 if (node.isInstanceOf(p3r.Equipment)) {\r
 253                                         newNode = new ParameterizedModelNode(\r
 254                                                         ProcessEditor.this, parent, node.getGraph(),\r
 255                                                         node.getResource(), p3r.HasGraphics);\r
 256                                 } else if (node.isInstanceOf(p3r.PipeRun)) {\r
 257                                         newNode = new PipeRunNode(parent, node.getGraph(), node.getResource());\r
 258                                 } else if (node.isInstanceOf(p3r.Nozzle)) {\r
 259                                         newNode = new ParameterizedModelNode(\r
 260                                                         ProcessEditor.this, parent, node.getGraph(),\r
 261                                                         node.getResource(), p3r.HasGraphics);\r
 262                                         // CodedComponent must be handled first since it uses\r
 263                                         // hard-coded geometries\r
 264                                         // TODO : is this really necessary, or could we unify\r
 265                                         // PipeComponentNode, InlineComponentNode,...\r
 266                                 } else if (node.isInstanceOf(p3r.CodedComponent)) {\r
 267                                         newNode = new PipeComponentNode(ProcessEditor.this,\r
 268                                                         parent, node.getGraph(), node.getResource());\r
 269                                 } else if (node.isInstanceOf(p3r.NonVisibleComponent)) {\r
 270                                         newNode = new NonVisibleNode(parent, node.getGraph(), node.getResource());\r
 271                                 } else if (node.isInstanceOf(p3r.PipelineComponent)) {\r
 272                                         newNode = new PipelineComponentNode(ProcessEditor.this,\r
 273                                                         parent, node.getGraph(), node.getResource());\r
 274                                 } \r
 275 \r
 276                                 // } else if (node instanceof Shape) // Markers (ar/mobile)\r
 277                                 // needed this\r
 278                                 // newNode = new ShapeNode(TestProcessEditor.this,parent,node);\r
 279                                 if (newNode != null) {\r
 280                                         if (newNode instanceof ISelectableNode)\r
 281                                                 ((ISelectableNode) newNode).setVisible(true);\r
 282                                         if (newNode instanceof IGeometryNode) {\r
 283                                                 updateGeometry((IGeometryNode) newNode);\r
 284                                         }\r
 285                                         return newNode;\r
 286                                 }\r
 287                         } catch (Exception e) {\r
 288                                 ErrorLogger.defaultLogError("Cannot handle node " + node.getResource(), e);\r
 289                                 return null;\r
 290                         }\r
 291                         ErrorLogger.defaultLogError("Cannot handle node " + node.getResource(), null);\r
 292                         return null;\r
 293 \r
 294                 }\r
 295 \r
 296                 /**\r
 297                  * This is used to create elbows and straight pipes to pipeline TODO :\r
 298                  * this should be done with rule-engine!\r
 299                  * \r
 300                  * \r
 301                  * @author Marko Luukkainen\r
 302                  * \r
 303                  */\r
 304                 protected class PipeRunControlPointQuery extends NodeQuery {\r
 305                         private List<Resource> removed = new ArrayList<Resource>();\r
 306                         private List<Resource> added = new ArrayList<Resource>();\r
 307 \r
 308                         public PipeRunControlPointQuery(Resource r) {\r
 309                                 super(r);\r
 310                                 if (DEBUG) System.out.println("Created PipeRunControlPointQuery for " + r);\r
 311 \r
 312                         }\r
 313 \r
 314                         @Override\r
 315                         protected Object compute2(Graph graph) {\r
 316                                 PipeRun run = new PipeRun(graph, nodeResource);\r
 317                                 Collection<IEntity> cps = run\r
 318                                                 .getRelatedObjects(ProcessResource.plant3Dresource.HasControlPoints);\r
 319                                 List<Resource> res = new ArrayList<Resource>();\r
 320                                 for (IEntity t : cps)\r
 321                                         res.add(t.getResource());\r
 322                                 return res;\r
 323                         }\r
 324 \r
 325                         @Override\r
 326                         public boolean updated(Graph graph, Object oldResult,\r
 327                                         Object newResult) {\r
 328                                 \r
 329                                 removed.clear();\r
 330                                 added.clear();\r
 331 \r
 332                                 List<Resource> oldCps = (List<Resource>) oldResult;\r
 333                                 List<Resource> newCps = (List<Resource>) newResult;\r
 334                                 if (oldCps == null)\r
 335                                         oldCps = new ArrayList<Resource>();\r
 336 \r
 337                                 for (Resource r : oldCps) {\r
 338                                         if (!newCps.contains(r))\r
 339                                                 removed.add(r);\r
 340                                 }\r
 341 \r
 342                                 for (Resource r : newCps) {\r
 343                                         if (!oldCps.contains(r))\r
 344                                                 added.add(r);\r
 345                                 }\r
 346                                 for (Resource r : removed)\r
 347                                         removeControlPoint(graph, r);\r
 348                                 for (Resource r : added) {\r
 349                                         addControlPoint(graph, r);\r
 350                                         // ControlPointTools.addControlPoint(new\r
 351                                         // PipeRun(graph,pipeRun), new PipeControlPoint(graph, r));\r
 352                                 }\r
 353 \r
 354                                 return (added.size() > 0 || removed.size() > 0);\r
 355                         }\r
 356                         \r
 357                         @Override\r
 358                         public void dispose() {\r
 359                                 super.dispose();\r
 360                                 for (ControlPointPropertyQuery q : controlPointPropertyQueries.values())\r
 361                                         q.dispose();\r
 362                                 controlPointPropertyQueries.clear();\r
 363                         }\r
 364                         \r
 365                         private Map<Resource,ControlPointPropertyQuery> controlPointPropertyQueries = new HashMap<Resource, ControlPointPropertyQuery>();\r
 366                         \r
 367                         private void addControlPoint(Graph graph, Resource resource) {\r
 368                                 ControlPointPropertyQuery query = new ControlPointPropertyQuery(resource);\r
 369                                 graph.performQuery(query);\r
 370                                 controlPointPropertyQueries.put(resource,query);\r
 371                         }\r
 372                         \r
 373                         private void removeControlPoint(Graph graph, Resource resource) {\r
 374                                 ControlPointPropertyQuery query = controlPointPropertyQueries.remove(resource);\r
 375                                 query.dispose();\r
 376                                 ControlPointTools.removeControlPoint(new PipeControlPoint(\r
 377                                                 graph, resource));\r
 378                         }\r
 379 \r
 380                 }\r
 381 \r
 382                 protected class ControlPointPropertyQuery extends NodeQuery {\r
 383                         boolean initialized = false;\r
 384                         \r
 385                         public ControlPointPropertyQuery(Resource r) {\r
 386                                 super(r);\r
 387                                 if (DEBUG) System.out.println("Created ControlPointPropertyQuery for " + r);\r
 388                         }\r
 389                         \r
 390                         @Override\r
 391                 public List<Object> compute2(Graph g) {\r
 392                         IEntity t = EntityFactory.create(g,nodeResource);\r
 393                         \r
 394                         Collection<Property> properties = t.getRelatedProperties(ProcessResource.builtins.HasProperty);\r
 395                         List<Object> propertyValues = new ArrayList<Object>();\r
 396                         p(properties,propertyValues);\r
 397 \r
 398                         return propertyValues;\r
 399                 }\r
 400                 \r
 401                 private void p(Collection<Property> properties, List<Object> propertyValues) {\r
 402                         for (Property p : properties) {\r
 403                                 Collection<Property> subProperties = p.getRelatedProperties(p.getGraph().getBuiltins().HasProperty);\r
 404                                 if (subProperties.size() != 0) {\r
 405                                         p(subProperties,propertyValues);\r
 406                                 } \r
 407                                 if (p.hasValue()){\r
 408                                         propertyValues.add(p.getValue());\r
 409                                 }\r
 410                         }\r
 411                 }\r
 412                         \r
 413                         @Override\r
 414                         public boolean updated(Graph graph, Object oldResult, Object newResult) {\r
 415                                 PipingRules.pipeControlPointPositionUpdate(graph, this.nodeResource);\r
 416                                 if (initialized) {\r
 417                                         //PipingRules.pipeControlPointPositionUpdate(graph, this.nodeResource);\r
 418                                 } else {\r
 419                                         initialized = true;\r
 420                                 }\r
 421                                 return true;\r
 422                         }\r
 423                 }\r
 424                 \r
 425                 @Override\r
 426                 protected void removeNode(Resource parent, Resource r) {\r
 427                         super.removeNode(parent, r);\r
 428                         PipeRunControlPointQuery q = pipeRunQueries.get(r);\r
 429                         if (q != null)\r
 430                                 q.dispose();\r
 431                 }\r
 432                 \r
 433                 @Override\r
 434                 public void dispose() {\r
 435                         super.dispose();\r
 436                 }\r
 437         }\r
 438     \r
 439     @Override\r
 440     protected void pageSelectionChanged(IWorkbenchPart part, ISelection selection) {\r
 441         if (!(selection instanceof StructuredResourceSelection)) {\r
 442             return;\r
 443         }\r
 444         \r
 445         StructuredResourceSelection s = (StructuredResourceSelection) selection;\r
 446         selectionAdapter.setCurrentSelection(s);\r
 447         viewChanged = true;\r
 448         \r
 449         //if (s.getRootSelection() == null) {\r
 450         if (!(part instanceof ProcessEditor)) {\r
 451             //System.out.println("ShapeEditorView.pageSelectionChanged() no root selection");\r
 452                 ((ProcessEditorSelectionAdapter)selectionAdapter).setEditorSelection(true);\r
 453             return;\r
 454         } \r
 455         //if (!s.getRootSelection().getResource().getId().equals(plant.getResource().getId())) {\r
 456         ProcessEditor sender = (ProcessEditor)part;\r
 457         if (!sender.getPlantResource().equals(plantResource)) {\r
 458 //          System.out.println("ShapeEditorView.pageSelectionChanged() not right group "\r
 459 //                  + s.getRootSelection().getResource().getId() + " != " + model.getResource().getId());\r
 460                 selectionAdapter.setCurrentSelection(new StructuredResourceSelection());\r
 461                 ((ProcessEditorSelectionAdapter)selectionAdapter).setEditorSelection(false);\r
 462           return;\r
 463       }\r
 464         selectionAdapter.setEditorSelection();\r
 465         \r
 466     }\r
 467 \r
 468     @Override\r
 469     protected void reloadFrom(IEntity thing) {\r
 470         if (plantResource != null) {\r
 471             throw new UnsupportedOperationException("Reloading instantiated viewer not supported");\r
 472         }\r
 473         if (thing.isInstanceOf(ProcessResource.plant3Dresource.Plant)) {\r
 474             plantResource = thing.getResource();\r
 475             G3DNode plant = new G3DNode(thing);\r
 476             adapter.setRootNode(plant);\r
 477             //adapter.addOutbound(plant);\r
 478             ControlPointTools.reloadCache(thing.getGraph(),plant.getResource());\r
 479         } else {\r
 480             throw new IllegalArgumentException("Resource is not a plant");\r
 481         } \r
 482     }\r
 483 \r
 484     public Resource getPlantResource() {\r
 485         return plantResource;\r
 486     }\r
 487     \r
 488     public Plant getPlant(Graph g) {\r
 489         return new Plant(g, plantResource);\r
 490     }\r
 491     \r
 492     @Override\r
 493     protected SelectionAdapter createSelectionAdapter() {\r
 494         return new ProcessEditorSelectionAdapter(adapter);\r
 495     }\r
 496     \r
 497     protected class ProcessEditorSelectionAdapter extends SelectionAdapter {\r
 498         \r
 499         \r
 500          public ProcessEditorSelectionAdapter(ScenegraphAdapter adapter) {\r
 501                         super(adapter);\r
 502                         // TODO Auto-generated constructor stub\r
 503                 }\r
 504 \r
 505                 @Override\r
 506             protected StructuredResourceSelection filterSelection(ISelection s) {\r
 507                 if (!(s instanceof StructuredResourceSelection))\r
 508                     return new StructuredResourceSelection();\r
 509                 return (StructuredResourceSelection)s;\r
 510             }\r
 511 \r
 512             @Override\r
 513             public void setEditorSelection() {\r
 514                 List<IGraphicsNode> sel = getSelectedObjects();\r
 515                 for (IGraphicsNode o : adapter.getNodes())\r
 516                         if (o instanceof ISelectableNode) {\r
 517                                 if (sel.contains(o)) {\r
 518                                 ((ISelectableNode)o).setSelected(true);\r
 519                         } else {\r
 520                                 ((ISelectableNode)o).setSelected(false);\r
 521                         }\r
 522                         }\r
 523                 List<Resource> selected = getSelectedResources();\r
 524              // TODO : don't know why this code is here, but it seems unnecessary\r
 525 //              for (Resource r : selected) {\r
 526 //                  if (!adapter.hasNode(r)) {\r
 527 //                      // instantiating a new resource : usin this editor's tc\r
 528 //                      Resource resource = graph.getResource(r.getId());\r
 529 //                      adapter.addInbound(resource).setSelected(true);\r
 530 //\r
 531 //                  }\r
 532 //              }\r
 533                 \r
 534             }\r
 535             \r
 536             public void setEditorSelection(boolean addShapes) {\r
 537 \r
 538                 List<IGraphicsNode> sel = getSelectedObjects();\r
 539                 for (IGraphicsNode o : adapter.getNodes())\r
 540                         if (o instanceof ISelectableNode) {\r
 541                                 if (sel.contains(o)) {\r
 542                                 ((ISelectableNode)o).setSelected(true);\r
 543                         } else {\r
 544                                 ((ISelectableNode)o).setSelected(false);\r
 545                         }\r
 546                         }\r
 547                 if (addShapes) {\r
 548                         // TODO : don't know why this code is here, but it seems unnecessary\r
 549 //                  List<Resource> selected = getSelectedResources();\r
 550 //                  for (Resource r : selected) {\r
 551 //                      if (!adapter.hasNode(r)) {\r
 552 //                          if (r.isInstanceOf(GlobalIdMap.get(PSK3DModelingOntologyMapping.EQUIPMENT))) {\r
 553 //                              Resource group = GraphicsNodeTools.getModelFromResource(r);\r
 554 //                              if (group != null && group.getId() == plant.getResource().getId()) {\r
 555 ////                                      instantiating a new resource : usin this editor's tc\r
 556 //                                  Resource resource = graph.getResource(r.getId());\r
 557 //                                  adapter.addInbound(resource).setSelected(true);\r
 558 //                              }\r
 559 //                                  \r
 560 //                          }\r
 561 //                      }\r
 562 //                  }\r
 563                 }\r
 564             }\r
 565 \r
 566             @Override\r
 567             protected void setEditorHighlightSelection() {\r
 568                 List<IGraphicsNode> sel = getInteractiveSelectedObjects();\r
 569                 for (IGraphicsNode o : adapter.getNodes())\r
 570                         if (o instanceof ISelectableNode) {\r
 571                                 if (sel.contains(o)) {\r
 572                                 ((ISelectableNode)o).setHighlighted(true);\r
 573                         } else {\r
 574                                 ((ISelectableNode)o).setHighlighted(false);\r
 575                         }\r
 576                         }\r
 577             }\r
 578     }\r
 579     \r
 580     private class FloorConfigureDialog extends Dialog implements KeyListener,SelectionListener {\r
 581         \r
 582         private boolean floorEnabled = true;\r
 583         private double floorHeight = 0.0;\r
 584         \r
 585         private Text floorHeightText = null;\r
 586         private Button floorEnabledButton = null;\r
 587         \r
 588         public FloorConfigureDialog(Shell shell) {\r
 589                 super(shell);\r
 590         }\r
 591         \r
 592         @Override\r
 593         protected Control createDialogArea(Composite parent) {\r
 594                 Composite composite = (Composite) super.createDialogArea(parent);\r
 595                 Label label = new Label(composite, SWT.WRAP);\r
 596             label.setText("Configure floor");\r
 597             GridData data = new GridData(GridData.GRAB_HORIZONTAL\r
 598                     | GridData.GRAB_VERTICAL | GridData.HORIZONTAL_ALIGN_FILL\r
 599                     | GridData.VERTICAL_ALIGN_CENTER);\r
 600                 \r
 601             data.widthHint = convertHorizontalDLUsToPixels(IDialogConstants.MINIMUM_MESSAGE_AREA_WIDTH);\r
 602             label.setLayoutData(data);\r
 603             label.setFont(parent.getFont());\r
 604             floorEnabledButton = new Button(composite,SWT.CHECK);\r
 605             floorEnabledButton.setText("Enabled");\r
 606             label = new Label(composite, SWT.WRAP);\r
 607             label.setText("Height");\r
 608             label.setLayoutData(data);\r
 609             label.setFont(parent.getFont());\r
 610             floorHeightText = new Text(composite,SWT.NONE);\r
 611                 \r
 612                 \r
 613             floorHeightText.addKeyListener(this);\r
 614                 floorEnabledButton.addSelectionListener(this);\r
 615                 floorEnabledButton.setSelection(floorEnabled);\r
 616                 floorHeightText.setText(Double.toString(floorHeight));\r
 617                 \r
 618                 return composite;\r
 619         }\r
 620         \r
 621         @Override\r
 622         protected void configureShell(Shell newShell) {\r
 623                 super.configureShell(newShell);\r
 624                 newShell.setText("Configure floor");\r
 625         }\r
 626         \r
 627         public void keyPressed(KeyEvent e) {\r
 628                 \r
 629         }\r
 630         \r
 631         public void keyReleased(KeyEvent e) {\r
 632                 boolean ok = true;\r
 633                 try {\r
 634                         floorHeight = Double.parseDouble(floorHeightText.getText());    \r
 635                 } catch (NumberFormatException err) {\r
 636                         ok = false;\r
 637                 }\r
 638                 if (ok) {\r
 639                         this.getButton(IDialogConstants.OK_ID).setEnabled(true);\r
 640                 } else {\r
 641                         this.getButton(IDialogConstants.OK_ID).setEnabled(false);\r
 642                 }\r
 643         }\r
 644         \r
 645         public void widgetDefaultSelected(SelectionEvent e) {\r
 646                 \r
 647         }\r
 648         \r
 649         public void widgetSelected(SelectionEvent e) {\r
 650                 floorEnabled = floorEnabledButton.getSelection();\r
 651         }\r
 652 \r
 653                 public boolean isFloorEnabled() {\r
 654                         return floorEnabled;\r
 655                 }\r
 656 \r
 657                 public double getFloorHeight() {\r
 658                         return floorHeight;\r
 659                 }\r
 660 \r
 661     }\r
 662     \r
 663     @Override\r
 664     protected void hookDragAndDrop() {\r
 665         super.hookDragAndDrop();\r
 666         dropTarget.addDropListener(new InsertEquipmentAction(this));\r
 667         dropTarget.addDropListener(new InsertNozzleAction(this));\r
 668         dropTarget.addDropListener(new InsertComponentAction(this));\r
 669         dropTarget.addDropListener(new RoutePipeAction(this));\r
 670     }\r
 671     \r
 672     @Override\r
 673         public Object getAdapter(Class adapter) {\r
 674                 if (adapter == IContentOutlinePage.class) {\r
 675                         if (getPlantResource() == null)\r
 676                                 return null;\r
 677                         final PlantStructureOutlinePage page = new PlantStructureOutlinePage(sessionContext,getPlantResource());\r
 678                         \r
 679                         getSelectionAdapter().addSelectionChangedListener(new ISelectionChangedListener() {\r
 680                                 @Override\r
 681                                 public void selectionChanged(SelectionChangedEvent event) {\r
 682                                         page.setSelection(event.getSelection());\r
 683                                         \r
 684                                 }\r
 685                         });\r
 686                         parent.getDisplay().asyncExec(new Runnable() {\r
 687                                 @Override\r
 688                                 public void run() {\r
 689                                         page.addSelectionChangedListener(new ISelectionChangedListener() {\r
 690                                                 @Override\r
 691                                                 public void selectionChanged(SelectionChangedEvent event) {\r
 692                                                         selectionAdapter.setSelection(SelectionAdapter.transformSelection(event.getSelection()));\r
 693                                                 }\r
 694                                         });\r
 695                                 }\r
 696                         });\r
 697                         \r
 698                         \r
 699                         \r
 700                         return page;\r
 701                 }\r
 702                 return null;\r
 703         }\r
 704 }